// Constructors
public UpgradeHintsProcessor(
HandlerAccessor handlers,
MappingResolver resolver,
StoredDomainModel currentDomainModel,
StoredDomainModel extractedDomainModel,
StorageModel extractedStorageModel,
bool autoDetectTypesMovements)
{
ArgumentValidator.EnsureArgumentNotNull(handlers, "handlers");
ArgumentValidator.EnsureArgumentNotNull(resolver, "resolver");
ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, "currentDomainModel");
ArgumentValidator.EnsureArgumentNotNull(extractedDomainModel, "extractedDomainModel");
ArgumentValidator.EnsureArgumentNotNull(extractedStorageModel, "extractedStorageModel");
typeMapping = new Dictionary <StoredTypeInfo, StoredTypeInfo>();
reverseTypeMapping = new Dictionary <StoredTypeInfo, StoredTypeInfo>();
fieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>();
reverseFieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>();
this.resolver = resolver;
nameBuilder = handlers.NameBuilder;
domainModel = handlers.Domain.Model;
this.extractedStorageModel = extractedStorageModel;
currentModel = currentDomainModel;
currentTypes = currentModel.Types.ToDictionary(t => t.UnderlyingType);
extractedModel = extractedDomainModel;
extractedTypes = extractedModel.Types.ToDictionary(t => t.UnderlyingType);
this.autoDetectTypesMovements = autoDetectTypesMovements;
hints = new NativeTypeClassifier <UpgradeHint>(true);
suspiciousTypes = new List <StoredTypeInfo>();
}
private static MappingResolver MapFiles(string source, string target, string definitionFolder)
{
var definitionName = Path.GetFileNameWithoutExtension(source);
var definitionStore = DefinitionFactory.Open(definitionName, definitionFolder);
using (var sourceStream = File.OpenRead(source))
using (var targetStream = File.OpenRead(target))
{
var sourceAnalyzer = AnalyzerFactory.Create(sourceStream);
var targetAnalyzer = AnalyzerFactory.Create(targetStream);
var sourceType = definitionStore[sourceAnalyzer.LayoutHash];
var targetType = definitionStore[targetAnalyzer.LayoutHash];
if (sourceType == null)
{
return(null);
}
sourceAnalyzer = AnalyzerFactory.Create(sourceType, sourceStream);
if (targetType != null)
{
targetAnalyzer = AnalyzerFactory.Create(targetType, targetStream);
}
var resolver = new MappingResolver(definitionName, sourceAnalyzer, targetAnalyzer);
return(resolver);
}
}
private void BuildServices()
{
var services = context.Services;
var configuration = context.Configuration;
services.Configuration = configuration;
services.IndexFilterCompiler = new PartialIndexFilterCompiler();
if (context.ParentDomain == null)
{
var descriptor = ProviderDescriptor.Get(configuration.ConnectionInfo.Provider);
var driverFactory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
var handlerFactory = (HandlerFactory)Activator.CreateInstance(descriptor.HandlerFactory);
var driver = StorageDriver.Create(driverFactory, configuration);
services.HandlerFactory = handlerFactory;
services.StorageDriver = driver;
services.NameBuilder = new NameBuilder(configuration, driver.ProviderInfo);
}
else
{
var handlers = context.ParentDomain.Handlers;
services.HandlerFactory = handlers.Factory;
services.StorageDriver = handlers.StorageDriver;
services.NameBuilder = handlers.NameBuilder;
}
CreateConnection(services);
context.DefaultSchemaInfo = defaultSchemaInfo = services.StorageDriver.GetDefaultSchema(services.Connection);
services.MappingResolver = MappingResolver.Create(configuration, context.NodeConfiguration, defaultSchemaInfo);
BuildExternalServices(services, configuration);
services.Lock();
context.TypeIdProvider = new TypeIdProvider(context);
}
public override void OnComplete(Domain domain)
{
base.OnComplete(domain);
TargetStorageModel = UpgradeContext.TargetStorageModel;
MappingResolver = UpgradeContext.Services.MappingResolver;
}
public void SetUp()
{
_generator = new UniqueIdentifierGenerator();
_mappingResolver = new MappingResolver(new AttributeMappingSource().GetModel(typeof(DataContextTestClass)));
_unmappedInfo = _unmappedType.GetProperty("GUID");
new AttributeMappingSource().GetModel(typeof(DataContextTestClass));
}
public static Type GetPropType <T>(string propName)
{
Type DefaultType = typeof(string);
Type result = typeof(string);
Type entityType = typeof(T);
var map = MappingResolver.GetEntityMap(entityType);
if (map != null)
{
var cmi = map.PropertyMaps.FirstOrDefault(e => e.PropertyName == propName);
if (cmi != null)
{
result = cmi.PropertyType;
}
}
else
{
var pInfo = entityType.GetProperty(propName, BindFlags);
result = pInfo == null ? DefaultType : pInfo.PropertyType;
}
if (result.IsEnum)
{
result = Enum.GetUnderlyingType(result);
}
return(result);
}
// Constructors
public DomainModelConverter(
HandlerAccessor handlers,
ITypeIdProvider typeIdProvider,
PartialIndexFilterCompiler compiler,
MappingResolver resolver,
IFullTextCatalogNameBuilder fulltextCatalogNameBuilder,
bool isUpgradingStage)
{
ArgumentValidator.EnsureArgumentNotNull(handlers, "handlers");
ArgumentValidator.EnsureArgumentNotNull(typeIdProvider, "typeIdProvider");
ArgumentValidator.EnsureArgumentNotNull(compiler, "compiler");
ArgumentValidator.EnsureArgumentNotNull(resolver, "resolver");
this.handlers = handlers;
this.compiler = compiler;
this.typeIdProvider = typeIdProvider;
this.resolver = resolver;
this.isUpgradingStage = isUpgradingStage;
this.fulltextCatalogNameBuilder = fulltextCatalogNameBuilder;
sourceModel = handlers.Domain.Model;
configuration = handlers.Domain.Configuration;
providerInfo = handlers.ProviderInfo;
driver = handlers.StorageDriver;
nameBuilder = handlers.NameBuilder;
FieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>();
StorageModel = null;
CurrentModelTypes = new Dictionary <string, StoredTypeInfo>();
}
private void CreateAccessor()
{
var nodeConfiguration = new NodeConfiguration();
var configuration = DomainConfigurationFactory.Create();
var descriptor = ProviderDescriptor.Get(configuration.ConnectionInfo.Provider);
var driverFactory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
var storageDriver = StorageDriver.Create(driverFactory, configuration);
var nameBuilder = new NameBuilder(configuration, storageDriver.ProviderInfo);
var handlerFactory = (HandlerFactory)Activator.CreateInstance(descriptor.HandlerFactory);
var accessor = new UpgradeServiceAccessor {
Configuration = configuration,
StorageDriver = storageDriver,
NameBuilder = nameBuilder,
HandlerFactory = handlerFactory
};
configuration.Lock();
var connection = storageDriver.CreateConnection(null);
connection.Open();
accessor.MappingResolver = MappingResolver.Create(configuration, nodeConfiguration, storageDriver.GetDefaultSchema(connection));
if (storageDriver.ProviderInfo.Supports(ProviderFeatures.SingleConnection))
{
accessor.RegisterTemporaryResource(connection);
}
else
{
accessor.RegisterResource(connection);
}
accessor.Connection = connection;
accessor.Connection.Extensions.AddOne(new TypeDelegator(typeof(IProviderExecutor)));
this.accessor = accessor;
}
public void SetUp()
{
_generator = new UniqueIdentifierGenerator();
_mappingResolver = new MappingResolver (new AttributeMappingSource().GetModel (typeof (DataContextTestClass)));
_unmappedInfo = _unmappedType.GetProperty ("GUID");
new AttributeMappingSource().GetModel (typeof (DataContextTestClass));
}
// Constructors
/// <summary>
/// Creates instance of <see cref="IgnoreRuleCollection"/> handler
/// </summary>
/// <param name="model">Extracted model</param>
/// <param name="configuration">Configuration of domain</param>
public IgnoreRulesHandler(SchemaExtractionResult model, DomainConfiguration configuration, MappingResolver resolver)
{
ArgumentValidator.EnsureArgumentNotNull(model, "model");
ArgumentValidator.EnsureArgumentNotNull(configuration, "configuration");
targetModel = model;
ignoreRules = configuration.IgnoreRules;
mappingResolver = resolver;
}
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 MappingProvider(MappingResolver serviceAccessor)
{
MAPPING = new Dictionary <PaymentServiceConstants.PaymentMappingType, IMappingTransaction>()
{
{ PaymentServiceConstants.PaymentMappingType.Stripe_Succeeded, serviceAccessor(PaymentServiceConstants.PaymentMappingType.Stripe_Succeeded) },
{ PaymentServiceConstants.PaymentMappingType.Stripe_Refund, serviceAccessor(PaymentServiceConstants.PaymentMappingType.Stripe_Refund) },
{ PaymentServiceConstants.PaymentMappingType.Failed, serviceAccessor(PaymentServiceConstants.PaymentMappingType.Failed) },
};
}
public Catalog Clone(Catalog source, MappingResolver mappingResolver, string newCatalogName)
{
var newCatalog = new Catalog(newCatalogName);
var schemaMap = CloneSchemas(newCatalog, source, mappingResolver);
ClonePartitionFuctionsAndSchemas(newCatalog, source);
CloneSchemas(newCatalog, source, schemaMap);
return(newCatalog);
}
internal NodeExtractedModelBuilder(UpgradeServiceAccessor services, StorageNode defaultNode, NodeConfiguration buildingNodeConfiguration, bool defaultNodeIsUnreadable)
{
ArgumentValidator.EnsureArgumentNotNull(services, "services");
ArgumentValidator.EnsureArgumentNotNull(defaultNode, "defaultNode");
ArgumentValidator.EnsureArgumentNotNull(buildingNodeConfiguration, "buildingNodeConfiguration");
mappingResolver = services.MappingResolver;
this.buildingNodeConfiguration = buildingNodeConfiguration;
defaultStorageNode = defaultNode;
buildAsCopy = !defaultNodeIsUnreadable;
}
// Constructors
public SqlModelConverter(UpgradeServiceAccessor services, SchemaExtractionResult sourceModel,
IEnumerable <StoredPartialIndexFilterInfo> partialIndexes)
{
ArgumentValidator.EnsureArgumentNotNull(services, "handlers");
ArgumentValidator.EnsureArgumentNotNull(sourceModel, "sourceModel");
ArgumentValidator.EnsureArgumentNotNull(partialIndexes, "partialIndexes");
this.sourceModel = sourceModel;
resolver = services.MappingResolver;
providerInfo = services.ProviderInfo;
driver = services.StorageDriver;
partialIndexMap = new PartialIndexInfoMap(resolver, partialIndexes);
}
public override void SetUp()
{
base.SetUp();
_storageSpecificExpressionResolverStub = MockRepository.GenerateStub <IStorageSpecificExpressionResolver>();
_storageNameProviderStub = MockRepository.GenerateStub <IStorageNameProvider>();
_storageNameProviderStub.Stub(stub => stub.GetIDColumnName()).Return("ID");
_storageNameProviderStub.Stub(stub => stub.GetClassIDColumnName()).Return("ClassID");
_storageNameProviderStub.Stub(stub => stub.GetTimestampColumnName()).Return("Timestamp");
_resolver = new MappingResolver(_storageSpecificExpressionResolverStub);
_generator = new UniqueIdentifierGenerator();
_orderTable = new SqlTable(new ResolvedSimpleTableInfo(typeof(Order), "Order", "o"), JoinSemantics.Inner);
_fakeSimpleTableInfo = new ResolvedSimpleTableInfo(typeof(Order), "OrderTable", "o");
_fakeColumnDefinitionExpression = new SqlColumnDefinitionExpression(typeof(int), "o", "ColumnName", false);
_fakeJoinInfo = new ResolvedJoinInfo(_fakeSimpleTableInfo, Expression.Constant(true));
}
public static void UnSafeInit()
{
if (s_inited)
{
return;
}
var typeFinder = IocManager.Instance.Resolve <ITypeFinder>();
var entityTypes = typeFinder.FindAllEntity();
foreach (var type in entityTypes)
{
//缓存相关信息
MappingResolver.CreateEntityMap(type);
}
s_inited = true;
}
/// <summary>
/// 获取实体的主键字段
/// </summary>
/// <param name="entityType">实体类型</param>
/// <returns>主键字段</returns>
public static string GetPrimaryKeyField(Type entityType)
{
var map = MappingResolver.GetEntityMap(entityType);
if (map != null)
{
var colinfo = map.KeyMaps.First();
if (colinfo == null)
{
throw new ArgumentException(string.Format("实体{0}不存在主键字段", entityType.FullName));
}
return(colinfo.PropertyName);
}
else
{
throw new ArgumentException(string.Format("实体{0}不存在", entityType.FullName));
}
}
// Constructors
public UpgradeHintsProcessor(
HandlerAccessor handlers,
MappingResolver resolver,
StoredDomainModel currentDomainModel,
StoredDomainModel extractedDomainModel,
StorageModel extractedStorageModel,
bool autoDetectTypesMovements)
{
ArgumentValidator.EnsureArgumentNotNull(handlers, nameof(handlers));
ArgumentValidator.EnsureArgumentNotNull(resolver, nameof(resolver));
ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, nameof(currentDomainModel));
ArgumentValidator.EnsureArgumentNotNull(extractedDomainModel, nameof(extractedDomainModel));
ArgumentValidator.EnsureArgumentNotNull(extractedStorageModel, nameof(extractedStorageModel));
// since type mapping is intersection of current types and extracted types
// it will be equal or less than min size of these two sets
var typesCapacity = currentDomainModel.Types.Length > extractedDomainModel.Types.Length
? extractedDomainModel.Types.Length
: currentDomainModel.Types.Length;
// By setting capacity we eliminate resize work and memory fluctuations.
// In the worst case, when almost all types don't intersect, we will have some waste of memory
// but in real life this is very rare case.
typeMapping = new Dictionary <StoredTypeInfo, StoredTypeInfo>(typesCapacity);
reverseTypeMapping = new Dictionary <StoredTypeInfo, StoredTypeInfo>(typesCapacity);
fieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>();
reverseFieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>();
this.resolver = resolver;
nameBuilder = handlers.NameBuilder;
domainModel = handlers.Domain.Model;
this.extractedStorageModel = extractedStorageModel;
currentModel = currentDomainModel;
currentTypes = currentModel.Types.ToDictionary(t => t.UnderlyingType, StringComparer.Ordinal, currentModel.Types.Length);
extractedModel = extractedDomainModel;
extractedTypes = extractedModel.Types.ToDictionary(t => t.UnderlyingType, StringComparer.Ordinal, extractedModel.Types.Length);
this.autoDetectTypesMovements = autoDetectTypesMovements;
hints = new NativeTypeClassifier <UpgradeHint>(true);
suspiciousTypes = new HashSet <StoredTypeInfo>();
}
private void DropExistingSequences()
{
var configuration = BuildDomainConfiguration();
var sqlDriver = TestSqlDriver.Create(configuration.ConnectionInfo);
using (var connection = sqlDriver.CreateConnection()) {
connection.Open();
var defaultNodeConfiguration = new NodeConfiguration(WellKnown.DefaultNodeId)
{
UpgradeMode = configuration.UpgradeMode
};
var mappingResolver = MappingResolver.Create(configuration, defaultNodeConfiguration, sqlDriver.GetDefaultSchema(connection));
var extractionResult = sqlDriver.Extract(connection, mappingResolver.GetSchemaTasks());
var queryBatch = SqlDml.Batch();
extractionResult.Catalogs
.Where(c => c.GetDbNameInternal().In(GetUsedCatalogs()))
.SelectMany(x => x.Schemas)
.SelectMany(x => x.Sequences)
.Select(SqlDdl.Drop)
.ForEach(statement => queryBatch.Add(statement));
if (queryBatch.Count == 0)
{
return;
}
var compiledBatch = sqlDriver.Compile(queryBatch, new SqlCompilerConfiguration {
DatabaseQualifiedObjects = true
})
.GetCommandText();
if (string.IsNullOrWhiteSpace(compiledBatch))
{
return;
}
using (var cmd = connection.CreateCommand(compiledBatch)) {
_ = cmd.ExecuteNonQuery();
}
}
}
public PartialIndexInfoMap(MappingResolver resolver, IEnumerable <StoredPartialIndexFilterInfo> indexes)
{
ArgumentValidator.EnsureArgumentNotNull(resolver, "resolver");
ArgumentValidator.EnsureArgumentNotNull(indexes, "indexes");
items = new Dictionary <string, Dictionary <string, StoredPartialIndexFilterInfo> >(Comparer);
foreach (var index in indexes)
{
var tableName = resolver.GetNodeName(index.Database, index.Schema, index.Table);
Dictionary <string, StoredPartialIndexFilterInfo> indexesForTable;
if (!items.TryGetValue(tableName, out indexesForTable))
{
indexesForTable = new Dictionary <string, StoredPartialIndexFilterInfo>(Comparer);
items.Add(tableName, indexesForTable);
}
indexesForTable.Add(index.Name, index);
}
}
// Constructors
public HintGenerator(Dictionary <StoredTypeInfo, StoredTypeInfo> typeMapping,
Dictionary <StoredTypeInfo, StoredTypeInfo> reverseTypeMapping,
Dictionary <StoredFieldInfo, StoredFieldInfo> fieldMapping,
NativeTypeClassifier <UpgradeHint> hints,
HandlerAccessor handlers,
MappingResolver resolver,
StorageModel extractedStorageModel,
StoredDomainModel currentDomainModel,
StoredDomainModel extractedDomainModel)
{
ArgumentValidator.EnsureArgumentNotNull(typeMapping, "typeMapping");
ArgumentValidator.EnsureArgumentNotNull(reverseTypeMapping, "reverseTypeMapping");
ArgumentValidator.EnsureArgumentNotNull(fieldMapping, "fieldMapping");
ArgumentValidator.EnsureArgumentNotNull(hints, "hints");
ArgumentValidator.EnsureArgumentNotNull(handlers, "handlers");
ArgumentValidator.EnsureArgumentNotNull(resolver, "resolver");
ArgumentValidator.EnsureArgumentNotNull(extractedStorageModel, "extractedStorageModel");
ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, "currentDomainModel");
ArgumentValidator.EnsureArgumentNotNull(extractedDomainModel, "extractedDomainModel");
this.typeMapping = typeMapping;
this.reverseTypeMapping = reverseTypeMapping;
this.fieldMapping = fieldMapping;
this.hints = hints;
extractedModelFields = new Dictionary <StoredTypeInfo, StoredFieldInfo[]>();
this.extractedStorageModel = extractedStorageModel;
this.resolver = resolver;
nameBuilder = handlers.NameBuilder;
currentModel = currentDomainModel;
currentModel.UpdateReferences();
extractedModel = extractedDomainModel;
foreach (var type in extractedModel.Types)
{
extractedModelFields.Add(type, type.Fields.Flatten(f => f.Fields, null, true).ToArray());
}
}
private async ValueTask BuildServices(bool isAsync, CancellationToken token = default)
{
var services = context.Services;
var configuration = context.Configuration;
services.Configuration = configuration;
services.IndexFilterCompiler = new PartialIndexFilterCompiler();
if (context.ParentDomain == null)
{
var descriptor = ProviderDescriptor.Get(configuration.ConnectionInfo.Provider);
var driverFactory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
var handlerFactory = (HandlerFactory)Activator.CreateInstance(descriptor.HandlerFactory);
var driver = isAsync
? await StorageDriver.CreateAsync(driverFactory, configuration, token).ConfigureAwait(false)
: StorageDriver.Create(driverFactory, configuration);
services.HandlerFactory = handlerFactory;
services.StorageDriver = driver;
services.NameBuilder = new NameBuilder(configuration, driver.ProviderInfo);
}
else
{
var handlers = context.ParentDomain.Handlers;
services.HandlerFactory = handlers.Factory;
services.StorageDriver = handlers.StorageDriver;
services.NameBuilder = handlers.NameBuilder;
}
await CreateConnection(services, isAsync, token).ConfigureAwait(false);
context.DefaultSchemaInfo = defaultSchemaInfo = isAsync
? await services.StorageDriver.GetDefaultSchemaAsync(services.Connection, token).ConfigureAwait(false)
: services.StorageDriver.GetDefaultSchema(services.Connection);
services.MappingResolver = MappingResolver.Create(configuration, context.NodeConfiguration, defaultSchemaInfo);
BuildExternalServices(services, configuration);
services.Lock();
context.TypeIdProvider = new TypeIdProvider(context);
}
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 RelinqNorthwindDataProvider()
{
_manager = new NorthwindConnectionManager();
_context = new NorthwindDataContext(_manager.GetConnectionString());
_resolver = new MappingResolver(_context.Mapping);
_retriever = new QueryResultRetriever(_manager, _resolver);
_resultOperatorHandlerRegistry = ResultOperatorHandlerRegistry.CreateDefault();
var methodBasedTransformerRegistry = MethodInfoBasedMethodCallTransformerRegistry.CreateDefault();
var nameBasedTransformerRegistry = NameBasedMethodCallTransformerRegistry.CreateDefault();
_methodCallTransformerProvider = new CompoundMethodCallTransformerProvider(methodBasedTransformerRegistry, nameBasedTransformerRegistry);
methodBasedTransformerRegistry.Register(
typeof(SqlMethods).GetMethod("Like", new[] { typeof(string), typeof(string) }),
new LikeMethodCallTransformer());
methodBasedTransformerRegistry.Register(DateDiffDayMethodCallTransformer.SupportedMethods, new DateDiffDayMethodCallTransformer());
foreach (var userDefinedFunction in _context.GetType().GetMethods().Where(mi => mi.IsDefined(typeof(FunctionAttribute), false)))
{
methodBasedTransformerRegistry.Register(userDefinedFunction, new UserDefinedFunctionTransformer());
}
var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
customNodeTypeRegistry.Register(new[] { typeof(EntitySet <>).GetMethod("Contains") }, typeof(ContainsExpressionNode));
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(customNodeTypeRegistry);
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
_queryParser = new QueryParser(expressionTreeParser);
_executor = new QueryExecutor(_resolver, _retriever, _resultOperatorHandlerRegistry, _methodCallTransformerProvider, false);
}
// Constructors
public HintGenerator(UpgradeHintsProcessingResult hintsProcessingResult,
HandlerAccessor handlers,
MappingResolver resolver,
StorageModel extractedStorageModel,
StoredDomainModel currentDomainModel,
StoredDomainModel extractedDomainModel)
{
ArgumentValidator.EnsureArgumentNotNull(hintsProcessingResult, nameof(hintsProcessingResult));
ArgumentValidator.EnsureArgumentNotNull(handlers, nameof(handlers));
ArgumentValidator.EnsureArgumentNotNull(resolver, nameof(resolver));
ArgumentValidator.EnsureArgumentNotNull(extractedStorageModel, nameof(extractedStorageModel));
ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, nameof(currentDomainModel));
ArgumentValidator.EnsureArgumentNotNull(extractedDomainModel, nameof(extractedDomainModel));
typeMapping = hintsProcessingResult.TypeMapping;
reverseTypeMapping = hintsProcessingResult.ReverseTypeMapping;
fieldMapping = hintsProcessingResult.FieldMapping;
hints = hintsProcessingResult.Hints;
suspiciousTypes = hintsProcessingResult.SuspiciousTypes;
currentNonConnectorTypes = hintsProcessingResult.CurrentNonConnectorTypes;
extractedNonConnectorTypes = hintsProcessingResult.ExtractedNonConnectorTypes;
this.extractedStorageModel = extractedStorageModel;
this.resolver = resolver;
nameBuilder = handlers.NameBuilder;
currentModel = currentDomainModel;
currentModel.UpdateReferences();
extractedModelFields = new Dictionary <StoredTypeInfo, StoredFieldInfo[]>();
extractedModel = extractedDomainModel;
foreach (var type in extractedModel.Types)
{
extractedModelFields.Add(type, type.Fields.Flatten(f => f.Fields, null, true).ToArray());
}
}
private Dictionary <string, string> CloneSchemas(Catalog newCatalog, Catalog sourceCatalog, MappingResolver mappingResolver)
{
var schemaMap = new Dictionary <string, string>();
foreach (var schema in sourceCatalog.Schemas)
{
var complexName = mappingResolver.GetNodeName(newCatalog.Name, schema.Name, "Dummy");
var names = complexName.Split(NameElementSeparator);
var schemaName = schema.Name;
switch (names.Length)
{
case 3:
schemaName = names[1];
break;
case 2:
schemaName = names[0];
break;
}
schemaMap.Add(schema.Name, schemaName);
}
return(schemaMap);
}
public ModelToSqlExpressionHelper()
{
_mapper = MappingResolver.ResolveMapperByType(typeof(T));
}
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 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));
}
}
}
private void MapFiles(object sender, EventArgs e)
{
if (_sourceFileAnalyzer == null || _targetFileAnalyzer == null)
{
return;
}
var sourceFile = Path.GetFileNameWithoutExtension(_sourceFile);
var targetFile = Path.GetFileNameWithoutExtension(_targetFile);
if (sourceFile != targetFile)
{
return;
}
targetGridView.Rows.Clear();
var mappingResolver = new MappingResolver(sourceFile, _sourceFileAnalyzer, _targetFileAnalyzer);
foreach (var mapping in mappingResolver)
{
var dataRow = new DataGridViewRow();
var dataType = (mapping.Key as PropertyInfo)?.PropertyType;
if (dataType == null)
{
throw new InvalidOperationException("unreachable");
}
var arraySize = 0;
if (dataType.IsArray)
{
dataType = dataType.GetElementType();
arraySize = mapping.Key.GetCustomAttribute <CardinalityAttribute>().SizeConst;
}
var isIndex = mapping.Key.IsDefined(typeof(IndexAttribute), false);
if (mapping.Value.From == null)
{
dataRow.Cells.Add(new DataGridViewTextBoxCell {
Value = mapping.Key.Name
});
dataRow.Cells.Add(new DataGridViewTextBoxCell {
Value = dataType.ToAlias()
});
dataRow.Cells.Add(new DataGridViewTextBoxCell {
Value = arraySize == 0 ? "" : arraySize.ToString()
});
dataRow.Cells.Add(new DataGridViewCheckBoxCell {
Value = isIndex
});
}
else
{
dataRow.Cells.Add(new DataGridViewTextBoxCell {
Value = mapping.Value.From.Name
});
dataRow.Cells.Add(new DataGridViewTextBoxCell {
Value = dataType.ToAlias()
});
dataRow.Cells.Add(new DataGridViewTextBoxCell {
Value = arraySize == 0 ? "" : arraySize.ToString()
});
dataRow.Cells.Add(new DataGridViewCheckBoxCell {
Value = isIndex
});
}
targetGridView.Rows.Add(dataRow);
_targetFileAnalyzer.RecordType = mappingResolver.Type;
}
Console.WriteLine("Mapped");
}
