/// <summary>
/// 设置值生成策略
/// </summary>
/// <param name="value">值生成策略</param>
/// <returns></returns>
protected virtual bool SetValueGenerationStrategy(OracleValueGenerationStrategy?value)
{
if (value.HasValue)
{
Type clrType = Property.ClrType;
if (value == OracleValueGenerationStrategy.IdentityColumn && !IsCompatibleIdentityColumn(Property))
{
if (ShouldThrowOnInvalidConfiguration)
{
throw new ArgumentException(OracleStrings.IdentityBadType(Property.Name, Property.DeclaringEntityType.DisplayName(), clrType.ShortDisplayName()));
}
return(false);
}
if (value == OracleValueGenerationStrategy.SequenceHiLo && !IsCompatibleSequenceHiLo(Property))
{
if (ShouldThrowOnInvalidConfiguration)
{
throw new ArgumentException(OracleStrings.SequenceBadType(Property.Name, Property.DeclaringEntityType.DisplayName(), clrType.ShortDisplayName()));
}
return(false);
}
}
if (!CanSetValueGenerationStrategy(value))
{
return(false);
}
if (!ShouldThrowOnConflict && ValueGenerationStrategy != value && value.HasValue)
{
ClearAllServerGeneratedValues();
}
return(Annotations.SetAnnotation(OracleAnnotationNames.ValueGenerationStrategy, value));
}
public override void ValidateTypeName(string storeType)
{
if (_disallowedMappings.Contains(storeType))
{
throw new ArgumentException(OracleStrings.UnqualifiedDataType(storeType));
}
}
public void Throws_for_non_key_SequenceHiLo()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Dog>().Property(c => c.Type).ForOracleUseSequenceHiLo();
VerifyError(OracleStrings.NonKeyValueGeneration(nameof(Dog.Type), nameof(Dog)), modelBuilder.Model);
}
public void Throws_for_multiple_identity_properties()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Dog>().Property(c => c.Type).UseOracleIdentityColumn();
modelBuilder.Entity <Dog>().Property <int?>("Tag").UseOracleIdentityColumn();
VerifyError(OracleStrings.MultipleIdentityColumns("'Dog.Tag', 'Dog.Type'", nameof(Dog)), modelBuilder.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>
protected override RelationalTypeMapping FindMapping(RelationalTypeMappingInfo mappingInfo)
{
var mapping = FindRawMapping(mappingInfo)?.Clone(mappingInfo);
if (_disallowedMappings.Contains(mapping?.StoreType))
{
throw new ArgumentException(OracleStrings.UnqualifiedDataType(mapping.StoreType));
}
return(mapping);
}
public virtual void Throws_for_unsupported_data_types()
{
var modelBuilder = new ModelBuilder(new CoreConventionSetBuilder(
new CoreConventionSetBuilderDependencies(new CoreTypeMapper(new CoreTypeMapperDependencies()))).CreateConventionSet());
modelBuilder.Entity <Cheese>().Property(e => e.Name).HasColumnType("NVARCHAR2");
Assert.Equal(
OracleStrings.UnqualifiedDataType("NVARCHAR2"),
Assert.Throws <ArgumentException>(() => Validate(modelBuilder.Model)).Message);
}
public virtual void Detects_incompatible_momory_optimized_shared_table()
{
var modelBuilder = new ModelBuilder(new CoreConventionSetBuilder(new CoreConventionSetBuilderDependencies(new CoreTypeMapper(new CoreTypeMapperDependencies()))).CreateConventionSet());
modelBuilder.Entity <A>().HasOne <B>().WithOne().IsRequired().HasForeignKey <A>(a => a.Id).HasPrincipalKey <B>(b => b.Id);
modelBuilder.Entity <A>().ToTable("Table").ForOracleIsMemoryOptimized();
modelBuilder.Entity <B>().ToTable("Table");
VerifyError(OracleStrings.IncompatibleTableMemoryOptimizedMismatch("Table", nameof(A), nameof(B), nameof(A), nameof(B)),
modelBuilder.Model);
}
protected virtual void ValidateNonKeyValueGeneration([NotNull] IModel model)
{
foreach (var property in model.GetEntityTypes()
.SelectMany(t => t.GetDeclaredProperties())
.Where(
p =>
((OraclePropertyAnnotations)p.Oracle()).GetOracleValueGenerationStrategy(fallbackToModel: false) == OracleValueGenerationStrategy.SequenceHiLo &&
!p.IsKey()))
{
throw new InvalidOperationException(
OracleStrings.NonKeyValueGeneration(property.Name, property.DeclaringEntityType.DisplayName()));
}
}
public void Throws_setting_identity_generation_for_invalid_type()
{
var modelBuilder = GetModelBuilder();
var property = modelBuilder
.Entity <Customer>()
.Property(e => e.Name)
.Metadata;
Assert.Equal(
OracleStrings.IdentityBadType("Name", nameof(Customer), "string"),
Assert.Throws <ArgumentException>(
() => property.Oracle().ValueGenerationStrategy = OracleValueGenerationStrategy.IdentityColumn).Message);
}
private static (string Schema, string Table) Parse(string table)
{
var match = _partExtractor.Match(table.Trim());
if (!match.Success)
{
throw new InvalidOperationException(OracleStrings.InvalidTableToIncludeInScaffolding(table));
}
var part1 = match.Groups["part1"].Value.Replace("]]", "]");
var part2 = match.Groups["part2"].Value.Replace("]]", "]");
return(string.IsNullOrEmpty(part2) ? (null, part1) : (part1, part2));
}
public void Throws_setting_identity_generation_for_invalid_type_only_with_explicit()
{
var propertyBuilder = CreateBuilder()
.Entity(typeof(Splot), ConfigurationSource.Convention)
.Property("Name", typeof(string), ConfigurationSource.Convention);
Assert.False(propertyBuilder.Oracle(ConfigurationSource.Convention)
.ValueGenerationStrategy(OracleValueGenerationStrategy.IdentityColumn));
Assert.Equal(
OracleStrings.IdentityBadType("Name", nameof(Splot), "string"),
Assert.Throws <ArgumentException>(
() => propertyBuilder.Oracle(ConfigurationSource.Explicit).ValueGenerationStrategy(OracleValueGenerationStrategy.IdentityColumn)).Message);
}
protected override void ValidateSharedColumnsCompatibility(IReadOnlyList <IEntityType> mappedTypes, string tableName)
{
base.ValidateSharedColumnsCompatibility(mappedTypes, tableName);
var identityColumns = EnumerableExtensions.Distinct(mappedTypes.SelectMany(et => et.GetDeclaredProperties())
.Where(p => p.Oracle().ValueGenerationStrategy == OracleValueGenerationStrategy.IdentityColumn), (p1, p2) => p1.Name == p2.Name)
.ToList();
if (identityColumns.Count > 1)
{
var sb = new StringBuilder()
.AppendJoin(identityColumns.Select(p => "'" + p.DeclaringEntityType.DisplayName() + "." + p.Name + "'"));
throw new InvalidOperationException(OracleStrings.MultipleIdentityColumns(sb, tableName));
}
}
