public void MainTest()
{
SchemaExtractionResult extractionResult;
using (var connection = driver.CreateConnection()) {
connection.Open();
var defaultSchema = driver.ExtractDefaultSchema(connection);
extractionResult = new SchemaExtractionResult();
extractionResult.Catalogs.Add(defaultSchema.Catalog);
}
Assert.That(extractionResult.IsShared, Is.False);
Assert.DoesNotThrow(() => { var name = extractionResult.Catalogs.First().Name; });
Assert.DoesNotThrow(() => { var name = extractionResult.Catalogs.First().DbName; });
Assert.DoesNotThrow(() => { var name = extractionResult.Catalogs.First().DefaultSchema.Name; });
Assert.DoesNotThrow(() => { var name = extractionResult.Catalogs.First().DefaultSchema.DbName; });
Assert.DoesNotThrow(() => { var name = extractionResult.Catalogs.First().DefaultSchema.Tables["Product"].Name; });
Assert.DoesNotThrow(() => { var name = extractionResult.Catalogs.First().DefaultSchema.Tables["Product"].DbName; });
extractionResult.MakeShared();
Assert.That(extractionResult.IsShared, Is.True);
Assert.Throws <InvalidOperationException>(() => { var name = extractionResult.Catalogs.First().Name; });
Assert.Throws <InvalidOperationException>(() => { var name = extractionResult.Catalogs.First().DbName; });
Assert.Throws <InvalidOperationException>(() => { var name = extractionResult.Catalogs.First().DefaultSchema.Name; });
Assert.Throws <InvalidOperationException>(() => { var name = extractionResult.Catalogs.First().DefaultSchema.DbName; });
Assert.DoesNotThrow(() => { var name = extractionResult.Catalogs.First().DefaultSchema.Tables["Product"].Name; });
Assert.DoesNotThrow(() => { var name = extractionResult.Catalogs.First().DefaultSchema.Tables["Product"].DbName; });
}
public void SimpleMappingResolverTest()
{
var domainConfiguration = DomainConfigurationFactory.Create();
domainConfiguration.UpgradeMode = DomainUpgradeMode.Recreate;
domainConfiguration.Types.Register(typeof(model.Part1.TestEntity1).Assembly, typeof(model.Part1.TestEntity1).Namespace);
using (var domain = Domain.Build(domainConfiguration)) {
var node = domain.StorageNodeManager.GetNode(WellKnown.DefaultNodeId);
var nodeConfiguration = node.Configuration;
DefaultSchemaInfo defaultSchemaInfo;
using (var connection = driver.CreateConnection()) {
connection.Open();
defaultSchemaInfo = driver.GetDefaultSchema(connection);
}
var mappingResolver = MappingResolver.Create(domainConfiguration, nodeConfiguration, defaultSchemaInfo);
Assert.That(mappingResolver, Is.InstanceOf <SimpleMappingResolver>());
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(defaultSchemaInfo.Schema));
var schemaExtractionTasks = mappingResolver.GetSchemaTasks();
Assert.That(schemaExtractionTasks.SequenceEqual(metadataExtactionTasks));
SchemaExtractionResult extractionResult;
using (var connection = driver.CreateConnection()) {
connection.Open();
extractionResult = new SchemaExtractionResult(driver.Extract(connection, mappingResolver.GetSchemaTasks()));
}
var fullName = mappingResolver.GetNodeName("dummy", "dummy", "Table1");
Assert.That(fullName.ToLower(), Is.EqualTo("Table1".ToLower()));
fullName = mappingResolver.GetNodeName(extractionResult.Catalogs.First().DefaultSchema.Tables["TestEntity1"]);
Assert.That(fullName.ToLower(), Is.EqualTo("TestEntity1".ToLower()));
var typeInfo = domain.Model.Types[typeof(model.Part1.TestEntity1)];
fullName = mappingResolver.GetNodeName(typeInfo);
Assert.That(fullName.ToLower(), Is.EqualTo("TestEntity1".ToLower()));
var sequence = typeInfo.Hierarchy.Key.Sequence;
fullName = mappingResolver.GetNodeName(sequence);
Assert.That(fullName.ToLower(), Is.EqualTo(sequence.MappingName.ToLower()));
var schema = mappingResolver.ResolveSchema(extractionResult, defaultSchemaInfo.Database, defaultSchemaInfo.Schema);
Assert.That(schema, Is.EqualTo(extractionResult.Catalogs.First().DefaultSchema));
var resolveResult = mappingResolver.Resolve(extractionResult, typeInfo.MappingName);
Assert.That(resolveResult.Name, Is.EqualTo(typeInfo.MappingName));
Assert.That(resolveResult.Schema, Is.EqualTo(extractionResult.Catalogs.Single().DefaultSchema));
Assert.That(resolveResult.GetTable(), Is.EqualTo(extractionResult.Catalogs.Single().DefaultSchema.Tables["TestEntity1"]));
resolveResult = mappingResolver.Resolve(extractionResult, sequence.MappingName);
Assert.That(resolveResult.Name, Is.EqualTo(sequence.MappingName));
Assert.That(resolveResult.Schema, Is.EqualTo(extractionResult.Catalogs.Single().DefaultSchema));
}
}
public override MappingResolveResult Resolve(SchemaExtractionResult model, string nodeName)
{
// Since 5.0.7 we extract all schemas of catalog when it's possible.
// Anyway, model have the only catalog at this point. But the catalog might have more than 1 schema.
// General behavior is to get single catalog and find schema by name.
// But, for some RDBMS, extraction task has empty schema name and look up by empty string returns null.
// Fortunately, these RDBMS does not support multiple schemas in catalog.
var schema = model.Catalogs.Single().Schemas[extractionTask.Schema] ?? model.Catalogs.Single().Schemas.Single();
return(new MappingResolveResult(schema, nodeName));
}
public override MappingResolveResult Resolve(SchemaExtractionResult model, string nodeName)
{
var names = nodeName.Split(NameElementSeparator);
var schema = (model.IsShared)
? model.Catalogs.Single().Schemas[reversedSchemaMapping.Apply(names[0])]
: model.Catalogs.Single().Schemas[names[0]];
var name = names[1];
if (schema == null)
{
throw new InvalidOperationException(string.Format(Strings.ExUnableToResolveSchemaForNodeXPleaseVerifyThatThisSchemaExists, nodeName));
}
return(new MappingResolveResult(schema, name));
}
public SchemaExtractionResult Run()
{
var result = new SchemaExtractionResult();
if (buildAsCopy)
{
CopyCatalogs(result.Catalogs);
}
else
{
GetDefaultNodeCatalogs().ForEach(result.Catalogs.Add);
result.MakeShared();
}
return(result);
}
internal DomainExtractedModelBuilder(UpgradeServiceAccessor services, StorageModel model, bool makeSharedFinally)
{
ArgumentValidator.EnsureArgumentNotNull(services, "services");
ArgumentValidator.EnsureArgumentNotNull(model, "model");
this.model = model;
this.mappingResolver = services.MappingResolver;
this.provider = services.ProviderInfo;
this.driver = services.StorageDriver;
this.makeSharedFinally = makeSharedFinally;
this.targetResult = new SchemaExtractionResult();
if (provider.Supports(ProviderFeatures.Collations))
{
var collation = services.Configuration.Collation;
if (!string.IsNullOrEmpty(collation))
{
collationName = collation;
}
}
}
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 Schema ResolveSchema(SchemaExtractionResult model, string mappingDatabase, string mappingSchema)
{
var sampleNameNode = GetNodeName(mappingDatabase, mappingSchema, "sample");
return(Resolve(model, sampleNameNode).Schema);
}
public abstract MappingResolveResult Resolve(SchemaExtractionResult model, string nodeName);
public static ModelMapping Build(HandlerAccessor handlers, SchemaExtractionResult sqlModel, MappingResolver resolver, NodeConfiguration nodeConfiguration, bool isLegacy)
{
var domainModel = handlers.Domain.Model;
var configuration = handlers.Domain.Configuration;
var providerInfo = handlers.ProviderInfo;
var mapping = new ModelMapping();
// Register persistent types
var typesToProcess = domainModel.Types.AsEnumerable();
if (isLegacy || configuration.IsMultidatabase)
{
typesToProcess = typesToProcess.Where(t => !t.IsSystem);
}
foreach (var type in typesToProcess)
{
var primaryIndex = type.Indexes.FindFirst(IndexAttributes.Real | IndexAttributes.Primary);
if (primaryIndex == null || primaryIndex.IsAbstract)
{
continue;
}
var reflectedType = primaryIndex.ReflectedType;
var nodeName = resolver.GetNodeName(reflectedType);
var storageTable = resolver.Resolve(sqlModel, nodeName).GetTable();
if (storageTable == null)
{
throw new DomainBuilderException(String.Format(Strings.ExTableXIsNotFound, nodeName));
}
mapping.Register(reflectedType, storageTable);
}
// Register key generators
var keyGenerator = domainModel.Hierarchies
.Select(h => h.Key.Sequence)
.Where(s => s != null)
.Distinct();
Func <MappingResolveResult, SchemaNode> nodeResolver;
if (providerInfo.Supports(ProviderFeatures.Sequences))
{
nodeResolver = r => r.GetSequence();
}
else
{
nodeResolver = r => r.GetTable();
}
foreach (var sequence in keyGenerator)
{
var nodeResult = resolver.Resolve(sqlModel, resolver.GetNodeName(sequence));
var node = nodeResolver.Invoke(nodeResult);
mapping.Register(sequence, node);
}
// Fill information for TemporaryTableManager
var defaultSchema = resolver.ResolveSchema(sqlModel, configuration.DefaultDatabase, configuration.DefaultSchema);
if (configuration.ShareStorageSchemaOverNodes && handlers.ProviderInfo.Supports(ProviderFeatures.Multischema))
{
mapping.TemporaryTableDatabase = nodeConfiguration.GetActualNameFor(defaultSchema.Catalog);
mapping.TemporaryTableSchema = nodeConfiguration.GetActualNameFor(defaultSchema);
}
else
{
mapping.TemporaryTableDatabase = defaultSchema.Catalog.GetNameInternal();
mapping.TemporaryTableSchema = defaultSchema.GetNameInternal();
}
if (providerInfo.Supports(ProviderFeatures.Collations))
{
if (!string.IsNullOrEmpty(configuration.Collation))
{
// If user explicitly specified collation use that
mapping.TemporaryTableCollation = configuration.Collation;
}
else
{
// Otherwise use first available collation
var collation = defaultSchema.Collations.FirstOrDefault();
mapping.TemporaryTableCollation = collation != null ? collation.Name : null;
}
}
mapping.Lock();
return(mapping);
}
public void AddFinalResult(SchemaExtractionResult extractionResult)
{
finalResults.Add(extractionResult);
}
public void AddInitialResult(SchemaExtractionResult extractionResult)
{
initialResults.Add(extractionResult);
}
