Ejemplo n.º 1
0
        public void StoreThenIncludeTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.TemporaryTables);
            using (var session = Domain.OpenSession())
                using (var transaction = session.OpenTransaction()) {
                    var businessUnitIds = session.Query.All <BusinessUnit>().Select(bu => bu.Id).ToList();

                    var bounds = new Tuple <DateTime, DateTime, string> [26];
                    for (var i = 0; i < bounds.Length; i++)
                    {
                        bounds[i] = new Tuple <DateTime, DateTime, string>(DateTime.UtcNow, DateTime.UtcNow, "");
                    }
                    var list = session.Query.All <Job>()
                               .Select(job => new { BusinessUnitId = job.BusinessUnit.Id, Month = bounds.FirstOrDefault().Item3 })
                               .Where(job => job.BusinessUnitId.In(businessUnitIds))
                               .ToList();
                }
        }
        public void SimplifiedTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.ScalarSubqueries);
            var today = DateTime.Now;

            using (var session = Domain.OpenSession()) {
                using (var t = session.OpenTransaction()) {
                    var query =
                        from kalinaGasObject in session.Query.All <PipeAbonent>()
                        let matchGuess                         = session.Query.All <Kalina2RngGasObjectMatchGuess>().FirstOrDefault()
                                                     let owner = session.Query.All <PipeAbonentOwnershipInfo>().FirstOrDefault()
                                                                 orderby matchGuess.Rank ?? 0 descending
                                                                 select matchGuess;

                    var result = query.ToList();
                }
            }
        }
Ejemplo n.º 3
0
        public void TypeIdExtractionTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.Multischema);

            InitializeSchemas();

            var defaultSchemaMap     = new Dictionary <Type, int>();
            var alternativeSchemaMap = new Dictionary <Type, int>();

            BuildDomain(DefaultSchema, DomainUpgradeMode.Recreate, typeof(Entity1)).Dispose();
            using (var domain = BuildDomain(DefaultSchema, DomainUpgradeMode.PerformSafely, typeof(Entity1), typeof(Entity2)))
                defaultSchemaMap = domain.Model.Types.ToDictionary(el => el.UnderlyingType, el => el.TypeId);

            BuildDomain(AlternativeSchema, DomainUpgradeMode.Recreate, typeof(Entity2));
            using (var domain = BuildDomain(AlternativeSchema, DomainUpgradeMode.PerformSafely, typeof(Entity2), typeof(Entity1)))
                alternativeSchemaMap = domain.Model.Types.ToDictionary(el => el.UnderlyingType, el => el.TypeId);

            using (var domain = BuildDomain(DefaultSchema, DomainUpgradeMode.Validate, typeof(Entity1), typeof(Entity2))) {
                var nodeConfiguration = new NodeConfiguration(AlternativeSchema)
                {
                    UpgradeMode = DomainUpgradeMode.Validate
                };
                nodeConfiguration.SchemaMapping.Add(DefaultSchema, AlternativeSchema);
                domain.StorageNodeManager.AddNode(nodeConfiguration);

                using (var session = domain.OpenSession()) {
                    session.SelectStorageNode(WellKnown.DefaultNodeId);
                    var types = new[] { typeof(BaseEntity), typeof(Entity1), typeof(Entity2) };
                    foreach (var type in types)
                    {
                        Assert.That(session.StorageNode.TypeIdRegistry[domain.Model.Types[type]], Is.EqualTo(defaultSchemaMap[type]));
                    }
                }

                using (var session = domain.OpenSession()) {
                    session.SelectStorageNode(AlternativeSchema);
                    var types = new[] { typeof(BaseEntity), typeof(Entity1), typeof(Entity2) };
                    foreach (var type in types)
                    {
                        Assert.That(session.StorageNode.TypeIdRegistry[domain.Model.Types[type]], Is.EqualTo(alternativeSchemaMap[type]));
                    }
                }
            }
        }
    public void MySqlModeGeneration()
    {
      Require.AllFeaturesNotSupported(ProviderFeatures.Sequences);
      Require.AllFeaturesSupported(ProviderFeatures.AutoIncrementSettingsInMemory);

      using (var session = Domain.OpenSession()) {
        foreach (var keyGenerator in Domain.Configuration.KeyGenerators)
          CheckGeneratorsAfterDomainBuilded(keyGenerator, session, 0);
      }
      using (var session = Domain.OpenSession())
      using (session.Activate())
      using (var transaction = session.OpenTransaction()) {
        for (int i = 0; i < 1; i++) {
          var entity = new Entity1();
        }
      }
      using (var session = Domain.OpenSession()) {
        foreach (var keyGenerator in Domain.Configuration.KeyGenerators)
          CheckGeneratorsAfterDomainBuilded(keyGenerator, session, 1);
      }
      using (var session = Domain.OpenSession())
      using (session.Activate())
      using (var transaction = session.OpenTransaction()) {
        for (int i = 0; i < 120; i++) {
          var entity = new Entity1();
        }
      }

      using (var session = Domain.OpenSession()) {
        foreach (var keyGenerator in Domain.Configuration.KeyGenerators)
          CheckGeneratorsAfterDomainBuilded(keyGenerator, session, 1);
      }
      using (var session = Domain.OpenSession())
      using (session.Activate())
      using (var transaction = session.OpenTransaction()) {
        for (int i = 0; i < 250; i++) {
          var entity = new Entity1();
        }
      }
      using (var session = Domain.OpenSession()) {
        foreach (var keyGenerator in Domain.Configuration.KeyGenerators)
          CheckGeneratorsAfterDomainBuilded(keyGenerator, session, 1);
      }
    }
