Merge branch '6.0' into 6.0-test-fixes

# Conflicts:
#	Extensions/Xtensive.Orm.Reprocessing.Tests/Tests/Other.cs
#	Extensions/Xtensive.Orm.Reprocessing.Tests/Tests/Reprocessing.cs

Author: alex-kulakov

ChangeLog/6.0.6_dev.txt

@@ -0,0 +1,8 @@
+[main] Fixed possible cases of broken serialization due to comparers
+[main] Fixed rare cases of insert wrong data into some table columns for SingleTable hierarchies
+[sqlserver] Fixed incorrect DateTimeOffset.Date part extraction
+[sqlserver] Improved translation of DateTimeOffset.LocalDateTime and DateTimeOffset.TimeOfDay parts extraction
+[postgresql] Improved performance of First(), FirstOrDefault() being subqueries
+[postgresql] Improved translation of Math.Ceiling(), Math.Truncate() and Math.Floor()
+[reprocessing] ExecuteActionStrategy.Execute doesn't get external session though Session.Current at all
+[reprocessing] Introduced DomainExtension.WithSession and IExecuteConfiguration WithSession methods to pass external session

Extensions/Xtensive.Orm.Reprocessing.Tests/Tests/Other.cs

@@ -3,7 +3,6 @@
 using NUnit.Framework;
 using TestCommon.Model;
 using Xtensive.Orm.Configuration;
