public void Circular_inheritance_should_throw()
{
var model = new Model();
// A
// / \
// B C
// \
// D
var a = model.AddEntityType(typeof(A).Name);
var b = model.AddEntityType(typeof(B).Name);
var c = model.AddEntityType(typeof(C).Name);
var d = model.AddEntityType(typeof(D).Name);
b.BaseType = a;
c.BaseType = a;
d.BaseType = c;
Assert.Equal(
Strings.CircularInheritance(a, a),
Assert.Throws<InvalidOperationException>(() => a.BaseType = a).Message);
Assert.Equal(
Strings.CircularInheritance(a, b),
Assert.Throws<InvalidOperationException>(() => a.BaseType = b).Message);
Assert.Equal(
Strings.CircularInheritance(a, d),
Assert.Throws<InvalidOperationException>(() => a.BaseType = d).Message);
}
public virtual void Detects_foreign_key_cycles()
{
var model = new Model();
var entityA = model.AddEntityType(typeof(A));
var keyA = CreateKey(entityA);
var entityB = model.AddEntityType(typeof(B));
var keyB = CreateKey(entityB);
CreateForeignKey(keyA, keyB);
CreateForeignKey(keyB, keyA);
VerifyError(Strings.CircularDependency("'A' {'P0'} -> 'B' {'P0'}, 'B' {'P0'} -> 'A' {'P0'}"), model);
}
public void Throws_when_referenced_key_not_on_referenced_entity()
{
var model = new Model();
var principalEntityType = model.AddEntityType("R");
var dependentEntityType = model.AddEntityType("D");
var fk = dependentEntityType.AddProperty("Fk", typeof(int), shadowProperty: true);
var principalKey = dependentEntityType.SetPrimaryKey(fk);
Assert.Throws<ArgumentException>(() =>
new ForeignKey(new[] { fk }, principalKey, principalEntityType));
}
public virtual void Passes_on_escapable_foreign_key_cycles_not_starting_at_hub()
{
var model = new Model();
var entityA = model.AddEntityType(typeof(A));
var keyA1 = CreateKey(entityA);
var keyA2 = CreateKey(entityA, startingPropertyIndex: 1, propertyCount: 2);
var entityB = model.AddEntityType(typeof(B));
var keyB1 = CreateKey(entityB);
var keyB2 = CreateKey(entityB, startingPropertyIndex: 0, propertyCount: 2);
CreateForeignKey(keyA1, keyB1);
CreateForeignKey(keyB1, keyA1);
CreateForeignKey(keyB2, keyA2);
Validate(model);
}
public virtual void Detects_shadow_entities()
{
var model = new Model();
model.AddEntityType("A");
VerifyError(CoreStrings.ShadowEntity("A"), model);
}
public void Properties_on_base_type_should_be_inherited()
{
var model = new Model();
// A
// / \
// B C
var a = model.AddEntityType(typeof(A));
a.AddProperty("G", typeof(string));
a.AddProperty("E", typeof(string));
var b = model.AddEntityType(typeof(B));
b.AddProperty("H", typeof(string));
b.AddProperty("F", typeof(string));
var c = model.AddEntityType(typeof(C));
c.AddProperty("H", typeof(string), true);
c.AddProperty("I", typeof(string), true);
Assert.Equal(new[] { "E", "G" }, a.Properties.Select(p => p.Name).ToArray());
Assert.Equal(new[] { "F", "H" }, b.Properties.Select(p => p.Name).ToArray());
Assert.Equal(new[] { "H", "I" }, c.Properties.Select(p => p.Name).ToArray());
b.BaseType = a;
c.BaseType = a;
Assert.Equal(new[] { "E", "G" }, a.Properties.Select(p => p.Name).ToArray());
Assert.Equal(new[] { "E", "G", "F", "H" }, b.Properties.Select(p => p.Name).ToArray());
Assert.Equal(new[] { "E", "G", "H", "I" }, c.Properties.Select(p => p.Name).ToArray());
Assert.Equal(new[] { 0, 1, 2, 3 }, b.Properties.Select(p => p.Index));
Assert.Equal(new[] { 0, 1, 2, 3 }, c.Properties.Select(p => p.Index));
}
private ForeignKey CreateForeignKey()
{
var model = new Model();
var entityType = model.AddEntityType("E");
var property = entityType.AddProperty("p", typeof(int), shadowProperty: true);
var key = entityType.SetPrimaryKey(property);
return new ForeignKey(new[] { property }, key);
}
public virtual void Detects_a_null_primary_key()
{
var model = new Model();
var entityType = model.AddEntityType(typeof(A));
var property = entityType.AddProperty("Id", typeof(int));
VerifyError(CoreStrings.EntityRequiresKey(typeof(A).FullName), model);
}
private ForeignKey CreateForeignKey()
{
var model = new Model();
var entityType = model.AddEntityType("E");
var idProperty = entityType.AddProperty("id", typeof(int));
var key = entityType.SetPrimaryKey(idProperty);
var fkProperty = entityType.AddProperty("p", typeof(int));
return entityType.AddForeignKey(fkProperty, key, entityType);
}
public virtual void Detects_a_non_shadow_property_that_doesnt_match_the_CLR_property_type()
{
var model = new Model();
var entityType = model.AddEntityType(typeof(A));
var property = entityType.AddProperty("P0", typeof(string));
property.IsShadowProperty = false;
VerifyError(Strings.PropertyWrongClrType("P0", typeof(A).FullName), model);
}
public virtual void Detects_shadow_keys()
{
var model = new Model();
var entityType = model.AddEntityType("E");
var keyProperty = entityType.AddProperty("Id", typeof(int), shadowProperty: true);
entityType.AddKey(keyProperty);
VerifyWarning(Strings.ShadowKey("{'Id'}", "E", "{'Id'}"), model);
}
public virtual void Detects_a_non_shadow_property_that_doesnt_match_a_CLR_property()
{
var model = new Model();
var entityType = model.AddEntityType(typeof(A));
var property = entityType.AddProperty("Id1", typeof(int));
property.IsShadowProperty = false;
entityType.SetPrimaryKey(property);
VerifyError(CoreStrings.NoClrProperty("Id1", typeof(A).FullName), model);
}
public virtual void Detects_shadow_keys()
{
var model = new Model();
var entityType = model.AddEntityType(typeof(A));
SetPrimaryKey(entityType);
var keyProperty = entityType.AddProperty("Key", typeof(int));
entityType.AddKey(keyProperty);
VerifyWarning(CoreStrings.ShadowKey("{'Key'}", typeof(A).FullName, "{'Key'}"), model);
}
protected override Model BuildModel()
{
var model = new Model();
var entityType1 = new EntityType("SomeEntity");
model.AddEntityType(entityType1);
var key1 = entityType1.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false);
key1.ValueGenerationOnSave = ValueGenerationOnSave.WhenInserting;
key1.ValueGenerationOnAdd = ValueGenerationOnAdd.Client;
entityType1.SetKey(key1);
entityType1.AddProperty("Name", typeof(string), shadowProperty: true, concurrencyToken: true);
var entityType2 = new EntityType("SomeDependentEntity");
model.AddEntityType(entityType2);
var key2a = entityType2.AddProperty("Id1", typeof(int), shadowProperty: true, concurrencyToken: false);
var key2b = entityType2.AddProperty("Id2", typeof(string), shadowProperty: true, concurrencyToken: false);
entityType2.SetKey(key2a, key2b);
var fk = entityType2.AddProperty("SomeEntityId", typeof(int), shadowProperty: true, concurrencyToken: false);
entityType2.AddForeignKey(entityType1.GetKey(), new[] { fk });
var justAProperty = entityType2.AddProperty("JustAProperty", typeof(int), shadowProperty: true, concurrencyToken: false);
justAProperty.ValueGenerationOnSave = ValueGenerationOnSave.WhenInserting;
justAProperty.ValueGenerationOnAdd = ValueGenerationOnAdd.Client;
var entityType3 = new EntityType(typeof(FullNotificationEntity));
model.AddEntityType(entityType3);
entityType3.SetKey(entityType3.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
entityType3.AddProperty("Name", typeof(string), shadowProperty: true, concurrencyToken: true);
var entityType4 = new EntityType(typeof(ChangedOnlyEntity));
model.AddEntityType(entityType4);
entityType4.SetKey(entityType4.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
entityType4.AddProperty("Name", typeof(string), shadowProperty: true, concurrencyToken: true);
var entityType5 = new EntityType("SomeMoreDependentEntity");
model.AddEntityType(entityType5);
var key5 = entityType5.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false);
entityType5.SetKey(key5);
var fk5a = entityType5.AddProperty("Fk1", typeof(int), shadowProperty: true, concurrencyToken: false);
var fk5b = entityType5.AddProperty("Fk2", typeof(string), shadowProperty: true, concurrencyToken: false);
entityType5.AddForeignKey(entityType2.GetKey(), new[] { fk5a, fk5b });
return model;
}
private static Model CreateModel(bool generateValues = true)
{
var model = new Model();
var entityType = model.AddEntityType("Led");
entityType.AddProperty("Zeppelin", typeof(Guid));
entityType.AddProperty("Stairway", typeof(Guid)).RequiresValueGenerator = generateValues;
return model;
}
public virtual void Detects_self_referencing_properties()
{
var model = new Model();
var entityA = model.AddEntityType(typeof(A));
var keyA = CreateKey(entityA);
CreateForeignKey(keyA, keyA);
VerifyError(Strings.CircularDependency("'A' {'P0'} -> 'A' {'P0'}"), model);
}
public void Adding_duplicate_entity_by_type_throws()
{
var model = new Model();
Assert.Null(model.RemoveEntityType(new EntityType(typeof(Customer).FullName, model)));
model.AddEntityType(typeof(Customer));
Assert.Equal(
Strings.DuplicateEntityType(typeof(Customer).FullName),
Assert.Throws<InvalidOperationException>(() => model.AddEntityType(typeof(Customer))).Message);
}
private static Model CreateModel(bool generateValues = true)
{
var model = new Model();
var entityType = model.AddEntityType("Led");
var property1 = entityType.GetOrAddProperty("Zeppelin", typeof(Guid), shadowProperty: true);
property1.RequiresValueGenerator = generateValues;
var property2 = entityType.GetOrAddProperty("Stairway", typeof(Guid), shadowProperty: true);
property2.RequiresValueGenerator = generateValues;
return model;
}
public void Can_get_entity_by_type()
{
var model = new Model();
var entityType = new EntityType(typeof(Customer));
model.AddEntityType(entityType);
Assert.Same(entityType, model.GetEntityType(typeof(Customer)));
Assert.Same(entityType, model.TryGetEntityType(typeof(Customer)));
Assert.Null(model.TryGetEntityType(typeof(string)));
Assert.Equal(
Strings.FormatEntityTypeNotFound("String"),
Assert.Throws<ModelItemNotFoundException>(() => model.GetEntityType(typeof(string))).Message);
}
public void Can_get_referencing_foreign_keys()
{
var model = new Model();
var entityType1 = new EntityType(typeof(Customer));
var entityType2 = new EntityType(typeof(Order));
var keyProperty = new Property("Id", typeof(Customer))
{
EntityType = entityType1
};
var fkProperty = new Property("CustomerId", typeof(Order))
{
EntityType = entityType2
};
var foreignKey = entityType2.AddForeignKey(new Key(new[] { keyProperty }), fkProperty);
model.AddEntityType(entityType1);
model.AddEntityType(entityType2);
var referencingForeignKeys = model.GetReferencingForeignKeys(entityType1);
Assert.Same(foreignKey, referencingForeignKeys.Single());
Assert.Same(foreignKey, entityType1.GetReferencingForeignKeys().Single());
}
public void Can_get_entity_by_name()
{
var model = new Model();
var entityType = new EntityType(typeof(Customer));
model.AddEntityType(entityType);
Assert.Same(entityType, model.GetEntityType("Customer"));
Assert.Same(entityType, model.TryGetEntityType("Customer"));
Assert.Null(model.TryGetEntityType(typeof(string)));
Assert.Equal(
Strings.FormatEntityTypeNotFound("String"),
Assert.Throws <ModelItemNotFoundException>(() => model.GetEntityType("String")).Message);
}
protected override Model BuildModel()
{
var model = new Model();
var entityType1 = model.AddEntityType(typeof(SomeEntity).FullName);
var key1 = entityType1.GetOrAddProperty("Id", typeof(int), shadowProperty: true);
key1.GenerateValueOnAdd = true;
entityType1.GetOrSetPrimaryKey(key1);
entityType1.GetOrAddProperty("Name", typeof(string), shadowProperty: true).IsConcurrencyToken = true;
var entityType2 = model.AddEntityType(typeof(SomeDependentEntity).FullName);
var key2a = entityType2.GetOrAddProperty("Id1", typeof(int), shadowProperty: true);
var key2b = entityType2.GetOrAddProperty("Id2", typeof(string), shadowProperty: true);
entityType2.GetOrSetPrimaryKey(new[] { key2a, key2b });
var fk = entityType2.GetOrAddProperty("SomeEntityId", typeof(int), shadowProperty: true);
entityType2.GetOrAddForeignKey(new[] { fk }, entityType1.GetPrimaryKey());
var justAProperty = entityType2.GetOrAddProperty("JustAProperty", typeof(int), shadowProperty: true);
justAProperty.GenerateValueOnAdd = true;
var entityType3 = model.AddEntityType(typeof(FullNotificationEntity));
entityType3.GetOrSetPrimaryKey(entityType3.GetOrAddProperty("Id", typeof(int), shadowProperty: true));
entityType3.GetOrAddProperty("Name", typeof(string), shadowProperty: true).IsConcurrencyToken = true;
var entityType4 = model.AddEntityType(typeof(ChangedOnlyEntity));
entityType4.GetOrSetPrimaryKey(entityType4.GetOrAddProperty("Id", typeof(int), shadowProperty: true));
entityType4.GetOrAddProperty("Name", typeof(string), shadowProperty: true).IsConcurrencyToken = true;
var entityType5 = model.AddEntityType(typeof(SomeMoreDependentEntity).FullName);
var key5 = entityType5.GetOrAddProperty("Id", typeof(int), shadowProperty: true);
entityType5.GetOrSetPrimaryKey(key5);
var fk5a = entityType5.GetOrAddProperty("Fk1", typeof(int), shadowProperty: true);
var fk5b = entityType5.GetOrAddProperty("Fk2", typeof(string), shadowProperty: true);
entityType5.GetOrAddForeignKey(new[] { fk5a, fk5b }, entityType2.GetPrimaryKey());
return model;
}
public void Can_add_and_remove_entity()
{
var model = new Model();
var entityType = new EntityType(typeof(Customer));
Assert.Null(entityType.Model);
model.AddEntityType(entityType);
Assert.NotNull(model.TryGetEntityType(typeof(Customer)));
Assert.Same(model, entityType.Model);
model.RemoveEntityType(entityType);
Assert.Null(model.TryGetEntityType(typeof(Customer)));
Assert.Null(entityType.Model);
}
public void Can_add_and_remove_entity()
{
var model = new Model();
var entityType = new EntityType(typeof(Customer));
Assert.Null(entityType.Model);
model.AddEntityType(entityType);
Assert.NotNull(model.TryGetEntityType(typeof(Customer)));
Assert.Same(model, entityType.Model);
model.RemoveEntityType(entityType);
Assert.Null(model.TryGetEntityType(typeof(Customer)));
Assert.Null(entityType.Model);
}
public void Creates_shadow_state_only_entry_when_entity_is_fully_shadow_state()
{
var model = new Model();
var entityType = model.AddEntityType("RedHook");
entityType.AddProperty("Long", typeof(int));
entityType.AddProperty("Hammer", typeof(string));
var contextServices = TestHelpers.Instance.CreateContextServices(model);
var stateManager = contextServices.GetRequiredService<IStateManager>();
var factory = contextServices.GetRequiredService<IInternalEntityEntryFactory>();
var entry = factory.Create(stateManager, entityType, new Random());
Assert.IsType<InternalShadowEntityEntry>(entry);
Assert.Same(stateManager, entry.StateManager);
Assert.Same(entityType, entry.EntityType);
Assert.Null(entry.Entity);
}
public void Members_check_arguments()
{
var model = new Model();
Assert.Equal(
"entityType",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => model.AddEntityType(null)).ParamName);
Assert.Equal(
"entityType",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => model.RemoveEntityType(null)).ParamName);
Assert.Equal(
"type",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => model.TryGetEntityType((Type)null)).ParamName);
}
public void Members_check_arguments()
{
var model = new Model();
Assert.Equal(
"entityType",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws<ArgumentNullException>(() => model.AddEntityType(null)).ParamName);
Assert.Equal(
"entityType",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws<ArgumentNullException>(() => model.RemoveEntityType(null)).ParamName);
Assert.Equal(
"type",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws<ArgumentNullException>(() => model.TryGetEntityType((Type)null)).ParamName);
}
public void Can_add_and_remove_entity_by_type()
{
var model = new Model();
Assert.Null(model.FindEntityType(typeof(Customer)));
Assert.Null(model.RemoveEntityType(new EntityType(typeof(Customer), model)));
var entityType = model.AddEntityType(typeof(Customer));
Assert.Equal(typeof(Customer), entityType.ClrType);
Assert.NotNull(model.FindEntityType(typeof(Customer)));
Assert.Same(model, entityType.Model);
Assert.Same(entityType, model.GetOrAddEntityType(typeof(Customer)));
Assert.Equal(new[] { entityType }, model.EntityTypes.ToArray());
Assert.Same(entityType, model.RemoveEntityType(entityType));
Assert.Null(model.RemoveEntityType(entityType));
Assert.Null(model.FindEntityType(typeof(Customer)));
}
protected override Model BuildModel()
{
var model = new Model();
var someSimpleEntityType = model.AddEntityType(typeof(SomeSimpleEntityBase).FullName);
var simpleKeyProperty = someSimpleEntityType.AddProperty("Id", typeof(int));
simpleKeyProperty.RequiresValueGenerator = true;
someSimpleEntityType.GetOrSetPrimaryKey(simpleKeyProperty);
var someCompositeEntityType = model.AddEntityType(typeof(SomeCompositeEntityBase).FullName);
var compositeKeyProperty1 = someCompositeEntityType.AddProperty("Id1", typeof(int));
var compositeKeyProperty2 = someCompositeEntityType.AddProperty("Id2", typeof(string));
someCompositeEntityType.GetOrSetPrimaryKey(new[] { compositeKeyProperty1, compositeKeyProperty2 });
var entityType1 = model.AddEntityType(typeof(SomeEntity).FullName);
entityType1.BaseType = someSimpleEntityType;
var property3 = entityType1.AddProperty("Name", typeof(string));
property3.IsConcurrencyToken = true;
var entityType2 = model.AddEntityType(typeof(SomeDependentEntity).FullName);
entityType2.BaseType = someCompositeEntityType;
var fk = entityType2.AddProperty("SomeEntityId", typeof(int));
entityType2.GetOrAddForeignKey(new[] { fk }, entityType1.GetPrimaryKey(), entityType1);
var justAProperty = entityType2.AddProperty("JustAProperty", typeof(int));
justAProperty.RequiresValueGenerator = true;
var entityType3 = model.AddEntityType(typeof(FullNotificationEntity));
entityType3.GetOrSetPrimaryKey(entityType3.AddProperty("Id", typeof(int)));
var property6 = entityType3.AddProperty("Name", typeof(string));
property6.IsConcurrencyToken = true;
var entityType4 = model.AddEntityType(typeof(ChangedOnlyEntity));
entityType4.GetOrSetPrimaryKey(entityType4.AddProperty("Id", typeof(int)));
var property8 = entityType4.AddProperty("Name", typeof(string));
property8.IsConcurrencyToken = true;
var entityType5 = model.AddEntityType(typeof(SomeMoreDependentEntity).FullName);
entityType5.BaseType = someSimpleEntityType;
var fk5a = entityType5.AddProperty("Fk1", typeof(int));
var fk5b = entityType5.AddProperty("Fk2", typeof(string));
entityType5.GetOrAddForeignKey(new[] { fk5a, fk5b }, entityType2.GetPrimaryKey(), entityType2);
return model;
}
public void Creates_mixed_entry_when_entity_CLR_entity_type_and_shadow_properties()
{
var model = new Model();
var entityType = model.AddEntityType(typeof(RedHook));
entityType.GetOrAddProperty("Long", typeof(int));
entityType.GetOrAddProperty("Hammer", typeof(string), shadowProperty: true);
var contextServices = TestHelpers.Instance.CreateContextServices(model);
var stateManager = contextServices.GetRequiredService<IStateManager>();
var factory = contextServices.GetRequiredService<IInternalEntityEntryFactory>();
var entity = new RedHook();
var entry = factory.Create(stateManager, entityType, entity);
Assert.IsType<InternalMixedEntityEntry>(entry);
Assert.Same(stateManager, entry.StateManager);
Assert.Same(entityType, entry.EntityType);
Assert.Same(entity, entry.Entity);
}
public virtual IModel ConstructRelationalModel()
{
var relationalModel = new Microsoft.Data.Entity.Metadata.Model();
foreach (var table in _tables.Values)
{
relationalModel.AddEntityType(table.Id);
}
foreach (var tc in _tableColumns.Values)
{
var entityType = relationalModel.FindEntityType(tc.TableId);
if (entityType == null)
{
_logger.LogWarning(
Strings.CannotFindTableForColumn(tc.Id, tc.TableId));
continue;
}
// IModel will not allow Properties to be created without a Type, so map to CLR type here.
// This means if we come across a column with a SQL Server type which we can't map we will ignore it.
// Note: foreign key properties appear just like any other property in the relational model.
Type clrPropertyType;
if (!SqlServerTypeMapping._sqlTypeToClrTypeMap.TryGetValue(tc.DataType, out clrPropertyType))
{
_logger.LogWarning(
Strings.CannotFindTypeMappingForColumn(tc.Id, tc.DataType));
continue;
}
if (tc.IsNullable)
{
clrPropertyType = clrPropertyType.MakeNullable();
}
var relationalProperty = entityType.AddProperty(tc.Id, clrPropertyType, shadowProperty: true);
_relationalColumnIdToRelationalPropertyMap[tc.Id] = relationalProperty;
}
return(relationalModel);
}
public void Creates_CLR_only_entry_when_entity_has_no_shadow_properties()
{
var model = new Model();
var entityType = model.AddEntityType(typeof(RedHook));
var property = entityType.AddProperty("Long", typeof(int));
property.IsShadowProperty = false;
var property1 = entityType.AddProperty("Hammer", typeof(string));
property1.IsShadowProperty = false;
var contextServices = TestHelpers.Instance.CreateContextServices(model);
var stateManager = contextServices.GetRequiredService<IStateManager>();
var factory = contextServices.GetRequiredService<IInternalEntityEntryFactory>();
var entity = new RedHook();
var entry = factory.Create(stateManager, entityType, entity);
Assert.IsType<InternalClrEntityEntry>(entry);
Assert.Same(stateManager, entry.StateManager);
Assert.Same(entityType, entry.EntityType);
Assert.Same(entity, entry.Entity);
}
public virtual IModel ConstructCodeGenModel(
[NotNull] IModel relationalModel, [NotNull] SqlServerNameMapper nameMapper)
{
Check.NotNull(relationalModel, nameof(relationalModel));
Check.NotNull(nameMapper, nameof(nameMapper));
var codeGenModel = new Microsoft.Data.Entity.Metadata.Model();
foreach (var relationalEntityType in relationalModel.EntityTypes.Cast<EntityType>())
{
var codeGenEntityType = codeGenModel
.AddEntityType(nameMapper.EntityTypeToClassNameMap[relationalEntityType]);
_relationalEntityTypeToCodeGenEntityTypeMap[relationalEntityType] = codeGenEntityType;
codeGenEntityType.Relational().Table = _tables[relationalEntityType.Name].TableName;
codeGenEntityType.Relational().Schema = _tables[relationalEntityType.Name].SchemaName;
// Loop over relational properties constructing a matching property in the
// codeGenModel. Also accumulate:
// a) primary key properties
// b) constraint properties
var primaryKeyProperties = new List<Property>();
var constraints = new Dictionary<string, List<Property>>();
_relationalEntityTypeToForeignKeyConstraintsMap[relationalEntityType] = constraints;
foreach (var relationalProperty in relationalEntityType.Properties)
{
int primaryKeyOrdinal;
if (_primaryKeyOrdinals.TryGetValue(relationalProperty.Name, out primaryKeyOrdinal))
{
// add _relational_ property so we can order on the ordinal later
primaryKeyProperties.Add(relationalProperty);
}
Dictionary<string, int> foreignKeyConstraintIdOrdinalMap;
if (_foreignKeyOrdinals.TryGetValue(relationalProperty.Name, out foreignKeyConstraintIdOrdinalMap))
{
// relationalProperty represents (part of) a foreign key
foreach (var constraintId in foreignKeyConstraintIdOrdinalMap.Keys)
{
List<Property> constraintProperties;
if (!constraints.TryGetValue(constraintId, out constraintProperties))
{
constraintProperties = new List<Property>();
constraints.Add(constraintId, constraintProperties);
}
constraintProperties.Add(relationalProperty);
}
}
var codeGenProperty = codeGenEntityType.AddProperty(
nameMapper.PropertyToPropertyNameMap[relationalProperty],
relationalProperty.ClrType,
shadowProperty: true);
_relationalPropertyToCodeGenPropertyMap[relationalProperty] = codeGenProperty;
ApplyPropertyProperties(codeGenProperty, _tableColumns[relationalProperty.Name]);
} // end of loop over all relational properties for given EntityType
if (primaryKeyProperties.Count() > 0)
{
// order the relational properties by their primaryKeyOrdinal, then return a list
// of the codeGen properties mapped to each relational property in that order
codeGenEntityType.SetPrimaryKey(
primaryKeyProperties
.OrderBy(p => _primaryKeyOrdinals[p.Name]) // note: for relational property p.Name is its columnId
.Select(p => _relationalPropertyToCodeGenPropertyMap[p])
.ToList());
}
else
{
var errorMessage = Strings.NoPrimaryKeyColumns(
codeGenEntityType.Name,
_tables[relationalEntityType.Name].SchemaName,
_tables[relationalEntityType.Name].TableName);
codeGenEntityType.AddAnnotation(AnnotationNameEntityTypeError, errorMessage);
_logger.LogWarning(Strings.CannotGenerateEntityType(codeGenEntityType.Name, errorMessage));
}
} // end of loop over all relational EntityTypes
AddForeignKeysToCodeGenModel(codeGenModel);
return codeGenModel;
}
public virtual void Detects_multiple_root_principal_properties()
{
var model = new Model();
var entityA = model.AddEntityType(typeof(A));
SetPrimaryKey(entityA);
var keyA1 = CreateKey(entityA);
var keyA2 = CreateKey(entityA, startingPropertyIndex: 0, propertyCount: 2);
var entityB = model.AddEntityType(typeof(B));
SetPrimaryKey(entityB);
var keyB1 = CreateKey(entityB);
var keyB2 = CreateKey(entityB, startingPropertyIndex: 1, propertyCount: 2);
CreateForeignKey(keyA1, keyB1);
CreateForeignKey(keyA2, keyB2);
VerifyWarning(CoreStrings.MultipleRootPrincipals("A", "{'P0'}", "B", "P0", "{'P0', 'P1'}", "B", "P1"), model);
}
public virtual void Pases_on_diamond_path_to_root_principal_property()
{
var model = new Model();
var entityA = model.AddEntityType(typeof(A));
SetPrimaryKey(entityA);
var keyA1 = CreateKey(entityA);
var keyA2 = CreateKey(entityA, startingPropertyIndex: 0, propertyCount: 2);
var keyA3 = CreateKey(entityA);
var keyA4 = CreateKey(entityA, startingPropertyIndex: 2, propertyCount: 2);
var entityB = model.AddEntityType(typeof(B));
SetPrimaryKey(entityB);
var keyB1 = CreateKey(entityB);
var keyB2 = CreateKey(entityB, startingPropertyIndex: 1, propertyCount: 2);
CreateForeignKey(keyA1, keyB1);
CreateForeignKey(keyA2, keyB2);
CreateForeignKey(keyB1, keyA3);
CreateForeignKey(keyB2, keyA4);
Validate(model);
}
public virtual void Detects_GenerateOnAdd_not_set_on_principal_key_properties()
{
var model = new Model();
var entityA = model.AddEntityType(typeof(A));
SetPrimaryKey(entityA);
var keyA = CreateKey(entityA);
var entityB = model.AddEntityType(typeof(B));
SetPrimaryKey(entityB);
var keyB = CreateKey(entityB);
CreateForeignKey(keyA, keyB);
keyB.Properties[0].RequiresValueGenerator = false;
VerifyError(CoreStrings.PrincipalKeyNoValueGenerationOnAdd("P0", "B"), model);
}
