Merge branch '7.2'

# Conflicts:
#	Directory.Build.props
#	Orm.sln
#	Orm/Xtensive.Orm.Tests.FSharp/ArithmeticOperationsCompilersTest.fs
#	Orm/Xtensive.Orm.Tests.FSharp/ComparisonCompilersTest.fs
#	Orm/Xtensive.Orm.Tests.FSharp/Model.fs
#	Orm/Xtensive.Orm.Tests.FSharp/QueryEntityBackTest.fs
#	Orm/Xtensive.Orm.Tests.FSharp/Xtensive.Orm.Tests.FSharp.fsproj
#	Orm/Xtensive.Orm.Tests.VB/Xtensive.Orm.Tests.VB.vbproj
#	Orm/Xtensive.Orm/Linq/ExpressionExtensions.cs
#	Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs
#	Orm/Xtensive.Orm/Orm/Providers/DomainHandler.cs
#	Orm/Xtensive.Orm/Orm/Providers/Expressions/MemberCompilers/FSharpConversionsCompilers.cs
#	Orm/Xtensive.Orm/Orm/Providers/Expressions/MemberCompilers/FSharpMathOperationsCompilers.cs
#	Orm/Xtensive.Orm/Orm/Providers/Expressions/MemberCompilers/FSharpOperatorsCompilers.cs
#	Orm/Xtensive.Orm/Orm/Providers/Expressions/MemberCompilers/FSharpStringCompilers.cs
#	Orm/Xtensive.Orm/Orm/Providers/Expressions/MemberCompilers/VBStringsCompilers.cs
#	Orm/Xtensive.Orm/Orm/Providers/Expressions/MemberCompilers/VbConversionsCompilers.cs
#	Orm/Xtensive.Orm/Orm/Providers/Expressions/MemberCompilers/VbDateAndTimeCompilers.cs
#	Version.props

Author: alex-kulakov

.github/workflows/reusable-storage-dependant-tests.yml

@@ -116,18 +116,20 @@ jobs:
         timeout-minutes: 10
         run: '${{ vars[env.DOCKER_SCRIPT_KEY] }}'
 
-      - name: Build Orm
-        if: ${{ success() }}
-        timeout-minutes: 5
-        run: dotnet build Orm.sln -c ${{ inputs.build_config }}
-
       - name: Setup .NETs
         if: ${{ success() }}
         timeout-minutes: 2
         uses: ./.github/actions/setup-dotnets
         with:
           target_framework: ${{ env.DO_TargetFrameworks }}
 
+      - name: Build Orm
+        if: ${{ success() }}
+        timeout-minutes: 5
+        run: dotnet build Orm.sln -c ${{ inputs.build_config }}
+
+      
+
       # Since composite action syntax does not allow to define step timeout
       # we have to run Reprocessing project here, because it may stuck in forever-loop
       - name: Test Reprocessing extension set of tests

.github/workflows/reusable-storage-independant-tests.yml

@@ -84,18 +84,18 @@ jobs:
         if: ${{ inputs.specific_sha != '' && github.reg_type == 'branch' }}
         run: git checkout ${{ inputs.specific_sha }}
 
-      - name: Build Orm
-        if: ${{ success() }}
-        timeout-minutes: 5
-        run: dotnet build Orm.sln -c ${{ inputs.build_config }}
-
       - name: Setup .NETs
         if: ${{ success() }}
         timeout-minutes: 2
         uses: ./.github/actions/setup-dotnets
         with:
           target_framework: ${{ env.DO_TargetFrameworks }}
 
+      - name: Build Orm
+        if: ${{ success() }}
+        timeout-minutes: 5
+        run: dotnet build Orm.sln -c ${{ inputs.build_config }}
+
       - name: Run tests
         id: complex_tests
         if: ${{ success() }}

ChangeLog/7.2.2-dev.txt

