Exemple #1
0
 public async Task PrefetchManySeveralBatchesAsyncTest()
 {
     using (var session = Domain.OpenSession())
         using (var tx = session.OpenTransaction()) {
             var linesField = Domain.Model.Types[typeof(Invoice)].Fields["InvoiceLines"];
             var trackField = Domain.Model.Types[typeof(InvoiceLine)].Fields["Track"];
             var invoices   = session.Query.All <Invoice>()
                              .Take(90)
                              .Prefetch(o => o.InvoiceLines.Prefetch(od => od.Track)).AsAsync();
             int count1 = 0, count2 = 0;
             foreach (var invoice in await invoices)
             {
                 count1++;
                 var entitySetState = GetFullyLoadedEntitySet(session, invoice.Key, linesField);
                 foreach (var line in entitySetState)
                 {
                     count2++;
                     PrefetchTestHelper.AssertOnlySpecifiedColumnsAreLoaded(line, line.TypeInfo, session,
                                                                            PrefetchTestHelper.IsFieldToBeLoadedByDefault);
                     PrefetchTestHelper.AssertReferencedEntityIsLoaded(line, session, trackField);
                 }
             }
             Console.WriteLine(count1);
             Console.WriteLine(count2);
             Assert.AreEqual(11, session.Handler.PrefetchTaskExecutionCount);
         }
 }
        public void PrefetchViaReferenceToSelfTest()
        {
            Key key;

            using (var session = Domain.OpenSession())
                using (var tx = session.OpenTransaction()) {
                    var referenceToSelf = new ReferenceToSelf {
                        AuxField = 100
                    };
                    key = referenceToSelf.Key;
                    referenceToSelf.Reference = referenceToSelf;
                    tx.Complete();
                }

            using (var session = Domain.OpenSession())
                using (session.OpenTransaction()) {
                    var prefetchManager = (PrefetchManager)PrefetchProcessorField.GetValue(session.Handler);
                    var referenceField  = Domain.Model.Types[typeof(ReferenceToSelf)].Fields["Reference"];
                    prefetchManager.InvokePrefetch(key, null, new PrefetchFieldDescriptor(referenceField, true, true));
                    prefetchManager.ExecuteTasks(true);
                    PrefetchTestHelper.AssertOnlySpecifiedColumnsAreLoaded(key, key.TypeInfo, session,
                                                                           PrefetchTestHelper.IsFieldToBeLoadedByDefault);
                    PrefetchTestHelper.AssertReferencedEntityIsLoaded(key, session, referenceField);
                }
        }
        public void ReferencedEntityWhichOwnerHasAlreadyBeenFetchedInAnotherTransactionPrefetchTest()
        {
            var orderKey = GetFirstKey <Order>();

            using (var session = Domain.OpenSession()) {
                using (session.OpenTransaction())
                    session.Query.Single <Order>(orderKey);

                using (session.OpenTransaction()) {
                    session.Handler.InvokePrefetch(orderKey, null, new PrefetchFieldDescriptor(CustomerField));
                    session.Handler.ExecutePrefetchTasks();
                    PrefetchTestHelper.AssertReferencedEntityIsLoaded(orderKey, session, CustomerField);
                }
            }
        }