Ejemplo n.º 5
0
        public void TwoCalculateWithApplyTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.Apply);

            var actual = from c in Session.Query.All <Customer>()
                         from n in (c.Invoices.Select(i => c.FirstName + i.BillingAddress.StreetAddress))
                         .Union(c.Invoices.Select(i => c.FirstName + i.BillingAddress.StreetAddress))
                         orderby n
                         select n;

            var expected = from c in Customers
                           from n in (c.Invoices.Select(i => c.FirstName + i.BillingAddress.StreetAddress))
                           .Union(c.Invoices.Select(i => c.FirstName + i.BillingAddress.StreetAddress))
                           orderby n
                           select n;

            Assert.That(actual, Is.Not.Empty);
            Assert.IsTrue(expected.SequenceEqual(actual));
        }
        public void JoinStructureDirectTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.TemporaryTables);

            using (Session session = Domain.OpenSession()) {
                using (TransactionScope t = session.OpenTransaction()) {
                    session.SaveChanges();
                    var localStructure = session.Query.All <EntityB>().Select(b => b.AdditionalInfo).First();
                    var array          = session.Query.All <EntityB>().Where(b => b.AdditionalInfo == localStructure).ToArray();
                    var localItems     = session.Query.All <EntityB>().Select(b => b.AdditionalInfo).ToArray();
                    var join           = session.Query.All <EntityB>().Select(b => b.AdditionalInfo).Join(localItems, b => b, l => l, (b, l) => new { b, l });
                    var expected       = session.Query.All <EntityB>().AsEnumerable().Select(b => b.AdditionalInfo).Join(localItems, b => b, l => l, (b, l) => new { b, l });
                    var except         = expected.Except(join);
                    var joinArray      = join.ToArray();
                    var expectedArray  = expected.ToArray();
                    Assert.AreEqual(0, except.Count());
                }
            }
        }
Ejemplo n.º 7
0
        public void JoinEntityTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.TemporaryTables);
            var localInvoices = Session.Query.All <Invoice>().Take(5).ToList();
            var query         = Session.Query.All <Invoice>().Join(
                localInvoices,
                invoice => invoice,
                localInvoice => localInvoice,
                (invoice, localInvoice) => new { invoice, localInvoice });

            Assert.That(query, Is.Not.Empty);
            QueryDumper.Dump(query);
            var expectedQuery = Invoices.Join(
                localInvoices,
                invoice => invoice,
                localInvoice => localInvoice,
                (invoice, localInvoice) => new { invoice, localInvoice });

            Assert.AreEqual(0, expectedQuery.Except(query).Count());
        }
Ejemplo n.º 8
0
        public void JoinEntityField2MaterializeTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.TemporaryTables);
            var localCommissions = Session.Query.All <Invoice>().Take(5).Select(invoice => invoice.Commission).ToList();
            var query            = Session.Query.All <Invoice>().Join(
                localCommissions,
                invoice => invoice.Commission,
                commission => commission,
                (invoice, commission) => new { invoice, commission }).Select(x => x.commission);

            Assert.That(query, Is.Not.Empty);
            QueryDumper.Dump(query);
            var expectedQuery = Invoices.Join(
                localCommissions,
                invoice => invoice.Commission,
                commission => commission,
                (invoice, commission) => new { invoice, commission }).Select(x => x.commission);

            Assert.AreEqual(0, expectedQuery.Except(query).Count());
        }
        public void Store2Test()
        {
            Require.AllFeaturesSupported(ProviderFeatures.TemporaryTables);

            var query = Session.Query.All <Customer>()
                        .Join(
                Session.Query.Store(Session.Query.All <Customer>().Take(10)),
                customer => customer,
                localCustomer => localCustomer,
                (customer, localCustomer) => new { customer, localCustomer });
            var expected = Session.Query.All <Customer>().AsEnumerable()
                           .Join(
                Session.Query.Store(Session.Query.All <Customer>().Take(10)),
                customer => customer,
                localCustomer => localCustomer,
                (customer, localCustomer) => new { customer, localCustomer });

            Assert.That(query, Is.Not.Empty);
            Assert.AreEqual(0, expected.Except(query).Count());
        }
        public void MainTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.ScalarSubqueries);

            using (var session = Domain.OpenSession())
                using (var tx = session.OpenTransaction()) {
                    var r = session.Query.All <Container>()
                            .Select(c => new {
                        c.Id,
                        LastLocation = Query.All <StoredContainer>()
                                       .Where(s => s.Container == c)
                                       .OrderByDescending(s => s.CreationTime)
                                       .Select(s => s.Address)
                                       .FirstOrDefault()
                    })
                            .OrderBy(c => c.Id)
                            .Single();
                    Assert.That(r.LastLocation, Is.EqualTo("3"));
                }
        }
 public void MainTest()
 {
     Require.AllFeaturesSupported(ProviderFeatures.ScalarSubqueries);
     using (var session = Domain.OpenSession()) {
         using (var transaction = session.OpenTransaction()) {
             var myEntity = new MyEntity()
             {
                 Date = DateTime.Now,
                 Text = "Text"
             };
             var query = session.Query.All <MyEntity>()
                         .Select(e => new {
                 MyEntity = e,
                 Year     = (int?)e.Date.Value.Year,
                 Status   = e.Infos.OfType <SuccessInfo>().Any() ? Status.Success : (e.Infos.OfType <ErrorInfo>().Any() ? Status.Error : Status.Unknown)
             })
                         .Select(o => new object[] { o.MyEntity.Id, o.Year, o.Status });
             var result = query.ToList();
         }
     }
 }
