protected static EntityTypeMapping GetEntityTypeMappingInHierarchy(
DbDatabaseMapping databaseMapping, EntityType entityType)
{
DebugCheck.NotNull(databaseMapping);
DebugCheck.NotNull(entityType);
var entityTypeMapping = databaseMapping.GetEntityTypeMapping(entityType);
if (entityTypeMapping == null)
{
var entitySetMapping =
databaseMapping.GetEntitySetMapping(databaseMapping.Model.GetEntitySet(entityType));
if (entitySetMapping != null)
{
entityTypeMapping = entitySetMapping
.EntityTypeMappings
.First(
etm => entityType.DeclaredProperties.All(
dp => etm.MappingFragments.First()
.ColumnMappings.Select(pm => pm.PropertyPath.First()).Contains(dp)));
}
}
Debug.Assert(entityTypeMapping != null);
return(entityTypeMapping);
}
protected static StorageEntityTypeMapping GetEntityTypeMappingInHierarchy(
DbDatabaseMapping databaseMapping, EntityType entityType)
{
DebugCheck.NotNull(databaseMapping);
DebugCheck.NotNull(entityType);
var entityTypeMapping = databaseMapping.GetEntityTypeMapping(entityType);
if (entityTypeMapping == null)
{
var entitySetMapping =
databaseMapping.GetEntitySetMapping(databaseMapping.Model.GetEntitySet(entityType));
if (entitySetMapping != null)
{
entityTypeMapping = entitySetMapping
.EntityTypeMappings
.First(
etm => entityType.DeclaredProperties.All(
dp => etm.MappingFragments.First()
.ColumnMappings.Select(pm => pm.PropertyPath.First()).Contains(dp)));
}
}
if (entityTypeMapping == null)
{
throw Error.UnmappedAbstractType(entityType.GetClrType());
}
return(entityTypeMapping);
}
public void Generate(EntityType entityType, DbDatabaseMapping databaseMapping)
{
if (entityType.Abstract)
{
return;
}
EntitySet entitySet = databaseMapping.Model.GetEntitySet(entityType);
EntitySetMapping entitySetMapping = databaseMapping.GetEntitySetMapping(entitySet);
List <ColumnMappingBuilder> list1 = ModificationFunctionMappingGenerator.GetColumnMappings(entityType, entitySetMapping).ToList <ColumnMappingBuilder>();
List <Tuple <ModificationFunctionMemberPath, EdmProperty> > list2 = ModificationFunctionMappingGenerator.GetIndependentFkColumns(entityType, databaseMapping).ToList <Tuple <ModificationFunctionMemberPath, EdmProperty> >();
ModificationFunctionMapping functionMapping1 = this.GenerateFunctionMapping(ModificationOperator.Insert, (EntitySetBase)entitySetMapping.EntitySet, (EntityTypeBase)entityType, databaseMapping, (IEnumerable <EdmProperty>)entityType.Properties, (IEnumerable <Tuple <ModificationFunctionMemberPath, EdmProperty> >)list2, (IList <ColumnMappingBuilder>)list1, entityType.Properties.Where <EdmProperty>((Func <EdmProperty, bool>)(p => p.HasStoreGeneratedPattern())), (string)null);
ModificationFunctionMapping functionMapping2 = this.GenerateFunctionMapping(ModificationOperator.Update, (EntitySetBase)entitySetMapping.EntitySet, (EntityTypeBase)entityType, databaseMapping, (IEnumerable <EdmProperty>)entityType.Properties, (IEnumerable <Tuple <ModificationFunctionMemberPath, EdmProperty> >)list2, (IList <ColumnMappingBuilder>)list1, entityType.Properties.Where <EdmProperty>((Func <EdmProperty, bool>)(p =>
{
StoreGeneratedPattern?generatedPattern = p.GetStoreGeneratedPattern();
if (generatedPattern.GetValueOrDefault() == StoreGeneratedPattern.Computed)
{
return(generatedPattern.HasValue);
}
return(false);
})), (string)null);
ModificationFunctionMapping functionMapping3 = this.GenerateFunctionMapping(ModificationOperator.Delete, (EntitySetBase)entitySetMapping.EntitySet, (EntityTypeBase)entityType, databaseMapping, (IEnumerable <EdmProperty>)entityType.Properties, (IEnumerable <Tuple <ModificationFunctionMemberPath, EdmProperty> >)list2, (IList <ColumnMappingBuilder>)list1, (IEnumerable <EdmProperty>)null, (string)null);
EntityTypeModificationFunctionMapping modificationFunctionMapping = new EntityTypeModificationFunctionMapping(entityType, functionMapping3, functionMapping1, functionMapping2);
entitySetMapping.AddModificationFunctionMapping(modificationFunctionMapping);
}
public void Can_get_and_set_mapping_for_entity_set()
{
var databaseMapping = new DbDatabaseMapping()
.Initialize(new EdmModel(DataSpace.CSpace), new EdmModel(DataSpace.SSpace));
var entitySet = new EntitySet
{
Name = "ES"
};
Assert.Same(databaseMapping.AddEntitySetMapping(entitySet), databaseMapping.GetEntitySetMapping(entitySet));
}
protected static EntityTypeMapping GetEntityTypeMappingInHierarchy(
DbDatabaseMapping databaseMapping,
EntityType entityType)
{
EntityTypeMapping entityTypeMapping = databaseMapping.GetEntityTypeMapping(entityType);
if (entityTypeMapping == null)
{
EntitySetMapping entitySetMapping = databaseMapping.GetEntitySetMapping(databaseMapping.Model.GetEntitySet(entityType));
if (entitySetMapping != null)
{
entityTypeMapping = entitySetMapping.EntityTypeMappings.First <EntityTypeMapping>((Func <EntityTypeMapping, bool>)(etm => entityType.DeclaredProperties.All <EdmProperty>((Func <EdmProperty, bool>)(dp => etm.MappingFragments.First <MappingFragment>().ColumnMappings.Select <ColumnMappingBuilder, EdmProperty>((Func <ColumnMappingBuilder, EdmProperty>)(pm => pm.PropertyPath.First <EdmProperty>())).Contains <EdmProperty>(dp)))));
}
}
return(entityTypeMapping);
}
public void Generate(EntityType entityType, DbDatabaseMapping databaseMapping)
{
EntitySet entitySet = databaseMapping.Model.GetEntitySet(entityType);
EntitySetMapping entitySetMapping = databaseMapping.GetEntitySetMapping(entitySet) ?? databaseMapping.AddEntitySetMapping(entitySet);
EntityTypeMapping entityTypeMapping1 = entitySetMapping.EntityTypeMappings.FirstOrDefault <EntityTypeMapping>((Func <EntityTypeMapping, bool>)(m => m.EntityTypes.Contains((EntityTypeBase)entitySet.ElementType))) ?? entitySetMapping.EntityTypeMappings.FirstOrDefault <EntityTypeMapping>();
EntityType entityType1 = entityTypeMapping1 != null?entityTypeMapping1.MappingFragments.First <MappingFragment>().Table : databaseMapping.Database.AddTable(entityType.GetRootType().Name);
EntityTypeMapping entityTypeMapping2 = new EntityTypeMapping((EntitySetMapping)null);
MappingFragment mappingFragment = new MappingFragment(databaseMapping.Database.GetEntitySet(entityType1), (TypeMapping)entityTypeMapping2, false);
entityTypeMapping2.AddType(entityType);
entityTypeMapping2.AddFragment(mappingFragment);
entityTypeMapping2.SetClrType(EntityTypeExtensions.GetClrType(entityType));
entitySetMapping.AddTypeMapping(entityTypeMapping2);
new PropertyMappingGenerator(this._providerManifest).Generate(entityType, (IEnumerable <EdmProperty>)entityType.Properties, entitySetMapping, mappingFragment, (IList <EdmProperty>) new List <EdmProperty>(), false);
}
public void Generate(EntityType entityType, DbDatabaseMapping databaseMapping)
{
DebugCheck.NotNull(entityType);
DebugCheck.NotNull(databaseMapping);
var entitySet = databaseMapping.Model.GetEntitySet(entityType);
var entitySetMapping
= databaseMapping.GetEntitySetMapping(entitySet)
?? databaseMapping.AddEntitySetMapping(entitySet);
var entityTypeMapping =
entitySetMapping.EntityTypeMappings.FirstOrDefault(
m => m.EntityTypes.Contains(entitySet.ElementType))
?? entitySetMapping.EntityTypeMappings.FirstOrDefault();
var table
= entityTypeMapping != null
? entityTypeMapping.MappingFragments.First().Table
: databaseMapping.Database.AddTable(entityType.GetRootType().Name);
entityTypeMapping = new EntityTypeMapping(null);
var entityTypeMappingFragment
= new MappingFragment(databaseMapping.Database.GetEntitySet(table), entityTypeMapping, false);
entityTypeMapping.AddType(entityType);
entityTypeMapping.AddFragment(entityTypeMappingFragment);
entityTypeMapping.SetClrType(entityType.GetClrType());
entitySetMapping.AddTypeMapping(entityTypeMapping);
new PropertyMappingGenerator(_providerManifest)
.Generate(
entityType,
entityType.Properties,
entitySetMapping,
entityTypeMappingFragment,
new List <EdmProperty>(),
false);
}
public void Generate(EntityType entityType, DbDatabaseMapping databaseMapping)
{
DebugCheck.NotNull(entityType);
DebugCheck.NotNull(databaseMapping);
if (entityType.Abstract)
{
return;
}
var entitySet = databaseMapping.Model.GetEntitySet(entityType);
Debug.Assert(entitySet != null);
var entitySetMapping = databaseMapping.GetEntitySetMapping(entitySet);
Debug.Assert(entitySetMapping != null);
var columnMappings = GetColumnMappings(entityType, entitySetMapping).ToList();
var iaFkProperties = GetIndependentFkColumns(entityType, databaseMapping).ToList();
var insertFunctionMapping
= GenerateFunctionMapping(
ModificationOperator.Insert,
entitySetMapping.EntitySet,
entityType,
databaseMapping,
entityType.Properties,
iaFkProperties,
columnMappings,
entityType
.Properties
.Where(p => p.HasStoreGeneratedPattern()));
var updateFunctionMapping
= GenerateFunctionMapping(
ModificationOperator.Update,
entitySetMapping.EntitySet,
entityType,
databaseMapping,
entityType.Properties,
iaFkProperties,
columnMappings,
entityType
.Properties
.Where(p => p.GetStoreGeneratedPattern() == StoreGeneratedPattern.Computed));
var deleteFunctionMapping
= GenerateFunctionMapping(
ModificationOperator.Delete,
entitySetMapping.EntitySet,
entityType,
databaseMapping,
entityType.Properties,
iaFkProperties,
columnMappings);
var modificationStoredProcedureMapping
= new EntityTypeModificationFunctionMapping(
entityType,
deleteFunctionMapping,
insertFunctionMapping,
updateFunctionMapping);
entitySetMapping.AddModificationFunctionMapping(modificationStoredProcedureMapping);
}
protected static DbEntityTypeMapping GetEntityTypeMappingInHierarchy(
DbDatabaseMapping databaseMapping, EdmEntityType entityType)
{
Contract.Requires(databaseMapping != null);
Contract.Requires(entityType != null);
var entityTypeMapping = databaseMapping.GetEntityTypeMapping(entityType);
if (entityTypeMapping == null)
{
var entitySetMapping =
databaseMapping.GetEntitySetMapping(databaseMapping.Model.GetEntitySet(entityType));
if (entitySetMapping != null)
{
entityTypeMapping = entitySetMapping
.EntityTypeMappings
.First(
etm => entityType.DeclaredProperties.All(
dp => etm.TypeMappingFragments.First()
.PropertyMappings.Select(pm => pm.PropertyPath.First()).Contains(dp)));
}
}
if (entityTypeMapping == null)
{
throw Error.UnmappedAbstractType(entityType.GetClrType());
}
return entityTypeMapping;
}
private void Transform()
{
foreach (var entitySet in _entityTypes.GetEntitySets())
{
var setRootMappings = new Dictionary <TableMapping, Dictionary <EntityType, StorageEntityTypeMapping> >();
foreach (var entityType in _entityTypes.GetEntityTypes(entitySet))
{
foreach (
var tableMapping in
_tableMappings.Values.Where(tm => tm.EntityTypes.Contains(entitySet, entityType)))
{
Dictionary <EntityType, StorageEntityTypeMapping> rootMappings;
if (!setRootMappings.TryGetValue(tableMapping, out rootMappings))
{
rootMappings = new Dictionary <EntityType, StorageEntityTypeMapping>();
setRootMappings.Add(tableMapping, rootMappings);
}
RemoveRedundantDefaultDiscriminators(tableMapping);
var requiresIsTypeOf = DetermineRequiresIsTypeOf(tableMapping, entitySet, entityType);
var requiresSplit = false;
// Find the entity type mapping and fragment for this table / entity type mapping where properties will be mapped
StorageEntityTypeMapping propertiesTypeMapping;
StorageMappingFragment propertiesTypeMappingFragment;
if (
!FindPropertyEntityTypeMapping(
tableMapping,
entitySet,
entityType,
requiresIsTypeOf,
out propertiesTypeMapping,
out propertiesTypeMappingFragment))
{
continue;
}
// Determine if the entity type mapping needs to be split into separate properties and condition type mappings.
requiresSplit = DetermineRequiresSplitEntityTypeMapping(
tableMapping, entityType, requiresIsTypeOf);
// Find the entity type mapping and fragment for this table / entity type mapping where conditions will be mapped
var conditionTypeMapping
= FindConditionTypeMapping(entityType, requiresSplit, propertiesTypeMapping);
var conditionTypeMappingFragment
= FindConditionTypeMappingFragment(
_databaseMapping.Database.GetEntitySet(tableMapping.Table),
propertiesTypeMappingFragment,
conditionTypeMapping);
// Set the IsTypeOf appropriately
if (requiresIsTypeOf)
{
if (propertiesTypeMapping.IsHierarchyMapping == false)
{
var isTypeOfEntityTypeMapping =
_databaseMapping.GetEntityTypeMappings(entityType).SingleOrDefault(
etm => etm.IsHierarchyMapping);
if (isTypeOfEntityTypeMapping == null)
{
if (propertiesTypeMapping.MappingFragments.Count > 1)
{
// Need to create a new entity type mapping with the non-IsTypeOf contents
var nonIsTypeOfEntityTypeMapping = propertiesTypeMapping.Clone();
var parentEntitySetMapping =
_databaseMapping.GetEntitySetMappings().Single(
esm => esm.EntityTypeMappings.Contains(propertiesTypeMapping));
parentEntitySetMapping.AddTypeMapping(nonIsTypeOfEntityTypeMapping);
foreach (
var fragment in
propertiesTypeMapping.MappingFragments.Where(
tmf => tmf != propertiesTypeMappingFragment).ToArray())
{
propertiesTypeMapping.RemoveFragment(fragment);
nonIsTypeOfEntityTypeMapping.AddFragment(fragment);
}
}
// else we just use the existing property mapping
propertiesTypeMapping.AddIsOfType(propertiesTypeMapping.EntityType);
}
else
{
// found an existing IsTypeOf mapping, so re-use that one
propertiesTypeMapping.RemoveFragment(propertiesTypeMappingFragment);
if (propertiesTypeMapping.MappingFragments.Count == 0)
{
_databaseMapping
.GetEntitySetMapping(entitySet)
.RemoveTypeMapping(propertiesTypeMapping);
}
propertiesTypeMapping = isTypeOfEntityTypeMapping;
propertiesTypeMapping.AddFragment(propertiesTypeMappingFragment);
}
}
rootMappings.Add(entityType, propertiesTypeMapping);
}
ConfigureTypeMappings(
tableMapping, rootMappings, entityType, propertiesTypeMappingFragment,
conditionTypeMappingFragment);
if (propertiesTypeMappingFragment.IsUnmappedPropertiesFragment()
&&
propertiesTypeMappingFragment.ColumnMappings.All(
pm => entityType.GetKeyProperties().Contains(pm.PropertyPath.First())))
{
RemoveFragment(entitySet, propertiesTypeMapping, propertiesTypeMappingFragment);
if (requiresSplit
&&
conditionTypeMappingFragment.ColumnMappings.All(
pm => entityType.GetKeyProperties().Contains(pm.PropertyPath.First())))
{
RemoveFragment(entitySet, conditionTypeMapping, conditionTypeMappingFragment);
}
}
EntityMappingConfiguration.CleanupUnmappedArtifacts(_databaseMapping, tableMapping.Table);
foreach (var fkConstraint in tableMapping.Table.ForeignKeyBuilders)
{
var associationType = fkConstraint.GetAssociationType();
if (associationType != null &&
associationType.IsRequiredToNonRequired())
{
AssociationEndMember _, dependentEnd;
fkConstraint.GetAssociationType().TryGuessPrincipalAndDependentEnds(
out _, out dependentEnd);
if (dependentEnd.GetEntityType() == entityType)
{
MarkColumnsAsNonNullableIfNoTableSharing(
entitySet, tableMapping.Table, entityType, fkConstraint.DependentColumns);
}
}
}
}
}
ConfigureAssociationSetMappingForeignKeys(entitySet);
}
}