Merge pull request #422 from DataObjects-NET/7.1-recordsetreader-overlaps-sqlexception

RecordSetReader overlaps SQL exception when DbCommand execution failed

Author: alex-kulakov

ChangeLog/7.1.5_dev.txt

@@ -0,0 +1 @@
+[main] Addressed certain cases of overlaping server-side error by new one when temporary tables are used in query

Orm/Xtensive.Orm.Tests/Linq/LocalCollectionsTest.cs

@@ -15,6 +15,7 @@
 using Xtensive.Orm.Tests.ObjectModel;
 using Xtensive.Orm.Tests.ObjectModel.ChinookDO;
 using System.Threading.Tasks;
+using Xtensive.Orm.Configuration;
 
 namespace Xtensive.Orm.Tests.Linq.LocalCollectionsTest_Model
 {
@@ -910,6 +911,40 @@ public void ClosureCacheTest()
       });
     }
 
+    [Test]
+    public void TempTableCleanupAfterTimeout()
+    {
+      Require.ProviderIs(StorageProvider.PostgreSql | StorageProvider.SqlServer, "Uses database-specific syntax.");
+
+      var localItems = GetLocalItems(100);
+
+      var sessionConfig = new SessionConfiguration(SessionOptions.Default | SessionOptions.AutoActivation);
+      sessionConfig.BatchSize = 1;
+      sessionConfig.DefaultCommandTimeout = 10;
+
+      using (var session = Domain.OpenSession(sessionConfig))
+      using (var tx = session.OpenTransaction()) {
+        session.Events.DbCommandExecuting += Events_DbCommandExecuting;
+
+        var storeQueryable = session.Query.Store(localItems);
+        _ = Assert.Throws<OperationTimeoutException>(() => session.Query.All<Invoice>()
+          .Where(invoice => invoice.Commission > storeQueryable.Max(poco => poco.Value2)).ToArray());
+
+        session.Events.DbCommandExecuting -= Events_DbCommandExecuting;
+      }
+
+      static void Events_DbCommandExecuting(object sender, DbCommandEventArgs e)
+      {
+        // makes query to delay more than current setting of command timeout
+        var originalCommandText = e.Command.CommandText;
+        if (originalCommandText.Contains("Select", StringComparison.OrdinalIgnoreCase)) {
+          var session = ((SessionEventAccessor) sender).Session;
+          e.Command.CommandText = GetFakeDelayedCommandTest(session, originalCommandText);
+        }
+      }
+    }
+
+
     [Test]
     [Ignore("Very long")]
     public void VeryLongTest()
@@ -935,7 +970,18 @@ private IEnumerable<Poco<int, decimal, string>> GetLocalItems(int count)
             Value3 = Guid.NewGuid().ToString()
           }
         )
-        .ToList();
+        .ToList(count);
+    }
+
+    private static string GetFakeDelayedCommandTest(Session session, string originalCommandText)
+    {
+      var currentCommandTimeout = session.CommandTimeout.Value;
+
+      return StorageProviderInfo.Instance.Provider switch {
+        StorageProvider.SqlServer => $"WAITFOR DELAY '{TimeSpan.FromSeconds(currentCommandTimeout + 2).ToString("hh:mm.ss")}'" + originalCommandText,
+        StorageProvider.PostgreSql => $"SELECT pg_sleep({currentCommandTimeout + 2});" + originalCommandText,
+        _ => throw new ArgumentOutOfRangeException()
+      };
     }
   }
 }

Orm/Xtensive.Orm/Orm/Rse/RecordSetReader.cs

@@ -139,11 +139,13 @@ private async ValueTask Prepare(bool executeAsync)
         context.SetValue(provider, enumerationMarker, true);
       }
 
+      bool isOnEnumerateSuccessful = false;
       try {
         dataReader = executeAsync
           ? await provider.OnEnumerateAsync(context, token).ConfigureAwait(false)
           : provider.OnEnumerate(context);
 
+        isOnEnumerateSuccessful = true;
         if (isGreedy && !dataReader.IsInMemory) {
           var tuples = new List<Tuple>();
           if (executeAsync) {
@@ -164,16 +166,30 @@ private async ValueTask Prepare(bool executeAsync)
         }
       }
       catch {
-        FinishEnumeration(true);
+        FinishEnumeration(true, !isOnEnumerateSuccessful);
         throw;
       }
       state = State.Prepared;
     }
 
-    private void FinishEnumeration(bool isError)
+    private void FinishEnumeration(bool isError, bool isErrorOnServerSide = false)
     {
-      if (!enumerated) {
-        provider?.OnAfterEnumerate(context);
+      if (isErrorOnServerSide) {
+        // Possible connection closing because of server-side error, like operation timeout,
+        // which makes finish of some providers imposible, like ones that work with temporary tables and require clean-up.
+        // Exception may happen but we must prevent overlaping original exception with new one.
+        if (!enumerated) {
+          try {
+            provider?.OnAfterEnumerate(context);
+          }
+          catch {
+          }
+        }
+      }
+      else {
+        if (!enumerated) {
+          provider?.OnAfterEnumerate(context);
+        }
       }
 
       if (!isError) {