private static MappingFragment FindConditionTypeMappingFragment(
EntitySet tableSet, MappingFragment propertiesTypeMappingFragment,
EntityTypeMapping conditionTypeMapping)
{
var table = tableSet.ElementType;
var conditionTypeMappingFragment
= conditionTypeMapping.MappingFragments
.SingleOrDefault(x => x.Table == table);
if (conditionTypeMappingFragment == null)
{
conditionTypeMappingFragment
= EntityMappingOperations
.CreateTypeMappingFragment(conditionTypeMapping, propertiesTypeMappingFragment, tableSet);
conditionTypeMappingFragment.SetIsConditionOnlyFragment(true);
if (propertiesTypeMappingFragment.GetDefaultDiscriminator() != null)
{
conditionTypeMappingFragment.SetDefaultDiscriminator(
propertiesTypeMappingFragment.GetDefaultDiscriminator());
propertiesTypeMappingFragment.RemoveDefaultDiscriminatorAnnotation();
}
}
return(conditionTypeMappingFragment);
}
public void AddEntityTypeMappingFragment(
EntitySet entitySet, EntityType entityType, MappingFragment fragment)
{
Debug.Assert(fragment.Table == Table);
_entityTypes.Add(entitySet, entityType);
var defaultDiscriminatorColumn = fragment.GetDefaultDiscriminator();
ConditionPropertyMapping defaultDiscriminatorCondition = null;
if (defaultDiscriminatorColumn != null)
{
defaultDiscriminatorCondition =
fragment.ColumnConditions.SingleOrDefault(cc => cc.Column == defaultDiscriminatorColumn);
}
foreach (var pm in fragment.ColumnMappings)
{
var columnMapping = FindOrCreateColumnMapping(pm.ColumnProperty);
columnMapping.AddMapping(
entityType,
pm.PropertyPath,
fragment.ColumnConditions.Where(cc => cc.Column == pm.ColumnProperty),
defaultDiscriminatorColumn == pm.ColumnProperty);
}
// Add any column conditions that aren't mapped to properties
foreach (
var cc in
fragment.ColumnConditions.Where(cc => !fragment.ColumnMappings.Any(pm => pm.ColumnProperty == cc.Column)))
{
var columnMapping = FindOrCreateColumnMapping(cc.Column);
columnMapping.AddMapping(entityType, null, new[] { cc }, defaultDiscriminatorColumn == cc.Column);
}
}
private void RemoveFragment(
EntitySet entitySet,
EntityTypeMapping entityTypeMapping,
MappingFragment fragment)
{
EdmProperty defaultDiscriminator = fragment.GetDefaultDiscriminator();
if (defaultDiscriminator != null && entityTypeMapping.EntityType.BaseType != null && !entityTypeMapping.EntityType.Abstract)
{
ColumnMapping columnMapping = this._tableMappings[fragment.Table].ColumnMappings.SingleOrDefault <ColumnMapping>((Func <ColumnMapping, bool>)(cm => cm.Column == defaultDiscriminator));
if (columnMapping != null)
{
PropertyMappingSpecification mappingSpecification = columnMapping.PropertyMappings.SingleOrDefault <PropertyMappingSpecification>((Func <PropertyMappingSpecification, bool>)(pm => pm.EntityType == entityTypeMapping.EntityType));
if (mappingSpecification != null)
{
columnMapping.PropertyMappings.Remove(mappingSpecification);
}
}
defaultDiscriminator.Nullable = true;
}
if (entityTypeMapping.EntityType.Abstract)
{
foreach (ColumnMapping columnMapping in this._tableMappings[fragment.Table].ColumnMappings.Where <ColumnMapping>((Func <ColumnMapping, bool>)(cm => cm.PropertyMappings.All <PropertyMappingSpecification>((Func <PropertyMappingSpecification, bool>)(pm => pm.EntityType == entityTypeMapping.EntityType)))))
{
fragment.Table.RemoveMember((EdmMember)columnMapping.Column);
}
}
entityTypeMapping.RemoveFragment(fragment);
if (entityTypeMapping.MappingFragments.Any <MappingFragment>())
{
return;
}
this._databaseMapping.GetEntitySetMapping(entitySet).RemoveTypeMapping(entityTypeMapping);
}
public static EdmProperty RemoveDefaultDiscriminatorCondition(
this MappingFragment entityTypeMappingFragment)
{
EdmProperty defaultDiscriminator = entityTypeMappingFragment.GetDefaultDiscriminator();
if (defaultDiscriminator != null && entityTypeMappingFragment.ColumnConditions.Any <ConditionPropertyMapping>())
{
entityTypeMappingFragment.ClearConditions();
}
entityTypeMappingFragment.RemoveDefaultDiscriminatorAnnotation();
return(defaultDiscriminator);
}
private void RemoveFragment(
EntitySet entitySet, EntityTypeMapping entityTypeMapping, MappingFragment fragment)
{
// Make the default discriminator nullable if this type isn't using it but there is a base type
var defaultDiscriminator = fragment.GetDefaultDiscriminator();
if (defaultDiscriminator != null &&
entityTypeMapping.EntityType.BaseType != null &&
!entityTypeMapping.EntityType.Abstract)
{
var columnMapping =
_tableMappings[fragment.Table].ColumnMappings.SingleOrDefault(
cm => cm.Column == defaultDiscriminator);
if (columnMapping != null)
{
var propertyMapping = columnMapping.PropertyMappings.SingleOrDefault(
pm => pm.EntityType == entityTypeMapping.EntityType);
if (propertyMapping != null)
{
columnMapping.PropertyMappings.Remove(propertyMapping);
}
}
defaultDiscriminator.Nullable = true;
}
// The default TPH mapping may result in columns being created that are no longer required
// when an abstract type mapping to the table is removed, for example in TPC cases. We need
// to remove these columns.
if (entityTypeMapping.EntityType.Abstract)
{
foreach (var columnMapping in _tableMappings[fragment.Table].ColumnMappings.Where(
cm => cm.PropertyMappings.All(pm => pm.EntityType == entityTypeMapping.EntityType)))
{
fragment.Table.RemoveMember(columnMapping.Column);
}
}
entityTypeMapping.RemoveFragment(fragment);
if (!entityTypeMapping.MappingFragments.Any())
{
_databaseMapping.GetEntitySetMapping(entitySet).RemoveTypeMapping(entityTypeMapping);
}
}
private static void CopyDefaultDiscriminator(
MappingFragment fromFragment, MappingFragment toFragment)
{
var discriminatorColumn = fromFragment.GetDefaultDiscriminator();
if (discriminatorColumn != null)
{
var discriminator
= fromFragment.ColumnConditions
.SingleOrDefault(cc => cc.Column == discriminatorColumn);
if (discriminator != null)
{
toFragment.AddDiscriminatorCondition(discriminator.Column, discriminator.Value);
toFragment.SetDefaultDiscriminator(discriminator.Column);
}
}
}
public static EdmProperty RemoveDefaultDiscriminatorCondition(
this MappingFragment entityTypeMappingFragment)
{
DebugCheck.NotNull(entityTypeMappingFragment);
var discriminatorColumn = entityTypeMappingFragment.GetDefaultDiscriminator();
if (discriminatorColumn != null &&
entityTypeMappingFragment.ColumnConditions.Any())
{
Debug.Assert(entityTypeMappingFragment.ColumnConditions.Count() == 1);
entityTypeMappingFragment.ClearConditions();
}
entityTypeMappingFragment.RemoveDefaultDiscriminatorAnnotation();
return(discriminatorColumn);
}
private static void CopyDefaultDiscriminator(
MappingFragment fromFragment,
MappingFragment toFragment)
{
EdmProperty discriminatorColumn = fromFragment.GetDefaultDiscriminator();
if (discriminatorColumn == null)
{
return;
}
ConditionPropertyMapping conditionPropertyMapping = fromFragment.ColumnConditions.SingleOrDefault <ConditionPropertyMapping>((Func <ConditionPropertyMapping, bool>)(cc => cc.Column == discriminatorColumn));
if (conditionPropertyMapping == null)
{
return;
}
toFragment.AddDiscriminatorCondition(conditionPropertyMapping.Column, conditionPropertyMapping.Value);
toFragment.SetDefaultDiscriminator(conditionPropertyMapping.Column);
}
public void AddEntityTypeMappingFragment(
EntitySet entitySet,
EntityType entityType,
MappingFragment fragment)
{
this._entityTypes.Add(entitySet, entityType);
EdmProperty defaultDiscriminator = fragment.GetDefaultDiscriminator();
foreach (ColumnMappingBuilder columnMapping in fragment.ColumnMappings)
{
ColumnMappingBuilder cm = columnMapping;
this.FindOrCreateColumnMapping(cm.ColumnProperty).AddMapping(entityType, cm.PropertyPath, fragment.ColumnConditions.Where <ConditionPropertyMapping>((Func <ConditionPropertyMapping, bool>)(cc => cc.Column == cm.ColumnProperty)), defaultDiscriminator == cm.ColumnProperty);
}
foreach (ConditionPropertyMapping conditionPropertyMapping in fragment.ColumnConditions.Where <ConditionPropertyMapping>((Func <ConditionPropertyMapping, bool>)(cc => fragment.ColumnMappings.All <ColumnMappingBuilder>((Func <ColumnMappingBuilder, bool>)(pm => pm.ColumnProperty != cc.Column)))))
{
this.FindOrCreateColumnMapping(conditionPropertyMapping.Column).AddMapping(entityType, (IList <EdmProperty>)null, (IEnumerable <ConditionPropertyMapping>) new ConditionPropertyMapping[1]
{
conditionPropertyMapping
}, (defaultDiscriminator == conditionPropertyMapping.Column ? 1 : 0) != 0);
}
}