Ejemplo n.º 12
0
        public void OuterJoinAnonymousTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.ScalarSubqueries);
            var assertCount =
                Session.Query.All <Invoice>().Count() +
                Session.Query.All <Customer>().Count(c => !Session.Query.All <Invoice>().Any(i => i.Customer == c));
            var result = from c in Session.Query.All <Customer>()
                         from i in Session.Query.All <Invoice>().Where(i => i.Customer == c).Select(i => new { i.InvoiceId, c.Phone }).DefaultIfEmpty()
                         select new { c.LastName, i };
            var list = result.ToList();

            Assert.That(list, Is.Not.Empty);
            Assert.AreEqual(assertCount, list.Count);
            foreach (var item in result)
            {
                Assert.IsNotNull(item);
                Assert.IsNotNull(item.LastName);
                Assert.IsNotNull(item.i);
            }
            QueryDumper.Dump(list);
        }
Ejemplo n.º 13
0
        public void Subquery2Test()
        {
            Require.AllFeaturesSupported(ProviderFeatures.TemporaryTables);
            var localItems = GetLocalItems(10);
            var queryable  = Session.Query.Store(localItems);
            var result     = queryable
                             .Select(poco => queryable.Where(poco2 => poco2.Value2 > poco.Value2).Select(p => p.Value3)).AsEnumerable().Cast <IEnumerable <string> >();
            var expected = localItems
                           .Select(poco => localItems.Where(poco2 => poco2.Value2 > poco.Value2).Select(p => p.Value3));
            var expectedList = expected.ToList();
            var resultList   = result.ToList();

            Assert.That(resultList, Is.Not.Empty);
            Assert.AreEqual(resultList.Count, expectedList.Count);

            for (var i = 0; i < resultList.Count; i++)
            {
                Assert.AreEqual(0, expectedList[i].Except(resultList[i]).Count());
            }
            QueryDumper.Dump(result);
        }
        public void BaseTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.UpdateFrom);
            // Test MoveFieldHint (RemoveFieldHint)
            var config = base.BuildConfiguration();

            config.Types.Register(Assembly.GetExecutingAssembly(), "Xtensive.Orm.Tests.Issues.Issue0376.Model2");
            config.UpgradeMode = DomainUpgradeMode.PerformSafely;
            Domain domain;

            using (M2.Upgrader.Enable()) {
                domain = Domain.Build(config);
            }
            using (var session = domain.OpenSession()) {
                using (var transactionScope = session.OpenTransaction()) {
                    var son = session.Query.All <M2.Son>().Single();
                    Assert.AreEqual("FirstName", son.FirstName);
                    Assert.AreEqual("LastName", son.LastName);
                    Assert.AreEqual("NickName", son.NickName);
                    transactionScope.Complete();
                }
            }

            // Test RemoveTypeHint
            config = base.BuildConfiguration();
            config.Types.Register(Assembly.GetExecutingAssembly(), "Xtensive.Orm.Tests.Issues.Issue0376.Model3");
            config.UpgradeMode = DomainUpgradeMode.PerformSafely;
            using (M3.Upgrader.Enable()) {
                domain = Domain.Build(config);
            }
            using (var session = domain.OpenSession()) {
                using (var transactionScope = session.OpenTransaction()) {
                    Assert.IsTrue(session.Query.All <M3.Father>().Count() == 0);
                    transactionScope.Complete();
                }
            }
        }
Ejemplo n.º 15
0
        public void Grouping2Test()
        {
            Require.AllFeaturesSupported(ProviderFeatures.TemporaryTables);
            var localItems = GetLocalItems(10);
            var queryable  = Session.Query.Store(localItems);
            var result     = queryable
                             .GroupBy(keySelector => keySelector.Value3[0], (key, grouping) => new { key, Value1 = grouping.Select(p => p.Value1) })
                             .OrderBy(grouping => grouping.key);
            var expected = localItems
                           .GroupBy(keySelector => keySelector.Value3[0], (key, grouping) => new { key, Value1 = grouping.Select(p => p.Value1) })
                           .OrderBy(grouping => grouping.key);
            var expectedList = expected.ToList();
            var resultList   = result.ToList();

            Assert.That(resultList, Is.Not.Empty);
            Assert.AreEqual(resultList.Count, expectedList.Count);

            for (var i = 0; i < resultList.Count; i++)
            {
                Assert.AreEqual(resultList[i].key, expectedList[i].key);
                Assert.AreEqual(0, expectedList[i].Value1.Except(resultList[i].Value1).Count());
            }
            QueryDumper.Dump(result);
        }
Ejemplo n.º 16
0
        public void MainTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.Multischema);

            InitializeSchemas();

            BuildDomain(DefaultSchema, DomainUpgradeMode.Recreate, typeof(Entity1)).Dispose();
            BuildDomain(DefaultSchema, DomainUpgradeMode.PerformSafely, typeof(Entity1), typeof(Entity2)).Dispose();

            BuildDomain(AlternativeSchema, DomainUpgradeMode.Recreate, typeof(Entity2));
            BuildDomain(AlternativeSchema, DomainUpgradeMode.PerformSafely, typeof(Entity2), typeof(Entity1)).Dispose();

            using (var domain = BuildDomain(DefaultSchema, DomainUpgradeMode.Validate, typeof(Entity1), typeof(Entity2))) {
                var nodeConfiguration = new NodeConfiguration(AlternativeSchema)
                {
                    UpgradeMode = DomainUpgradeMode.Validate
                };
                nodeConfiguration.SchemaMapping.Add(DefaultSchema, AlternativeSchema);
                domain.StorageNodeManager.AddNode(nodeConfiguration);

                RunTest(domain, WellKnown.DefaultNodeId, MainTestBody);
                RunTest(domain, AlternativeSchema, MainTestBody);
            }
        }
