public void GenerateFluentApi_identity_sequence_options()
{
var generator = new NpgsqlAnnotationCodeGenerator(new AnnotationCodeGeneratorDependencies());
var modelBuilder = new ModelBuilder(NpgsqlConventionSetBuilder.Build());
modelBuilder.Entity(
"Post",
x =>
{
x.Property <int>("Id")
.UseIdentityByDefaultColumn()
.HasIdentityOptions(
startValue: 5,
incrementBy: 2,
minValue: 3,
maxValue: 2000,
isCyclic: true,
numbersToCache: 10);
});
var property = modelBuilder.Model.FindEntityType("Post").GetProperties()
.Single(p => p.Name == "Id");
var annotation = property.FindAnnotation(NpgsqlAnnotationNames.IdentityOptions);
Assert.False(generator.IsHandledByConvention(property, annotation));
var result = generator.GenerateFluentApi(property, annotation);
Assert.Equal(nameof(NpgsqlPropertyBuilderExtensions.HasIdentityOptions), result.Method);
Assert.Equal(5L, result.Arguments[0]);
Assert.Equal(2L, result.Arguments[1]);
Assert.Equal(3L, result.Arguments[2]);
Assert.Equal(2000L, result.Arguments[3]);
Assert.Equal(true, result.Arguments[4]);
Assert.Equal(10L, result.Arguments[5]);
}
private static DbCompiledModelInfo BuildDbCompiledModelInfo(string nameOrConStr, DatabaseType dbType)
{
lock (_buildCompiledModelLock)
{
ConventionSet conventionSet = null;
switch (dbType)
{
case DatabaseType.SqlServer: conventionSet = SqlServerConventionSetBuilder.Build(); break;
case DatabaseType.MySql: conventionSet = MySqlConventionSetBuilder.Build(); break;
case DatabaseType.PostgreSql: conventionSet = NpgsqlConventionSetBuilder.Build(); break;
case DatabaseType.Oracle: conventionSet = OracleConventionSetBuilder.Build(); break;
default: throw new Exception("暂不支持该数据库!");
}
ModelBuilder modelBuilder = new ModelBuilder(conventionSet);
_modelTypeMap.Values.ForEach(x =>
{
modelBuilder.Model.AddEntityType(x);
});
DbCompiledModelInfo newInfo = new DbCompiledModelInfo
{
ConStr = nameOrConStr,
DatabaseType = dbType,
Model = modelBuilder.FinalizeModel()
};
return(newInfo);
}
}
private static IModel BuildDbCompiledModel(DatabaseType dbType)
{
ConventionSet conventionSet = null;
switch (dbType)
{
case DatabaseType.SqlServer: conventionSet = SqlServerConventionSetBuilder.Build(); break;
case DatabaseType.MySql: conventionSet = MySqlConventionSetBuilder.Build(); break;
case DatabaseType.PostgreSql: conventionSet = NpgsqlConventionSetBuilder.Build(); break;
case DatabaseType.Oracle: conventionSet = OracleConventionSetBuilder.Build(); break;
default: throw new Exception("暂不支持该数据库!");
}
ModelBuilder modelBuilder = new ModelBuilder(conventionSet);
_entityTypeMap.Values.ForEach(x =>
{
modelBuilder.Model.AddEntityType(x);
});
return(modelBuilder.FinalizeModel());
}
public void Extension_with_null_schema()
{
var generator = CreateGenerator();
var modelBuilder = new ModelBuilder(NpgsqlConventionSetBuilder.Build());
modelBuilder.HasPostgresExtension(null, "postgis");
var model = (IModel)modelBuilder.Model;
var annotations = model.GetAnnotations().ToDictionary(a => a.Name, a => a);
var result = generator.GenerateFluentApiCalls(model, annotations)
.Single(c => c.Method == nameof(NpgsqlModelBuilderExtensions.HasPostgresExtension));
Assert.Collection(result.Arguments, name => Assert.Equal("postgis", name));
}
public void GenerateFluentApi_value_generation()
{
var generator = CreateGenerator();
var modelBuilder = new ModelBuilder(NpgsqlConventionSetBuilder.Build());
modelBuilder.Entity(
"Post",
x =>
{
x.Property <int>("IdentityByDefault").UseIdentityByDefaultColumn();
x.Property <int>("IdentityAlways").UseIdentityAlwaysColumn();
x.Property <int>("Serial").UseSerialColumn();
});
// Note: both serial and identity-by-default columns are considered by-convention - we don't want
// to assume that the PostgreSQL version of the scaffolded database necessarily determines the
// version of the database that the scaffolded model will target. This makes life difficult for
// models with mixed strategies but that's an edge case.
var entity = modelBuilder.Model.FindEntityType("Post");
var property = entity.GetProperties().Single(p => p.Name == "IdentityByDefault");
var annotations = property.GetAnnotations().ToDictionary(a => a.Name, a => a);
generator.RemoveAnnotationsHandledByConventions(property, annotations);
Assert.Empty(annotations);
var result = generator.GenerateFluentApiCalls(property, property.GetAnnotations().ToDictionary(a => a.Name, a => a))
.Single();
Assert.Equal(nameof(NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn), result.Method);
Assert.Equal(0, result.Arguments.Count);
property = entity.GetProperties().Single(p => p.Name == "IdentityAlways");
annotations = property.GetAnnotations().ToDictionary(a => a.Name, a => a);
generator.RemoveAnnotationsHandledByConventions(property, annotations);
Assert.Contains(annotations, kv => kv.Key == NpgsqlAnnotationNames.ValueGenerationStrategy);
result = generator.GenerateFluentApiCalls(property, annotations).Single();
Assert.Equal(nameof(NpgsqlPropertyBuilderExtensions.UseIdentityAlwaysColumn), result.Method);
Assert.Equal(0, result.Arguments.Count);
property = entity.GetProperties().Single(p => p.Name == "Serial");
annotations = property.GetAnnotations().ToDictionary(a => a.Name, a => a);
generator.RemoveAnnotationsHandledByConventions(property, annotations);
Assert.Empty(annotations);
result = generator.GenerateFluentApiCalls(property, property.GetAnnotations().ToDictionary(a => a.Name, a => a))
.Single();
Assert.Equal(nameof(NpgsqlPropertyBuilderExtensions.UseSerialColumn), result.Method);
Assert.Equal(0, result.Arguments.Count);
}
public void GenerateFluentApi_IModel_works_with_IdentityAlways()
{
var generator = CreateGenerator();
var modelBuilder = new ModelBuilder(NpgsqlConventionSetBuilder.Build());
modelBuilder.UseIdentityAlwaysColumns();
var annotations = modelBuilder.Model.GetAnnotations().ToDictionary(a => a.Name, a => a);
var result = generator.GenerateFluentApiCalls(((IModel)modelBuilder.Model), annotations).Single();
Assert.Equal("UseIdentityAlwaysColumns", result.Method);
Assert.Equal("NpgsqlModelBuilderExtensions", result.DeclaringType);
Assert.Empty(result.Arguments);
}
public void Range()
{
var generator = CreateGenerator();
var modelBuilder = new ModelBuilder(NpgsqlConventionSetBuilder.Build());
modelBuilder.HasPostgresRange("some_range", "some_subtype");
var model = (IModel)modelBuilder.Model;
var annotations = model.GetAnnotations().ToDictionary(a => a.Name, a => a);
var result = generator.GenerateFluentApiCalls(model, annotations)
.Single(c => c.Method == nameof(NpgsqlModelBuilderExtensions.HasPostgresRange));
Assert.Collection(result.Arguments,
name => Assert.Equal("some_range", name),
subtype => Assert.Equal("some_subtype", subtype));
}
public void GenerateFluentApi_IProperty_works_with_IdentityAlways()
{
var generator = CreateGenerator();
var modelBuilder = new ModelBuilder(NpgsqlConventionSetBuilder.Build());
modelBuilder.Entity("Post", x => x.Property <int>("Id").UseIdentityAlwaysColumn());
var property = (IProperty)modelBuilder.Model.FindEntityType("Post").FindProperty("Id");
var annotations = property.GetAnnotations().ToDictionary(a => a.Name, a => a);
var result = generator.GenerateFluentApiCalls(property, annotations).Single();
Assert.Equal("UseIdentityAlwaysColumn", result.Method);
Assert.Equal("NpgsqlPropertyBuilderExtensions", result.DeclaringType);
Assert.Empty(result.Arguments);
}
private IModel BuildDbCompiledModel()
{
if (ModelTypeMap.Count == 0)
{
InitModelType();
}
#pragma warning disable EF1001 // Internal EF Core API usage.
ConventionSet conventionSet = NpgsqlConventionSetBuilder.Build();
#pragma warning restore EF1001 // Internal EF Core API usage.
ModelBuilder modelBuilder = new ModelBuilder(conventionSet);
ModelTypeMap.Values.ForEach(x =>
{
modelBuilder.Model.AddEntityType(x);
});
return(modelBuilder.FinalizeModel());
}
public void GenerateFluentApi_IModel_works_with_HiLo()
{
var generator = CreateGenerator();
var modelBuilder = new ModelBuilder(NpgsqlConventionSetBuilder.Build());
modelBuilder.UseHiLo("HiLoIndexName", "HiLoIndexSchema");
var annotations = modelBuilder.Model.GetAnnotations().ToDictionary(a => a.Name, a => a);
var result = generator.GenerateFluentApiCalls(modelBuilder.Model, annotations).Single();
Assert.Equal("UseHiLo", result.Method);
Assert.Collection(
result.Arguments,
name => Assert.Equal("HiLoIndexName", name),
schema => Assert.Equal("HiLoIndexSchema", schema));
}
public void Enum_with_null_schema()
{
var generator = CreateGenerator();
var modelBuilder = new ModelBuilder(NpgsqlConventionSetBuilder.Build());
var enumLabels = new[] { "someValue1", "someValue2" };
modelBuilder.HasPostgresEnum(schema: null, "some_enum", enumLabels);
var model = (IModel)modelBuilder.Model;
var annotations = model.GetAnnotations().ToDictionary(a => a.Name, a => a);
var result = generator.GenerateFluentApiCalls(model, annotations)
.Single(c => c.Method == nameof(NpgsqlModelBuilderExtensions.HasPostgresEnum));
Assert.Collection(result.Arguments,
name => Assert.Equal("some_enum", name),
labels => Assert.Equal(enumLabels, labels));
}
public void GenerateFluentApi_IProperty_works_with_HiLo()
{
var generator = CreateGenerator();
var modelBuilder = new ModelBuilder(NpgsqlConventionSetBuilder.Build());
modelBuilder.Entity("Post", x => x.Property <int>("Id").UseHiLo("HiLoIndexName", "HiLoIndexSchema"));
var property = modelBuilder.Model.FindEntityType("Post").FindProperty("Id");
var annotations = property.GetAnnotations().ToDictionary(a => a.Name, a => a);
var result = generator.GenerateFluentApiCalls(property, annotations).Single();
Assert.Equal("UseHiLo", result.Method);
Assert.Collection(
result.Arguments,
name => Assert.Equal("HiLoIndexName", name),
schema => Assert.Equal("HiLoIndexSchema", schema));
}
public void GenerateFluentApi_identity()
{
var generator = new NpgsqlAnnotationCodeGenerator(new AnnotationCodeGeneratorDependencies());
var modelBuilder = new ModelBuilder(NpgsqlConventionSetBuilder.Build());
modelBuilder.Entity(
"Post",
x =>
{
x.Property <int>("Id").UseNpgsqlIdentityAlwaysColumn();
});
var property = modelBuilder.Model.FindEntityType("Post").GetProperties().Single();
var annotation = property.FindAnnotation(NpgsqlAnnotationNames.ValueGenerationStrategy);
var result = generator.GenerateFluentApi(property, annotation);
Assert.Equal("UseNpgsqlIdentityAlwaysColumn", result.Method);
Assert.Equal(0, result.Arguments.Count);
}
public void GenerateFluentApi_identity_sequence_options()
{
var generator = CreateGenerator();
var modelBuilder = new ModelBuilder(NpgsqlConventionSetBuilder.Build());
modelBuilder.Entity(
"Post",
x =>
{
x.Property <int>("Id")
.UseIdentityByDefaultColumn()
.HasIdentityOptions(
startValue: 5,
incrementBy: 2,
minValue: 3,
maxValue: 2000,
cyclic: true,
numbersToCache: 10);
});
var property = (IProperty)modelBuilder.Model.FindEntityType("Post").GetProperties()
.Single(p => p.Name == "Id");
var annotations = property.GetAnnotations().ToDictionary(a => a.Name, a => a);
generator.RemoveAnnotationsHandledByConventions(property, annotations);
Assert.Contains(annotations, kv => kv.Key == NpgsqlAnnotationNames.IdentityOptions);
var result = generator.GenerateFluentApiCalls(property, annotations).Single();
Assert.Equal(nameof(NpgsqlPropertyBuilderExtensions.HasIdentityOptions), result.Method);
Assert.Equal(5L, result.Arguments[0]);
Assert.Equal(2L, result.Arguments[1]);
Assert.Equal(3L, result.Arguments[2]);
Assert.Equal(2000L, result.Arguments[3]);
Assert.Equal(true, result.Arguments[4]);
Assert.Equal(10L, result.Arguments[5]);
}
public virtual MappingInfo GetMappingInfo()
{
return(_cache.GetOrAdd(GetCacheKey(), a =>
{
var _schema = _schemaProvider.GetSchema();
_mappingResolver = new MappingResolver(_schema);
ConventionSet conventionSet;
if (_schema.Schema.DBType == DatabaseType.Postgres)
{
conventionSet = NpgsqlConventionSetBuilder.Build();
}
else
{
conventionSet = SqlServerConventionSetBuilder.Build();
}
var builder = new ModelBuilder(conventionSet);
OnModelCreating(builder);
builder.FinalizeModel();
return new Lazy <MappingInfo>(
() => new MappingInfo(builder.Model, _schema),
LazyThreadSafetyMode.ExecutionAndPublication);
}).Value);
}
public override ModelBuilder GetModelBuilder() => new ModelBuilder(NpgsqlConventionSetBuilder.Build());
