public void Generate_maps_abstract_type_hierarchies_correctly()
{
var model = new EdmModel(DataSpace.CSpace);
var rootEntityType = model.AddEntityType("E");
rootEntityType.Annotations.SetClrType(typeof(object));
var property0
= EdmProperty.Primitive("P1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
rootEntityType.AddMember(property0);
rootEntityType.AddKeyMember(rootEntityType.Properties.First());
var property1
= EdmProperty.Primitive("P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
rootEntityType.AddMember(property1);
model.AddEntitySet("ESet", rootEntityType);
var entityType2 = model.AddEntityType("E2");
var property2
= EdmProperty.Primitive("P3", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType2.AddMember(property2);
entityType2.Annotations.SetClrType(typeof(string));
entityType2.Abstract = true;
entityType2.BaseType = rootEntityType;
var entityType3 = model.AddEntityType("E3");
entityType3.Annotations.SetClrType(typeof(int));
var property3
= EdmProperty.Primitive("P4", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType3.AddMember(property3);
entityType3.BaseType = entityType2;
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entityType1Mapping = databaseMapping.GetEntityTypeMapping(rootEntityType);
var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3);
Assert.Equal(2, entityType1Mapping.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal("P1", entityType1Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name);
Assert.Equal("P2", entityType1Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name);
Assert.Equal(4, entityType3Mapping.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal("P1", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name);
Assert.Equal("P2", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name);
Assert.Equal("P3", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(2).ColumnProperty.Name);
Assert.Equal("P4", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(3).ColumnProperty.Name);
var table = entityType1Mapping.MappingFragments.Single().Table;
Assert.Equal(5, table.Properties.Count);
}
public void Generate_can_map_type_hierarchies_using_Tph()
{
var model = new EdmModel(DataSpace.CSpace);
var rootEntityType = model.AddEntityType("E");
var type = typeof(object);
rootEntityType.Annotations.SetClrType(type);
var property = EdmProperty.Primitive("P1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
rootEntityType.AddMember(property);
var property1 = EdmProperty.Primitive("P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
rootEntityType.AddMember(property1);
var entitySet = model.AddEntitySet("ESet", rootEntityType);
var entityType2 = model.AddEntityType("E2");
var property2 = EdmProperty.Primitive("P3", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType2.AddMember(property2);
var type1 = typeof(string);
entityType2.Annotations.SetClrType(type1);
entityType2.BaseType = rootEntityType;
var entityType3 = model.AddEntityType("E3");
var type2 = typeof(int);
entityType3.Annotations.SetClrType(type2);
var property3 = EdmProperty.Primitive("P4", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType3.AddMember(property3);
entityType3.BaseType = entityType2;
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entitySetMapping = databaseMapping.GetEntitySetMapping(entitySet);
Assert.NotNull(entitySetMapping);
var entityTypeMappings = entitySetMapping.EntityTypeMappings;
Assert.Equal(3, entityTypeMappings.Count());
var entityType1Mapping = databaseMapping.GetEntityTypeMapping(rootEntityType);
var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2);
var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3);
Assert.Equal(2, entityType1Mapping.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal(3, entityType2Mapping.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal(4, entityType3Mapping.MappingFragments.Single().ColumnMappings.Count());
var table = entityType1Mapping.MappingFragments.Single().Table;
Assert.Same(table, entityType2Mapping.MappingFragments.Single().Table);
Assert.Same(table, entityType3Mapping.MappingFragments.Single().Table);
Assert.Equal(5, table.Properties.Count);
Assert.Equal("P1", table.Properties[0].Name);
Assert.Equal("P2", table.Properties[1].Name);
Assert.Equal("P3", table.Properties[2].Name);
Assert.Equal("P4", table.Properties[3].Name);
Assert.Equal("Discriminator", table.Properties[4].Name);
}
public void Generate_can_map_foreign_key_association_type()
{
var model = new EdmModel(DataSpace.CSpace);
var principalEntityType = model.AddEntityType("P");
principalEntityType.Annotations.SetClrType(typeof(object));
var dependentEntityType = model.AddEntityType("D");
dependentEntityType.Annotations.SetClrType(typeof(string));
var dependentProperty1 = EdmProperty.Primitive("FK1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
dependentProperty1.Nullable = false;
dependentEntityType.AddMember(dependentProperty1);
var dependentProperty2 = EdmProperty.Primitive("FK2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
dependentEntityType.AddMember(dependentProperty2);
model.AddEntitySet("PSet", principalEntityType);
model.AddEntitySet("DSet", dependentEntityType);
var associationType
= model.AddAssociationType(
"P_D",
principalEntityType, RelationshipMultiplicity.One,
dependentEntityType, RelationshipMultiplicity.Many);
associationType.Constraint
= new ReferentialConstraint(
associationType.SourceEnd,
associationType.TargetEnd,
principalEntityType.KeyProperties,
new[] { dependentProperty1, dependentProperty2 });
associationType.SourceEnd.DeleteBehavior = OperationAction.Cascade;
var databaseMapping
= new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var dependentTable = databaseMapping.GetEntityTypeMapping(dependentEntityType).MappingFragments.Single().Table;
var foreignKeyConstraint = dependentTable.ForeignKeyBuilders.Single();
Assert.Equal(2, dependentTable.Properties.Count());
Assert.Equal(2, foreignKeyConstraint.DependentColumns.Count());
Assert.Equal(OperationAction.Cascade, foreignKeyConstraint.DeleteAction);
Assert.Equal(associationType.Name, foreignKeyConstraint.Name);
var foreignKeyColumn = foreignKeyConstraint.DependentColumns.First();
Assert.False(foreignKeyColumn.Nullable);
Assert.Equal("FK1", foreignKeyColumn.Name);
}
public void Generate_can_map_independent_association_type()
{
var model = new EdmModel(DataSpace.CSpace);
var principalEntityType = model.AddEntityType("P");
var type = typeof(object);
principalEntityType.Annotations.SetClrType(type);
var property = EdmProperty.Primitive("Id1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
principalEntityType.AddMember(property);
var idProperty1 = property;
principalEntityType.AddKeyMember(idProperty1);
var property1 = EdmProperty.Primitive("Id2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
principalEntityType.AddMember(property1);
var idProperty2 = property1;
principalEntityType.AddKeyMember(idProperty2);
var dependentEntityType = model.AddEntityType("D");
var type1 = typeof(string);
dependentEntityType.Annotations.SetClrType(type1);
model.AddEntitySet("PSet", principalEntityType);
model.AddEntitySet("DSet", dependentEntityType);
var associationType
= model.AddAssociationType(
"P_D",
principalEntityType, RelationshipMultiplicity.One,
dependentEntityType, RelationshipMultiplicity.Many);
model.AddAssociationSet("P_DSet", associationType);
associationType.SourceEnd.DeleteBehavior = OperationAction.Cascade;
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var foreignKeyConstraint
=
databaseMapping.GetEntityTypeMapping(dependentEntityType).MappingFragments.Single().Table.ForeignKeyBuilders.Single();
Assert.Equal(2, foreignKeyConstraint.DependentColumns.Count());
Assert.Equal(associationType.Name, foreignKeyConstraint.Name);
Assert.Equal(1, databaseMapping.EntityContainerMappings.Single().AssociationSetMappings.Count());
Assert.Equal(OperationAction.Cascade, foreignKeyConstraint.DeleteAction);
var foreignKeyColumn = foreignKeyConstraint.DependentColumns.First();
Assert.False(foreignKeyColumn.Nullable);
Assert.Equal("P_Id1", foreignKeyColumn.Name);
}
public void Generate_should_correctly_map_string_primitive_property_facets()
{
var model = new EdmModel(DataSpace.CSpace);
var entityType = model.AddEntityType("E");
var type = typeof(object);
entityType.Annotations.SetClrType(type);
model.AddEntitySet("ESet", entityType);
var property
= EdmProperty
.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property);
property.Nullable = false;
property.IsFixedLength = true;
property.IsMaxLength = true;
property.IsUnicode = true;
property.MaxLength = 42;
property.Precision = 23;
property.Scale = 77;
property.SetStoreGeneratedPattern(StoreGeneratedPattern.Identity);
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var column = databaseMapping.GetEntityTypeMapping(entityType).MappingFragments.Single().ColumnMappings.Single().ColumnProperty;
Assert.False(column.Nullable);
Assert.True(column.IsFixedLengthConstant);
Assert.False(column.IsMaxLength);
Assert.True(column.IsUnicodeConstant);
Assert.Equal(42, column.MaxLength);
Assert.Null(column.Precision);
Assert.Null(column.Scale);
Assert.Equal(StoreGeneratedPattern.Identity, column.StoreGeneratedPattern);
}
public void Generate_should_correctly_map_time_primitive_property_facets()
{
var model = new EdmModel(DataSpace.CSpace);
var entityType = model.AddEntityType("E");
var type = typeof(object);
entityType.Annotations.SetClrType(type);
model.AddEntitySet("ESet", entityType);
var property
= EdmProperty
.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Time));
entityType.AddMember(property);
property.Nullable = false;
property.IsFixedLength = true;
property.IsMaxLength = true;
property.IsUnicode = false;
property.MaxLength = 42;
property.Precision = 23;
property.Scale = 77;
property.SetStoreGeneratedPattern(StoreGeneratedPattern.Identity);
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var column = databaseMapping.GetEntityTypeMapping(entityType).MappingFragments.Single().ColumnMappings.Single().ColumnProperty;
Assert.False(column.Nullable);
Assert.Null(column.IsFixedLength);
Assert.False(column.IsMaxLength);
Assert.Null(column.IsUnicode);
Assert.Null(column.MaxLength);
Assert.Equal <byte?>(23, column.Precision);
Assert.Null(column.Scale);
Assert.Equal(StoreGeneratedPattern.Identity, column.StoreGeneratedPattern);
}
public void Configure_mapping_can_process_entity_splitting()
{
EdmModel model =
new TestModelBuilder()
.Entity("E")
.Key("P1")
.Property("P2")
.Property("P3")
.Property("P4")
.Property("P5");
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entityType = model.GetEntityType("E");
var modelConfiguration = new ModelConfiguration();
var entityMappingConfiguration1 =
new EntityMappingConfiguration
{
Properties =
new List<PropertyPath>
{
new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P1").GetClrPropertyInfo()),
new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P2").GetClrPropertyInfo()),
new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P3").GetClrPropertyInfo())
},
TableName = new DatabaseName("E1")
};
var entityMappingConfiguration2 =
new EntityMappingConfiguration
{
Properties =
new List<PropertyPath>
{
new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P1").GetClrPropertyInfo()),
new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P4").GetClrPropertyInfo()),
new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P5").GetClrPropertyInfo())
},
TableName = new DatabaseName("E2")
};
var entityConfiguration = modelConfiguration.Entity(entityType.GetClrType());
entityConfiguration.AddMappingConfiguration(entityMappingConfiguration1);
entityConfiguration.AddMappingConfiguration(entityMappingConfiguration2);
modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
var entityTypeMapping = databaseMapping.GetEntityTypeMapping(entityType);
var table1 = entityTypeMapping.TypeMappingFragments[0].Table;
var table2 = entityTypeMapping.TypeMappingFragments[1].Table;
Assert.NotSame(table1, table2);
Assert.Equal("E1", table1.GetTableName().Name);
Assert.Equal("E2", table2.GetTableName().Name);
Assert.Equal(3, table1.Columns.Count);
Assert.Equal(3, table2.Columns.Count);
Assert.Equal(2, entityTypeMapping.TypeMappingFragments.Count);
var entityTypeMappingFragment1 = entityTypeMapping.TypeMappingFragments[0];
var entityTypeMappingFragment2 = entityTypeMapping.TypeMappingFragments[1];
Assert.Equal(3, entityTypeMappingFragment1.PropertyMappings.Count);
Assert.Equal("P1", entityTypeMappingFragment1.PropertyMappings[0].Column.Name);
Assert.Equal("P2", entityTypeMappingFragment1.PropertyMappings[1].Column.Name);
Assert.Equal("P3", entityTypeMappingFragment1.PropertyMappings[2].Column.Name);
Assert.Equal(3, entityTypeMappingFragment2.PropertyMappings.Count);
Assert.Equal("P1", entityTypeMappingFragment2.PropertyMappings[0].Column.Name);
Assert.Equal("P4", entityTypeMappingFragment2.PropertyMappings[1].Column.Name);
Assert.Equal("P5", entityTypeMappingFragment2.PropertyMappings[2].Column.Name);
}
public void Configure_mapping_can_process_one_level_TPH_on_both_sides_of_tree()
{
//Setup
var model = TestModelBuilderHelpers.CreateSingleLevelInheritanceWithThreeEntities();
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entityType1 = model.GetEntityType("E1");
var entityType2 = model.GetEntityType("E2");
var entityType3 = model.GetEntityType("E3");
// Action
var modelConfiguration = new ModelConfiguration();
var entity1Configuration = modelConfiguration.Entity(entityType1.GetClrType());
var entity1MappingConfiguration =
new EntityMappingConfiguration
{
TableName = new DatabaseName("E1")
};
entity1MappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity1MappingConfiguration, "P3")
{
Value = null
});
entity1MappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity1MappingConfiguration, "P4")
{
Value = null
});
entity1Configuration.AddMappingConfiguration(entity1MappingConfiguration);
var entity1SubTypeMappingConfiguration =
new EntityMappingConfiguration
{
TableName = new DatabaseName("E1")
};
entity1SubTypeMappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity1SubTypeMappingConfiguration, "P3")
{
Value = null
});
entity1SubTypeMappingConfiguration
.AddNullabilityCondition(
new NotNullConditionConfiguration(
entity1SubTypeMappingConfiguration,
new PropertyPath(entityType3.GetDeclaredPrimitiveProperty("P4").GetClrPropertyInfo())));
entity1Configuration.AddSubTypeMappingConfiguration(entityType3.GetClrType(), entity1SubTypeMappingConfiguration);
var entity2Configuration = modelConfiguration.Entity(entityType2.GetClrType());
var entity2MappingConfiguration =
new EntityMappingConfiguration
{
TableName = new DatabaseName("E1")
};
entity2MappingConfiguration
.AddNullabilityCondition(
new NotNullConditionConfiguration(
entity2MappingConfiguration, new PropertyPath(entityType2.GetDeclaredPrimitiveProperty("P3").GetClrPropertyInfo())));
entity2MappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity2MappingConfiguration, "P4")
{
Value = null
});
entity2Configuration.AddMappingConfiguration(entity2MappingConfiguration);
modelConfiguration.NormalizeConfigurations();
modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
//Validate
var entitySetMapping = databaseMapping.GetEntitySetMapping(model.GetEntitySet(entityType1));
Assert.NotNull(entitySetMapping);
Assert.Equal(4, entitySetMapping.EntityTypeMappings.Count);
var entityType1Mapping = databaseMapping.GetEntityTypeMapping(entityType1);
var entityType1MappingConditions = databaseMapping.GetEntityTypeMappings(entityType1).Single(x => !x.IsHierarchyMapping);
var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2);
var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3);
var table1 = entityType1Mapping.TypeMappingFragments.Single().Table;
var table2 = entityType2Mapping.TypeMappingFragments.Single().Table;
var table3 = entityType3Mapping.TypeMappingFragments.Single().Table;
Assert.True(entityType1Mapping.IsHierarchyMapping);
Assert.Equal(4, table1.Columns.Count);
Assert.Equal("P1", table1.Columns[0].Name);
Assert.Equal("P2", table1.Columns[1].Name);
Assert.Equal("P3", table1.Columns[2].Name);
Assert.Equal("P4", table1.Columns[3].Name);
Assert.Equal(2, entityType1Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal("P1", entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P2", entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Same(table1.Columns[2], entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions[0].Column);
Assert.True((bool)entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions[0].IsNull);
Assert.Same(table1.Columns[3], entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions[1].Column);
Assert.True((bool)entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions[1].IsNull);
Assert.False(entityType2Mapping.IsHierarchyMapping);
Assert.Same(table1, table2);
Assert.Same(table1.Columns[0], table2.Columns[0]);
Assert.Same(table1.Columns[1], table2.Columns[1]);
Assert.Equal(2, entityType2Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal("P1", entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P3", entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Same(table1.Columns[3], entityType2Mapping.TypeMappingFragments.Single().ColumnConditions[0].Column);
Assert.True((bool)entityType2Mapping.TypeMappingFragments.Single().ColumnConditions[0].IsNull);
Assert.Same(table1.Columns[2], entityType2Mapping.TypeMappingFragments.Single().ColumnConditions[1].Column);
Assert.False((bool)entityType2Mapping.TypeMappingFragments.Single().ColumnConditions[1].IsNull);
Assert.False(entityType3Mapping.IsHierarchyMapping);
Assert.Same(table1, table3);
Assert.Same(table1.Columns[0], table3.Columns[0]);
Assert.Same(table1.Columns[1], table3.Columns[1]);
Assert.Equal(2, entityType3Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal("P1", entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P4", entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Same(table1.Columns[2], entityType3Mapping.TypeMappingFragments.Single().ColumnConditions[0].Column);
Assert.True((bool)entityType3Mapping.TypeMappingFragments.Single().ColumnConditions[0].IsNull);
Assert.Same(table1.Columns[3], entityType3Mapping.TypeMappingFragments.Single().ColumnConditions[1].Column);
Assert.False((bool)entityType3Mapping.TypeMappingFragments.Single().ColumnConditions[1].IsNull);
}
public void Configure_mapping_can_process_simple_TPH_mapping()
{
//Setup
var model = TestModelBuilderHelpers.CreateSimpleInheritanceTwoEntities();
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entityType1 = model.GetEntityType("E1");
var entityType2 = model.GetEntityType("E2");
// Action
var modelConfiguration = new ModelConfiguration();
var entity1Configuration = modelConfiguration.Entity(entityType1.GetClrType());
var entity1MappingConfiguration =
new EntityMappingConfiguration
{
TableName = new DatabaseName("E1")
};
entity1MappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity1MappingConfiguration, "disc")
{
Value = "foo"
});
entity1Configuration.AddMappingConfiguration(entity1MappingConfiguration);
var entity1SubTypeMappingConfiguration =
new EntityMappingConfiguration
{
TableName = new DatabaseName("E1")
};
entity1SubTypeMappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity1SubTypeMappingConfiguration, "disc")
{
Value = "bar"
});
entity1Configuration.AddSubTypeMappingConfiguration(entityType2.GetClrType(), entity1SubTypeMappingConfiguration);
modelConfiguration.NormalizeConfigurations();
modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
//Validate
var entitySetMapping = databaseMapping.GetEntitySetMapping(model.GetEntitySet(entityType1));
Assert.NotNull(entitySetMapping);
Assert.Equal(3, entitySetMapping.EntityTypeMappings.Count);
var entityType1Mapping = databaseMapping.GetEntityTypeMapping(entityType1);
var entityType1MappingConditions = databaseMapping.GetEntityTypeMappings(entityType1).Single(tm => !tm.IsHierarchyMapping);
var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2);
var table1 = entityType1Mapping.TypeMappingFragments.Single().Table;
var table2 = entityType2Mapping.TypeMappingFragments.Single().Table;
Assert.True(entityType1Mapping.IsHierarchyMapping);
Assert.Equal(4, table1.Columns.Count);
Assert.Equal("P1", table1.Columns[0].Name);
Assert.Equal("P2", table1.Columns[1].Name);
Assert.Equal("P3", table1.Columns[2].Name);
Assert.Equal("disc", table1.Columns[3].Name);
Assert.Equal(2, entityType1Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal("P1", entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P2", entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Same(table1.Columns[3], entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions.Single().Column);
Assert.Equal("foo", entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions.Single().Value);
Assert.Equal("nvarchar", entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions.Single().Column.TypeName);
Assert.Equal(
DatabaseMappingGenerator.DiscriminatorLength,
entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions.Single().Column.Facets.MaxLength);
Assert.False(entityType2Mapping.IsHierarchyMapping);
Assert.Same(table1, table2);
Assert.Equal(2, entityType2Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Same(table1.Columns[0], table2.Columns[0]);
Assert.Same(table1.Columns[1], table2.Columns[1]);
Assert.Equal("P1", entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P3", entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Same(table2.Columns[3], entityType2Mapping.TypeMappingFragments.Single().ColumnConditions.Single().Column);
Assert.Equal("bar", entityType2Mapping.TypeMappingFragments.Single().ColumnConditions.Single().Value);
}
public void Generate_can_map_foreign_key_association_type()
{
var model = new EdmModel(DataSpace.CSpace);
var principalEntityType = model.AddEntityType("P");
principalEntityType.Annotations.SetClrType(typeof(object));
var dependentEntityType = model.AddEntityType("D");
dependentEntityType.Annotations.SetClrType(typeof(string));
var dependentProperty1 = EdmProperty.Primitive("FK1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
dependentProperty1.Nullable = false;
dependentEntityType.AddMember(dependentProperty1);
var dependentProperty2 = EdmProperty.Primitive("FK2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
dependentEntityType.AddMember(dependentProperty2);
model.AddEntitySet("PSet", principalEntityType);
model.AddEntitySet("DSet", dependentEntityType);
var associationType
= model.AddAssociationType(
"P_D",
principalEntityType, RelationshipMultiplicity.One,
dependentEntityType, RelationshipMultiplicity.Many);
associationType.Constraint
= new ReferentialConstraint(
associationType.SourceEnd,
associationType.TargetEnd,
principalEntityType.KeyProperties,
new[] { dependentProperty1, dependentProperty2 });
associationType.SourceEnd.DeleteBehavior = OperationAction.Cascade;
var databaseMapping
= new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var dependentTable = databaseMapping.GetEntityTypeMapping(dependentEntityType).MappingFragments.Single().Table;
var foreignKeyConstraint = dependentTable.ForeignKeyBuilders.Single();
Assert.Equal(2, dependentTable.Properties.Count());
Assert.Equal(2, foreignKeyConstraint.DependentColumns.Count());
Assert.Equal(OperationAction.Cascade, foreignKeyConstraint.DeleteAction);
Assert.Equal(associationType.Name, foreignKeyConstraint.Name);
var foreignKeyColumn = foreignKeyConstraint.DependentColumns.First();
Assert.False(foreignKeyColumn.Nullable);
Assert.Equal("FK1", foreignKeyColumn.Name);
}
public void Configure_mapping_can_configure_one_level_TPT_on_both_sides_of_tree()
{
//Setup
var model = TestModelBuilderHelpers.CreateSingleLevelInheritanceWithThreeEntities();
var entityType1 = model.GetEntityType("E1");
var entityType2 = model.GetEntityType("E2");
var entityType3 = model.GetEntityType("E3");
entityType1.GetDeclaredPrimitiveProperty("P1").SetStoreGeneratedPattern(DbStoreGeneratedPattern.Identity);
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var modelConfiguration = new ModelConfiguration();
modelConfiguration.Entity(entityType2.GetClrType()).ToTable("E2");
modelConfiguration.Entity(entityType3.GetClrType()).ToTable("E3");
modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
var entityTypeMapping1 = databaseMapping.GetEntityTypeMapping(entityType1);
var entityTypeMapping2 = databaseMapping.GetEntityTypeMapping(entityType2);
var entityTypeMapping3 = databaseMapping.GetEntityTypeMapping(entityType3);
var table1 = entityTypeMapping1.TypeMappingFragments.Single().Table;
var table2 = entityTypeMapping2.TypeMappingFragments.Single().Table;
var table3 = entityTypeMapping3.TypeMappingFragments.Single().Table;
Assert.NotSame(table1, table2);
Assert.NotSame(table1, table3);
Assert.NotSame(table3, table2);
Assert.True(entityTypeMapping1.IsHierarchyMapping);
Assert.Equal(2, table1.Columns.Count);
Assert.Equal("P1", table1.Columns[0].Name);
Assert.Equal(DbStoreGeneratedPattern.Identity, table1.Columns[0].StoreGeneratedPattern);
Assert.Equal("P2", table1.Columns[1].Name);
Assert.Equal(2, entityTypeMapping1.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal("P1", entityTypeMapping1.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P2", entityTypeMapping1.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.False(entityTypeMapping2.IsHierarchyMapping);
Assert.Equal(2, entityTypeMapping2.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal("P1", entityTypeMapping2.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal(DbStoreGeneratedPattern.None, table2.Columns[0].StoreGeneratedPattern);
Assert.Equal("P3", entityTypeMapping2.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Equal(2, table2.Columns.Count);
Assert.Equal("P1", table2.Columns[0].Name);
Assert.Equal("P3", table2.Columns[1].Name);
Assert.NotSame(table1.Columns[0], table2.Columns[0]);
Assert.False(entityTypeMapping3.IsHierarchyMapping);
Assert.Equal(2, entityTypeMapping3.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal(DbStoreGeneratedPattern.None, table3.Columns[0].StoreGeneratedPattern);
Assert.Equal("P1", entityTypeMapping3.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P4", entityTypeMapping3.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Equal(2, table3.Columns.Count);
Assert.Equal("P1", table3.Columns[0].Name);
Assert.Equal("P4", table3.Columns[1].Name);
Assert.NotSame(table1.Columns[0], table3.Columns[0]);
Assert.NotSame(table2.Columns[0], table3.Columns[0]);
}
public void Configure_mapping_can_process_simple_TPC_mapping()
{
//Setup
var model = TestModelBuilderHelpers.CreateSimpleInheritanceTwoEntities();
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderInfo, ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entityType1 = model.GetEntityType("E1");
var entityType2 = model.GetEntityType("E2");
// Action
var modelConfiguration = new ModelConfiguration();
modelConfiguration.Entity(entityType2.GetClrType())
.AddMappingConfiguration(
new EntityMappingConfiguration
{
MapInheritedProperties = true,
TableName = new DatabaseName("E2")
});
modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
//Validate
var entitySetMapping = databaseMapping.GetEntitySetMapping(model.GetEntitySet(entityType1));
Assert.NotNull(entitySetMapping);
Assert.Equal(2, entitySetMapping.EntityTypeMappings.Count());
var entityType1Mapping = databaseMapping.GetEntityTypeMapping(entityType1);
var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2);
var table1 = entityType1Mapping.MappingFragments.Single().Table;
var table2 = entityType2Mapping.MappingFragments.Single().Table;
Assert.NotSame(table1, table2);
Assert.False(entityType1Mapping.IsHierarchyMapping);
Assert.Equal(2, table1.Properties.Count);
Assert.Equal("P1", table1.Properties[0].Name);
Assert.Equal("P2", table1.Properties[1].Name);
Assert.Equal(2, entityType1Mapping.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal("P1", entityType1Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name);
Assert.Equal("P2", entityType1Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name);
Assert.False(entityType2Mapping.IsHierarchyMapping);
Assert.Equal(3, entityType2Mapping.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal("P1", entityType2Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name);
Assert.Equal("P2", entityType2Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name);
Assert.Equal("P3", entityType2Mapping.MappingFragments.Single().ColumnMappings.ElementAt(2).ColumnProperty.Name);
Assert.Equal(3, table2.Properties.Count);
Assert.Equal("P1", table2.Properties[0].Name);
Assert.Equal("P2", table2.Properties[1].Name);
Assert.Equal("P3", table2.Properties[2].Name);
Assert.NotSame(table1.Properties[0], table2.Properties[0]);
Assert.NotSame(table1.Properties[1], table2.Properties[1]);
Assert.NotSame(
entityType1Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty,
entityType2Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty);
Assert.NotSame(
entityType1Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty,
entityType2Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty);
}
public void Configure_mapping_can_configure_two_levels_of_TPT()
{
//Setup
var model = TestModelBuilderHelpers.CreateTwoLevelInheritanceWithThreeEntities();
var entityType1 = model.GetEntityType("E1");
var entityType2 = model.GetEntityType("E2");
var entityType3 = model.GetEntityType("E3");
(entityType1.GetDeclaredPrimitiveProperties().SingleOrDefault(p => p.Name == "P1")).SetStoreGeneratedPattern(
StoreGeneratedPattern.Identity);
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderInfo, ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var modelConfiguration = new ModelConfiguration();
modelConfiguration.Entity(entityType2.GetClrType()).ToTable("E2");
modelConfiguration.Entity(entityType3.GetClrType()).ToTable("E3");
modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
var entityTypeMapping1 = databaseMapping.GetEntityTypeMapping(entityType1);
var entityTypeMapping2 = databaseMapping.GetEntityTypeMapping(entityType2);
var entityTypeMapping3 = databaseMapping.GetEntityTypeMapping(entityType3);
var table1 = entityTypeMapping1.MappingFragments.Single().Table;
var table2 = entityTypeMapping2.MappingFragments.Single().Table;
var table3 = entityTypeMapping3.MappingFragments.Single().Table;
Assert.NotSame(table1, table2);
Assert.NotSame(table1, table3);
Assert.NotSame(table3, table2);
Assert.True(entityTypeMapping1.IsHierarchyMapping);
Assert.Equal(2, table1.Properties.Count);
Assert.Equal("P1", table1.Properties[0].Name);
Assert.Equal("P2", table1.Properties[1].Name);
Assert.Equal(StoreGeneratedPattern.Identity, table1.Properties[0].StoreGeneratedPattern);
Assert.Equal(2, entityTypeMapping1.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal("P1", entityTypeMapping1.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name);
Assert.Equal("P2", entityTypeMapping1.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name);
Assert.True(entityTypeMapping2.IsHierarchyMapping);
Assert.Equal(StoreGeneratedPattern.None, table2.Properties[0].StoreGeneratedPattern);
Assert.Equal(2, entityTypeMapping2.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal("P1", entityTypeMapping2.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name);
Assert.Equal("P3", entityTypeMapping2.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name);
Assert.Equal(2, table2.Properties.Count);
Assert.Equal("P1", table2.Properties[0].Name);
Assert.Equal("P3", table2.Properties[1].Name);
Assert.NotSame(table1.Properties[0], table2.Properties[0]);
Assert.False(entityTypeMapping3.IsHierarchyMapping);
Assert.Equal(StoreGeneratedPattern.None, table3.Properties[0].StoreGeneratedPattern);
Assert.Equal(2, entityTypeMapping3.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal("P1", entityTypeMapping3.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name);
Assert.Equal("P4", entityTypeMapping3.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name);
Assert.Equal(2, table3.Properties.Count);
Assert.Equal("P1", table3.Properties[0].Name);
Assert.Equal("P4", table3.Properties[1].Name);
Assert.NotSame(table1.Properties[0], table3.Properties[0]);
Assert.NotSame(table2.Properties[0], table3.Properties[0]);
}
public void Configure_mapping_can_process_two_levels_of_TPH()
{
//Setup
var model = TestModelBuilderHelpers.CreateTwoLevelInheritanceWithThreeEntities();
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderInfo, ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entityType1 = model.GetEntityType("E1");
var entityType2 = model.GetEntityType("E2");
var entityType3 = model.GetEntityType("E3");
// Action
var modelConfiguration = new ModelConfiguration();
var entity1Configuration = modelConfiguration.Entity(entityType1.GetClrType());
var entity1MappingConfiguration =
new EntityMappingConfiguration
{
TableName = new DatabaseName("E1")
};
entity1MappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity1MappingConfiguration, "disc")
{
Value = 1
});
entity1Configuration.AddMappingConfiguration(entity1MappingConfiguration);
var entity1SubTypeMappingConfiguration =
new EntityMappingConfiguration
{
TableName = new DatabaseName("E1")
};
entity1SubTypeMappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity1SubTypeMappingConfiguration, "disc")
{
Value = 3
});
entity1SubTypeMappingConfiguration
.AddNullabilityCondition(
new NotNullConditionConfiguration(
entity1SubTypeMappingConfiguration,
new PropertyPath(
entityType3.GetDeclaredPrimitiveProperties().SingleOrDefault(p => p.Name == "P4").GetClrPropertyInfo())));
entity1Configuration.AddSubTypeMappingConfiguration(entityType3.GetClrType(), entity1SubTypeMappingConfiguration);
var entity2Configuration = modelConfiguration.Entity(entityType2.GetClrType());
var entity2MappingConfiguration =
new EntityMappingConfiguration
{
TableName = new DatabaseName("E1")
};
entity2MappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity2MappingConfiguration, "disc")
{
Value = 2
});
entity2Configuration.AddMappingConfiguration(entity2MappingConfiguration);
modelConfiguration.NormalizeConfigurations();
modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
//Validate
var entitySetMapping = databaseMapping.GetEntitySetMapping(model.GetEntitySet(entityType1));
Assert.NotNull(entitySetMapping);
Assert.Equal(4, entitySetMapping.EntityTypeMappings.Count());
var entityType1Mapping = databaseMapping.GetEntityTypeMapping(entityType1);
var entityType1MappingConditions = databaseMapping.GetEntityTypeMappings(entityType1).Single(x => !x.IsHierarchyMapping);
var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2);
var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3);
var table1 = entityType1Mapping.MappingFragments.Single().Table;
var table2 = entityType2Mapping.MappingFragments.Single().Table;
var table3 = entityType3Mapping.MappingFragments.Single().Table;
Assert.True(entityType1Mapping.IsHierarchyMapping);
Assert.Equal(5, table1.Properties.Count);
Assert.Equal("P1", table1.Properties[0].Name);
Assert.Equal("P2", table1.Properties[1].Name);
Assert.Equal("P3", table1.Properties[2].Name);
Assert.Equal("P4", table1.Properties[3].Name);
Assert.Equal("disc", table1.Properties[4].Name);
Assert.Equal(2, entityType1Mapping.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal("P1", entityType1Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name);
Assert.Equal("P2", entityType1Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name);
Assert.Same(
table1.Properties[4], entityType1MappingConditions.MappingFragments.Single().ColumnConditions.Single().Column);
Assert.Equal(1, entityType1MappingConditions.MappingFragments.Single().ColumnConditions.Single().Value);
Assert.False(entityType2Mapping.IsHierarchyMapping);
Assert.Same(table1, table2);
Assert.Same(table1.Properties[0], table2.Properties[0]);
Assert.Same(table1.Properties[1], table2.Properties[1]);
Assert.Equal(2, entityType2Mapping.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal("P1", entityType2Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name);
Assert.Equal("P3", entityType2Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name);
Assert.Same(table2.Properties[4], entityType2Mapping.MappingFragments.Single().ColumnConditions.Single().Column);
Assert.Equal(2, entityType2Mapping.MappingFragments.Single().ColumnConditions.Single().Value);
Assert.Null(entityType2Mapping.MappingFragments.Single().ColumnConditions.Single().IsNull);
Assert.False(entityType3Mapping.IsHierarchyMapping);
Assert.Same(table1, table3);
Assert.Same(table1.Properties[0], table3.Properties[0]);
Assert.Same(table1.Properties[1], table3.Properties[1]);
Assert.Equal(3, entityType3Mapping.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal("P1", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name);
Assert.Equal("P3", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name);
Assert.Equal("P4", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(2).ColumnProperty.Name);
Assert.Same(table3.Properties[4], entityType3Mapping.MappingFragments.Single().ColumnConditions.ElementAt(0).Column);
Assert.Equal(3, entityType3Mapping.MappingFragments.Single().ColumnConditions.ElementAt(0).Value);
Assert.Equal("int", entityType3Mapping.MappingFragments.Single().ColumnConditions.ElementAt(0).Column.TypeName);
Assert.Same(table3.Properties[3], entityType3Mapping.MappingFragments.Single().ColumnConditions.ElementAt(1).Column);
Assert.Equal(false, entityType3Mapping.MappingFragments.Single().ColumnConditions.ElementAt(1).IsNull);
}
public void Generate_maps_abstract_type_hierarchies_correctly()
{
var model = new EdmModel(DataSpace.CSpace);
var rootEntityType = model.AddEntityType("E");
rootEntityType.Annotations.SetClrType(typeof(object));
var property0
= EdmProperty.Primitive("P1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
rootEntityType.AddMember(property0);
rootEntityType.AddKeyMember(rootEntityType.Properties.First());
var property1
= EdmProperty.Primitive("P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
rootEntityType.AddMember(property1);
model.AddEntitySet("ESet", rootEntityType);
var entityType2 = model.AddEntityType("E2");
var property2
= EdmProperty.Primitive("P3", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType2.AddMember(property2);
entityType2.Annotations.SetClrType(typeof(string));
entityType2.Abstract = true;
entityType2.BaseType = rootEntityType;
var entityType3 = model.AddEntityType("E3");
entityType3.Annotations.SetClrType(typeof(int));
var property3
= EdmProperty.Primitive("P4", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType3.AddMember(property3);
entityType3.BaseType = entityType2;
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entityType1Mapping = databaseMapping.GetEntityTypeMapping(rootEntityType);
var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3);
Assert.Equal(2, entityType1Mapping.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal("P1", entityType1Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name);
Assert.Equal("P2", entityType1Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name);
Assert.Equal(4, entityType3Mapping.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal("P1", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name);
Assert.Equal("P2", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name);
Assert.Equal("P3", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(2).ColumnProperty.Name);
Assert.Equal("P4", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(3).ColumnProperty.Name);
var table = entityType1Mapping.MappingFragments.Single().Table;
Assert.Equal(5, table.Properties.Count);
}
public void Generate_can_map_type_hierarchies_using_Tph()
{
var model = new EdmModel(DataSpace.CSpace);
var rootEntityType = model.AddEntityType("E");
var type = typeof(object);
rootEntityType.Annotations.SetClrType(type);
var property = EdmProperty.Primitive("P1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
rootEntityType.AddMember(property);
var property1 = EdmProperty.Primitive("P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
rootEntityType.AddMember(property1);
var entitySet = model.AddEntitySet("ESet", rootEntityType);
var entityType2 = model.AddEntityType("E2");
var property2 = EdmProperty.Primitive("P3", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType2.AddMember(property2);
var type1 = typeof(string);
entityType2.Annotations.SetClrType(type1);
entityType2.BaseType = rootEntityType;
var entityType3 = model.AddEntityType("E3");
var type2 = typeof(int);
entityType3.Annotations.SetClrType(type2);
var property3 = EdmProperty.Primitive("P4", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType3.AddMember(property3);
entityType3.BaseType = entityType2;
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entitySetMapping = databaseMapping.GetEntitySetMapping(entitySet);
Assert.NotNull(entitySetMapping);
var entityTypeMappings = entitySetMapping.EntityTypeMappings;
Assert.Equal(3, entityTypeMappings.Count());
var entityType1Mapping = databaseMapping.GetEntityTypeMapping(rootEntityType);
var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2);
var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3);
Assert.Equal(2, entityType1Mapping.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal(3, entityType2Mapping.MappingFragments.Single().ColumnMappings.Count());
Assert.Equal(4, entityType3Mapping.MappingFragments.Single().ColumnMappings.Count());
var table = entityType1Mapping.MappingFragments.Single().Table;
Assert.Same(table, entityType2Mapping.MappingFragments.Single().Table);
Assert.Same(table, entityType3Mapping.MappingFragments.Single().Table);
Assert.Equal(5, table.Properties.Count);
Assert.Equal("P1", table.Properties[0].Name);
Assert.Equal("P2", table.Properties[1].Name);
Assert.Equal("P3", table.Properties[2].Name);
Assert.Equal("P4", table.Properties[3].Name);
Assert.Equal("Discriminator", table.Properties[4].Name);
}
public void Configure_mapping_can_process_one_level_TPC_on_both_sides_of_tree()
{
//Setup
var model = TestModelBuilderHelpers.CreateSingleLevelInheritanceWithThreeEntities();
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entityType1 = model.GetEntityType("E1");
var entityType2 = model.GetEntityType("E2");
var entityType3 = model.GetEntityType("E3");
// Action
var modelConfiguration = new ModelConfiguration();
modelConfiguration.Entity(entityType2.GetClrType())
.AddMappingConfiguration(
new EntityMappingConfiguration
{
MapInheritedProperties = true,
TableName = new DatabaseName("E2")
});
modelConfiguration.Entity(entityType3.GetClrType())
.AddMappingConfiguration(
new EntityMappingConfiguration
{
MapInheritedProperties = true,
TableName = new DatabaseName("E3")
});
modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
//Validate
var entitySetMapping = databaseMapping.GetEntitySetMapping(model.GetEntitySet(entityType1));
Assert.NotNull(entitySetMapping);
Assert.Equal(3, entitySetMapping.EntityTypeMappings.Count);
var entityType1Mapping = databaseMapping.GetEntityTypeMapping(entityType1);
var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2);
var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3);
var table1 = entityType1Mapping.TypeMappingFragments.Single().Table;
var table2 = entityType2Mapping.TypeMappingFragments.Single().Table;
var table3 = entityType3Mapping.TypeMappingFragments.Single().Table;
Assert.False(entityType1Mapping.IsHierarchyMapping);
Assert.Equal(2, table1.Columns.Count);
Assert.Equal("P1", table1.Columns[0].Name);
Assert.Equal("P2", table1.Columns[1].Name);
Assert.Equal(2, entityType1Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Same(entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column, table1.Columns[0]);
Assert.Same(entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column, table1.Columns[1]);
Assert.False(entityType2Mapping.IsHierarchyMapping);
Assert.Equal("E2", table2.Name);
Assert.Equal(3, table2.Columns.Count);
Assert.Equal("P1", table2.Columns[0].Name);
Assert.Equal("P2", table2.Columns[1].Name);
Assert.Equal("P3", table2.Columns[2].Name);
Assert.NotSame(table1, table2);
Assert.NotSame(table1.Columns[0], table2.Columns[0]);
Assert.NotSame(table1.Columns[1], table2.Columns[1]);
Assert.Equal(3, entityType2Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Same(entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column, table2.Columns[0]);
Assert.Same(entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column, table2.Columns[1]);
Assert.Same(entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[2].Column, table2.Columns[2]);
Assert.False(entityType3Mapping.IsHierarchyMapping);
Assert.Equal("E3", table3.Name);
Assert.Equal(3, table3.Columns.Count);
Assert.Equal("P1", table3.Columns[0].Name);
Assert.Equal("P2", table3.Columns[1].Name);
Assert.Equal("P4", table3.Columns[2].Name);
Assert.NotSame(table1, table3);
Assert.NotSame(table3, table2);
Assert.NotSame(table1.Columns[0], table3.Columns[0]);
Assert.NotSame(table1.Columns[1], table3.Columns[1]);
Assert.Equal(3, entityType3Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Same(entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column, table3.Columns[0]);
Assert.Same(entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column, table3.Columns[1]);
Assert.Same(entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[2].Column, table3.Columns[2]);
}
public void Generate_can_map_independent_association_type()
{
var model = new EdmModel(DataSpace.CSpace);
var principalEntityType = model.AddEntityType("P");
var type = typeof(object);
principalEntityType.Annotations.SetClrType(type);
var property = EdmProperty.Primitive("Id1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
principalEntityType.AddMember(property);
var idProperty1 = property;
principalEntityType.AddKeyMember(idProperty1);
var property1 = EdmProperty.Primitive("Id2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
principalEntityType.AddMember(property1);
var idProperty2 = property1;
principalEntityType.AddKeyMember(idProperty2);
var dependentEntityType = model.AddEntityType("D");
var type1 = typeof(string);
dependentEntityType.Annotations.SetClrType(type1);
model.AddEntitySet("PSet", principalEntityType);
model.AddEntitySet("DSet", dependentEntityType);
var associationType
= model.AddAssociationType(
"P_D",
principalEntityType, RelationshipMultiplicity.One,
dependentEntityType, RelationshipMultiplicity.Many);
model.AddAssociationSet("P_DSet", associationType);
associationType.SourceEnd.DeleteBehavior = OperationAction.Cascade;
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var foreignKeyConstraint
=
databaseMapping.GetEntityTypeMapping(dependentEntityType).MappingFragments.Single().Table.ForeignKeyBuilders.Single();
Assert.Equal(2, foreignKeyConstraint.DependentColumns.Count());
Assert.Equal(associationType.Name, foreignKeyConstraint.Name);
Assert.Equal(1, databaseMapping.EntityContainerMappings.Single().AssociationSetMappings.Count());
Assert.Equal(OperationAction.Cascade, foreignKeyConstraint.DeleteAction);
var foreignKeyColumn = foreignKeyConstraint.DependentColumns.First();
Assert.False(foreignKeyColumn.Nullable);
Assert.Equal("P_Id1", foreignKeyColumn.Name);
}
