public void Configure_should_update_table_name_when_base_type_is_null()
{
var entityMappingConfiguration
= new EntityMappingConfiguration
{
TableName = new DatabaseName("Foo")
};
var entityTypeMapping = new StorageEntityTypeMapping(null);
entityTypeMapping.AddType(new EntityType("E", "N", DataSpace.CSpace));
var databaseMapping =
new DbDatabaseMapping().Initialize(new EdmModel(DataSpace.CSpace), new EdmModel(DataSpace.SSpace));
var table = databaseMapping.Database.AddTable("foo");
var entitySet = databaseMapping.Database.GetEntitySet(table);
entityTypeMapping.AddFragment(new StorageMappingFragment(entitySet, entityTypeMapping, false));
entityMappingConfiguration.Configure(
databaseMapping, ProviderRegistry.Sql2008_ProviderManifest, entityTypeMapping.EntityType, ref entityTypeMapping, false, 0, 1);
Assert.Equal("Foo", table.GetTableName().Name);
}
private void RemoveFragment(
EntitySet entitySet, StorageEntityTypeMapping entityTypeMapping, StorageMappingFragment 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)
{
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;
}
entityTypeMapping.RemoveFragment(fragment);
if (!entityTypeMapping.MappingFragments.Any())
{
_databaseMapping.GetEntitySetMapping(entitySet).RemoveTypeMapping(entityTypeMapping);
}
}
private static bool RemapsInheritedProperties(
DbDatabaseMapping databaseMapping, StorageEntityTypeMapping 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 = (EntityType)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 = (EntityType)baseType.BaseType;
}
}
}
return(false);
}
internal void ConfigureTablesAndConditions(
StorageEntityTypeMapping entityTypeMapping,
DbDatabaseMapping databaseMapping,
DbProviderManifest providerManifest)
{
DebugCheck.NotNull(databaseMapping);
DebugCheck.NotNull(providerManifest);
var entityType
= (entityTypeMapping != null)
? entityTypeMapping.EntityType
: databaseMapping.Model.GetEntityType(ClrType);
if (_entityMappingConfigurations.Any())
{
for (var i = 0; i < _entityMappingConfigurations.Count; i++)
{
_entityMappingConfigurations[i]
.Configure(
databaseMapping,
providerManifest,
entityType,
ref entityTypeMapping,
IsMappingAnyInheritedProperty(entityType),
i,
_entityMappingConfigurations.Count);
}
}
else
{
ConfigureUnconfiguredType(databaseMapping, providerManifest, entityType);
}
}
public static void SetClrType(this StorageEntityTypeMapping entityTypeMapping, Type type)
{
DebugCheck.NotNull(entityTypeMapping);
DebugCheck.NotNull(type);
entityTypeMapping.Annotations.SetClrType(type);
}
public static void SetConfiguration(this StorageEntityTypeMapping entityTypeMapping, object configuration)
{
DebugCheck.NotNull(entityTypeMapping);
DebugCheck.NotNull(configuration);
entityTypeMapping.Annotations.SetConfiguration(configuration);
}
public void WriteMappingFragment_should_write_store_entity_set_name()
{
var fixture = new Fixture();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
var entityContainer = new EntityContainer("EC", DataSpace.SSpace);
entityContainer.AddEntitySetBase(entitySet);
var storageEntitySetMapping
= new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(entityContainer));
StorageTypeMapping typeMapping = new StorageEntityTypeMapping(storageEntitySetMapping);
var mappingFragment = new StorageMappingFragment(entitySet, typeMapping, false);
fixture.Writer.WriteMappingFragmentElement(mappingFragment);
Assert.Equal(
@"<MappingFragment StoreEntitySet=""ES"" />",
fixture.ToString());
}
public static ColumnMappingBuilder GetPropertyMapping(
this StorageEntityTypeMapping entityTypeMapping, params EdmProperty[] propertyPath)
{
DebugCheck.NotNull(entityTypeMapping);
DebugCheck.NotNull(propertyPath);
Debug.Assert(propertyPath.Length > 0);
return(entityTypeMapping.MappingFragments
.SelectMany(f => f.ColumnMappings)
.Single(p => p.PropertyPath.SequenceEqual(propertyPath)));
}
public static StorageEntityTypeMapping Clone(this StorageEntityTypeMapping entityTypeMapping)
{
DebugCheck.NotNull(entityTypeMapping);
var clone = new StorageEntityTypeMapping(null);
clone.AddType(entityTypeMapping.EntityType);
entityTypeMapping.Annotations.Copy(clone.Annotations);
return(clone);
}
private void WriteEntityTypeMappingElement(StorageEntityTypeMapping entityTypeMapping)
{
_xmlWriter.WriteStartElement(StorageMslConstructs.EntityTypeMappingElement);
_xmlWriter.WriteAttributeString(
StorageMslConstructs.EntityTypeMappingTypeNameAttribute,
GetEntityTypeName(
_entityTypeNamespace + "." + entityTypeMapping.EntityType.Name, entityTypeMapping.IsHierarchyMapping));
foreach (var mappingFragment in entityTypeMapping.MappingFragments)
{
WriteMappingFragmentElement(mappingFragment);
}
_xmlWriter.WriteEndElement();
}
public static StorageMappingFragment CreateTypeMappingFragment(
StorageEntityTypeMapping entityTypeMapping, StorageMappingFragment templateFragment, EntitySet tableSet)
{
var fragment = new StorageMappingFragment(tableSet, entityTypeMapping, false);
entityTypeMapping.AddFragment(fragment);
// Move all PK mappings to the extra fragment
foreach (
var pkPropertyMapping in templateFragment.ColumnMappings.Where(pm => pm.ColumnProperty.IsPrimaryKeyColumn))
{
CopyPropertyMappingToFragment(pkPropertyMapping, fragment, true);
}
return(fragment);
}
public void GetEntityTypeMapping_should_return_mapping_for_type()
{
var databaseMapping = new DbDatabaseMapping()
.Initialize(new EdmModel(DataSpace.CSpace), new EdmModel(DataSpace.SSpace));
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entityTypeMapping = new StorageEntityTypeMapping(null);
entityTypeMapping.AddType(entityType);
databaseMapping.AddEntitySetMapping(
new EntitySet
{
Name = "ES"
}).AddTypeMapping(entityTypeMapping);
Assert.Same(entityTypeMapping, databaseMapping.GetEntityTypeMapping(entityType));
}
private static EntityType FindParentTable(
DbDatabaseMapping databaseMapping,
EntityType fromTable,
StorageEntityTypeMapping entityTypeMapping,
EntityType toTable,
bool isMappingInheritedProperties,
int configurationIndex,
int configurationCount,
out bool isSplitting)
{
EntityType parentTable = null;
isSplitting = false;
// Check for entity splitting first, since splitting on a derived type in TPT/TPC will always have fromTable != toTable
if (entityTypeMapping.UsesOtherTables(toTable) ||
configurationCount > 1)
{
if (configurationIndex != 0)
{
// Entity Splitting case
parentTable = entityTypeMapping.GetPrimaryTable();
isSplitting = true;
}
}
if (parentTable == null &&
fromTable != toTable &&
!isMappingInheritedProperties)
{
// TPT case
var baseType = entityTypeMapping.EntityType.BaseType;
while (baseType != null &&
parentTable == null)
{
// Traverse to first anscestor with a mapping
var baseMapping = databaseMapping.GetEntityTypeMappings((EntityType)baseType).FirstOrDefault();
if (baseMapping != null)
{
parentTable = baseMapping.GetPrimaryTable();
}
baseType = baseType.BaseType;
}
}
return(parentTable);
}
public void GetComplexPropertyMappings_should_return_all_complex_property_mappings_for_type()
{
var databaseMapping = new DbDatabaseMapping()
.Initialize(new EdmModel(DataSpace.CSpace), new EdmModel(DataSpace.SSpace));
var entitySet = new EntitySet
{
Name = "ES"
};
var entitySetMapping = databaseMapping.AddEntitySetMapping(entitySet);
var entityTypeMapping = new StorageEntityTypeMapping(null);
entitySetMapping.AddTypeMapping(entityTypeMapping);
var entityTypeMappingFragment = new StorageMappingFragment(entitySet, entityTypeMapping, false);
entityTypeMapping.AddFragment(entityTypeMappingFragment);
var complexType = new ComplexType("C");
var propertyMapping1
= new ColumnMappingBuilder(
new EdmProperty("C"),
new[]
{
EdmProperty.Complex("P1", complexType),
EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))
});
var type = typeof(object);
complexType.Annotations.SetClrType(type);
entityTypeMappingFragment.AddColumnMapping(propertyMapping1);
var propertyMapping2
= new ColumnMappingBuilder(
new EdmProperty("C"),
new List <EdmProperty>
{
EdmProperty.Complex("P3", complexType),
EdmProperty.Primitive(
"P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
});
entityTypeMappingFragment.AddColumnMapping(propertyMapping2);
Assert.Equal(2, databaseMapping.GetComplexPropertyMappings(typeof(object)).Count());
}
public void GetEntityTypeMapping_should_return_mapping_for_type_by_clrType()
{
var databaseMapping = new DbDatabaseMapping()
.Initialize(new EdmModel(DataSpace.CSpace), new EdmModel(DataSpace.SSpace));
var entityType = new EntityType("Foo", "N", DataSpace.CSpace);
var type = typeof(object);
entityType.Annotations.SetClrType(type);
var entityTypeMapping = new StorageEntityTypeMapping(null);
entityTypeMapping.AddType(entityType);
entityTypeMapping.SetClrType(typeof(object));
databaseMapping.AddEntitySetMapping(
new EntitySet
{
Name = "ES"
}).AddTypeMapping(entityTypeMapping);
Assert.Same(entityTypeMapping, databaseMapping.GetEntityTypeMapping(typeof(object)));
}
// effects: Given the metadata information for a container in
// containerMap, generate the cells for it and modify cells to
// contain the newly-generated cells
private void ExtractCells(List <Cell> cells)
{
// extract entity mappings, i.e., for CPerson1, COrder1, etc
foreach (StorageSetMapping extentMap in m_containerMapping.AllSetMaps)
{
// Get each type map in an entity set mapping, i.e., for
// CPerson, CCustomer, etc in CPerson1
foreach (StorageTypeMapping typeMap in extentMap.TypeMappings)
{
StorageEntityTypeMapping entityTypeMap = typeMap as StorageEntityTypeMapping;
Debug.Assert(entityTypeMap != null ||
typeMap is StorageAssociationTypeMapping, "Invalid typemap");
// A set for all the types in this type mapping
Set <EdmType> allTypes = new Set <EdmType>();
if (entityTypeMap != null)
{
// Gather a set of all explicit types for an entity
// type mapping in allTypes. Note that we do not have
// subtyping in association sets
allTypes.AddRange(entityTypeMap.Types);
foreach (EdmType type in entityTypeMap.IsOfTypes)
{
IEnumerable <EdmType> typeAndSubTypes = MetadataHelper.GetTypeAndSubtypesOf(type, m_containerMapping.StorageMappingItemCollection.EdmItemCollection, false /*includeAbstractTypes*/);
allTypes.AddRange(typeAndSubTypes);
}
}
EntitySetBase extent = extentMap.Set;
Debug.Assert(extent != null, "Extent map for a null extent or type of extentMap.Exent " +
"is not Extent");
// For each table mapping for the type mapping, we create cells
foreach (StorageMappingFragment fragmentMap in typeMap.MappingFragments)
{
ExtractCellsFromTableFragment(extent, fragmentMap, allTypes, cells);
}
}
}
}
public void GetPropertyMapping_should_return_mapping_with_path()
{
var entityTypeMapping = new StorageEntityTypeMapping(null);
var propertyFoo = EdmProperty.Complex("Foo", new ComplexType());
var propertyBar = EdmProperty.Primitive("Bar", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var entityPropertyMapping
= new ColumnMappingBuilder(
EdmProperty.Primitive("C", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
new[]
{
propertyFoo,
propertyBar,
});
var entityTypeMappingFragment
= new StorageMappingFragment(new EntitySet(), entityTypeMapping, false);
entityTypeMappingFragment.AddColumnMapping(entityPropertyMapping);
entityTypeMapping.AddFragment(entityTypeMappingFragment);
Assert.Same(entityPropertyMapping, entityTypeMapping.GetPropertyMapping(propertyFoo, propertyBar));
}
private StorageEntityTypeMapping FindConditionTypeMapping(
EntityType entityType, bool requiresSplit, StorageEntityTypeMapping propertiesTypeMapping)
{
var conditionTypeMapping = propertiesTypeMapping;
if (requiresSplit)
{
if (!entityType.Abstract)
{
conditionTypeMapping = propertiesTypeMapping.Clone();
conditionTypeMapping.RemoveIsOfType(conditionTypeMapping.EntityType);
var parentEntitySetMapping =
_databaseMapping.GetEntitySetMappings().Single(
esm => esm.EntityTypeMappings.Contains(propertiesTypeMapping));
parentEntitySetMapping.AddTypeMapping(conditionTypeMapping);
}
propertiesTypeMapping.MappingFragments.Each(tmf => tmf.ClearConditions());
}
return(conditionTypeMapping);
}
/// <summary>
/// Determines if the table and entity type need mapping, and if not, removes the existing entity type mapping
/// </summary>
private bool FindPropertyEntityTypeMapping(
TableMapping tableMapping,
EntitySet entitySet,
EntityType entityType,
bool requiresIsTypeOf,
out StorageEntityTypeMapping entityTypeMapping,
out StorageMappingFragment fragment)
{
entityTypeMapping = null;
fragment = null;
var mapping = (from etm in _databaseMapping.GetEntityTypeMappings(entityType)
from tmf in etm.MappingFragments
where tmf.Table == tableMapping.Table
select new
{
TypeMapping = etm,
Fragment = tmf
}).SingleOrDefault();
if (mapping != null)
{
entityTypeMapping = mapping.TypeMapping;
fragment = mapping.Fragment;
if (!requiresIsTypeOf &&
entityType.Abstract)
{
RemoveFragment(entitySet, mapping.TypeMapping, mapping.Fragment);
return(false);
}
return(true);
}
else
{
return(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 table
= entitySetMapping.EntityTypeMappings.Any()
? entitySetMapping.EntityTypeMappings.First().MappingFragments.First().Table
: databaseMapping.Database.AddTable(entityType.GetRootType().Name);
var entityTypeMapping = new StorageEntityTypeMapping(null);
var entityTypeMappingFragment
= new StorageMappingFragment(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 Configure(
DbDatabaseMapping databaseMapping,
DbProviderManifest providerManifest,
EntityType entityType,
ref StorageEntityTypeMapping entityTypeMapping,
bool isMappingAnyInheritedProperty,
int configurationIndex,
int configurationCount)
{
DebugCheck.NotNull(entityType);
DebugCheck.NotNull(databaseMapping);
DebugCheck.NotNull(providerManifest);
var isIdentityTable = entityType.BaseType == null && configurationIndex == 0;
var fragment = FindOrCreateTypeMappingFragment(
databaseMapping, ref entityTypeMapping, configurationIndex, entityType, providerManifest);
var fromTable = fragment.Table;
bool isTableSharing;
var toTable = FindOrCreateTargetTable(
databaseMapping, fragment, entityType, fromTable, out isTableSharing);
var isSharingTableWithBase = DiscoverIsSharingWithBase(databaseMapping, entityType, toTable);
// Ensure all specified properties are the only ones present in this fragment and table
var mappingsToContain = DiscoverAllMappingsToContain(
databaseMapping, entityType, toTable, isSharingTableWithBase);
// Validate that specified properties can be mapped
var mappingsToMove = fragment.ColumnMappings.ToList();
foreach (var propertyPath in mappingsToContain)
{
var propertyMapping = fragment.ColumnMappings.SingleOrDefault(
pm =>
pm.PropertyPath.SequenceEqual(propertyPath));
if (propertyMapping == null)
{
throw Error.EntityMappingConfiguration_DuplicateMappedProperty(
entityType.Name, propertyPath.ToString());
}
mappingsToMove.Remove(propertyMapping);
}
// Add table constraint if there are no inherited properties
if (!isIdentityTable)
{
bool isSplitting;
var parentTable = FindParentTable(
databaseMapping,
fromTable,
entityTypeMapping,
toTable,
isMappingAnyInheritedProperty,
configurationIndex,
configurationCount,
out isSplitting);
if (parentTable != null)
{
DatabaseOperations.AddTypeConstraint(databaseMapping.Database, entityType, parentTable, toTable, isSplitting);
}
}
// Update AssociationSetMappings (IAs) and FKs
if (fromTable != toTable)
{
if (Properties == null)
{
AssociationMappingOperations.MoveAllDeclaredAssociationSetMappings(
databaseMapping, entityType, fromTable, toTable, !isTableSharing);
ForeignKeyPrimitiveOperations.MoveAllDeclaredForeignKeyConstraintsForPrimaryKeyColumns(
entityType, fromTable, toTable);
}
if (isMappingAnyInheritedProperty)
{
// With TPC, we need to move down FK constraints, even on PKs (except type mapping constraints that are not about associations)
ForeignKeyPrimitiveOperations.CopyAllForeignKeyConstraintsForPrimaryKeyColumns(
databaseMapping.Database, fromTable, toTable);
}
}
if (mappingsToMove.Any())
{
EntityType extraTable = null;
if (configurationIndex < configurationCount - 1)
{
// Move all extra properties to a single new fragment
var anyPropertyMapping = mappingsToMove.First();
extraTable
= FindTableForTemporaryExtraPropertyMapping(
databaseMapping, entityType, fromTable, toTable, anyPropertyMapping);
var extraFragment
= EntityMappingOperations
.CreateTypeMappingFragment(
entityTypeMapping, fragment, databaseMapping.Database.GetEntitySet(extraTable));
var requiresUpdate = extraTable != fromTable;
foreach (var pm in mappingsToMove)
{
// move the property mapping from toFragment to extraFragment
EntityMappingOperations.MovePropertyMapping(
databaseMapping.Database, fragment, extraFragment, pm, requiresUpdate, true);
}
}
else
{
// Move each extra property mapping to a fragment refering to the table with the base mapping
EntityType unmappedTable = null;
foreach (var pm in mappingsToMove)
{
extraTable = FindTableForExtraPropertyMapping(
databaseMapping, entityType, fromTable, toTable, ref unmappedTable, pm);
var extraFragment =
entityTypeMapping.MappingFragments.SingleOrDefault(tmf => tmf.Table == extraTable);
if (extraFragment == null)
{
extraFragment
= EntityMappingOperations
.CreateTypeMappingFragment(
entityTypeMapping, fragment, databaseMapping.Database.GetEntitySet(extraTable));
extraFragment.SetIsUnmappedPropertiesFragment(true);
}
if (extraTable == fromTable)
{
// move the default discriminator along with the properties
MoveDefaultDiscriminator(fragment, extraFragment);
}
var requiresUpdate = extraTable != fromTable;
EntityMappingOperations.MovePropertyMapping(
databaseMapping.Database, fragment, extraFragment, pm, requiresUpdate, true);
}
}
}
// Ensure all property mappings refer to the table in the fragment
// Uniquify: true if table sharing, false otherwise
// FK names should be uniquified
// declared properties are moved, inherited ones are copied (duplicated)
EntityMappingOperations.UpdatePropertyMappings(
databaseMapping.Database, fromTable, fragment, !isTableSharing);
// Configure Conditions for the fragment
ConfigureDefaultDiscriminator(entityType, fragment, isSharingTableWithBase);
ConfigureConditions(databaseMapping, entityType, fragment, providerManifest);
// Ensure all conditions refer to columns on the table in the fragment
EntityMappingOperations.UpdateConditions(databaseMapping.Database, fromTable, fragment);
ForeignKeyPrimitiveOperations.UpdatePrincipalTables(
databaseMapping, entityType, fromTable, toTable, isMappingAnyInheritedProperty);
CleanupUnmappedArtifacts(databaseMapping, fromTable);
CleanupUnmappedArtifacts(databaseMapping, toTable);
toTable.SetConfiguration(this);
}
private StorageMappingFragment FindOrCreateTypeMappingFragment(
DbDatabaseMapping databaseMapping,
ref StorageEntityTypeMapping entityTypeMapping,
int configurationIndex,
EntityType entityType,
DbProviderManifest providerManifest)
{
StorageMappingFragment fragment = null;
if (entityTypeMapping == null)
{
Debug.Assert(entityType.Abstract);
new EntityTypeMappingGenerator(providerManifest).
Generate(entityType, databaseMapping);
entityTypeMapping = databaseMapping.GetEntityTypeMapping(entityType);
configurationIndex = 0;
}
if (configurationIndex < entityTypeMapping.MappingFragments.Count)
{
fragment = entityTypeMapping.MappingFragments[configurationIndex];
}
else
{
if (MapInheritedProperties)
{
throw Error.EntityMappingConfiguration_DuplicateMapInheritedProperties(entityType.Name);
}
else if (Properties == null)
{
throw Error.EntityMappingConfiguration_DuplicateMappedProperties(entityType.Name);
}
else
{
Properties.Each(
p =>
{
if (
PropertyPathToEdmPropertyPath(p, entityType).Any(
pp => !entityType.KeyProperties().Contains(pp.First())))
{
throw Error.EntityMappingConfiguration_DuplicateMappedProperty(
entityType.Name, p.ToString());
}
});
}
// Special case where they've asked for an extra table related to this type that only will include the PK columns
// Uniquify: can be false, always move to a new table
var templateTable = entityTypeMapping.MappingFragments[0].Table;
var table = databaseMapping.Database.AddTable(templateTable.Name, templateTable);
fragment
= EntityMappingOperations.CreateTypeMappingFragment(
entityTypeMapping,
entityTypeMapping.MappingFragments[0],
databaseMapping.Database.GetEntitySet(table));
}
return(fragment);
}
public void Generate_should_exclude_sgp_properties_from_corresponding_function_mappings()
{
var functionMappingGenerator
= new ModificationFunctionMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest);
var databaseMapping
= new DbDatabaseMapping()
.Initialize(new EdmModel(DataSpace.CSpace), new EdmModel(DataSpace.SSpace));
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var intProperty = EdmProperty.Primitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
intProperty.SetStoreGeneratedPattern(StoreGeneratedPattern.Identity);
entityType.AddKeyMember(intProperty);
var stringProperty = EdmProperty.Primitive("Name", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
stringProperty.SetStoreGeneratedPattern(StoreGeneratedPattern.Computed);
entityType.AddMember(stringProperty);
var entitySetMapping
= databaseMapping.AddEntitySetMapping(
databaseMapping.Model.AddEntitySet("ES", entityType));
var storageEntityTypeMapping
= new StorageEntityTypeMapping(
new StorageEntitySetMapping(new EntitySet(), databaseMapping.EntityContainerMappings.Single()));
storageEntityTypeMapping.AddType(entityType);
var storageMappingFragment = new StorageMappingFragment(new EntitySet(), storageEntityTypeMapping, false);
storageMappingFragment.AddColumnMapping(
new ColumnMappingBuilder(new EdmProperty("C0"), new[] { intProperty }));
storageMappingFragment.AddColumnMapping(
new ColumnMappingBuilder(new EdmProperty("C1"), new[] { stringProperty }));
storageEntityTypeMapping.AddFragment(storageMappingFragment);
entitySetMapping.AddTypeMapping(storageEntityTypeMapping);
functionMappingGenerator.Generate(entityType, databaseMapping);
var modificationFunctionMapping
= entitySetMapping.ModificationFunctionMappings.Single();
Assert.NotNull(modificationFunctionMapping);
var functionMapping = modificationFunctionMapping.InsertFunctionMapping;
Assert.NotNull(functionMapping);
Assert.Equal(0, functionMapping.ParameterBindings.Count);
Assert.Equal(2, functionMapping.ResultBindings.Count);
var function = functionMapping.Function;
Assert.NotNull(function);
Assert.Equal("E_Insert", function.Name);
Assert.Equal(0, function.Parameters.Count);
functionMapping = modificationFunctionMapping.UpdateFunctionMapping;
Assert.NotNull(functionMapping);
Assert.Equal(1, functionMapping.ParameterBindings.Count);
Assert.Equal(1, functionMapping.ResultBindings.Count);
function = functionMapping.Function;
Assert.NotNull(function);
Assert.Equal("E_Update", function.Name);
Assert.Equal(1, function.Parameters.Count);
functionMapping = modificationFunctionMapping.DeleteFunctionMapping;
Assert.NotNull(functionMapping);
Assert.Equal(1, functionMapping.ParameterBindings.Count);
Assert.Null(functionMapping.ResultBindings);
function = modificationFunctionMapping.DeleteFunctionMapping.Function;
Assert.NotNull(function);
Assert.Equal("E_Delete", function.Name);
Assert.Equal(1, function.Parameters.Count);
}
private static StorageMappingFragment FindConditionTypeMappingFragment(
EntitySet tableSet, StorageMappingFragment propertiesTypeMappingFragment, StorageEntityTypeMapping 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);
}
private HashSet <EdmPropertyPath> DiscoverAllMappingsToContain(
DbDatabaseMapping databaseMapping, EntityType entityType, EntityType toTable,
bool isSharingTableWithBase)
{
// Ensure all specified properties are the only ones present in this fragment and table
var mappingsToContain = new HashSet <EdmPropertyPath>();
// Include Key Properties always
entityType.KeyProperties().Each(
p =>
mappingsToContain.AddRange(p.ToPropertyPathList()));
// Include All Inherited Properties
if (MapInheritedProperties)
{
entityType.Properties.Except(entityType.DeclaredProperties).Each(
p =>
mappingsToContain.AddRange(p.ToPropertyPathList()));
}
// If sharing table with base type, include all the mappings that the base has
if (isSharingTableWithBase)
{
var baseMappingsToContain = new HashSet <EdmPropertyPath>();
var baseType = (EntityType)entityType.BaseType;
StorageEntityTypeMapping baseMapping = null;
StorageMappingFragment baseFragment = null;
// if the base is abstract it may have no mapping so look upwards until you find either:
// 1. a type with mappings and
// 2. if none can be found (abstract until the root or hit another table), then include all declared properties on that base type
while (baseType != null &&
baseMapping == null)
{
baseMapping = databaseMapping.GetEntityTypeMapping((EntityType)entityType.BaseType);
if (baseMapping != null)
{
baseFragment = baseMapping.MappingFragments.SingleOrDefault(tmf => tmf.Table == toTable);
}
if (baseFragment == null)
{
baseType.DeclaredProperties.Each(
p =>
baseMappingsToContain.AddRange(p.ToPropertyPathList()));
}
baseType = (EntityType)baseType.BaseType;
}
if (baseFragment != null)
{
foreach (var pm in baseFragment.ColumnMappings)
{
mappingsToContain.Add(new EdmPropertyPath(pm.PropertyPath));
}
}
mappingsToContain.AddRange(baseMappingsToContain);
}
if (Properties == null)
{
// Include All Declared Properties
entityType.DeclaredProperties.Each(
p =>
mappingsToContain.AddRange(p.ToPropertyPathList()));
}
else
{
// Include Specific Properties
Properties.Each(
p =>
mappingsToContain.AddRange(PropertyPathToEdmPropertyPath(p, entityType)));
}
return(mappingsToContain);
}
private static StorageMappingFragment GetFragmentForPropertyMapping(
StorageEntityTypeMapping entityTypeMapping, EdmProperty property)
{
return(entityTypeMapping.MappingFragments
.SingleOrDefault(tmf => tmf.ColumnMappings.Any(pm => pm.PropertyPath.Last() == property)));
}
public static Type GetClrType(this StorageEntityTypeMapping entityTypeMappping)
{
DebugCheck.NotNull(entityTypeMappping);
return(entityTypeMappping.Annotations.GetClrType());
}
public static bool UsesOtherTables(this StorageEntityTypeMapping entityTypeMapping, EntityType table)
{
return(entityTypeMapping.MappingFragments.Any(f => f.Table != table));
}
public static EntityType GetPrimaryTable(this StorageEntityTypeMapping entityTypeMapping)
{
return(entityTypeMapping.MappingFragments.First().Table);
}
public static object GetConfiguration(this StorageEntityTypeMapping entityTypeMapping)
{
DebugCheck.NotNull(entityTypeMapping);
return(entityTypeMapping.Annotations.GetConfiguration());
}