-using Xtensive.Orm.Reprocessing.Configuration;
 
 namespace Xtensive.Orm.Reprocessing.Tests
 {
@@ -53,9 +52,9 @@ public void NestedNewSession()
     [Test]
     public void NestedSessionReuse()
     {
-      Domain.Execute(
-        session1 => Domain.Execute(
-          session2 => Assert.That(session1, Is.SameAs(session2))));
+      Domain.Execute(session1 =>
+        Domain.WithSession(session1)
+          .Execute(session2 => Assert.That(session1, Is.SameAs(session2))));
     }
 
     [Test]
@@ -75,13 +74,15 @@ public void Test()
     [Test]
     public void ParentIsDisconnectedState()
     {
-      Domain.Execute(session => { _ = new Bar(session); });
+      Domain.Execute(session => {
+        _ = new Bar(session);
+      });
       using (var session = Domain.OpenSession(new SessionConfiguration(SessionOptions.ClientProfile)))
       using(session.Activate()) {
         var bar = session.Query.All<Bar>().FirstOrDefault();
-        bar=new Bar(session);
+        bar = new Bar(session);
         session.SaveChanges();
-        Domain.Execute(session1 => {
+        Domain.WithSession(session).Execute(session1 => {
           bar = session1.Query.All<Bar>().FirstOrDefault();
           bar = new Bar(session1);
         });
@@ -90,4 +91,4 @@ public void ParentIsDisconnectedState()
       Domain.Execute(session => Assert.That(session.Query.All<Bar>().Count(), Is.EqualTo(3)));
     }
   }
-}
+}

Extensions/Xtensive.Orm.Reprocessing.Tests/Tests/Reprocessing.cs

@@ -33,7 +33,7 @@ public void Deadlock(bool first, IsolationLevel? isolationLevel, TransactionOpen
         domain.WithStrategy(ExecuteActionStrategy.HandleUniqueConstraintViolation).WithIsolationLevel(isolationLevel.GetValueOrDefault(IsolationLevel.RepeatableRead)).WithTransactionOpenMode(transactionOpenMode.GetValueOrDefault(TransactionOpenMode.New)).Execute(
           session => {
             _ = Interlocked.Increment(ref Count);
-            _ = new Bar2(session, DateTime.Now, Guid.NewGuid()) {Name = Guid.NewGuid().ToString()};
+            _ = new Bar2(session, DateTime.Now, Guid.NewGuid()) { Name = Guid.NewGuid().ToString() };
             if (first) {
               _ = session.Query.All<Foo>().Lock(LockMode.Exclusive, LockBehavior.Wait).ToArray();
               if (wait1 != null) {
@@ -59,14 +59,13 @@ public void External(
         bool first,
         IsolationLevel? isolationLevel,
         TransactionOpenMode? transactionOpenMode,
-        Action<bool, IsolationLevel?, TransactionOpenMode?> action)
+        Action<Session, bool, IsolationLevel?, TransactionOpenMode?> action)
       {
         using (var session = domain.OpenSession())
-        using (var tran = isolationLevel == null ? null : session.OpenTransaction())
-        using (session.Activate()) {
+        using (var tran = isolationLevel == null ? null : session.OpenTransaction()) {
           if (tran != null) {
             session.EnsureTransactionIsStarted();
-            _ = new Bar2(session, DateTime.Now, Guid.NewGuid()) {Name = Guid.NewGuid().ToString()};
+            _ = new Bar2(session, DateTime.Now, Guid.NewGuid()) { Name = Guid.NewGuid().ToString() };
           }
           if (first) {
             if (wait1 != null && wait2 != null) {
@@ -78,8 +77,8 @@ public void External(
             _ = wait2.Set();
             _ = wait1.WaitOne();
           }
-          action(first, isolationLevel, transactionOpenMode);
-          if (tran!=null) {
+          action(session, first, isolationLevel, transactionOpenMode);
+          if (tran != null) {
             tran.Complete();
           }
         }
@@ -92,22 +91,55 @@ public void Parent(
         IExecuteActionStrategy strategy,
         Action<bool, IsolationLevel?, TransactionOpenMode?> action)
       {
-        domain.WithStrategy(strategy).WithIsolationLevel(isolationLevel.GetValueOrDefault(IsolationLevel.RepeatableRead)).WithTransactionOpenMode(transactionOpenMode.GetValueOrDefault(TransactionOpenMode.New)).Execute(
-          session => {
-            session.EnsureTransactionIsStarted();
-            _ = new Bar2(session, DateTime.Now, Guid.NewGuid()) {Name = Guid.NewGuid().ToString()};
-            if (first) {
-              if (wait1 != null && wait2 != null) {
-                _ = wait1.Set();
-                _ = wait2.WaitOne();
+        domain.WithStrategy(strategy)
+          .WithIsolationLevel(isolationLevel.GetValueOrDefault(IsolationLevel.RepeatableRead))
+          .WithTransactionOpenMode(transactionOpenMode.GetValueOrDefault(TransactionOpenMode.New))
+          .Execute(
+            session => {
+              session.EnsureTransactionIsStarted();
+              _ = new Bar2(session, DateTime.Now, Guid.NewGuid()) { Name = Guid.NewGuid().ToString() };
+              if (first) {
+                if (wait1 != null && wait2 != null) {
+                  _ = wait1.Set();
+                  _ = wait2.WaitOne();
+                }
               }
-            }
-            else if (wait1!=null && wait2!=null) {
-              _ = wait2.Set();
-              _ = wait1.WaitOne();
-            }
-            action(first, isolationLevel, transactionOpenMode);
-          });
+              else if (wait1 != null && wait2 != null) {
+                _ = wait2.Set();
+                _ = wait1.WaitOne();
+              }
+              action(first, isolationLevel, transactionOpenMode);
+            });
+      }
+
+      public void Parent(
+        Session session,
+        bool first,
+        IsolationLevel? isolationLevel,
+        TransactionOpenMode? transactionOpenMode,
+        IExecuteActionStrategy strategy,
+        Action<bool, IsolationLevel?, TransactionOpenMode?> action)
+      {
+        domain.WithStrategy(strategy)
+          .WithSession(session)
+          .WithIsolationLevel(isolationLevel.GetValueOrDefault(IsolationLevel.RepeatableRead))
+          .WithTransactionOpenMode(transactionOpenMode.GetValueOrDefault(TransactionOpenMode.New))
+          .Execute(
+            session => {
+              session.EnsureTransactionIsStarted();
+              _ = new Bar2(session, DateTime.Now, Guid.NewGuid()) { Name = Guid.NewGuid().ToString() };
+              if (first) {
+                if (wait1 != null && wait2 != null) {
+                  _ = wait1.Set();
+                  _ = wait2.WaitOne();
+                }
+              }
+              else if (wait1 != null && wait2 != null) {
+                _ = wait2.Set();
+                _ = wait1.WaitOne();
+              }
+              action(first, isolationLevel, transactionOpenMode);
+            });
       }
 
       public void Run(
@@ -135,7 +167,7 @@ public void UniqueConstraintViolation(
           session => {
             _ = Interlocked.Increment(ref Count);
             session.EnsureTransactionIsStarted();
-            _ = new Bar2(session, DateTime.Now, Guid.NewGuid()) {Name = Guid.NewGuid().ToString()};
+            _ = new Bar2(session, DateTime.Now, Guid.NewGuid()) { Name = Guid.NewGuid().ToString() };
             var name = "test";
             if (!session.Query.All<Foo>().Any(a => a.Name == name)) {
               if (first) {
@@ -150,7 +182,7 @@ public void UniqueConstraintViolation(
                 _ = wait1.WaitOne();
                 wait2 = null;
               }
-              _ = new Foo(session) {Name = name};
+              _ = new Foo(session) { Name = name };
             }
             session.SaveChanges();
           });
@@ -163,19 +195,19 @@ public void UniqueConstraintViolationPrimaryKey(
           session => {
             _ = Interlocked.Increment(ref Count);
             session.EnsureTransactionIsStarted();
-            _ = new Bar2(session, DateTime.Now, Guid.NewGuid()) {Name = Guid.NewGuid().ToString()};
+            _ = new Bar2(session, DateTime.Now, Guid.NewGuid()) { Name = Guid.NewGuid().ToString() };
             var id = 10;
-            if (session.Query.SingleOrDefault<Foo>(id) == null) {
+            if (session.Query.SingleOrDefault<Foo>(id)==null) {
               var w1 = wait1;
               var w2 = wait2;
               if (first) {
-                if (w1 != null && w2 != null) {
+                if (w1!=null && w2!=null) {
                   _ = w1.Set();
                   _ = w2.WaitOne();
                   wait1 = null;
                 }
               }
-              else if (w1 != null && w2 != null) {
+              else if (w1!=null && w2!=null) {
                 _ = w2.Set();
                 _ = w1.WaitOne();
                 wait2 = null;
@@ -278,8 +310,9 @@ public void Test()
             b,
             null,
             open,
-            (b1, level1, open1) =>
+            (s, b1, level1, open1) =>
               context.Parent(
+                s,
                 b1,
                 IsolationLevel.Snapshot,
                 open1,
@@ -290,30 +323,24 @@ public void Test()
 
       //ExternalWithTransaction nested snapshot UniqueConstraint
       context = new Context(Domain);
-      var ex =
-        Assert.Throws<AggregateException>(
-          () =>
-            context.Run(
-              IsolationLevel.Snapshot,
-              null,
-              (b, level, open) =>
-                context.External(
-                  b,
-                  level,
-                  open,
-                  (b1, level1, open1) =>
-                    context.Parent(
-                      b1,
-                      level1,
-                      open1,
-                      ExecuteActionStrategy.HandleUniqueConstraintViolation,
-                      context.UniqueConstraintViolation))));
-      Assert.That(
-        ex.InnerExceptions.Single(),
-        Is.TypeOf<InvalidOperationException>().Or.TypeOf<StorageException>().With.Property("InnerException").TypeOf
-          <InvalidOperationException>());
-      Assert.That(context.Count, Is.EqualTo(2));
-      Assert.That(Bar2Count(), Is.EqualTo(3));
+      context.Run(
+        IsolationLevel.Snapshot,
+        null,
+        (b, level, open) =>
+          context.External(
+            b,
+            level,
+            open,
+            (s, b1, level1, open1) =>
+              context.Parent(
+                s,
+                b1,
+                level1,
+                open1,
+                ExecuteActionStrategy.HandleUniqueConstraintViolation,
+                context.UniqueConstraintViolation)));
+      Assert.That(context.Count, Is.EqualTo(3));
+      Assert.That(Bar2Count(), Is.EqualTo(6));
 
       //nested UniqueConstraint with auto transaction
       context = new Context(Domain);
@@ -350,8 +377,8 @@ public void UniqueConstraintViolationExceptionPrimary()
     public void UniqueConstraintViolationExceptionUnique()
     {
       var i = 0;
-      var b = false;
-      ExecuteActionStrategy.HandleUniqueConstraintViolation.Error += (sender, args) => b = true;
+      var errorNotified = false;
+      ExecuteActionStrategy.HandleUniqueConstraintViolation.Error += (sender, args) => errorNotified = true;
       Domain.WithStrategy(ExecuteActionStrategy.HandleUniqueConstraintViolation).Execute(
         session => {
           _ = new Foo(session) { Name = "test" };
@@ -361,11 +388,11 @@ public void UniqueConstraintViolationExceptionUnique()
           }
         });
       Assert.That(i, Is.EqualTo(5));
-      Assert.That(b, Is.True);
+      Assert.That(errorNotified, Is.True);
     }
   }
 }
 
 // ReSharper restore ReturnValueOfPureMethodIsNotUsed
 // ReSharper restore ConvertToConstant.Local
-// ReSharper restore AccessToModifiedClosure
+// ReSharper restore AccessToModifiedClosure

Extensions/Xtensive.Orm.Reprocessing/DomainExtensions.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Transactions;
 using Xtensive.Orm.Reprocessing.Configuration;
 
@@ -131,6 +131,18 @@ public static IExecuteConfiguration WithTransactionOpenMode(this Domain domain,
       return new ExecuteConfiguration(domain).WithTransactionOpenMode(transactionOpenMode);
     }
 
+    /// <summary>
+    /// Starts <see cref="IExecuteConfiguration"/> flow
+    /// and provides <see cref="Session"/> to use.
+    /// </summary>
+    /// <param name="domain">The domain.</param>
+    /// <param name="session">The external session to use.</param>
+    /// <returns>Created <see cref="IExecuteConfiguration"/>.</returns>
+    public static IExecuteConfiguration WithSession(this Domain domain, Session session)
+    {
+      return new ExecuteConfiguration(domain).WithSession(session);
+    }
+
     #region Non-public methods
 
     internal static void ExecuteInternal(
@@ -140,13 +152,33 @@ internal static void ExecuteInternal(
       IExecuteActionStrategy strategy,
       Action<Session> action)
     {
-      ExecuteInternal<object>(
+      _ = ExecuteInternal<object>(
         domain,
         isolationLevel,
         transactionOpenMode,
         strategy,
-        a => {
-          action(a);
+        sessionInstance => {
+          action(sessionInstance);
+          return null;
+        });
+    }
+
+    internal static void ExecuteInternal(
+      this Domain domain,
+      Session session,
+      IsolationLevel isolationLevel,
+      TransactionOpenMode? transactionOpenMode,
+      IExecuteActionStrategy strategy,
+      Action<Session> action)
+    {
+      _ = ExecuteInternal<object>(
+        domain,
+        session,
+        isolationLevel,
+        transactionOpenMode,
+        strategy,
+        sessionInstance => {
+          action(sessionInstance);
           return null;
         });
     }
@@ -158,14 +190,37 @@ internal static T ExecuteInternal<T>(
       IExecuteActionStrategy strategy,
       Func<Session, T> func)
     {
-      ReprocessingConfiguration config = domain.GetReprocessingConfiguration();
-      if (strategy==null)
+      var config = domain.GetReprocessingConfiguration();
+      if (strategy == null) {
         strategy = ExecuteActionStrategy.GetSingleton(config.DefaultExecuteStrategy);
-      if (transactionOpenMode==null)
+      }
+      if (transactionOpenMode == null) {
         transactionOpenMode = config.DefaultTransactionOpenMode;
+      }
       return strategy.Execute(new ExecutionContext<T>(domain, isolationLevel, transactionOpenMode.Value, func));
     }
 
+    internal static T ExecuteInternal<T>(
+      this Domain domain,
+      Session session,
+      IsolationLevel isolationLevel,
+      TransactionOpenMode? transactionOpenMode,
+      IExecuteActionStrategy strategy,
+      Func<Session, T> func)
+    {
+      var config = domain.GetReprocessingConfiguration();
+      if (strategy == null) {
+        strategy = ExecuteActionStrategy.GetSingleton(config.DefaultExecuteStrategy);
+      }
+      if (transactionOpenMode == null) {
+        transactionOpenMode = config.DefaultTransactionOpenMode;
+      }
+      if (session.IsDisposed) {
+        throw new ObjectDisposedException(nameof(session));
+      }
+      return strategy.Execute(new ExecutionContext<T>(domain, session, isolationLevel, transactionOpenMode.Value, func));
+    }
+
     #endregion
   }
 }