public virtual bool Apply(InternalKeyBuilder keyBuilder, Key previousPrimaryKey)
{
var entityTypeBuilder = keyBuilder.ModelBuilder.Entity(
keyBuilder.Metadata.DeclaringEntityType.Name, ConfigurationSource.Convention);
if (previousPrimaryKey != null)
{
foreach (var property in previousPrimaryKey.Properties)
{
if (entityTypeBuilder.Metadata.FindProperty(property.Name) != null)
{
entityTypeBuilder.Property(property.Name, ConfigurationSource.Convention)
?.ValueGenerated(null, ConfigurationSource.Convention);
}
}
}
var valueGeneratedOnAddProperty = FindValueGeneratedOnAddProperty(keyBuilder.Metadata.Properties);
if (valueGeneratedOnAddProperty != null
&& !valueGeneratedOnAddProperty.IsForeignKey(entityTypeBuilder.Metadata))
{
SetIdentity(entityTypeBuilder, valueGeneratedOnAddProperty);
}
return true;
}
public virtual InternalKeyBuilder Apply(InternalKeyBuilder keyBuilder)
{
Check.NotNull(keyBuilder, nameof(keyBuilder));
ConfigureKeyProperties(keyBuilder.ModelBuilder.Entity(keyBuilder.Metadata.EntityType.Name, ConfigurationSource.Convention),
keyBuilder.Metadata.Properties);
return keyBuilder;
}
public virtual InternalKeyBuilder Apply(InternalKeyBuilder keyBuilder)
{
var entityTypeBuilder = keyBuilder.ModelBuilder.Entity(
keyBuilder.Metadata.DeclaringEntityType.Name, ConfigurationSource.Convention);
SetValueGeneration(entityTypeBuilder, keyBuilder.Metadata.Properties);
return keyBuilder;
}
/// <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 virtual InternalKeyBuilder Apply(InternalKeyBuilder keyBuilder)
{
var key = keyBuilder.Metadata;
foreach (var index in key.DeclaringEntityType.GetDerivedIndexesInclusive()
.Where(i => AreIndexedBy(i.Properties, i.IsUnique, key.Properties, true)).ToList())
{
index.DeclaringEntityType.Builder.RemoveIndex(index, ConfigurationSource.Convention);
}
return(keyBuilder);
}
public virtual InternalKeyBuilder Apply(InternalKeyBuilder keyBuilder)
{
Check.NotNull(keyBuilder, nameof(keyBuilder));
var entityTypeBuilder = keyBuilder.ModelBuilder.Entity(keyBuilder.Metadata.DeclaringEntityType.Name, ConfigurationSource.Convention);
var properties = keyBuilder.Metadata.Properties;
SetValueGeneration(entityTypeBuilder, properties);
SetIdentity(entityTypeBuilder, properties);
return keyBuilder;
}
public virtual InternalKeyBuilder Apply(InternalKeyBuilder keyBuilder)
{
Check.NotNull(keyBuilder, nameof(keyBuilder));
var entityTypeBuilder = keyBuilder.ModelBuilder.Entity(keyBuilder.Metadata.DeclaringEntityType.Name, ConfigurationSource.Convention);
var properties = keyBuilder.Metadata.Properties;
SetValueGeneration(entityTypeBuilder, properties);
SetIdentity(entityTypeBuilder, properties);
return(keyBuilder);
}
public void OnKeyAdded_calls_apply_on_conventions_in_order(bool useBuilder)
{
var conventions = new ConventionSet();
InternalKeyBuilder keyBuilder = null;
var convention = new Mock <IKeyConvention>();
convention.Setup(c => c.Apply(It.IsAny <InternalKeyBuilder>())).Returns <InternalKeyBuilder>(b =>
{
Assert.NotNull(b);
keyBuilder = new InternalKeyBuilder(b.Metadata, b.ModelBuilder);
return(keyBuilder);
});
conventions.KeyAddedConventions.Add(convention.Object);
var nullConvention = new Mock <IKeyConvention>();
nullConvention.Setup(c => c.Apply(It.IsAny <InternalKeyBuilder>())).Returns <InternalKeyBuilder>(b =>
{
Assert.Same(keyBuilder, b);
return(null);
});
conventions.KeyAddedConventions.Add(nullConvention.Object);
var extraConvention = new Mock <IKeyConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny <InternalKeyBuilder>())).Returns <InternalKeyBuilder>(b =>
{
Assert.False(true);
return(null);
});
conventions.KeyAddedConventions.Add(extraConvention.Object);
var builder = new InternalModelBuilder(new Model(conventions));
var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention);
if (useBuilder)
{
Assert.Null(entityBuilder.HasKey(new List <string> {
"OrderId"
}, ConfigurationSource.Convention));
}
else
{
var property = entityBuilder.Property("OrderId", ConfigurationSource.Convention).Metadata;
property.IsNullable = false;
Assert.Null(entityBuilder.Metadata.AddKey(property));
}
Assert.NotNull(keyBuilder);
}
public virtual InternalKeyBuilder Apply(InternalKeyBuilder keyBuilder)
{
Check.NotNull(keyBuilder, nameof(keyBuilder));
var key = keyBuilder.Metadata;
ConfigureValueGenerationStrategy(
keyBuilder.ModelBuilder.Entity(key.EntityType.Name, ConfigurationSource.Convention),
key.Properties,
true);
return keyBuilder;
}
public virtual InternalKeyBuilder Apply(InternalKeyBuilder keyBuilder)
{
Check.NotNull(keyBuilder, nameof(keyBuilder));
var key = keyBuilder.Metadata;
ConfigureValueGenerationStrategy(
keyBuilder.ModelBuilder.Entity(key.EntityType.Name, ConfigurationSource.Convention),
key.Properties,
true);
return(keyBuilder);
}
/// <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 virtual bool Apply(InternalKeyBuilder keyBuilder, Key previousPrimaryKey)
{
if (previousPrimaryKey != null)
{
foreach (var property in previousPrimaryKey.Properties)
{
property.Builder?.ValueGenerated(ValueGenerated.Never, ConfigurationSource.Convention);
}
}
SetKeyValueGeneration(keyBuilder.Metadata.Properties, keyBuilder.Metadata.DeclaringEntityType);
return(true);
}
/// <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 virtual InternalKeyBuilder OnPrimaryKeySet([NotNull] InternalKeyBuilder keyBuilder, [CanBeNull] Key previousPrimaryKey)
{
Check.NotNull(keyBuilder, nameof(keyBuilder));
foreach (var keyConvention in _conventionSet.PrimaryKeySetConventions)
{
if (!keyConvention.Apply(keyBuilder, previousPrimaryKey))
{
break;
}
}
return(keyBuilder);
}
public virtual bool Apply(InternalKeyBuilder keyBuilder, Key previousPrimaryKey)
{
if (previousPrimaryKey != null)
{
foreach (var property in previousPrimaryKey.Properties)
{
property.Builder?.ValueGenerated(ValueGenerated.Never, ConfigurationSource.Convention);
property.Builder?.RequiresValueGenerator(false, ConfigurationSource.Convention);
}
}
SetIdentity(keyBuilder.Metadata.Properties, keyBuilder.Metadata.DeclaringEntityType);
return true;
}
/// <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 virtual InternalKeyBuilder OnKeyAdded([NotNull] InternalKeyBuilder keyBuilder)
{
Check.NotNull(keyBuilder, nameof(keyBuilder));
foreach (var keyConvention in _conventionSet.KeyAddedConventions)
{
keyBuilder = keyConvention.Apply(keyBuilder);
if (keyBuilder == null)
{
break;
}
}
return(keyBuilder);
}
/// <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 virtual InternalKeyBuilder Apply(InternalKeyBuilder keyBuilder)
{
var key = keyBuilder.Metadata;
foreach (var foreignKey in key.DeclaringEntityType.GetDerivedForeignKeysInclusive().ToList())
{
if (key.Properties.All(p => foreignKey.Properties.Contains(p)) &&
(!foreignKey.IsUnique || foreignKey.DeclaringEntityType.BaseType != null))
{
foreignKey.Builder.HasForeignKey((IReadOnlyList <Property>)null, ConfigurationSource.Convention);
}
}
return(keyBuilder);
}
public void OnPrimaryKeySet_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
InternalKeyBuilder internalKeyBuilder = null;
var convention = new Mock <IPrimaryKeyConvention>();
convention.Setup(c => c.Apply(It.IsAny <InternalKeyBuilder>(), It.IsAny <Key>()))
.Returns <InternalKeyBuilder, Key>((b, t) =>
{
Assert.NotNull(b);
Assert.Null(t);
internalKeyBuilder = b;
return(true);
});
conventions.PrimaryKeySetConventions.Add(convention.Object);
var nullConvention = new Mock <IPrimaryKeyConvention>();
nullConvention.Setup(c => c.Apply(It.IsAny <InternalKeyBuilder>(), It.IsAny <Key>()))
.Returns <InternalKeyBuilder, Key>((b, t) =>
{
Assert.Null(t);
Assert.Same(internalKeyBuilder, b);
return(false);
});
conventions.PrimaryKeySetConventions.Add(nullConvention.Object);
var extraConvention = new Mock <IPrimaryKeyConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny <InternalKeyBuilder>(), It.IsAny <Key>()))
.Returns <InternalKeyBuilder, Key>((b, t) =>
{
Assert.False(true);
return(false);
});
conventions.PrimaryKeySetConventions.Add(extraConvention.Object);
var entityBuilder = new InternalModelBuilder(new Model(), conventions)
.Entity(typeof(Order), ConfigurationSource.Convention);
entityBuilder.HasKey(new[] { "OrderId" }, ConfigurationSource.Convention);
Assert.NotNull(entityBuilder.PrimaryKey(new[] { "OrderId" }, ConfigurationSource.Convention));
Assert.NotNull(internalKeyBuilder);
}
public override InternalKeyBuilder OnKeyAdded(InternalKeyBuilder keyBuilder)
{
if (keyBuilder.Metadata.Builder == null)
{
return(null);
}
foreach (var keyConvention in _conventionSet.KeyAddedConventions)
{
keyBuilder = keyConvention.Apply(keyBuilder);
if (keyBuilder?.Metadata.Builder == null)
{
return(null);
}
}
return(keyBuilder);
}
public void OnKeyAdded_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
InternalKeyBuilder keyBuilder = null;
var convention = new Mock <IKeyConvention>();
convention.Setup(c => c.Apply(It.IsAny <InternalKeyBuilder>())).Returns <InternalKeyBuilder>(b =>
{
Assert.NotNull(b);
keyBuilder = new InternalKeyBuilder(b.Metadata, b.ModelBuilder);
return(keyBuilder);
});
conventions.KeyAddedConventions.Add(convention.Object);
var nullConvention = new Mock <IKeyConvention>();
nullConvention.Setup(c => c.Apply(It.IsAny <InternalKeyBuilder>())).Returns <InternalKeyBuilder>(b =>
{
Assert.Same(keyBuilder, b);
return(null);
});
conventions.KeyAddedConventions.Add(nullConvention.Object);
var extraConvention = new Mock <IKeyConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny <InternalKeyBuilder>())).Returns <InternalKeyBuilder>(b =>
{
Assert.False(true);
return(null);
});
conventions.KeyAddedConventions.Add(extraConvention.Object);
var builder = new InternalModelBuilder(new Model(), conventions);
var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention);
var explicitKeyBuilder = entityBuilder.Key(new List <string> {
"OrderId"
}, ConfigurationSource.Convention);
Assert.Null(explicitKeyBuilder);
Assert.NotNull(keyBuilder);
}
public void OnKeyRemoved_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
InternalKeyBuilder keyBuilder = null;
var convention = new Mock <IKeyRemovedConvention>();
convention.Setup(c => c.Apply(It.IsAny <InternalEntityTypeBuilder>(), It.IsAny <Key>()))
.Callback <InternalEntityTypeBuilder, Key>((b, k) =>
{
Assert.NotNull(b);
Assert.NotNull(k);
keyBuilder = new InternalKeyBuilder(k, b.ModelBuilder);
});
conventions.KeyRemovedConventions.Add(convention.Object);
var extraConvention = new Mock <IKeyRemovedConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny <InternalEntityTypeBuilder>(), It.IsAny <Key>()))
.Callback <InternalEntityTypeBuilder, Key>((b, k) =>
{
Assert.NotNull(b);
Assert.NotNull(k);
Assert.NotNull(keyBuilder);
});
conventions.KeyRemovedConventions.Add(extraConvention.Object);
var builder = new InternalModelBuilder(new Model(conventions));
var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention);
var key = entityBuilder.HasKey(new List <string> {
"OrderId"
}, ConfigurationSource.Convention).Metadata;
Assert.Same(key, entityBuilder.Metadata.RemoveKey(key.Properties));
Assert.NotNull(keyBuilder);
}
public virtual InternalKeyBuilder OnKeyAdded([NotNull] InternalKeyBuilder keyBuilder)
{
Add(new OnKeyAddedNode(keyBuilder));
return(keyBuilder);
}
public static RelationalKeyBuilderAnnotations Sqlite(
[NotNull] this InternalKeyBuilder builder,
ConfigurationSource configurationSource)
=> new RelationalKeyBuilderAnnotations(builder, configurationSource, SqliteAnnotationNames.Prefix);
/// <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 MySqlKeyBuilderAnnotations MySql(
[NotNull] this InternalKeyBuilder builder,
ConfigurationSource configurationSource)
=> new MySqlKeyBuilderAnnotations(builder, configurationSource);
public KeyBuilder([NotNull] InternalKeyBuilder builder)
{
Check.NotNull(builder, "builder");
_builder = builder;
}
public static OracleKeyBuilderAnnotations Oracle(
[NotNull] this InternalKeyBuilder builder,
ConfigurationSource configurationSource)
=> new OracleKeyBuilderAnnotations(builder, configurationSource);
/// <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 RelationalKeyBuilderAnnotations Taos(
[NotNull] this InternalKeyBuilder builder,
ConfigurationSource configurationSource)
=> new RelationalKeyBuilderAnnotations(builder, configurationSource);
public FbKeyBuilderAnnotations(InternalKeyBuilder internalBuilder, ConfigurationSource configurationSource)
: base(new RelationalAnnotationsBuilder(internalBuilder, configurationSource))
{
}
public KeyBuilder([NotNull] IMutableKey key)
{
Check.NotNull(key, nameof(key));
_builder = ((Key)key).Builder;
}
public static SqlServerKeyBuilderAnnotations SqlServer(
[NotNull] this InternalKeyBuilder builder,
ConfigurationSource configurationSource)
=> new SqlServerKeyBuilderAnnotations(builder, configurationSource);
/// <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 SqlServerKeyBuilderAnnotations(
[NotNull] InternalKeyBuilder internalBuilder,
ConfigurationSource configurationSource)
: base(new RelationalAnnotationsBuilder(internalBuilder, configurationSource))
{
}
/// <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 virtual InternalKeyBuilder Apply(InternalKeyBuilder keyBuilder)
{
SetValueGeneration(keyBuilder.Metadata.Properties);
return(keyBuilder);
}
public OnKeyAddedNode(InternalKeyBuilder keyBuilder)
{
KeyBuilder = keyBuilder;
}
public KeyBuilder([NotNull] InternalKeyBuilder builder)
{
Check.NotNull(builder, nameof(builder));
_builder = builder;
}
/// <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 JetKeyBuilderAnnotations Jet(
[NotNull] this InternalKeyBuilder builder,
ConfigurationSource configurationSource)
=> new JetKeyBuilderAnnotations(builder, configurationSource);
public virtual InternalKeyBuilder Apply(InternalKeyBuilder keyBuilder)
{
SetValueGeneration(keyBuilder.Metadata.Properties);
return keyBuilder;
}
/// <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 virtual InternalKeyBuilder OnKeyAdded([NotNull] InternalKeyBuilder keyBuilder) => _scope.OnKeyAdded(Check.NotNull(keyBuilder, nameof(keyBuilder)));
public static RelationalKeyBuilderAnnotations Firebird(this InternalKeyBuilder builder, ConfigurationSource configurationSource) => new RelationalKeyBuilderAnnotations(builder, configurationSource);
public void OnKeyRemoved_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
InternalKeyBuilder keyBuilder = null;
var convention = new Mock<IKeyRemovedConvention>();
convention.Setup(c => c.Apply(It.IsAny<InternalEntityTypeBuilder>(), It.IsAny<Key>()))
.Callback<InternalEntityTypeBuilder, Key>((b, k) =>
{
Assert.NotNull(b);
Assert.NotNull(k);
keyBuilder = new InternalKeyBuilder(k, b.ModelBuilder);
});
conventions.KeyRemovedConventions.Add(convention.Object);
var extraConvention = new Mock<IKeyRemovedConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny<InternalEntityTypeBuilder>(), It.IsAny<Key>()))
.Callback<InternalEntityTypeBuilder, Key>((b, k) =>
{
Assert.NotNull(b);
Assert.NotNull(k);
Assert.NotNull(keyBuilder);
});
conventions.KeyRemovedConventions.Add(extraConvention.Object);
var builder = new InternalModelBuilder(new Model(conventions));
var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention);
var key = entityBuilder.HasKey(new List<string> { "OrderId" }, ConfigurationSource.Convention).Metadata;
Assert.Same(key, entityBuilder.Metadata.RemoveKey(key.Properties));
Assert.NotNull(keyBuilder);
}
/// <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 DocumentKeyAnnotations Document([NotNull] this InternalKeyBuilder internalKeyBuilder) => Check.NotNull(internalKeyBuilder, nameof(internalKeyBuilder)).Metadata.Document();
/// <inheritdoc />
public InternalKeyBuilder Apply(InternalKeyBuilder keyBuilder)
{
Apply(Check.NotNull(keyBuilder, nameof(keyBuilder)).Metadata.DeclaringEntityType.Builder);
return(keyBuilder);
}
public void OnKeyAdded_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
InternalKeyBuilder keyBuilder = null;
var convention = new Mock<IKeyConvention>();
convention.Setup(c => c.Apply(It.IsAny<InternalKeyBuilder>())).Returns<InternalKeyBuilder>(b =>
{
Assert.NotNull(b);
keyBuilder = new InternalKeyBuilder(b.Metadata, b.ModelBuilder);
return keyBuilder;
});
conventions.KeyAddedConventions.Add(convention.Object);
var nullConvention = new Mock<IKeyConvention>();
nullConvention.Setup(c => c.Apply(It.IsAny<InternalKeyBuilder>())).Returns<InternalKeyBuilder>(b =>
{
Assert.Same(keyBuilder, b);
return null;
});
conventions.KeyAddedConventions.Add(nullConvention.Object);
var extraConvention = new Mock<IKeyConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny<InternalKeyBuilder>())).Returns<InternalKeyBuilder>(b =>
{
Assert.False(true);
return null;
});
conventions.KeyAddedConventions.Add(extraConvention.Object);
var builder = new InternalModelBuilder(new Model(), conventions);
var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention);
var explicitKeyBuilder = entityBuilder.HasKey(new List<string> { "OrderId" }, ConfigurationSource.Convention);
Assert.Null(explicitKeyBuilder);
Assert.NotNull(keyBuilder);
}