Ejemplo n.º 17
0
        public void Grouping1Test()
        {
            Require.AllFeaturesSupported(ProviderFeatures.TemporaryTables);
            var localItems = GetLocalItems(10);
            var queryable  = Session.Query.Store(localItems);
            var result     = queryable
                             .GroupBy(keySelector => keySelector.Value3.Substring(0, 1),
                                      (key, grouping) => new { key, Value1 = grouping.Select(p => p.Value1) })
                             .OrderBy(grouping => grouping.key);
            var expected = localItems
                           .GroupBy(keySelector => keySelector.Value3.Substring(0, 1),
                                    (key, grouping) => new { key, Value1 = grouping.Select(p => p.Value1) })
                           .OrderBy(grouping => grouping.key);
            var expectedList = expected.ToList();
            var resultList   = result.ToList();

            Assert.That(resultList, Is.Not.Empty);
            Assert.AreEqual(resultList.Count, expectedList.Count);

            for (var i = 0; i < resultList.Count; i++)
            {
                Console.WriteLine(string.Format("Key (expected/result): {0} / {1}", expectedList[i].key, resultList[i].key));
                foreach (var expectedValue in expectedList[i].Value1)
                {
                    Console.WriteLine(string.Format("Expected Value: {0}", expectedValue));
                }
                foreach (var resultValue in resultList[i].Value1)
                {
                    Console.WriteLine(string.Format("Result Value: {0}", resultValue));
                }
                Assert.AreEqual(resultList[i].key, expectedList[i].key);
                var isCorrect = expectedList[i].Value1.Except(resultList[i].Value1).Count() == 0;
                Assert.IsTrue(isCorrect);
            }
            QueryDumper.Dump(result);
        }
Ejemplo n.º 18
0
        public void MainTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.ScalarSubqueries);
            using (var session = Domain.OpenSession())
                using (var t = session.OpenTransaction()) {
                    var person = new Person(Guid.NewGuid())
                    {
                        Rank = 1
                    };
                    var position = new Position(Guid.NewGuid())
                    {
                        Rank = 1
                    };
//        session.Persist();

                    var rank = session.Query.All <Position>().Where(r => r.Rank == 1).Single().Rank; // Ok here
                    Assert.AreEqual(1, rank);
                    var people = session.Query.All <Person>()
                                 .Where(p => p.Rank == session.Query.All <Position>().Where(r => r.Rank == 1).Single().Rank)
                                 .ToList(); //Exception
                    Assert.AreEqual(1, people.Count);
                    t.Complete();
                }
        }
        public void UpgradeDateTimeOffsetAndDateTimeTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.DateTimeOffset);
            Require.ProviderIsNot(StorageProvider.PostgreSql, "ToLocalTime is not supported");
            using (var domain = BuildInitialDomain())
                using (var session = domain.OpenSession())
                    using (var tx = session.OpenTransaction()) {
                        new V1.EntityWithDateTimeOffset {
                            DateTimeOffset = dateTimeOffset,
                            DateTime       = dateTime
                        };

                        tx.Complete();
                    }

            using (var domain = BuildUpgradedDomain())
                using (var session = domain.OpenSession())
                    using (var tx = session.OpenTransaction()) {
                        var valuesAfterUpgrade = session.Query.All <V2.EntityWithDateTimeOffsetUpgrade>().Single();

                        var queryServerOffset =
                            from t in session.Query.All <V2.EntityWithDateTimeOffsetUpgrade>()
                            group t by new {
                            ServerOffset = t.DateTime.ToLocalTime().Offset
                        };
                        var resultQueryServerOffset = queryServerOffset.ToList().FirstOrDefault();

                        if (resultQueryServerOffset != null)
                        {
                            Assert.That(valuesAfterUpgrade.DateTime, Is.EqualTo(new DateTimeOffset(dateTime, resultQueryServerOffset.Key.ServerOffset)));
                        }
                        Assert.That(valuesAfterUpgrade.DateTimeOffset, Is.EqualTo(dateTime));

                        tx.Complete();
                    }
        }
Ejemplo n.º 20
0
 protected override void CheckRequirements()
 {
     base.CheckRequirements();
     Require.AllFeaturesSupported(ProviderFeatures.Multidatabase);
 }
 protected override void  CheckRequirements()
 {
     Require.ProviderIs(StorageProvider.SqlServer);
     Require.AllFeaturesSupported(ProviderFeatures.Multidatabase);
 }
Ejemplo n.º 22
0
 protected override void CheckRequirements() => Require.AllFeaturesSupported(ProviderFeatures.Multischema);
Ejemplo n.º 23
0
 protected override void CheckRequirements()
 {
     Require.AllFeaturesSupported(ProviderFeatures.DateTimeOffset);
 }
Ejemplo n.º 24
0
 public void TestSetUp()
 {
     Require.AllFeaturesSupported(ProviderFeatures.FullText);
 }
Ejemplo n.º 25
0
 protected override void CheckRequirements()
 {
     Require.AllFeaturesSupported(ProviderFeatures.FullText);
 }
 protected override void CheckRequirements()
 {
     Require.AllFeaturesSupported(ProviderFeatures.ScalarSubqueries);
 }
