private void GenerateDiscriminators(DbDatabaseMapping databaseMapping)
{
//Contract.Requires(databaseMapping != null);
foreach (var entitySetMapping in databaseMapping.GetEntitySetMappings())
{
if (entitySetMapping.EntityTypeMappings.Count == 1)
{
continue;
}
var discriminatorColumn
= entitySetMapping
.EntityTypeMappings
.First()
.TypeMappingFragments
.Single()
.Table
.AddColumn(DiscriminatorColumnName);
InitializeDefaultDiscriminatorColumn(discriminatorColumn);
foreach (var entityTypeMapping in entitySetMapping.EntityTypeMappings)
{
var entityTypeMappingFragment = entityTypeMapping.TypeMappingFragments.Single();
entityTypeMappingFragment.SetDefaultDiscriminator(discriminatorColumn);
entityTypeMappingFragment
.AddDiscriminatorCondition(discriminatorColumn, entityTypeMapping.EntityType.Name);
}
}
}
private static bool RemapsInheritedProperties(
DbDatabaseMapping databaseMapping, DbEntityTypeMapping entityTypeMapping)
{
var inheritedProperties = entityTypeMapping.EntityType.Properties
.Except(entityTypeMapping.EntityType.DeclaredProperties)
.Except(entityTypeMapping.EntityType.GetKeyProperties());
foreach (var property in inheritedProperties)
{
var fragment = GetFragmentForPropertyMapping(entityTypeMapping, property);
if (fragment != null)
{
// find if this inherited property is mapped to another table by a base type
var baseType = entityTypeMapping.EntityType.BaseType;
while (baseType != null)
{
if (databaseMapping.GetEntityTypeMappings(baseType)
.Select(baseTypeMapping => GetFragmentForPropertyMapping(baseTypeMapping, property))
.Any(
baseFragment => baseFragment != null
&& baseFragment.Table != fragment.Table))
{
return true;
}
baseType = baseType.BaseType;
}
}
}
return false;
}
public void Initialize_should_add_default_entity_container_mapping()
{
var databaseMapping = new DbDatabaseMapping()
.Initialize(new EdmModel().Initialize(), new DbDatabaseMetadata());
Assert.Equal(1, databaseMapping.EntityContainerMappings.Count);
}
public void Serialize(DbDatabaseMapping databaseMapping, DbProviderInfo providerInfo, XmlWriter xmlWriter)
{
//Contract.Requires(xmlWriter != null);
//Contract.Requires(databaseMapping != null);
//Contract.Requires(providerInfo != null);
Contract.Assert(databaseMapping.Model != null);
Contract.Assert(databaseMapping.Database != null);
_xmlWriter = xmlWriter;
_databaseMapping = databaseMapping;
_version = databaseMapping.Model.Version;
_providerInfo = providerInfo;
_namespace = _version == DataModelVersions.Version3 ? EdmXmlNamespaceV3 : EdmXmlNamespaceV2;
_xmlWriter.WriteStartDocument();
using (Element("Edmx", "Version", string.Format(CultureInfo.InvariantCulture, "{0:F1}", _version)))
{
WriteEdmxRuntime();
WriteEdmxDesigner();
}
_xmlWriter.WriteEndDocument();
_xmlWriter.Flush();
}
public void Configure_should_update_table_name_when_base_type_is_null()
{
var entityMappingConfiguration = new EntityMappingConfiguration
{
TableName = new DatabaseName("Foo")
};
var entityTypeMapping = new DbEntityTypeMapping
{
EntityType = new EdmEntityType()
};
var table = new DbTableMetadata
{
Name = "foo"
};
entityTypeMapping.TypeMappingFragments.Add(
new DbEntityTypeMappingFragment
{
Table = table
});
var databaseMapping =
new DbDatabaseMapping().Initialize(new EdmModel().Initialize(), new DbDatabaseMetadata().Initialize());
databaseMapping.Database.AddTable("foo");
entityMappingConfiguration.Configure(
databaseMapping, ProviderRegistry.Sql2008_ProviderManifest, entityTypeMapping.EntityType, ref entityTypeMapping, false, 0, 1);
Assert.Equal("Foo", table.GetTableName().Name);
}
public void Apply_should_introduce_cascade_delete_on_constraints()
{
var databaseMapping
= new DbDatabaseMapping()
.Initialize(new EdmModel().Initialize(), new DbDatabaseMetadata().Initialize());
var foreignKeyConstraint = new DbForeignKeyConstraintMetadata();
Assert.Equal(DbOperationAction.None, foreignKeyConstraint.DeleteAction);
var table = new DbTableMetadata();
table.ForeignKeyConstraints.Add(foreignKeyConstraint);
var associationType = new EdmAssociationType().Initialize();
associationType.SourceEnd.EndKind = EdmAssociationEndKind.Many;
associationType.SourceEnd.EntityType = new EdmEntityType();
associationType.TargetEnd.EndKind = EdmAssociationEndKind.Many;
associationType.TargetEnd.EntityType = new EdmEntityType();
var associationSetMapping = databaseMapping.AddAssociationSetMapping(new EdmAssociationSet { ElementType = associationType });
associationSetMapping.Table = table;
((IDbMappingConvention)new ManyToManyCascadeDeleteConvention()).Apply(databaseMapping);
Assert.Equal(DbOperationAction.Cascade, foreignKeyConstraint.DeleteAction);
}
/// <summary>
/// Initializes a new instance of the <see cref="DbModel" /> class.
/// </summary>
internal DbModel(DbDatabaseMapping databaseMapping, DbModelBuilder modelBuilder)
{
Contract.Requires(databaseMapping != null);
Contract.Requires(modelBuilder != null);
_databaseMapping = databaseMapping;
_cachedModelBuilder = modelBuilder;
}
public void GetEntitySetMappings_should_return_mappings()
{
var databaseMapping = new DbDatabaseMapping()
.Initialize(new EdmModel().Initialize(), new DbDatabaseMetadata());
databaseMapping.AddAssociationSetMapping(new EdmAssociationSet());
Assert.Equal(1, databaseMapping.GetAssociationSetMappings().Count());
}
void IDbMappingConvention.Apply(DbDatabaseMapping databaseMapping)
{
databaseMapping.EntityContainerMappings
.SelectMany(ecm => ecm.AssociationSetMappings)
.Where(
asm => asm.AssociationSet.ElementType.IsManyToMany()
&& !asm.AssociationSet.ElementType.IsSelfReferencing())
.SelectMany(asm => asm.Table.ForeignKeyConstraints)
.Each(fk => fk.DeleteAction = DbOperationAction.Cascade);
}
/// <summary>
/// Serialize the <see cref="DbModel" /> to the XmlWriter
/// </summary>
/// <param name="databaseMapping"> The DbModel to serialize </param>
/// <param name="xmlWriter"> The XmlWriter to serialize to </param>
public virtual bool Serialize(DbDatabaseMapping databaseMapping, XmlWriter xmlWriter)
{
Contract.Requires(databaseMapping != null);
Contract.Requires(xmlWriter != null);
var schemaWriter = new DbModelMslSchemaWriter(xmlWriter, databaseMapping.Model.Version);
schemaWriter.WriteSchema(databaseMapping);
return true;
}
private static DbDatabaseMapping InitializeDatabaseMapping(EdmModel model)
{
//Contract.Requires(model != null);
var databaseMapping = new DbDatabaseMapping().Initialize(
model, new DbDatabaseMetadata().Initialize(model.Version));
databaseMapping.EntityContainerMappings.Single().EntityContainer = model.Containers.Single();
return databaseMapping;
}
public void AddAssociationSetMapping_should_add_mapping()
{
var databaseMapping = new DbDatabaseMapping()
.Initialize(new EdmModel().Initialize(), new DbDatabaseMetadata());
var associationSet = new EdmAssociationSet();
var associationSetMapping = databaseMapping.AddAssociationSetMapping(associationSet);
Assert.NotNull(associationSetMapping);
Assert.Equal(1, databaseMapping.EntityContainerMappings.Single().AssociationSetMappings.Count());
Assert.Same(associationSet, associationSetMapping.AssociationSet);
}
private void GenerateEntityTypes(EdmModel model, DbDatabaseMapping databaseMapping)
{
//Contract.Requires(model != null);
//Contract.Requires(databaseMapping != null);
foreach (var entityType in model.GetEntityTypes())
{
if (!entityType.IsAbstract)
{
new EntityTypeMappingGenerator(_providerManifest).
Generate(entityType, databaseMapping);
}
}
}
/// <summary>
/// Builds and stores the workspace based on the given code first configuration.
/// </summary>
/// <param name = "databaseMapping">The code first EDM model.</param>
public CodeFirstCachedMetadataWorkspace(DbDatabaseMapping databaseMapping)
{
//Contract.Requires(databaseMapping != null);
_providerInfo = databaseMapping.Database.GetProviderInfo();
_metadataWorkspace = databaseMapping.ToMetadataWorkspace();
_assemblies = databaseMapping.Model.GetClrTypes().Select(t => t.Assembly).Distinct().ToList();
Contract.Assert(
databaseMapping.Model.Containers.Count() == 1, "Expecting Code First to create only one container.");
_defaultContainerName = databaseMapping.Model.Containers.First().Name;
}
void IDbMappingConvention.Apply(DbDatabaseMapping databaseMapping)
{
databaseMapping.EntityContainerMappings
.SelectMany(ecm => ecm.EntitySetMappings)
.Each(
esm =>
{
foreach (var etm in esm.EntityTypeMappings)
{
if (RemapsInheritedProperties(databaseMapping, etm)
&& HasBaseWithIsTypeOf(esm, etm.EntityType))
{
throw Error.UnsupportedHybridInheritanceMapping(etm.EntityType.Name);
}
}
});
}
public void Generate(EdmAssociationType associationType, DbDatabaseMapping databaseMapping)
{
//Contract.Requires(associationType != null);
//Contract.Requires(databaseMapping != null);
if (associationType.Constraint != null)
{
GenerateForeignKeyAssociationType(associationType, databaseMapping);
}
else if (associationType.IsManyToMany())
{
GenerateManyToManyAssociation(associationType, databaseMapping);
}
else
{
GenerateIndependentAssociationType(associationType, databaseMapping);
}
}
internal void Configure(
DbDatabaseMapping databaseMapping, DbEntityTypeMappingFragment fragment, EdmEntityType entityType)
{
Contract.Requires(fragment != null);
var edmPropertyPath = EntityMappingConfiguration.PropertyPathToEdmPropertyPath(PropertyPath, entityType);
if (edmPropertyPath.Count() > 1)
{
throw Error.InvalidNotNullCondition(PropertyPath.ToString(), entityType.Name);
}
var column
= fragment.PropertyMappings
.Where(pm => pm.PropertyPath.SequenceEqual(edmPropertyPath.Single()))
.Select(pm => pm.Column)
.SingleOrDefault();
if (column == null
|| !fragment.Table.Columns.Contains(column))
{
throw Error.InvalidNotNullCondition(PropertyPath.ToString(), entityType.Name);
}
if (ValueConditionConfiguration.AnyBaseTypeToTableWithoutColumnCondition(
databaseMapping, entityType, fragment.Table, column))
{
column.IsNullable = true;
}
// Make the property required
var newConfiguration = new Properties.Primitive.PrimitivePropertyConfiguration
{
IsNullable = false,
OverridableConfigurationParts =
OverridableConfigurationParts.OverridableInSSpace
};
newConfiguration.Configure(edmPropertyPath.Single().Last());
fragment.AddNullabilityCondition(column, isNull: false);
}
public void Configure_should_configure_default_schema()
{
var modelConfiguration
= new ModelConfiguration
{
DefaultSchema = "foo"
};
var databaseMapping
= new DbDatabaseMapping().Initialize(
new EdmModel().Initialize(),
new DbDatabaseMetadata().Initialize());
Assert.Equal("dbo", databaseMapping.Database.Schemas.Single().Name);
Assert.Equal("dbo", databaseMapping.Database.Schemas.Single().DatabaseIdentifier);
modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
Assert.Equal("foo", databaseMapping.Database.Schemas.Single().Name);
Assert.Equal("foo", databaseMapping.Database.Schemas.Single().DatabaseIdentifier);
}
public void Generate(EdmEntityType entityType, DbDatabaseMapping databaseMapping)
{
//Contract.Requires(entityType != null);
//Contract.Requires(databaseMapping != null);
var entitySet = databaseMapping.Model.GetEntitySet(entityType);
var entitySetMapping
= databaseMapping.GetEntitySetMapping(entitySet)
?? databaseMapping.AddEntitySetMapping(entitySet);
var table
= entitySetMapping.EntityTypeMappings.Any()
? entitySetMapping.EntityTypeMappings.First().TypeMappingFragments.First().Table
: databaseMapping.Database.AddTable(entityType.GetRootType().Name);
var entityTypeMappingFragment = new DbEntityTypeMappingFragment
{
Table = table
};
var entityTypeMapping = new DbEntityTypeMapping
{
EntityType = entityType,
IsHierarchyMapping = false
};
entityTypeMapping.TypeMappingFragments.Add(entityTypeMappingFragment);
entityTypeMapping.SetClrType(entityType.GetClrType());
entitySetMapping.EntityTypeMappings.Add(entityTypeMapping);
new PropertyMappingGenerator(_providerManifest)
.Generate(
entityType,
entityType.Properties,
entitySetMapping,
entityTypeMappingFragment,
new List<EdmProperty>(),
false);
}
public void GetComplexPropertyMappings_should_return_all_complex_property_mappings_for_type()
{
var databaseMapping = new DbDatabaseMapping()
.Initialize(new EdmModel().Initialize(), new DbDatabaseMetadata());
var entitySet = new EdmEntitySet();
var entitySetMapping = databaseMapping.AddEntitySetMapping(entitySet);
var entityTypeMapping = new DbEntityTypeMapping();
entitySetMapping.EntityTypeMappings.Add(entityTypeMapping);
var entityTypeMappingFragment = new DbEntityTypeMappingFragment();
entityTypeMapping.TypeMappingFragments.Add(entityTypeMappingFragment);
var propertyMapping1 = new DbEdmPropertyMapping();
var complexType = new EdmComplexType();
complexType.SetClrType(typeof(object));
propertyMapping1.PropertyPath.Add(new EdmProperty { PropertyType = new EdmTypeReference { EdmType = complexType } });
entityTypeMappingFragment.PropertyMappings.Add(propertyMapping1);
var propertyMapping2 = new DbEdmPropertyMapping();
propertyMapping2.PropertyPath.Add(new EdmProperty { PropertyType = new EdmTypeReference() });
propertyMapping2.PropertyPath.Add(new EdmProperty { PropertyType = new EdmTypeReference { EdmType = complexType } });
entityTypeMappingFragment.PropertyMappings.Add(propertyMapping2);
Assert.Equal(2, databaseMapping.GetComplexPropertyMappings(typeof(object)).Count());
}
private void GenerateManyToManyAssociation(
EdmAssociationType associationType, DbDatabaseMapping databaseMapping)
{
//Contract.Requires(associationType != null);
//Contract.Requires(databaseMapping != null);
var sourceEntityType = associationType.SourceEnd.EntityType;
var targetEntityType = associationType.TargetEnd.EntityType;
var joinTable
= databaseMapping.Database.AddTable(sourceEntityType.Name + targetEntityType.Name);
var associationSetMapping
= GenerateAssociationSetMapping(
associationType, databaseMapping, associationType.SourceEnd, associationType.TargetEnd, joinTable);
GenerateIndependentForeignKeyConstraint(
databaseMapping,
sourceEntityType,
targetEntityType,
joinTable,
associationSetMapping,
associationSetMapping.SourceEndMapping,
associationType.SourceEnd.Name,
null,
isPrimaryKeyColumn: true);
GenerateIndependentForeignKeyConstraint(
databaseMapping,
targetEntityType,
sourceEntityType,
joinTable,
associationSetMapping,
associationSetMapping.TargetEndMapping,
associationType.TargetEnd.Name,
null,
isPrimaryKeyColumn: true);
}
private static void GenerateForeignKeyAssociationType(
EdmAssociationType associationType, DbDatabaseMapping databaseMapping)
{
//Contract.Requires(associationType != null);
//Contract.Requires(databaseMapping != null);
Contract.Assert(associationType.Constraint != null);
var dependentEnd = associationType.Constraint.DependentEnd;
var principalEnd = associationType.GetOtherEnd(dependentEnd);
var principalEntityTypeMapping = GetEntityTypeMappingInHierarchy(databaseMapping, principalEnd.EntityType);
var dependentEntityTypeMapping = GetEntityTypeMappingInHierarchy(databaseMapping, dependentEnd.EntityType);
var foreignKeyConstraint = new DbForeignKeyConstraintMetadata
{
Name = associationType.Name,
PrincipalTable =
principalEntityTypeMapping.TypeMappingFragments.Single().Table,
DeleteAction = principalEnd.DeleteAction.HasValue
? (DbOperationAction)principalEnd.DeleteAction.Value
: DbOperationAction.None
};
foreach (var dependentProperty in associationType.Constraint.DependentProperties)
{
foreignKeyConstraint.DependentColumns.Add(
dependentEntityTypeMapping.GetPropertyMapping(dependentProperty).Column);
}
foreignKeyConstraint.SetAssociationType(associationType);
dependentEntityTypeMapping
.TypeMappingFragments
.Single()
.Table
.ForeignKeyConstraints.Add(foreignKeyConstraint);
}
private void ConfigureAssociationMappings(DbDatabaseMapping databaseMapping, EdmEntityType entityType)
{
Contract.Requires(databaseMapping != null);
foreach (var configuration in _navigationPropertyConfigurations)
{
var propertyInfo = configuration.Key;
var navigationPropertyConfiguration = configuration.Value;
var navigationProperty = entityType.GetNavigationProperty(propertyInfo);
if (navigationProperty == null)
{
throw Error.NavigationPropertyNotFound(propertyInfo.Name, entityType.Name);
}
var associationSetMapping
= databaseMapping.GetAssociationSetMappings()
.SingleOrDefault(asm => asm.AssociationSet.ElementType == navigationProperty.Association);
if (associationSetMapping != null)
{
navigationPropertyConfiguration.Configure(associationSetMapping, databaseMapping);
}
}
}
internal void Configure(
EdmEntityType entityType,
DbDatabaseMapping databaseMapping,
DbProviderManifest providerManifest)
{
Contract.Requires(entityType != null);
Contract.Requires(databaseMapping != null);
Contract.Requires(providerManifest != null);
var entityTypeMapping
= databaseMapping.GetEntityTypeMapping(entityType.GetClrType());
if (entityTypeMapping != null)
{
VerifyAllCSpacePropertiesAreMapped(
databaseMapping.GetEntityTypeMappings(entityType),
entityTypeMapping.EntityType.DeclaredProperties,
new List<EdmProperty>());
}
ConfigurePropertyMappings(databaseMapping, entityType, providerManifest);
ConfigureAssociationMappings(databaseMapping, entityType);
ConfigureDependentKeys(databaseMapping);
}
private void ConfigurePropertyMappings(
DbDatabaseMapping databaseMapping, EdmEntityType entityType, DbProviderManifest providerManifest,
bool allowOverride = false)
{
Contract.Requires(databaseMapping != null);
Contract.Requires(entityType != null);
Contract.Requires(providerManifest != null);
var entityTypeMappings = databaseMapping.GetEntityTypeMappings(entityType);
var propertyMappings
= from etm in entityTypeMappings
from etmf in etm.TypeMappingFragments
from pm in etmf.PropertyMappings
select Tuple.Create(pm, etmf.Table);
Configure(propertyMappings, providerManifest, allowOverride);
foreach (
var derivedEntityType in databaseMapping.Model.GetEntityTypes().Where(et => et.BaseType == entityType))
{
ConfigurePropertyMappings(databaseMapping, derivedEntityType, providerManifest, true);
}
}
public void Configure_should_configure_mapping()
{
var manyToManyAssociationMappingConfiguration = new ManyToManyAssociationMappingConfiguration();
manyToManyAssociationMappingConfiguration.ToTable("Foo");
var navigationPropertyConfiguration = new NavigationPropertyConfiguration(new MockPropertyInfo())
{
AssociationMappingConfiguration = manyToManyAssociationMappingConfiguration
};
var databaseMapping = new DbDatabaseMapping().Initialize(new EdmModel().Initialize(), new DbDatabaseMetadata());
var associationSetMapping = databaseMapping.AddAssociationSetMapping(new EdmAssociationSet { ElementType = new EdmAssociationType() });
associationSetMapping.Table = new DbTableMetadata();
associationSetMapping.AssociationSet.ElementType.SetConfiguration(navigationPropertyConfiguration);
navigationPropertyConfiguration.Configure(associationSetMapping, databaseMapping);
Assert.Equal("Foo", associationSetMapping.Table.GetTableName().Name);
}
public EntityMappingService(DbDatabaseMapping databaseMapping)
{
Contract.Requires(databaseMapping != null);
_databaseMapping = databaseMapping;
}
void IDbMappingConvention.Apply(DbDatabaseMapping databaseMapping)
{
Contract.Requires(databaseMapping != null);
}
internal void Configure(DbAssociationSetMapping associationSetMapping, DbDatabaseMapping databaseMapping)
{
//Contract.Requires(associationSetMapping != null);
//Contract.Requires(databaseMapping != null);
// We may apply configuration twice from two different NavigationPropertyConfiguration objects,
// but that should be okay since they were validated as consistent above.
// We still apply twice because each object may have different pieces of the full configuration.
if (AssociationMappingConfiguration != null)
{
// This may replace a configuration previously set, but that's okay since we validated
// consistency when processing the configuration above.
associationSetMapping.SetConfiguration(this);
AssociationMappingConfiguration.Configure(associationSetMapping, databaseMapping.Database);
}
}
private static void ConfigureDependentKeys(DbDatabaseMapping databaseMapping)
{
Contract.Requires(databaseMapping != null);
var defaultSchema = databaseMapping.Database.Schemas.Single();
foreach (var foreignKeyConstraint in defaultSchema.Tables.SelectMany(t => t.ForeignKeyConstraints))
{
foreignKeyConstraint
.DependentColumns
.Each(
(c, i) =>
{
var primitivePropertyConfiguration =
c.GetConfiguration() as PrimitivePropertyConfiguration;
if ((primitivePropertyConfiguration != null)
&& (primitivePropertyConfiguration.ColumnType != null))
{
return;
}
var principalColumn = foreignKeyConstraint.PrincipalTable.KeyColumns.ElementAt(i);
c.TypeName = principalColumn.TypeName;
c.Facets.CopyFrom(principalColumn.Facets);
});
}
}