@@ -0,0 +1,6 @@
+[main] Query.CreateDelayedQuery(key, Func<IOrderedQueryable<TElement>>) applies external key instead of default computed, as it suppose to
+[main] QueryEndpoint.SingleAsync()/SingleOrDefaultAsync() get overloads that can recieve one key value as parameter without need to create array explicitly
+[main] PrefetchQuery<T> implements IAsyncEnumerable<T>, extra call for .AsAsyncEmumerable() is not needed for async enumeration
+[main] PrefetchQuery<T>.AsAsyncEmumerable() is marked as Obsolete
+[main] Support for C#14+ optimization that applies ReadOnlySpan<T>.Contains() extension instead of IEnumerable<T>.Contains() one to arrays
+[main] Compatibility with VB and FSharp improved

Orm/Xtensive.Orm.Manual/Prefetch/PrefetchTest.cs

@@ -180,7 +180,7 @@ public async Task MainAsyncTest()
           .Prefetch(p => p.Photo) // Lazy load field
           .Prefetch(p => p.Employees.Prefetch(e => e.Photo)) // EntitySet Employees and lazy load field of each of its items with the limit on number of items to be loaded
           .Prefetch(p => p.Manager.Photo); // Referenced entity and lazy load field for each of them
-        await foreach (var person in people.AsAsyncEnumerable()) {
+        await foreach (var person in people) {
           var accessor = DirectStateAccessor.Get(person);
           Assert.That(accessor.GetFieldState("Photo"), Is.EqualTo(PersistentFieldState.Loaded));
           Assert.That(accessor.GetFieldState("Manager"), Is.EqualTo(PersistentFieldState.Loaded));
@@ -275,7 +275,7 @@ orderby person.Name
           .Prefetch(p => p.Employees // EntitySet Employees
             .Prefetch(e => e.Photo)) // and lazy load field of each of its items
           .Prefetch(p => p.Manager); // Referenced entity
-        await foreach (var person in prefetchedPeople.AsAsyncEnumerable()) {
+        await foreach (var person in prefetchedPeople) {
           var accessor = DirectStateAccessor.Get(person);
           Assert.That(accessor.GetFieldState("Photo"), Is.EqualTo(PersistentFieldState.Loaded));
           Assert.That(accessor.GetFieldState("Manager"), Is.EqualTo(PersistentFieldState.Loaded));
@@ -362,7 +362,7 @@ public async Task DelayedQueryAsyncTest()
           .Prefetch(p => p.Photo) // Lazy load field
           .Prefetch(p => p.Employees.Prefetch(e => e.Photo)) // EntitySet Employees and lazy load field of each of its items with the limit on number of items to be loaded
           .Prefetch(p => p.Manager.Photo); // Referenced entity and lazy load field for each of them
-        await foreach (var person in people.AsAsyncEnumerable()) {
+        await foreach (var person in people) {
           var accessor = DirectStateAccessor.Get(person);
           Assert.That(accessor.GetFieldState("Photo"), Is.EqualTo(PersistentFieldState.Loaded));
           Assert.That(accessor.GetFieldState("Manager"), Is.EqualTo(PersistentFieldState.Loaded));
@@ -450,7 +450,7 @@ public async Task CachedQueryAsyncTest()
           .Prefetch(p => p.Photo) // Lazy load field
           .Prefetch(p => p.Employees.Prefetch(e => e.Photo)) // EntitySet Employees and lazy load field of each of its items with the limit on number of items to be loaded
           .Prefetch(p => p.Manager.Photo); // Referenced entity and lazy load field for each of them
-        await foreach (var person in people.AsAsyncEnumerable()) {
+        await foreach (var person in people) {
           var accessor = DirectStateAccessor.Get(person);
           Assert.That(accessor.GetFieldState("Photo"), Is.EqualTo(PersistentFieldState.Loaded));
           Assert.That(accessor.GetFieldState("Manager"), Is.EqualTo(PersistentFieldState.Loaded));

Orm/Xtensive.Orm.Tests.FSharp/Model.fs

@@ -93,4 +93,4 @@ type X() =
   [<Field>]
   member this.TimeSpanField
     with get() = this.GetFieldValue<System.TimeSpan> (nameof this.TimeSpanField)
-    and set(v: System.TimeSpan) = this.SetFieldValue (nameof this.TimeSpanField, v)
+    and set(v: System.TimeSpan) = this.SetFieldValue (nameof this.TimeSpanField, v)

Orm/Xtensive.Orm.Tests.FSharp/QueryEntityBackTest.fs

@@ -32,4 +32,5 @@ type Fixture() =
     let list = query |> Seq.toArray
     Assert.That(list.Length, Is.EqualTo(1))
     let fetched = list.[0]
-    Assert.That(fetched.Name, Is.EqualTo("John"))
+    Assert.That(fetched.Name, Is.EqualTo("John"))
+

Orm/Xtensive.Orm.Tests.FSharp/Xtensive.Orm.Tests.FSharp.fsproj

@@ -28,8 +28,11 @@
     <ProjectReference Include="..\Xtensive.Orm\Xtensive.Orm.csproj" />
   </ItemGroup>
   <ItemGroup>
+    <!-- Keep it before any tests -->
     <Compile Include="FsUnit.fs" />
     <Compile Include="Model.fs" />
+  </ItemGroup>
+  <ItemGroup>
     <Compile Include="ArithmeticOperationsCompilersTest.fs" />
     <Compile Include="ComparisonCompilersTest.fs" />
     <Compile Include="DateTimeCompilersTest.fs" />

Orm/Xtensive.Orm.Tests/Storage/Prefetch/FetchByKeyWithCachingTest.cs

@@ -143,7 +143,7 @@ public void SingleByExistingIdTest()
     }
 
     [Test]
-    public async Task SingleByExistingIdAsyncTest()
+    public async Task SingleByExistingIdAsyncTest1()
     {
       await RunWithinSessionAsync(async (s) => {
         var existingId = (int) existingKeys[customerType][0].Value.GetValue(0, out var _);
@@ -164,6 +164,28 @@ await RunWithinSessionAsync(async (s) => {
       });
     }
 
+    [Test]
+    public async Task SingleByExistingIdAsyncTest2()
+    {
+      await RunWithinSessionAsync(async (s) => {
+        var existingId = (int) existingKeys[customerType][0].Value.GetValue(0, out var _);
+        var detector = new QueryExecutionDetector();
+        using (detector.Attach(s)) {
+          // Entity is not in cache yet
+          var existingEntity = await s.Query.SingleAsync<Customer>(existingId);
+        }
+        Assert.That(detector.DbCommandsDetected, Is.True);
+        detector.Reset();
+
+        using (detector.Attach(s)) {
+          // now it is in cache
+          var existingEntity = await s.Query.SingleAsync<Customer>(existingId);
+        }
+        Assert.That(detector.DbCommandsDetected, Is.False);
+        detector.Reset();
+      });
+    }
+
     [Test]
     public void SingleByInexistentIdTest()
     {
@@ -186,7 +208,7 @@ public void SingleByInexistentIdTest()
     }
 
     [Test]
-    public async Task SingleByInexistentIdAsyncTest()
+    public async Task SingleByInexistentIdAsyncTest1()
     {
       await RunWithinSessionAsync(async (s) => {
         var inexistentId = 9999;
@@ -207,6 +229,28 @@ await RunWithinSessionAsync(async (s) => {
       });
     }
 
+    [Test]
+    public async Task SingleByInexistentIdAsyncTest2()
+    {
+      await RunWithinSessionAsync(async (s) => {
+        var inexistentId = 9999;
+
+        var detector = new QueryExecutionDetector();
+        using (detector.Attach(s)) {
+          _ = Assert.ThrowsAsync<KeyNotFoundException>(async () => await s.Query.SingleAsync<Customer>(inexistentId));
+        }
+        Assert.That(detector.DbCommandsDetected, Is.True);
+        detector.Reset();
+
+        using (detector.Attach(s)) {
+          _ = Assert.ThrowsAsync<KeyNotFoundException>(async () => await s.Query.SingleAsync<Customer>(inexistentId));
+        }
+        Assert.That(detector.DbCommandsDetected, Is.False);
+        detector.Reset();
+        await Task.CompletedTask;
+      });
+    }
+
     [Test]
     public void SingleOrDefaultByExistingKeyTest()
     {
@@ -327,7 +371,7 @@ public void SingleOrDefaultByExistingIdTest()
     }
 
     [Test]
-    public async Task SingleOrDefaultByExistingIdAsyncTest()
+    public async Task SingleOrDefaultByExistingIdAsyncTest1()
     {
       await RunWithinSessionAsync(async (s) => {
         var existingId = (int) existingKeys[customerType][0].Value.GetValue(0, out var _);
@@ -348,6 +392,28 @@ await RunWithinSessionAsync(async (s) => {
       });
     }
 
+    [Test]
+    public async Task SingleOrDefaultByExistingIdAsyncTest2()
+    {
+      await RunWithinSessionAsync(async (s) => {
+        var existingId = (int) existingKeys[customerType][0].Value.GetValue(0, out var _);
+        var detector = new QueryExecutionDetector();
+        using (detector.Attach(s)) {
+          // Entity is not in cache yet
+          var existingEntity = await s.Query.SingleOrDefaultAsync<Customer>(existingId);
+        }
+        Assert.That(detector.DbCommandsDetected, Is.True);
+        detector.Reset();
+
+        using (detector.Attach(s)) {
+          // now it is in cache
+          var existingEntity = await s.Query.SingleOrDefaultAsync<Customer>(existingId);
+        }
+        Assert.That(detector.DbCommandsDetected, Is.False);
+        detector.Reset();
+      });
+    }
+
     [Test]
     public void SingleOrDefaultByInexistentIdTest()
     {
@@ -372,7 +438,7 @@ public void SingleOrDefaultByInexistentIdTest()
     }
 
     [Test]
-    public async Task SingleOrDefaultByInexistentIdAsyncTest()
+    public async Task SingleOrDefaultByInexistentIdAsyncTest1()
     {
       await RunWithinSessionAsync(async (s) => {
         var inexistentId = 9999;
@@ -395,6 +461,29 @@ await RunWithinSessionAsync(async (s) => {
       });
     }
 
+    [Test]
+    public async Task SingleOrDefaultByInexistentIdAsyncTest2()
+    {
+      await RunWithinSessionAsync(async (s) => {
+        var inexistentId = 9999;
+
+        var detector = new QueryExecutionDetector();
+        using (detector.Attach(s)) {
+          var shouldBeNull = await s.Query.SingleOrDefaultAsync<Customer>(inexistentId);
+          Assert.That(shouldBeNull, Is.Null);
+        }
+        Assert.That(detector.DbCommandsDetected, Is.True);
+        detector.Reset();
+
+        using (detector.Attach(s)) {
+          var shouldBeNull = await s.Query.SingleOrDefaultAsync<Customer>(inexistentId);
+          Assert.That(shouldBeNull, Is.Null);
+        }
+        Assert.That(detector.DbCommandsDetected, Is.False);
+        detector.Reset();
+        await Task.CompletedTask;
+      });
+    }
 
     private void RunWithinSession(Action<Session> testAction)
     {

Orm/Xtensive.Orm.Tests/Storage/Prefetch/PrefetchTest.cs

@@ -181,8 +181,7 @@ public async Task PrefetchGraphPerformanceAsyncTest()
           .Prefetch(i => i.InvoiceLines
             .Prefetch(id => id.Track)
             .Prefetch(id => id.Track.Album)
-            .Prefetch(id => id.Track.Bytes))
-          .AsAsyncEnumerable();
+            .Prefetch(id => id.Track.Bytes));
         await foreach (var invoice in invoices) {
           var id = invoice.InvoiceId;
           var name = invoice.Customer.CompanyName;
@@ -247,7 +246,7 @@ public async Task EnumerableOfNonEntityAsyncTest()
       await using (var session = await Domain.OpenSessionAsync())
       await using (var tx = session.OpenTransaction()) {
         var invoices = session.Query.Many<Invoice>(keys)
-          .Prefetch(o => o.DesignatedEmployee).AsAsyncEnumerable();
+          .Prefetch(o => o.DesignatedEmployee);
         var invoiceType = Domain.Model.Types[typeof(Invoice)];
         var employeeField = invoiceType.Fields[nameof(Invoice.DesignatedEmployee)];
         var employeeType = Domain.Model.Types[typeof(Employee)];
@@ -361,7 +360,7 @@ public async Task PrefetchManyNotFullBatchAsyncTest()
         var invoicesField = Domain.Model.Types[typeof (Track)].Fields["Playlists"];
         var invoiceLinesField = Domain.Model.Types[typeof (Playlist)].Fields["Tracks"];
         var tracks = session.Query.All<Track>().Take(50)
-          .Prefetch(t => t.Playlists.Prefetch(il => il.Tracks)).AsAsyncEnumerable();
+          .Prefetch(t => t.Playlists.Prefetch(il => il.Tracks));
         int count1 = 0, count2 = 0;
         await foreach (var track in tracks) {
           count1++;
@@ -413,7 +412,7 @@ public async Task PrefetchManySeveralBatchesAsyncTest()
         var trackField = Domain.Model.Types[typeof(InvoiceLine)].Fields[nameof(InvoiceLine.Track)];
         var invoices = session.Query.All<Invoice>()
           .Take(90)
-          .Prefetch(o => o.InvoiceLines.Prefetch(od => od.Track)).AsAsyncEnumerable();
+          .Prefetch(o => o.InvoiceLines.Prefetch(od => od.Track));
         int count1 = 0, count2 = 0;
         await foreach (var invoice in invoices) {
           count1++;
@@ -483,7 +482,7 @@ public async Task PrefetchSingleAsyncTest()
         var employeeType = Domain.Model.Types[typeof(Employee)];
         var invoiceType = Domain.Model.Types[typeof(Invoice)];
         var invoices = session.Query.Many<Invoice>(keys)
-          .Prefetch(o => o.DesignatedEmployee.Invoices).AsAsyncEnumerable();
+          .Prefetch(o => o.DesignatedEmployee.Invoices);
         var count = 0;
         await foreach (var invoice in invoices) {
           Assert.That(invoice.Key, Is.EqualTo(keys[count]));
@@ -674,7 +673,7 @@ public async Task SimultaneouslyUsageOfMultipleEnumeratorsAsyncTest()
       await using (var session = await Domain.OpenSessionAsync())
       await using (var tx = session.OpenTransaction()) {
         var source = session.Query.All<Invoice>().ToList();
-        var prefetchQuery = source.Prefetch(i => i.InvoiceLines).AsAsyncEnumerable();
+        var prefetchQuery = source.Prefetch(i => i.InvoiceLines);
         await using (var enumerator0 = prefetchQuery.GetAsyncEnumerator()) {
           _ = await enumerator0.MoveNextAsync();
           _ = await enumerator0.MoveNextAsync();
@@ -729,7 +728,7 @@ public async Task RootElementIsNullPrefetchAsyncTest()
 
         await using (var tx = session.OpenTransaction()) {
           var books = session.Query.All<PrefetchModel.Book>().AsEnumerable()
-            .Concat(Enumerable.Repeat<PrefetchModel.Book>(null, 1)).Prefetch(b => b.Title).AsAsyncEnumerable();
+            .Concat(Enumerable.Repeat<PrefetchModel.Book>(null, 1)).Prefetch(b => b.Title);
           var titleField = Domain.Model.Types[typeof(PrefetchModel.Book)].Fields[nameof(PrefetchModel.Book.Title)];
           var titleType = Domain.Model.Types[typeof(PrefetchModel.Title)];
           var count = 0;
@@ -783,7 +782,7 @@ public async Task NestedPrefetchWhenChildElementIsNullAsyncTest()
 
         await using (var tx = session.OpenTransaction()) {
           var prefetcher = session.Query.All<PrefetchModel.Book>()
-            .Prefetch(b => b.Title.Book).AsAsyncEnumerable();
+            .Prefetch(b => b.Title.Book);
           var titleField = Domain.Model.Types[typeof(PrefetchModel.Book)].Fields[nameof(PrefetchModel.Book.Title)];
           var titleType = Domain.Model.Types[typeof(PrefetchModel.Title)];
           await foreach (var book in prefetcher) {
@@ -837,7 +836,7 @@ public async Task NestedPrefetchWhenRootElementIsNullAsyncTest()
 
         await using (var tx = session.OpenTransaction()) {
           var books = session.Query.All<PrefetchModel.Book>().AsEnumerable().Concat(Enumerable.Repeat<PrefetchModel.Book>(null, 1))
-            .Prefetch(b => b.Title.Book).AsAsyncEnumerable();
+            .Prefetch(b => b.Title.Book);
           var titleField = Domain.Model.Types[typeof(PrefetchModel.Book)].Fields[nameof(PrefetchModel.Book.Title)];
           var titleType = Domain.Model.Types[typeof(PrefetchModel.Title)];
           var count = 0;
@@ -883,7 +882,7 @@ public async Task StructureFieldsPrefetchAsyncTest()
       await using (var tx = session.OpenTransaction()) {
         var containers = session.Query.Many<PrefetchModel.OfferContainer>(Enumerable.Repeat(containerKey, 1))
           .Prefetch(oc => oc.RealOffer.Book)
-          .Prefetch(oc => oc.IntermediateOffer.RealOffer.BookShop).AsAsyncEnumerable();
+          .Prefetch(oc => oc.IntermediateOffer.RealOffer.BookShop);
         await foreach (var key in containers) {
           PrefetchTestHelper.AssertOnlyDefaultColumnsAreLoaded(book0Key, book0Key.TypeInfo, session);
           PrefetchTestHelper.AssertOnlyDefaultColumnsAreLoaded(bookShop1Key, bookShop1Key.TypeInfo, session);
@@ -917,7 +916,7 @@ public async Task StructurePrefetchAsyncTest()
       await using (var session = await Domain.OpenSessionAsync())
       await using (var tx = session.OpenTransaction()) {
         var containers = session.Query.Many<PrefetchModel.OfferContainer>(Enumerable.Repeat(containerKey, 1))
-          .Prefetch(oc => oc.IntermediateOffer).AsAsyncEnumerable();
+          .Prefetch(oc => oc.IntermediateOffer);
         await foreach (var key in containers) {
           PrefetchTestHelper.AssertOnlySpecifiedColumnsAreLoaded(containerKey, containerKey.TypeInfo, session,
             field => PrefetchTestHelper.IsFieldToBeLoadedByDefault(field) || field.Name.StartsWith("IntermediateOffer"));

Orm/Xtensive.Orm/Linq/ExpressionExtensions.cs

@@ -29,7 +29,6 @@ public static class ExpressionExtensions
     private static readonly Func<Type, MethodInfo> TupleValueAccessorFactory;
 
     private static readonly Type MemoryExtensionsType = typeof(MemoryExtensions);
-
     private static readonly int[] MemoryExtensionsContainsMethodTokens;
     private static readonly MethodInfo EnumerableContains;