Ejemplo n.º 27
0
 public virtual void CheckRequirements()
 {
     Require.AllFeaturesSupported(ProviderFeatures.Multischema);
 }
        public void MultidatabaseMappingResolverOnSharedSchemaTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.Multidatabase);

            var domainConfiguration = DomainConfigurationFactory.Create();

            domainConfiguration.UpgradeMode = DomainUpgradeMode.Recreate;
            domainConfiguration.Types.Register(typeof(model.Part1.TestEntity1).Assembly, typeof(model.Part1.TestEntity1).Namespace);
            domainConfiguration.Types.Register(typeof(model.Part2.TestEntity2).Assembly, typeof(model.Part2.TestEntity2).Namespace);
            domainConfiguration.Types.Register(typeof(model.Part3.TestEntity3).Assembly, typeof(model.Part3.TestEntity3).Namespace);
            domainConfiguration.Types.Register(typeof(model.Part4.TestEntity4).Assembly, typeof(model.Part4.TestEntity4).Namespace);

            _ = domainConfiguration.Databases.Add(DOTests1Db);
            _ = domainConfiguration.Databases.Add(DOTests2Db);

            domainConfiguration.MappingRules.Map(typeof(model.Part1.TestEntity1).Assembly, typeof(model.Part1.TestEntity1).Namespace).To(DOTests1Db, Schema1);
            domainConfiguration.MappingRules.Map(typeof(model.Part2.TestEntity2).Assembly, typeof(model.Part2.TestEntity2).Namespace).To(DOTests1Db, Schema2);
            domainConfiguration.MappingRules.Map(typeof(model.Part3.TestEntity3).Assembly, typeof(model.Part3.TestEntity3).Namespace).To(DOTests2Db, Schema1);
            domainConfiguration.MappingRules.Map(typeof(model.Part4.TestEntity4).Assembly, typeof(model.Part4.TestEntity4).Namespace).To(DOTests2Db, Schema2);

            domainConfiguration.DefaultDatabase = DOTests1Db;
            domainConfiguration.DefaultSchema   = Schema1;

            var nodeConfiguration = new NodeConfiguration("Additional");

            nodeConfiguration.UpgradeMode = DomainUpgradeMode.Recreate;
            nodeConfiguration.DatabaseMapping.Add(DOTests1Db, DOTests3Db);
            nodeConfiguration.DatabaseMapping.Add(DOTests2Db, DOTests4Db);
            nodeConfiguration.SchemaMapping.Add(Schema1, Schema3);
            nodeConfiguration.SchemaMapping.Add(Schema2, Schema4);


            using (var domain = Domain.Build(domainConfiguration)) {
                _ = domain.StorageNodeManager.AddNode(nodeConfiguration);

                var defaultNodeConfig    = domain.StorageNodeManager.GetNode(WellKnown.DefaultNodeId).Configuration;
                var additionalNodeConfig = domain.StorageNodeManager.GetNode("Additional").Configuration;

                DefaultSchemaInfo defaultSchemaInfo;
                using (var connection = driver.CreateConnection()) {
                    connection.Open();
                    defaultSchemaInfo = driver.GetDefaultSchema(connection);
                }

                var defaultMappingResolver = MappingResolver.Create(domainConfiguration, defaultNodeConfig, defaultSchemaInfo);
                Assert.That(defaultMappingResolver, Is.InstanceOf <MultidatabaseMappingResolver>());

                var additionalMappingResolver = MappingResolver.Create(domainConfiguration, additionalNodeConfig, defaultSchemaInfo);
                Assert.That(additionalMappingResolver, Is.InstanceOf <MultidatabaseMappingResolver>());

                SchemaExtractionResult extractionResult;
                using (var connection = driver.CreateConnection()) {
                    connection.Open();
                    extractionResult = new SchemaExtractionResult(driver.Extract(connection, defaultMappingResolver.GetSchemaTasks()));
                }
                _ = extractionResult.MakeShared();

                var resolverPerNodeMap = new Dictionary <NodeConfiguration, MappingResolver> {
                    { defaultNodeConfig, defaultMappingResolver },
                    { additionalNodeConfig, additionalMappingResolver }
                };

                var baseDb1  = DOTests1Db;
                var baseDb2  = DOTests2Db;
                var baseSch1 = Schema1;
                var baseSch2 = Schema2;
                foreach (var pair in resolverPerNodeMap)
                {
                    var nodeConfig = pair.Key;
                    var resolver   = pair.Value;

                    var tasks = resolver.GetSchemaTasks();
                    Assert.That(tasks.Count(), Is.EqualTo(4));
                    Assert.That(tasks.Any(t => t.Catalog == nodeConfig.DatabaseMapping.Apply(DOTests1Db) && t.Schema == nodeConfig.SchemaMapping.Apply(Schema1)), Is.True);
                    Assert.That(tasks.Any(t => t.Catalog == nodeConfig.DatabaseMapping.Apply(DOTests1Db) && t.Schema == nodeConfig.SchemaMapping.Apply(Schema2)), Is.True);
                    Assert.That(tasks.Any(t => t.Catalog == nodeConfig.DatabaseMapping.Apply(DOTests2Db) && t.Schema == nodeConfig.SchemaMapping.Apply(Schema1)), Is.True);
                    Assert.That(tasks.Any(t => t.Catalog == nodeConfig.DatabaseMapping.Apply(DOTests2Db) && t.Schema == nodeConfig.SchemaMapping.Apply(Schema2)), Is.True);

                    tasks = resolver.GetMetadataTasks();
                    Assert.That(tasks.Count(), Is.EqualTo(2));
                    Assert.That(tasks.Any(t => t.Catalog == nodeConfig.DatabaseMapping.Apply(DOTests1Db) && t.Schema == nodeConfig.SchemaMapping.Apply(Schema1)), Is.True);
                    Assert.That(tasks.Any(t => t.Catalog == nodeConfig.DatabaseMapping.Apply(DOTests2Db) && t.Schema == nodeConfig.SchemaMapping.Apply(Schema1)), Is.True);


                    var fullName = resolver.GetNodeName("TestDb", "TestSchema", "TestEntity1");
                    Assert.That(fullName, Is.EqualTo("TestDb:TestSchema:TestEntity1"));

                    var expectedDatabase = nodeConfig.DatabaseMapping.Apply(baseDb1);
                    var expectedSchema   = nodeConfig.SchemaMapping.Apply(baseSch1);

                    fullName = resolver.GetNodeName(DOTests1Db, Schema1, "TestEntity1");
                    Assert.That(fullName, Is.EqualTo(string.Format("{0}:{1}:TestEntity1", expectedDatabase, expectedSchema)));


                    var table = extractionResult
                                .Catalogs[baseDb1]
                                .Schemas[baseSch1]
                                .Tables["TestEntity1"];
                    fullName         = resolver.GetNodeName(table);
                    expectedDatabase = baseDb1;
                    expectedSchema   = baseSch1;
                    Assert.That(fullName, Is.EqualTo(string.Format("{0}:{1}:TestEntity1", expectedDatabase, expectedSchema)));

                    table = extractionResult
                            .Catalogs[baseDb1]
                            .Schemas[baseSch2]
                            .Tables["TestEntity2"];
                    fullName         = resolver.GetNodeName(table);
                    expectedDatabase = baseDb1;
                    expectedSchema   = baseSch2;
                    Assert.That(fullName, Is.EqualTo(string.Format("{0}:{1}:TestEntity2", expectedDatabase, expectedSchema)));

                    table = extractionResult
                            .Catalogs[baseDb2]
                            .Schemas[baseSch1]
                            .Tables["TestEntity3"];
                    expectedDatabase = baseDb2;
                    expectedSchema   = baseSch1;
                    fullName         = resolver.GetNodeName(table);
                    Assert.That(fullName, Is.EqualTo(string.Format("{0}:{1}:TestEntity3", expectedDatabase, expectedSchema)));

                    var typeinfo = domain.Model.Types[typeof(model.Part1.TestEntity1)];
                    expectedDatabase = nodeConfig.DatabaseMapping.Apply(baseDb1);
                    expectedSchema   = nodeConfig.SchemaMapping.Apply(baseSch1);
                    fullName         = resolver.GetNodeName(typeinfo);
                    Assert.That(fullName, Is.EqualTo(string.Format("{0}:{1}:TestEntity1", expectedDatabase, expectedSchema)));

                    var resolveResult = resolver.Resolve(extractionResult, fullName);
                    expectedDatabase = baseDb1;
                    expectedSchema   = baseSch1;
                    Assert.That(resolveResult.Schema.GetNameInternal(), Is.EqualTo(expectedSchema));
                    Assert.That(resolveResult.Schema.Catalog.GetNameInternal(), Is.EqualTo(expectedDatabase));

                    var schema = resolver.ResolveSchema(extractionResult, typeinfo.MappingDatabase, typeinfo.MappingSchema);
                    Assert.That(schema.GetNameInternal(), Is.EqualTo(expectedSchema));
                    Assert.That(schema.Catalog.GetNameInternal(), Is.EqualTo(expectedDatabase));

                    typeinfo         = domain.Model.Types[typeof(model.Part2.TestEntity2)];
                    expectedDatabase = nodeConfig.DatabaseMapping.Apply(baseDb1);
                    expectedSchema   = nodeConfig.SchemaMapping.Apply(baseSch2);
                    fullName         = resolver.GetNodeName(typeinfo);
                    Assert.That(fullName, Is.EqualTo(string.Format("{0}:{1}:TestEntity2", expectedDatabase, expectedSchema)));

                    resolveResult    = resolver.Resolve(extractionResult, fullName);
                    expectedDatabase = baseDb1;
                    expectedSchema   = baseSch2;
                    Assert.That(resolveResult.Schema.GetNameInternal(), Is.EqualTo(expectedSchema));
                    Assert.That(resolveResult.Schema.Catalog.GetNameInternal(), Is.EqualTo(expectedDatabase));

                    schema = resolver.ResolveSchema(extractionResult, typeinfo.MappingDatabase, typeinfo.MappingSchema);
                    Assert.That(schema.GetNameInternal(), Is.EqualTo(expectedSchema));
                    Assert.That(schema.Catalog.GetNameInternal(), Is.EqualTo(expectedDatabase));


                    typeinfo         = domain.Model.Types[typeof(model.Part3.TestEntity3)];
                    expectedDatabase = nodeConfig.DatabaseMapping.Apply(baseDb2);
                    expectedSchema   = nodeConfig.SchemaMapping.Apply(baseSch1);
                    fullName         = resolver.GetNodeName(typeinfo);
                    Assert.That(fullName, Is.EqualTo(string.Format("{0}:{1}:TestEntity3", expectedDatabase, expectedSchema)));

                    resolveResult    = resolver.Resolve(extractionResult, fullName);
                    expectedDatabase = baseDb2;
                    expectedSchema   = baseSch1;
                    Assert.That(resolveResult.Schema.GetNameInternal(), Is.EqualTo(expectedSchema));
                    Assert.That(resolveResult.Schema.Catalog.GetNameInternal(), Is.EqualTo(expectedDatabase));

                    schema = resolver.ResolveSchema(extractionResult, typeinfo.MappingDatabase, typeinfo.MappingSchema);
                    Assert.That(schema.GetNameInternal(), Is.EqualTo(expectedSchema));
                    Assert.That(schema.Catalog.GetNameInternal(), Is.EqualTo(expectedDatabase));
                }
            }
        }
        public void MultischemaMappingResolverOnSharedSchemaTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.Multischema);

            var domainConfiguration = DomainConfigurationFactory.Create();

            domainConfiguration.UpgradeMode = DomainUpgradeMode.Recreate;

            domainConfiguration.Types.Register(typeof(model.Part1.TestEntity1).Assembly, typeof(model.Part1.TestEntity1).Namespace);
            domainConfiguration.Types.Register(typeof(model.Part2.TestEntity2).Assembly, typeof(model.Part2.TestEntity2).Namespace);
            domainConfiguration.Types.Register(typeof(model.Part3.TestEntity3).Assembly, typeof(model.Part3.TestEntity3).Namespace);
            domainConfiguration.Types.Register(typeof(model.Part4.TestEntity4).Assembly, typeof(model.Part4.TestEntity4).Namespace);

            domainConfiguration.MappingRules.Map(typeof(model.Part1.TestEntity1).Assembly, typeof(model.Part1.TestEntity1).Namespace).ToSchema(Schema1);
            domainConfiguration.MappingRules.Map(typeof(model.Part2.TestEntity2).Assembly, typeof(model.Part2.TestEntity2).Namespace).ToSchema(Schema1);
            domainConfiguration.MappingRules.Map(typeof(model.Part3.TestEntity3).Assembly, typeof(model.Part3.TestEntity3).Namespace).ToSchema(Schema2);
            domainConfiguration.MappingRules.Map(typeof(model.Part4.TestEntity4).Assembly, typeof(model.Part4.TestEntity4).Namespace).ToSchema(Schema2);

            domainConfiguration.DefaultSchema = Schema1;

            var nodeConfiguration = new NodeConfiguration("Additional");

            nodeConfiguration.UpgradeMode = DomainUpgradeMode.Recreate;
            nodeConfiguration.SchemaMapping.Add(Schema1, Schema3);
            nodeConfiguration.SchemaMapping.Add(Schema2, Schema4);

            using (var domain = Domain.Build(domainConfiguration)) {
                domain.StorageNodeManager.AddNode(nodeConfiguration);

                var defaultNodeConfig    = domain.StorageNodeManager.GetNode(WellKnown.DefaultNodeId).Configuration;
                var additionalNodeConfig = domain.StorageNodeManager.GetNode("Additional").Configuration;

                DefaultSchemaInfo defaultSchemaInfo;
                using (var connection = driver.CreateConnection()) {
                    connection.Open();
                    defaultSchemaInfo = driver.GetDefaultSchema(connection);
                }

                var defaultMappingResolver = MappingResolver.Create(domainConfiguration, defaultNodeConfig, defaultSchemaInfo);
                Assert.That(defaultMappingResolver, Is.InstanceOf <MultischemaMappingResolver>());
                var additionalMappingResolver = MappingResolver.Create(domainConfiguration, additionalNodeConfig, defaultSchemaInfo);
                Assert.That(additionalMappingResolver, Is.InstanceOf <MultischemaMappingResolver>());

                SchemaExtractionResult extractionResult;
                using (var connection = driver.CreateConnection()) {
                    connection.Open();
                    extractionResult = new SchemaExtractionResult(driver.Extract(connection, defaultMappingResolver.GetSchemaTasks()));
                }
                _ = extractionResult.MakeShared();

                var resolverPerNodeMap = new Dictionary <NodeConfiguration, MappingResolver> {
                    { defaultNodeConfig, defaultMappingResolver },
                    { additionalNodeConfig, additionalMappingResolver }
                };

                foreach (var pair in resolverPerNodeMap)
                {
                    var nodeConfig      = pair.Key;
                    var mappingResolver = pair.Value;

                    Assert.That(mappingResolver, Is.InstanceOf <MultischemaMappingResolver>());
                    var metadataExtactionTasks = mappingResolver.GetMetadataTasks();
                    Assert.That(metadataExtactionTasks.Count(), Is.EqualTo(1));
                    Assert.That(metadataExtactionTasks.First().Catalog, Is.EqualTo(defaultSchemaInfo.Database));
                    Assert.That(metadataExtactionTasks.First().Schema, Is.EqualTo(nodeConfig.SchemaMapping.Apply(Schema1)));

                    var schemaExtractionTasks = mappingResolver.GetSchemaTasks();
                    Assert.That(schemaExtractionTasks.Count(), Is.EqualTo(2));
                    Assert.That(schemaExtractionTasks.Any(t => t.Catalog == defaultSchemaInfo.Database && t.Schema == nodeConfig.SchemaMapping.Apply(Schema1)), Is.True);
                    Assert.That(schemaExtractionTasks.Any(t => t.Catalog == defaultSchemaInfo.Database && t.Schema == nodeConfig.SchemaMapping.Apply(Schema2)), Is.True);

                    var fullName = mappingResolver.GetNodeName("dummy", "SchemaName", "Table1");
                    Assert.That(fullName, Is.EqualTo("SchemaName:Table1"));

                    fullName = mappingResolver.GetNodeName("dummy", Schema1, "Table1");
                    Assert.That(fullName, Is.EqualTo(nodeConfig.SchemaMapping.Apply(Schema1) + ":Table1"));

                    var table = extractionResult.Catalogs.First().Schemas[Schema1].Tables["TestEntity1"];
                    fullName = mappingResolver.GetNodeName(table);
                    Assert.That(fullName, Is.EqualTo(Schema1 + ":TestEntity1"));

                    table    = extractionResult.Catalogs.First().Schemas[Schema2].Tables["TestEntity4"];
                    fullName = mappingResolver.GetNodeName(table);
                    Assert.That(fullName, Is.EqualTo(Schema2 + ":TestEntity4"));

                    var typeInfo = domain.Model.Types[typeof(model.Part1.TestEntity1)];
                    fullName = mappingResolver.GetNodeName(typeInfo);
                    Assert.That(fullName, Is.EqualTo(nodeConfig.SchemaMapping.Apply(Schema1) + ":TestEntity1"));

                    var resolveResult = mappingResolver.Resolve(extractionResult, fullName);
                    Assert.That(resolveResult.Schema.GetNameInternal(), Is.EqualTo(Schema1));

                    var schema = mappingResolver.ResolveSchema(extractionResult, typeInfo.MappingDatabase, typeInfo.MappingSchema);
                    Assert.That(schema.GetNameInternal(), Is.EqualTo(Schema1));

                    typeInfo = domain.Model.Types[typeof(model.Part4.TestEntity4)];
                    fullName = mappingResolver.GetNodeName(typeInfo);
                    Assert.That(fullName, Is.EqualTo(nodeConfig.SchemaMapping.Apply(Schema2) + ":TestEntity4"));

                    resolveResult = mappingResolver.Resolve(extractionResult, fullName);
                    Assert.That(resolveResult.Schema.GetNameInternal(), Is.EqualTo(Schema2));

                    schema = mappingResolver.ResolveSchema(extractionResult, typeInfo.MappingDatabase, typeInfo.MappingSchema);
                    Assert.That(schema.GetNameInternal(), Is.EqualTo(Schema2));

                    var sequence = typeInfo.Hierarchy.Key.Sequence;
                    fullName = mappingResolver.GetNodeName(sequence);
                    Assert.That(fullName, Is.EqualTo(nodeConfig.SchemaMapping.Apply(Schema1) + ":" + sequence.MappingName));

                    resolveResult = mappingResolver.Resolve(extractionResult, fullName);
                    Assert.That(resolveResult.Schema.GetNameInternal(), Is.EqualTo(Schema1));
                }
            }
        }
        public void MainTest()
        {
            Require.AllFeaturesSupported(ProviderFeatures.ScalarSubqueries);
            using (var session = Domain.OpenSession()) {
                using (var transactionn = session.OpenTransaction()) {
                    var sevRGasCustomer2 = new SevRGasCustomer()
                    {
                        Code     = "Code",
                        FullName = "Customer FullName",
                        Name     = "Customer Name",
                        Tin      = 44
                    };
                    // var ePassportAgent2 = new EPassportAgent();
                    var sevRGas2EPassportCustomerMatchGuess2 = new SevRGas2EPassportCustomerMatchGuess {
                        SevRGasCustomerID   = sevRGasCustomer2.Id,
                        EPassportCustomerID = 12345,
                        Rank = 12345
                    };
                    var dataUnitCustomer2 = new DataUnitCustomer {
                        SevRGasCustomer = sevRGasCustomer2,
                        EPassportAgent  = null
                    };

                    var sevRGasCustomer1 = new SevRGasCustomer()
                    {
                        Code     = "Code",
                        FullName = "Customer FullName",
                        Name     = "Customer Name",
                        Tin      = 12
                    };
                    var ePassportAgent1 = new EPassportAgent();
                    var sevRGas2EPassportCustomerMatchGuess1 = new SevRGas2EPassportCustomerMatchGuess {
                        SevRGasCustomerID   = sevRGasCustomer1.Id,
                        EPassportCustomerID = ePassportAgent1.Id,
                        Rank = 12345
                    };
                    var dataUnitCustomer1 = new DataUnitCustomer {
                        SevRGasCustomer = sevRGasCustomer1,
                        EPassportAgent  = ePassportAgent1
                    };

                    var query =
                        from customer in session.Query.All <SevRGasCustomer>()
                        let matchGuess = session.Query.All <SevRGas2EPassportCustomerMatchGuess>().Where(
                            g => g.SevRGasCustomerID == customer.Id).FirstOrDefault()
                                         let matchGuessObject = session.Query.All <EPassportAgent>().Where(
                            go => go.Id == matchGuess.EPassportCustomerID).FirstOrDefault()
                                                                let unifiedCustomer = session.Query.All <DataUnitCustomer>().Where(
                            ua => ua.SevRGasCustomer == customer && ua.EPassportAgent != null).FirstOrDefault()
                                                                                      select new SevRGas2EPassportCustomerMatchListItem {
                        LeftID   = customer.Id,
                        LeftName = customer.Name ?? customer.FullName,
                        LeftUniqueTaxpayerNumber = customer.Tin,
                        LeftCode = customer.Code,
                        Rank     = matchGuess.Rank,
                        Status   = unifiedCustomer == null ? MatchStatus.NotConfirmed : MatchStatus.Confirmed,
                        Right    = GetRight(unifiedCustomer, matchGuess, matchGuessObject)
                    };
                    var result = query.ToList();
                }
            }
        }