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 EntityTypeMapping(null);
entitySetMapping.AddTypeMapping(entityTypeMapping);
var entityTypeMappingFragment = new MappingFragment(entitySet, entityTypeMapping, false);
entityTypeMapping.AddFragment(entityTypeMappingFragment);
var complexType = new ComplexType("C");
var propertyMapping1
= new ColumnMappingBuilder(
new EdmProperty("C", TypeUsage.Create(new PrimitiveType()
{
DataSpace = DataSpace.SSpace
})),
new[]
{
EdmProperty.CreateComplex("P1", complexType),
EdmProperty.CreatePrimitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))
});
var type = typeof(object);
complexType.GetMetadataProperties().SetClrType(type);
entityTypeMappingFragment.AddColumnMapping(propertyMapping1);
var propertyMapping2
= new ColumnMappingBuilder(
new EdmProperty("C", TypeUsage.Create(new PrimitiveType()
{
DataSpace = DataSpace.SSpace
})),
new List <EdmProperty>
{
EdmProperty.CreateComplex("P3", complexType),
EdmProperty.CreatePrimitive(
"P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
});
entityTypeMappingFragment.AddColumnMapping(propertyMapping2);
Assert.Equal(2, databaseMapping.GetComplexPropertyMappings(typeof(object)).Count());
}
public void GetPropertyMapping_should_return_mapping_with_path()
{
var entityTypeMapping = new EntityTypeMapping(null);
var propertyFoo = EdmProperty.CreateComplex("Foo", new ComplexType("CT"));
var propertyBar = EdmProperty.CreatePrimitive("Bar", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var entityPropertyMapping
= new ColumnMappingBuilder(
new EdmProperty("C", TypeUsage.Create(new PrimitiveType()
{
DataSpace = DataSpace.SSpace
})),
new[]
{
propertyFoo,
propertyBar,
});
var entityTypeMappingFragment
= new MappingFragment(new EntitySet(), entityTypeMapping, false);
entityTypeMappingFragment.AddColumnMapping(entityPropertyMapping);
entityTypeMapping.AddFragment(entityTypeMappingFragment);
Assert.Same(entityPropertyMapping, entityTypeMapping.GetPropertyMapping(propertyFoo, propertyBar));
}
public static void CopyPropertyMappingToFragment(
ColumnMappingBuilder propertyMappingBuilder,
MappingFragment fragment,
Func <EdmProperty, bool> isCompatible,
bool useExisting)
{
EdmProperty columnProperty = TablePrimitiveOperations.IncludeColumn(fragment.Table, propertyMappingBuilder.ColumnProperty, isCompatible, useExisting);
fragment.AddColumnMapping(new ColumnMappingBuilder(columnProperty, propertyMappingBuilder.PropertyPath));
}
public static void CopyPropertyMappingToFragment(
ColumnMappingBuilder propertyMappingBuilder, MappingFragment fragment,
Func <EdmProperty, bool> isCompatible, bool useExisting)
{
// Ensure column is in the fragment's table
var column = TablePrimitiveOperations.IncludeColumn(fragment.Table, propertyMappingBuilder.ColumnProperty, isCompatible, useExisting);
// Add the property mapping
fragment.AddColumnMapping(
new ColumnMappingBuilder(column, propertyMappingBuilder.PropertyPath));
}
public static void MovePropertyMapping(
DbDatabaseMapping databaseMapping,
IEnumerable <EntitySet> entitySets,
MappingFragment fromFragment,
MappingFragment toFragment,
ColumnMappingBuilder propertyMappingBuilder,
bool requiresUpdate,
bool useExisting)
{
if (requiresUpdate && fromFragment.Table != toFragment.Table)
{
EntityMappingOperations.UpdatePropertyMapping(databaseMapping, entitySets, EntityMappingOperations.GetColumnMappingIndex(databaseMapping), propertyMappingBuilder, fromFragment.Table, toFragment.Table, useExisting);
}
fromFragment.RemoveColumnMapping(propertyMappingBuilder);
toFragment.AddColumnMapping(propertyMappingBuilder);
}
public void Generate(
EntityType entityType,
IEnumerable <EdmProperty> properties,
EntitySetMapping entitySetMapping,
MappingFragment entityTypeMappingFragment,
IList <EdmProperty> propertyPath,
bool createNewColumn)
{
ReadOnlyMetadataCollection <EdmProperty> declaredProperties = entityType.GetRootType().DeclaredProperties;
foreach (EdmProperty property1 in properties)
{
EdmProperty property = property1;
if (property.IsComplexType && propertyPath.Any <EdmProperty>((Func <EdmProperty, bool>)(p =>
{
if (p.IsComplexType)
{
return(p.ComplexType == property.ComplexType);
}
return(false);
})))
{
throw Error.CircularComplexTypeHierarchy();
}
propertyPath.Add(property);
if (property.IsComplexType)
{
this.Generate(entityType, (IEnumerable <EdmProperty>)property.ComplexType.Properties, entitySetMapping, entityTypeMappingFragment, propertyPath, createNewColumn);
}
else
{
EdmProperty edmProperty = entitySetMapping.EntityTypeMappings.SelectMany <EntityTypeMapping, MappingFragment>((Func <EntityTypeMapping, IEnumerable <MappingFragment> >)(etm => (IEnumerable <MappingFragment>)etm.MappingFragments)).SelectMany <MappingFragment, ColumnMappingBuilder>((Func <MappingFragment, IEnumerable <ColumnMappingBuilder> >)(etmf => etmf.ColumnMappings)).Where <ColumnMappingBuilder>((Func <ColumnMappingBuilder, bool>)(pm => pm.PropertyPath.SequenceEqual <EdmProperty>((IEnumerable <EdmProperty>)propertyPath))).Select <ColumnMappingBuilder, EdmProperty>((Func <ColumnMappingBuilder, EdmProperty>)(pm => pm.ColumnProperty)).FirstOrDefault <EdmProperty>();
if (edmProperty == null || createNewColumn)
{
string columnName = string.Join("_", propertyPath.Select <EdmProperty, string>((Func <EdmProperty, string>)(p => p.Name)));
edmProperty = this.MapTableColumn(property, columnName, !declaredProperties.Contains(propertyPath.First <EdmProperty>()));
entityTypeMappingFragment.Table.AddColumn(edmProperty);
if (entityType.KeyProperties().Contains <EdmProperty>(property))
{
entityTypeMappingFragment.Table.AddKeyMember((EdmMember)edmProperty);
}
}
entityTypeMappingFragment.AddColumnMapping(new ColumnMappingBuilder(edmProperty, (IList <EdmProperty>)propertyPath.ToList <EdmProperty>()));
}
propertyPath.Remove(property);
}
}
public static void MovePropertyMapping(
DbDatabaseMapping databaseMapping,
MappingFragment fromFragment,
MappingFragment toFragment,
ColumnMappingBuilder propertyMappingBuilder,
bool requiresUpdate,
bool useExisting)
{
// move the column from the formTable to the table in fragment
if (requiresUpdate && fromFragment.Table != toFragment.Table)
{
UpdatePropertyMapping(databaseMapping, propertyMappingBuilder, fromFragment.Table, toFragment.Table, useExisting);
}
// move the propertyMapping
fromFragment.RemoveColumnMapping(propertyMappingBuilder);
toFragment.AddColumnMapping(propertyMappingBuilder);
}
BuildEntityTypeMapping(EntitySetMapping storeEntitySetMapping, SimpleMappingContext mappingContext, EntitySet storeEntitySet)
{
Debug.Assert(storeEntitySetMapping != null, "storeEntitySetMapping != null");
Debug.Assert(mappingContext != null, "mappingContext != null");
var entityType = storeEntitySetMapping.EntitySet.ElementType;
var entityTypeMapping = new EntityTypeMapping(storeEntitySetMapping);
entityTypeMapping.AddType(entityType);
var mappingFragment = new MappingFragment(storeEntitySet, entityTypeMapping, false);
entityTypeMapping.AddFragment(mappingFragment);
foreach (var propertyMapping in BuildPropertyMapping(storeEntitySet.ElementType, mappingContext))
{
mappingFragment.AddColumnMapping(propertyMapping);
}
return(entityTypeMapping);
}
// <summary>
// Makes sure only the required property mappings are present
// </summary>
private static void ConfigureTypeMappings(
TableMapping tableMapping,
Dictionary <EntityType, EntityTypeMapping> rootMappings,
EntityType entityType,
MappingFragment propertiesTypeMappingFragment,
MappingFragment conditionTypeMappingFragment)
{
var existingPropertyMappings =
new List <ColumnMappingBuilder>(
propertiesTypeMappingFragment.ColumnMappings.Where(pm => !pm.ColumnProperty.IsPrimaryKeyColumn));
var existingConditions = new List <ConditionPropertyMapping>(propertiesTypeMappingFragment.ColumnConditions);
foreach (var columnMapping in from cm in tableMapping.ColumnMappings
from pm in cm.PropertyMappings
where pm.EntityType == entityType
select new
{
cm.Column,
Property = pm
})
{
if (columnMapping.Property.PropertyPath != null
&&
!IsRootTypeMapping(
rootMappings, columnMapping.Property.EntityType, columnMapping.Property.PropertyPath))
{
var existingPropertyMapping =
propertiesTypeMappingFragment.ColumnMappings.SingleOrDefault(
x => x.PropertyPath == columnMapping.Property.PropertyPath);
if (existingPropertyMapping != null)
{
existingPropertyMappings.Remove(existingPropertyMapping);
}
else
{
existingPropertyMapping
= new ColumnMappingBuilder(columnMapping.Column, columnMapping.Property.PropertyPath);
propertiesTypeMappingFragment.AddColumnMapping(existingPropertyMapping);
}
}
if (columnMapping.Property.Conditions != null)
{
foreach (var condition in columnMapping.Property.Conditions)
{
if (conditionTypeMappingFragment.ColumnConditions.Contains(condition))
{
existingConditions.Remove(condition);
}
else if (!entityType.Abstract)
{
conditionTypeMappingFragment.AddConditionProperty(condition);
}
}
}
}
// Any leftover mappings are removed
foreach (var leftoverPropertyMapping in existingPropertyMappings)
{
propertiesTypeMappingFragment.RemoveColumnMapping(leftoverPropertyMapping);
}
foreach (var leftoverCondition in existingConditions)
{
conditionTypeMappingFragment.RemoveConditionProperty(leftoverCondition);
}
if (entityType.Abstract)
{
propertiesTypeMappingFragment.ClearConditions();
}
}
public void Can_generate_function_mappings_for_entity_type()
{
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.CreatePrimitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
entityType.AddKeyMember(intProperty);
var stringProperty = EdmProperty.CreatePrimitive("Name", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(stringProperty);
var entitySetMapping
= databaseMapping.AddEntitySetMapping(
databaseMapping.Model.AddEntitySet("ES", entityType));
var storageEntityTypeMapping
= new EntityTypeMapping(
new EntitySetMapping(new EntitySet(), databaseMapping.EntityContainerMappings.Single()));
storageEntityTypeMapping.AddType(entityType);
var storageMappingFragment = new MappingFragment(new EntitySet(), storageEntityTypeMapping, false);
storageMappingFragment.AddColumnMapping(
new ColumnMappingBuilder(new EdmProperty("C0", TypeUsage.Create(new PrimitiveType()
{
DataSpace = DataSpace.SSpace
})), new[] { intProperty }));
storageMappingFragment.AddColumnMapping(
new ColumnMappingBuilder(new EdmProperty("C1", TypeUsage.Create(new PrimitiveType()
{
DataSpace = DataSpace.SSpace
})), 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(2, functionMapping.ParameterBindings.Count);
Assert.Null(functionMapping.ResultBindings);
var function = functionMapping.Function;
Assert.NotNull(function);
Assert.Equal("E_Insert", function.Name);
Assert.Equal(2, function.Parameters.Count);
functionMapping = modificationFunctionMapping.UpdateFunctionMapping;
Assert.NotNull(functionMapping);
Assert.Equal(2, functionMapping.ParameterBindings.Count);
Assert.Null(functionMapping.ResultBindings);
function = functionMapping.Function;
Assert.NotNull(function);
Assert.Equal("E_Update", function.Name);
Assert.Equal(2, 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);
}
public void Generate(
EntityType entityType,
IEnumerable <EdmProperty> properties,
EntitySetMapping entitySetMapping,
MappingFragment entityTypeMappingFragment,
IList <EdmProperty> propertyPath,
bool createNewColumn)
{
DebugCheck.NotNull(entityType);
DebugCheck.NotNull(properties);
DebugCheck.NotNull(entityTypeMappingFragment);
DebugCheck.NotNull(propertyPath);
var rootDeclaredProperties = entityType.GetRootType().DeclaredProperties;
foreach (var property in properties)
{
if (property.IsComplexType &&
propertyPath.Any(
p => p.IsComplexType &&
(p.ComplexType == property.ComplexType)))
{
throw Error.CircularComplexTypeHierarchy();
}
propertyPath.Add(property);
if (property.IsComplexType)
{
Generate(
entityType,
property.ComplexType.Properties,
entitySetMapping,
entityTypeMappingFragment,
propertyPath,
createNewColumn);
}
else
{
var tableColumn
= entitySetMapping.EntityTypeMappings
.SelectMany(etm => etm.MappingFragments)
.SelectMany(etmf => etmf.ColumnMappings)
.Where(pm => pm.PropertyPath.SequenceEqual(propertyPath))
.Select(pm => pm.ColumnProperty)
.FirstOrDefault();
if (tableColumn == null || createNewColumn)
{
var columnName
= string.Join("_", propertyPath.Select(p => p.Name));
tableColumn
= MapTableColumn(
property,
columnName,
!rootDeclaredProperties.Contains(propertyPath.First()));
entityTypeMappingFragment.Table.AddColumn(tableColumn);
if (entityType.KeyProperties().Contains(property))
{
entityTypeMappingFragment.Table.AddKeyMember(tableColumn);
}
}
entityTypeMappingFragment.AddColumnMapping(
new ColumnMappingBuilder(tableColumn, propertyPath.ToList()));
}
propertyPath.Remove(property);
}
}
private static void ConfigureTypeMappings(
TableMapping tableMapping,
Dictionary <EntityType, EntityTypeMapping> rootMappings,
EntityType entityType,
MappingFragment propertiesTypeMappingFragment,
MappingFragment conditionTypeMappingFragment)
{
List <ColumnMappingBuilder> columnMappingBuilderList = new List <ColumnMappingBuilder>(propertiesTypeMappingFragment.ColumnMappings.Where <ColumnMappingBuilder>((Func <ColumnMappingBuilder, bool>)(pm => !pm.ColumnProperty.IsPrimaryKeyColumn)));
List <ConditionPropertyMapping> conditionPropertyMappingList = new List <ConditionPropertyMapping>(propertiesTypeMappingFragment.ColumnConditions);
foreach (var data in tableMapping.ColumnMappings.SelectMany((Func <ColumnMapping, IEnumerable <PropertyMappingSpecification> >)(cm => (IEnumerable <PropertyMappingSpecification>)cm.PropertyMappings), (cm, pm) => new
{
cm = cm,
pm = pm
}).Where(_param1 => _param1.pm.EntityType == entityType).Select(_param0 => new
{
Column = _param0.cm.Column,
Property = _param0.pm
}))
{
var columnMapping = data;
if (columnMapping.Property.PropertyPath != null && !EntityMappingService.IsRootTypeMapping(rootMappings, columnMapping.Property.EntityType, columnMapping.Property.PropertyPath))
{
ColumnMappingBuilder columnMappingBuilder1 = propertiesTypeMappingFragment.ColumnMappings.SingleOrDefault <ColumnMappingBuilder>((Func <ColumnMappingBuilder, bool>)(x => x.PropertyPath == columnMapping.Property.PropertyPath));
if (columnMappingBuilder1 != null)
{
columnMappingBuilderList.Remove(columnMappingBuilder1);
}
else
{
ColumnMappingBuilder columnMappingBuilder2 = new ColumnMappingBuilder(columnMapping.Column, columnMapping.Property.PropertyPath);
propertiesTypeMappingFragment.AddColumnMapping(columnMappingBuilder2);
}
}
if (columnMapping.Property.Conditions != null)
{
foreach (ConditionPropertyMapping condition in (IEnumerable <ConditionPropertyMapping>)columnMapping.Property.Conditions)
{
if (conditionTypeMappingFragment.ColumnConditions.Contains <ConditionPropertyMapping>(condition))
{
conditionPropertyMappingList.Remove(condition);
}
else if (!entityType.Abstract)
{
conditionTypeMappingFragment.AddConditionProperty(condition);
}
}
}
}
foreach (ColumnMappingBuilder columnMappingBuilder in columnMappingBuilderList)
{
propertiesTypeMappingFragment.RemoveColumnMapping(columnMappingBuilder);
}
foreach (ConditionPropertyMapping condition in conditionPropertyMappingList)
{
conditionTypeMappingFragment.RemoveConditionProperty(condition);
}
if (!entityType.Abstract)
{
return;
}
propertiesTypeMappingFragment.ClearConditions();
}