public void Does_non_key_SQL_Server_fixed_length_binary_mapping()
{
var property = CreateEntityType().AddProperty("MyBinaryProp", typeof(byte[]));
property.Relational().ColumnType = "binary(100)";
var typeMapping = new SqlServerTypeMapper().GetMapping(property);
Assert.Equal(DbType.Binary, typeMapping.DbType);
Assert.Equal("binary(100)", typeMapping.StoreType);
}
public void Does_not_do_rowversion_mapping_for_non_computed_concurrency_tokens()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(byte[]));
property.IsConcurrencyToken = true;
var typeMapping = new SqlServerTypeMapper(new RelationalTypeMapperDependencies()).GetMapping(property);
Assert.Equal(DbType.Binary, typeMapping.DbType);
Assert.Equal("varbinary(max)", typeMapping.StoreType);
}
private static IReadOnlyList <MigrationOperation> Process(
MigrationOperationCollection operations, IModel sourceModel, IModel targetModel = null)
{
var extensionProvider = new SqlServerMetadataExtensionProvider();
var typeMapper = new SqlServerTypeMapper();
var operationFactory = new SqlServerMigrationOperationFactory(extensionProvider);
var operationProcessor = new SqlServerMigrationOperationProcessor(
extensionProvider, typeMapper, operationFactory);
return(operationProcessor.Process(operations, sourceModel, targetModel ?? new Model()));
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public static ConventionSet Build()
{
var sqlServerTypeMapper = new SqlServerTypeMapper(new RelationalTypeMapperDependencies());
return(new SqlServerConventionSetBuilder(
new RelationalConventionSetBuilderDependencies(sqlServerTypeMapper, null, null),
new SqlServerSqlGenerationHelper(new RelationalSqlGenerationHelperDependencies()))
.AddConventions(
new CoreConventionSetBuilder(
new CoreConventionSetBuilderDependencies(sqlServerTypeMapper))
.CreateConventionSet()));
}
private static IReadOnlyList <MigrationOperation> Diff(IModel sourceModel, IModel targetModel)
{
var extensionProvider = new SqlServerMetadataExtensionProvider();
var typeMapper = new SqlServerTypeMapper();
var operationFactory = new SqlServerMigrationOperationFactory(extensionProvider);
var operationProcessor = new SqlServerMigrationOperationProcessor(
extensionProvider, typeMapper, operationFactory);
var modelDiffer = new SqlServerModelDiffer(
extensionProvider, typeMapper, operationFactory, operationProcessor);
return(modelDiffer.Diff(sourceModel, targetModel));
}
public void Binary_key_with_max_length_is_picked_up_by_FK()
{
var model = CreateModel();
var mapper = new SqlServerTypeMapper(new RelationalTypeMapperDependencies());
Assert.Equal(
"varbinary(100)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType2)).FindProperty("Id")).StoreType);
Assert.Equal(
"varbinary(100)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType3)).FindProperty("Relationship1Id")).StoreType);
}
public void Does_key_SQL_Server_binary_mapping()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(byte[]));
property.IsNullable = false;
property.DeclaringEntityType.SetPrimaryKey(property);
var typeMapping = new SqlServerTypeMapper(new RelationalTypeMapperDependencies()).GetMapping(property);
Assert.Equal(DbType.Binary, typeMapping.DbType);
Assert.Equal("varbinary(900)", typeMapping.StoreType);
Assert.Equal(900, typeMapping.CreateParameter(new TestCommand(), "Name", new byte[3]).Size);
}
public void String_FK_max_length_is_preferred_if_specified()
{
var model = CreateModel();
var mapper = new SqlServerTypeMapper();
Assert.Equal(
"nvarchar(200)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType1)).FindProperty("Id")).StoreType);
Assert.Equal(
"nvarchar(787)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType2)).FindProperty("Relationship2Id")).StoreType);
}
public void Does_indexed_column_SQL_Server_string_mapping()
{
var entityType = CreateEntityType();
var property = entityType.AddProperty("MyProp", typeof(string));
entityType.AddIndex(property);
var typeMapping = new SqlServerTypeMapper().GetMapping(property);
Assert.Null(typeMapping.StoreType);
Assert.Equal("nvarchar(450)", typeMapping.DefaultTypeName);
Assert.Equal(4000, typeMapping.CreateParameter(new TestCommand(), "Name", "Value").Size);
}
public void String_key_with_unicode_is_picked_up_by_FK()
{
var model = CreateModel();
var mapper = new SqlServerTypeMapper(new RelationalTypeMapperDependencies());
Assert.Equal(
"varchar(900)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType3)).FindProperty("Id")).StoreType);
Assert.Equal(
"varchar(900)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType4)).FindProperty("Relationship1Id")).StoreType);
}
public void Key_store_type_if_preferred_if_specified()
{
var model = CreateModel();
var mapper = new SqlServerTypeMapper(new RelationalTypeMapperDependencies());
Assert.Equal(
"money",
mapper.FindMapping(model.FindEntityType(typeof(MyType)).FindProperty("Id")).StoreType);
Assert.Equal(
"dec",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType1)).FindProperty("Relationship2Id")).StoreType);
}
public void Binary_FK_max_length_is_preferred_if_specified()
{
var model = CreateModel();
var mapper = new SqlServerTypeMapper(new RelationalTypeMapperDependencies());
Assert.Equal(
"varbinary(100)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType2)).FindProperty("Id")).StoreType);
Assert.Equal(
"varbinary(767)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType3)).FindProperty("Relationship2Id")).StoreType);
}
public void Key_with_store_type_is_picked_up_by_FK()
{
var model = CreateModel();
var mapper = new SqlServerTypeMapper(new RelationalTypeMapperDependencies());
Assert.Equal(
"money",
mapper.FindMapping(model.FindEntityType(typeof(MyType)).FindProperty("Id")).StoreType);
Assert.Equal(
"money",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType1)).FindProperty("Relationship1Id")).StoreType);
}
public void String_key_with_max_length_is_picked_up_by_FK()
{
var model = CreateModel();
var mapper = new SqlServerTypeMapper();
Assert.Equal(
"nvarchar(200)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType1)).FindProperty("Id")).StoreType);
Assert.Equal(
"nvarchar(200)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType2)).FindProperty("Relationship1Id")).StoreType);
}
public void Does_key_SQL_Server_string_mapping()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(string));
property.IsNullable = false;
property.DeclaringEntityType.SetPrimaryKey(property);
var typeMapping = new SqlServerTypeMapper().GetMapping(property);
Assert.Null(typeMapping.StoreType);
Assert.Equal("nvarchar(450)", typeMapping.DefaultTypeName);
Assert.Equal(4000, typeMapping.CreateParameter(new TestCommand(), "Name", "Value").Size);
}
public void String_FK_unicode_is_preferred_if_specified()
{
var model = CreateModel();
var mapper = new SqlServerTypeMapper(new RelationalTypeMapperDependencies());
Assert.Equal(
"varchar(900)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType3)).FindProperty("Id")).StoreType);
Assert.Equal(
"nvarchar(450)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType4)).FindProperty("Relationship2Id")).StoreType);
}
public void Does_key_SQL_Server_binary_mapping()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(byte[]), shadowProperty: true);
property.DeclaringEntityType.SetPrimaryKey(property);
property.IsNullable = false;
var typeMapping = new SqlServerTypeMapper().MapPropertyType(property);
Assert.Equal(DbType.Binary, typeMapping.StoreType);
Assert.Equal("varbinary(900)", typeMapping.DefaultTypeName);
Assert.Equal(8000, typeMapping.CreateParameter(new TestCommand(), "Name", new byte[3]).Size);
}
public void Does_indexed_column_SQL_Server_binary_mapping()
{
var entityType = CreateEntityType();
var property = entityType.AddProperty("MyProp", typeof(byte[]));
entityType.AddIndex(property);
var typeMapping = new SqlServerTypeMapper(new RelationalTypeMapperDependencies()).GetMapping(property);
Assert.Equal(DbType.Binary, typeMapping.DbType);
Assert.Equal("varbinary(900)", typeMapping.StoreType);
Assert.Equal(900, typeMapping.CreateParameter(new TestCommand(), "Name", "Value").Size);
}
public void Does_foreign_key_SQL_Server_string_mapping()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(string), shadowProperty: true);
var fkProperty = property.DeclaringEntityType.AddProperty("FK", typeof(string), shadowProperty: true);
var pk = property.DeclaringEntityType.SetPrimaryKey(property);
property.DeclaringEntityType.AddForeignKey(fkProperty, pk, property.DeclaringEntityType);
var typeMapping = new SqlServerTypeMapper().MapPropertyType(fkProperty);
Assert.Null(typeMapping.StoreType);
Assert.Equal("nvarchar(450)", typeMapping.DefaultTypeName);
Assert.Equal(4000, typeMapping.CreateParameter(new TestCommand(), "Name", "Value").Size);
}
public void Does_foreign_key_SQL_Server_binary_mapping()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(byte[]));
var fkProperty = property.DeclaringEntityType.AddProperty("FK", typeof(byte[]));
var pk = property.DeclaringEntityType.SetPrimaryKey(property);
property.DeclaringEntityType.AddForeignKey(fkProperty, pk, property.DeclaringEntityType);
var typeMapping = new SqlServerTypeMapper().GetMapping(fkProperty);
Assert.Equal(DbType.Binary, typeMapping.StoreType);
Assert.Equal("varbinary(900)", typeMapping.DefaultTypeName);
Assert.Equal(8000, typeMapping.CreateParameter(new TestCommand(), "Name", new byte[3]).Size);
}
public void Does_non_key_SQL_Server_rowversion_mapping()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(byte[]));
property.IsConcurrencyToken = true;
property.ValueGenerated = ValueGenerated.OnAddOrUpdate;
var typeMapping = new SqlServerTypeMapper(new RelationalTypeMapperDependencies()).GetMapping(property);
Assert.Equal(DbType.Binary, typeMapping.DbType);
Assert.Equal("rowversion", typeMapping.StoreType);
Assert.Equal(8, typeMapping.Size);
Assert.Equal(8, typeMapping.CreateParameter(new TestCommand(), "Name", new byte[8]).Size);
}
public void Does_indexed_column_SQL_Server_string_mapping_ansi()
{
var entityType = CreateEntityType();
var property = entityType.AddProperty("MyProp", typeof(string));
property.IsUnicode(false);
entityType.AddIndex(property);
var typeMapping = new SqlServerTypeMapper(new RelationalTypeMapperDependencies()).GetMapping(property);
Assert.Equal(DbType.AnsiString, typeMapping.DbType);
Assert.Equal("varchar(900)", typeMapping.StoreType);
Assert.Equal(900, typeMapping.Size);
Assert.False(typeMapping.IsUnicode);
Assert.Equal(900, typeMapping.CreateParameter(new TestCommand(), "Name", "Value").Size);
}
public void Does_key_SQL_Server_string_mapping_ansi()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(string));
property.IsNullable = false;
property.IsUnicode(false);
property.DeclaringEntityType.SetPrimaryKey(property);
var typeMapping = new SqlServerTypeMapper(new RelationalTypeMapperDependencies()).GetMapping(property);
Assert.Equal(DbType.AnsiString, typeMapping.DbType);
Assert.Equal("varchar(900)", typeMapping.StoreType);
Assert.Equal(900, typeMapping.Size);
Assert.False(typeMapping.IsUnicode);
Assert.Equal(900, typeMapping.CreateParameter(new TestCommand(), "Name", "Value").Size);
}
public void Does_foreign_key_SQL_Server_string_mapping()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(string));
property.IsNullable = false;
var fkProperty = property.DeclaringEntityType.AddProperty("FK", typeof(string));
var pk = property.DeclaringEntityType.SetPrimaryKey(property);
property.DeclaringEntityType.AddForeignKey(fkProperty, pk, property.DeclaringEntityType);
var typeMapping = new SqlServerTypeMapper().GetMapping(fkProperty);
Assert.Null(typeMapping.DbType);
Assert.Equal("nvarchar(450)", typeMapping.StoreType);
Assert.Equal(450, typeMapping.Size);
Assert.True(typeMapping.IsUnicode);
Assert.Equal(450, typeMapping.CreateParameter(new TestCommand(), "Name", "Value").Size);
}
public void Does_indexed_column_SQL_Server_string_mapping(bool?unicode)
{
var entityType = CreateEntityType();
var property = entityType.AddProperty("MyProp", typeof(string));
property.IsUnicode(unicode);
entityType.AddIndex(property);
var typeMapping = new SqlServerTypeMapper(
new CoreTypeMapperDependencies(),
new RelationalTypeMapperDependencies()).GetMapping(property);
Assert.Null(typeMapping.DbType);
Assert.Equal("nvarchar(450)", typeMapping.StoreType);
Assert.Equal(450, typeMapping.Size);
Assert.True(typeMapping.IsUnicode);
Assert.Equal(450, typeMapping.CreateParameter(new TestCommand(), "Name", "Value").Size);
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public static ConventionSet Build()
{
var sqlServerTypeMapper = new SqlServerTypeMapper(
new CoreTypeMapperDependencies(
new ValueConverterSelector(
new ValueConverterSelectorDependencies())),
new RelationalTypeMapperDependencies());
return(new SqlServerConventionSetBuilder(
new RelationalConventionSetBuilderDependencies(sqlServerTypeMapper, null, null),
new SqlServerSqlGenerationHelper(new RelationalSqlGenerationHelperDependencies()))
.AddConventions(
new CoreConventionSetBuilder(
new CoreConventionSetBuilderDependencies(
sqlServerTypeMapper,
new ConstructorBindingFactory()))
.CreateConventionSet()));
}
private static IHistoryRepository CreateHistoryRepository(string schema = null)
{
var annotationsProvider = new SqlServerAnnotationProvider();
var sqlGenerator = new SqlServerSqlGenerationHelper(new RelationalSqlGenerationHelperDependencies());
var typeMapper = new SqlServerTypeMapper(new RelationalTypeMapperDependencies());
var commandBuilderFactory = new RelationalCommandBuilderFactory(
new FakeSensitiveDataLogger <RelationalCommandBuilderFactory>(),
new DiagnosticListener("Fake"),
typeMapper);
return(new SqlServerHistoryRepository(
new HistoryRepositoryDependencies(
Mock.Of <IRelationalDatabaseCreator>(),
Mock.Of <IRawSqlCommandBuilder>(),
Mock.Of <ISqlServerConnection>(),
new DbContextOptions <DbContext>(
new Dictionary <Type, IDbContextOptionsExtension>
{
{
typeof(SqlServerOptionsExtension),
new SqlServerOptionsExtension {
MigrationsHistoryTableSchema = schema
}
}
}),
new MigrationsModelDiffer(
new SqlServerTypeMapper(new RelationalTypeMapperDependencies()),
annotationsProvider,
new SqlServerMigrationsAnnotationProvider(new MigrationsAnnotationProviderDependencies())),
new SqlServerMigrationsSqlGenerator(
new MigrationsSqlGeneratorDependencies(
commandBuilderFactory,
new SqlServerSqlGenerationHelper(new RelationalSqlGenerationHelperDependencies()),
typeMapper,
annotationsProvider),
new SqlServerMigrationsAnnotationProvider(new MigrationsAnnotationProviderDependencies())),
annotationsProvider,
sqlGenerator)));
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public static ConventionSet Build()
{
var coreTypeMapperDependencies = new CoreTypeMapperDependencies(
new ValueConverterSelector(
new ValueConverterSelectorDependencies()));
var sqlServerTypeMapper = new SqlServerTypeMapper(
new RelationalTypeMapperDependencies());
var convertingTypeMapper = new FallbackRelationalCoreTypeMapper(
coreTypeMapperDependencies,
new RelationalTypeMapperDependencies(),
sqlServerTypeMapper);
return(new SqlServerConventionSetBuilder(
new RelationalConventionSetBuilderDependencies(convertingTypeMapper, null, null, null),
new SqlServerSqlGenerationHelper(new RelationalSqlGenerationHelperDependencies()))
.AddConventions(
new CoreConventionSetBuilder(
new CoreConventionSetBuilderDependencies(convertingTypeMapper, null, null))
.CreateConventionSet()));
}
public static void Generate(this DbContext @context, Union <StringBuilder, StreamWriter> writer)
{
var sqlMapper = new SqlServerTypeMapper(new RelationalTypeMapperDependencies());
var entries = context.ChangeTracker.Entries();
var addedEntities = (from ent in entries
where ent.State == EntityState.Added
select ent);
var updatedEntities = (from ent in entries
where ent.State == EntityState.Modified
select ent);
var deletedEntities = (from ent in entries
where ent.State == EntityState.Deleted
select ent);
GenerateInserts(writer, context, addedEntities, sqlMapper);
GenerateUpdates(writer, context, updatedEntities, sqlMapper);
GenerateDeletes(writer, context, deletedEntities, sqlMapper);
}
private static void GenerateInserts(Union <StringBuilder, StreamWriter> sBuilder, DbContext context, IEnumerable <EntityEntry> entries, SqlServerTypeMapper mapper)
{
foreach (var entry in entries)
{
var tableName = GetTableName(entry.Entity.GetType(), context);
var lastProperty = entry.Properties.Last();
sBuilder.Append("EXECUTE sp_executesql N'INSERT INTO ");
sBuilder.Append(tableName);
sBuilder.Append(" ");
sBuilder.Append("(");
//We'll need this list later to add only the necesary parameters in order
var handledProperties = GetPropertiesToHandle(entry);
foreach (var prop in entry.Properties)
{
//Skip identity columnns and other generated values
if (prop.Metadata.ValueGenerated == Microsoft.EntityFrameworkCore.Metadata.ValueGenerated.OnAdd)
{
continue;
}
GenerateColumnName(sBuilder, prop);
sBuilder.Append((prop.Metadata.Name != lastProperty.Metadata.Name) ? ", ": "");
handledProperties.Add(prop);
}
sBuilder.Append(") VALUES (");
var handledPropertyCount = handledProperties.Count();
for (var i = 0; i < handledPropertyCount; i++)
{
var prop = handledProperties[i];
sBuilder.Append(GenerateParameterName(i));
sBuilder.Append((i != (handledPropertyCount - 1)) ? "," : "");
}
sBuilder.Append(")'");
//Generate Parameters
sBuilder.Append(", N'");
GenerateParameters(sBuilder, handledProperties, handledPropertyCount);
sBuilder.Append(";");
}
}
public void Does_non_key_SQL_Server_byteArray_mapping()
{
var typeMapping = new SqlServerTypeMapper()
.GetTypeMapping(null, "MyColumn", typeof(byte[]), isKey: false, isConcurrencyToken: false);
Assert.Equal(DbType.Binary, typeMapping.StoreType);
Assert.Equal("varbinary(max)", typeMapping.StoreTypeName);
}
public void Does_non_key_SQL_Server_string_mapping()
{
var typeMapping = new SqlServerTypeMapper()
.GetTypeMapping(null, "MyColumn", typeof(string), isKey: false, isConcurrencyToken: false);
Assert.Equal(DbType.String, typeMapping.StoreType);
Assert.Equal("nvarchar(max)", typeMapping.StoreTypeName);
}
public void Does_required_foreign_key_SQL_Server_string_mapping()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(string), shadowProperty: true);
var fkProperty = property.DeclaringEntityType.AddProperty("FK", typeof(string), shadowProperty: true);
var pk = property.DeclaringEntityType.SetPrimaryKey(property);
property.DeclaringEntityType.AddForeignKey(fkProperty, pk, property.DeclaringEntityType);
fkProperty.IsNullable = false;
var typeMapping = new SqlServerTypeMapper().MapPropertyType(fkProperty);
Assert.Null(typeMapping.StoreType);
Assert.Equal("nvarchar(450)", typeMapping.DefaultTypeName);
Assert.Equal(4000, typeMapping.CreateParameter(new TestCommand(), "Name", "Value").Size);
}
public void Does_required_foreign_key_SQL_Server_binary_mapping()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(byte[]), shadowProperty: true);
var fkProperty = property.DeclaringEntityType.AddProperty("FK", typeof(byte[]), shadowProperty: true);
var pk = property.DeclaringEntityType.SetPrimaryKey(property);
property.DeclaringEntityType.AddForeignKey(fkProperty, pk, property.DeclaringEntityType);
fkProperty.IsNullable = false;
var typeMapping = new SqlServerTypeMapper().MapPropertyType(fkProperty);
Assert.Equal(DbType.Binary, typeMapping.StoreType);
Assert.Equal("varbinary(900)", typeMapping.DefaultTypeName);
Assert.Equal(8000, typeMapping.CreateParameter(new TestCommand(), "Name", new byte[3]).Size);
}
