private static EntityType FindBaseTableForExtraPropertyMapping(
DbDatabaseMapping databaseMapping, EntityType entityType, ColumnMappingBuilder pm)
{
var baseType = (EntityType)entityType.BaseType;
MappingFragment baseFragment = null;
while (baseType != null &&
baseFragment == null)
{
var baseMapping = databaseMapping.GetEntityTypeMapping(baseType);
if (baseMapping != null)
{
baseFragment =
baseMapping.MappingFragments.SingleOrDefault(
f => f.ColumnMappings.Any(bpm => bpm.PropertyPath.SequenceEqual(pm.PropertyPath)));
if (baseFragment != null)
{
return(baseFragment.Table);
}
}
baseType = (EntityType)baseType.BaseType;
}
return(null);
}
public void Configure_should_merge_SSpace_configurations()
{
var configurationA = CreateConfiguration();
configurationA.ColumnName = "foo";
var configurationB = CreateConfiguration();
configurationB.ColumnType = "nvarchar";
var edmPropertyMapping = new ColumnMappingBuilder(new EdmProperty("C"), new List <EdmProperty>());
configurationA.Configure(
new[] { Tuple.Create(edmPropertyMapping, new EntityType("T", XmlConstants.TargetNamespace_3, DataSpace.SSpace)) },
ProviderRegistry.Sql2008_ProviderManifest);
Assert.Equal(
"foo",
((Properties.Primitive.PrimitivePropertyConfiguration)edmPropertyMapping.ColumnProperty.GetConfiguration()).ColumnName);
configurationB.Configure(
new[] { Tuple.Create(edmPropertyMapping, new EntityType("T", XmlConstants.TargetNamespace_3, DataSpace.SSpace)) },
ProviderRegistry.Sql2008_ProviderManifest);
Assert.Equal(
"foo",
((Properties.Primitive.PrimitivePropertyConfiguration)edmPropertyMapping.ColumnProperty.GetConfiguration()).ColumnName);
Assert.Equal(
"nvarchar",
((Properties.Primitive.PrimitivePropertyConfiguration)edmPropertyMapping.ColumnProperty.GetConfiguration()).ColumnType);
}
private EntityType FindOrCreateTargetTable(
DbDatabaseMapping databaseMapping,
MappingFragment fragment,
EntityType entityType,
EntityType fromTable,
out bool isTableSharing)
{
isTableSharing = false;
EntityType entityType1;
if (this.TableName == null)
{
entityType1 = fragment.Table;
}
else
{
entityType1 = databaseMapping.Database.FindTableByName(this.TableName) ?? (entityType.BaseType != null ? databaseMapping.Database.AddTable(this.TableName.Name, fromTable) : fragment.Table);
isTableSharing = EntityMappingConfiguration.UpdateColumnNamesForTableSharing(databaseMapping, entityType, entityType1, fragment);
fragment.TableSet = databaseMapping.Database.GetEntitySet(entityType1);
foreach (ColumnMappingBuilder columnMappingBuilder in fragment.ColumnMappings.Where <ColumnMappingBuilder>((Func <ColumnMappingBuilder, bool>)(cm => cm.ColumnProperty.IsPrimaryKeyColumn)))
{
ColumnMappingBuilder columnMapping = columnMappingBuilder;
EdmProperty edmProperty = entityType1.Properties.SingleOrDefault <EdmProperty>((Func <EdmProperty, bool>)(c => string.Equals(c.Name, columnMapping.ColumnProperty.Name, StringComparison.Ordinal)));
columnMapping.ColumnProperty = edmProperty ?? columnMapping.ColumnProperty;
}
entityType1.SetTableName(this.TableName);
}
return(entityType1);
}
public static void SyncNullabilityCSSpace(
this ColumnMappingBuilder propertyMappingBuilder,
DbDatabaseMapping databaseMapping,
IEnumerable <EntitySet> entitySets,
EntityType toTable)
{
DebugCheck.NotNull(propertyMappingBuilder);
var property = propertyMappingBuilder.PropertyPath.Last();
EntitySetMapping setMapping = null;
var baseType = (EntityType)property.DeclaringType.BaseType;
if (baseType != null)
{
setMapping = GetEntitySetMapping(databaseMapping, baseType, entitySets);
}
while (baseType != null)
{
if (toTable == setMapping.EntityTypeMappings.First(m => m.EntityType == baseType).GetPrimaryTable())
{
// CodePlex 2254: If current table is part of TPH mapping below the TPT mapping we are processing, then
// don't change the nullability because the TPH nullability calculated previously is still correct.
return;
}
baseType = (EntityType)baseType.BaseType;
}
propertyMappingBuilder.ColumnProperty.Nullable = property.Nullable;
}
private static EntityType FindTableForTemporaryExtraPropertyMapping(
DbDatabaseMapping databaseMapping,
EntityType entityType,
EntityType fromTable,
EntityType toTable,
ColumnMappingBuilder pm)
{
var extraTable = fromTable;
if (fromTable == toTable)
{
extraTable = databaseMapping.Database.AddTable(entityType.Name, fromTable);
}
else if (entityType.BaseType == null)
{
extraTable = fromTable;
}
else
{
// find where the base mappings are and put them in that table
extraTable = FindBaseTableForExtraPropertyMapping(databaseMapping, entityType, pm);
if (extraTable == null)
{
extraTable = fromTable;
}
}
return(extraTable);
}
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));
}
private static EntityType FindTableForExtraPropertyMapping(
DbDatabaseMapping databaseMapping,
EntityType entityType,
EntityType fromTable,
EntityType toTable,
ref EntityType unmappedTable,
ColumnMappingBuilder pm)
{
var extraTable = FindBaseTableForExtraPropertyMapping(databaseMapping, entityType, pm);
if (extraTable == null)
{
if (fromTable != toTable &&
entityType.BaseType == null)
{
return(fromTable);
}
if (unmappedTable == null)
{
unmappedTable = databaseMapping.Database.AddTable(fromTable.Name, fromTable);
}
extraTable = unmappedTable;
}
return(extraTable);
}
private static EntityType FindTableForTemporaryExtraPropertyMapping(
DbDatabaseMapping databaseMapping,
EntityType entityType,
EntityType fromTable,
EntityType toTable,
ColumnMappingBuilder pm)
{
return(fromTable != toTable ? (entityType.BaseType != null ? EntityMappingConfiguration.FindBaseTableForExtraPropertyMapping(databaseMapping, entityType, pm) ?? fromTable : fromTable) : databaseMapping.Database.AddTable(entityType.Name, fromTable));
}
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, StorageMappingFragment fragment, bool useExisting)
{
// Ensure column is in the fragment's table
var column = TablePrimitiveOperations.IncludeColumn(fragment.Table, propertyMappingBuilder.ColumnProperty, useExisting);
// Add the property mapping
fragment.AddColumnMapping(
new ColumnMappingBuilder(column, propertyMappingBuilder.PropertyPath));
}
private static void UpdatePropertyMapping(
DbDatabaseMapping databaseMapping,
IEnumerable <EntitySet> entitySets,
Dictionary <EdmProperty, IList <ColumnMappingBuilder> > columnMappingIndex,
ColumnMappingBuilder propertyMappingBuilder,
EntityType fromTable,
EntityType toTable,
bool useExisting)
{
propertyMappingBuilder.ColumnProperty = TableOperations.CopyColumnAndAnyConstraints(databaseMapping.Database, fromTable, toTable, propertyMappingBuilder.ColumnProperty, EntityMappingOperations.GetPropertyPathMatcher(columnMappingIndex, propertyMappingBuilder), useExisting);
propertyMappingBuilder.SyncNullabilityCSSpace(databaseMapping, entitySets, toTable);
}
private static void UpdatePropertyMapping(
EdmModel database,
ColumnMappingBuilder propertyMappingBuilder,
EntityType fromTable,
EntityType toTable,
bool useExisting)
{
propertyMappingBuilder.ColumnProperty
= TableOperations.CopyColumnAndAnyConstraints(
database, fromTable, toTable, propertyMappingBuilder.ColumnProperty, useExisting, false);
propertyMappingBuilder.SyncNullabilityCSSpace();
}
private static void UpdatePropertyMapping(
DbDatabaseMapping databaseMapping,
ColumnMappingBuilder propertyMappingBuilder,
EntityType fromTable,
EntityType toTable,
bool useExisting)
{
propertyMappingBuilder.ColumnProperty
= TableOperations.CopyColumnAndAnyConstraints(
databaseMapping.Database, fromTable, toTable, propertyMappingBuilder.ColumnProperty, GetPropertyPathMatcher(databaseMapping, propertyMappingBuilder), useExisting);
propertyMappingBuilder.SyncNullabilityCSSpace();
}
public void Configure_should_update_mapped_column_type()
{
var configuration = CreateConfiguration();
configuration.ColumnType = "NVarchaR(max)";
var edmPropertyMapping = new ColumnMappingBuilder(new EdmProperty("C"), new List <EdmProperty>());
configuration.Configure(
new[] { Tuple.Create(edmPropertyMapping, new EntityType("T", XmlConstants.TargetNamespace_3, DataSpace.SSpace)) },
ProviderRegistry.Sql2008_ProviderManifest);
Assert.Equal("nvarchar(max)", edmPropertyMapping.ColumnProperty.TypeName);
}
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 RemoveDuplicateTphColumns()
{
int index1;
for (int index2 = 0; index2 < this._columnMappings.Count - 1; index2 = index1)
{
StructuralType declaringType = this._columnMappings[index2].PropertyPath[0].DeclaringType;
EdmProperty column = this._columnMappings[index2].ColumnProperty;
index1 = index2 + 1;
EdmType commonBaseType;
while (index1 < this._columnMappings.Count && column.Name == this._columnMappings[index1].ColumnProperty.Name && (declaringType != this._columnMappings[index1].PropertyPath[0].DeclaringType && TypeSemantics.TryGetCommonBaseType((EdmType)declaringType, (EdmType)this._columnMappings[index1].PropertyPath[0].DeclaringType, out commonBaseType)))
{
++index1;
}
System.Data.Entity.ModelConfiguration.Configuration.Properties.Primitive.PrimitivePropertyConfiguration configuration1 = column.GetConfiguration() as System.Data.Entity.ModelConfiguration.Configuration.Properties.Primitive.PrimitivePropertyConfiguration;
for (int index3 = index2 + 1; index3 < index1; ++index3)
{
ColumnMappingBuilder toFixup = this._columnMappings[index3];
System.Data.Entity.ModelConfiguration.Configuration.Properties.Primitive.PrimitivePropertyConfiguration configuration2 = toFixup.ColumnProperty.GetConfiguration() as System.Data.Entity.ModelConfiguration.Configuration.Properties.Primitive.PrimitivePropertyConfiguration;
string errorMessage;
if (configuration1 != null && !configuration1.IsCompatible(configuration2, false, out errorMessage))
{
throw new MappingException(Strings.BadTphMappingToSharedColumn((object)string.Join(".", this._columnMappings[index2].PropertyPath.Select <EdmProperty, string>((Func <EdmProperty, string>)(p => p.Name))), (object)declaringType.Name, (object)string.Join(".", toFixup.PropertyPath.Select <EdmProperty, string>((Func <EdmProperty, string>)(p => p.Name))), (object)toFixup.PropertyPath[0].DeclaringType.Name, (object)column.Name, (object)column.DeclaringType.Name, (object)errorMessage));
}
configuration2?.Configure(column, this._table, this._storeModel.ProviderManifest, false, false);
column.Nullable = true;
foreach (AssociationType associationType in this._storeModel.AssociationTypes.Where <AssociationType>((Func <AssociationType, bool>)(a => a.Constraint != null)).Select(a => new
{
a = a,
p = a.Constraint.ToProperties
}).Where(_param1 =>
{
if (!_param1.p.Contains(column))
{
return(_param1.p.Contains(toFixup.ColumnProperty));
}
return(true);
}).Select(_param0 => _param0.a).ToArray <AssociationType>())
{
this._storeModel.RemoveAssociationType(associationType);
}
if (toFixup.ColumnProperty.DeclaringType.HasMember((EdmMember)toFixup.ColumnProperty))
{
toFixup.ColumnProperty.DeclaringType.RemoveMember((EdmMember)toFixup.ColumnProperty);
}
toFixup.ColumnProperty = column;
}
}
}
private static Dictionary <EdmProperty, IList <ColumnMappingBuilder> > GetColumnMappingIndex(
DbDatabaseMapping databaseMapping)
{
Dictionary <EdmProperty, IList <ColumnMappingBuilder> > dictionary = new Dictionary <EdmProperty, IList <ColumnMappingBuilder> >();
IEnumerable <EntitySetMapping> entitySetMappings = databaseMapping.EntityContainerMappings.Single <EntityContainerMapping>().EntitySetMappings;
if (entitySetMappings == null)
{
return(dictionary);
}
List <EntitySetMapping> list = entitySetMappings.ToList <EntitySetMapping>();
for (int index1 = 0; index1 < list.Count; ++index1)
{
IList <EntityTypeMapping> entityTypeMappings = (IList <EntityTypeMapping>)list[index1].EntityTypeMappings;
if (entityTypeMappings != null)
{
for (int index2 = 0; index2 < entityTypeMappings.Count; ++index2)
{
IList <MappingFragment> mappingFragments = (IList <MappingFragment>)entityTypeMappings[index2].MappingFragments;
if (mappingFragments != null)
{
for (int index3 = 0; index3 < mappingFragments.Count; ++index3)
{
IList <ColumnMappingBuilder> columnMappings = mappingFragments[index3].ColumnMappings as IList <ColumnMappingBuilder>;
if (columnMappings != null)
{
for (int index4 = 0; index4 < columnMappings.Count; ++index4)
{
ColumnMappingBuilder columnMappingBuilder = columnMappings[index4];
IList <ColumnMappingBuilder> columnMappingBuilderList;
if (dictionary.ContainsKey(columnMappingBuilder.ColumnProperty))
{
columnMappingBuilderList = dictionary[columnMappingBuilder.ColumnProperty];
}
else
{
dictionary.Add(columnMappingBuilder.ColumnProperty, columnMappingBuilderList = (IList <ColumnMappingBuilder>) new List <ColumnMappingBuilder>());
}
columnMappingBuilderList.Add(columnMappingBuilder);
}
}
}
}
}
}
}
return(dictionary);
}
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 static void MovePropertyMapping(
EdmModel database,
StorageMappingFragment fromFragment,
StorageMappingFragment 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(database, propertyMappingBuilder, fromFragment.Table, toFragment.Table, useExisting);
}
// move the propertyMapping
fromFragment.RemoveColumnMapping(propertyMappingBuilder);
toFragment.AddColumnMapping(propertyMappingBuilder);
}
public static void MovePropertyMapping(
DbDatabaseMapping databaseMapping,
IEnumerable <EntitySet> entitySets,
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, entitySets, GetColumnMappingIndex(databaseMapping), propertyMappingBuilder, fromFragment.Table, toFragment.Table, useExisting);
}
// move the propertyMapping
fromFragment.RemoveColumnMapping(propertyMappingBuilder);
toFragment.AddColumnMapping(propertyMappingBuilder);
}
public void Configure_should_set_SSpace_configuration_annotation()
{
var configuration = CreateConfiguration();
var edmPropertyMapping = new ColumnMappingBuilder(new EdmProperty("C"), new List <EdmProperty>());
Assert.Null(edmPropertyMapping.ColumnProperty.GetConfiguration());
configuration.Configure(
new[]
{
Tuple.Create(
edmPropertyMapping,
new EntityType("T", XmlConstants.TargetNamespace_3, DataSpace.SSpace))
},
ProviderRegistry.Sql2008_ProviderManifest);
Assert.Same(configuration, edmPropertyMapping.ColumnProperty.GetConfiguration());
}
public void Configure_should_update_IsRowVersion()
{
var configuration = CreateConfiguration();
configuration.IsRowVersion = true;
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
configuration.Configure(property);
Assert.Equal(8, property.MaxLength);
Assert.Equal(false, property.Nullable);
Assert.Equal(ConcurrencyMode.Fixed, property.ConcurrencyMode);
Assert.Equal(StoreGeneratedPattern.Computed, property.GetStoreGeneratedPattern());
var edmPropertyMapping = new ColumnMappingBuilder(new EdmProperty("C"), new List <EdmProperty>());
configuration.Configure(
new[] { Tuple.Create(edmPropertyMapping, new EntityType("T", XmlConstants.TargetNamespace_3, DataSpace.SSpace)) },
ProviderRegistry.Sql2008_ProviderManifest);
Assert.Equal("rowversion", edmPropertyMapping.ColumnProperty.TypeName);
}
private static Func <EdmProperty, bool> GetPropertyPathMatcher(
Dictionary <EdmProperty, IList <ColumnMappingBuilder> > columnMappingIndex,
ColumnMappingBuilder propertyMappingBuilder)
{
return((Func <EdmProperty, bool>)(c =>
{
if (!columnMappingIndex.ContainsKey(c))
{
return false;
}
IList <ColumnMappingBuilder> columnMappingBuilderList = columnMappingIndex[c];
for (int index = 0; index < columnMappingBuilderList.Count; ++index)
{
if (columnMappingBuilderList[index].PropertyPath.PathEqual(propertyMappingBuilder.PropertyPath))
{
return true;
}
}
return false;
}));
}
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);
}
}
private static EntityType FindBaseTableForExtraPropertyMapping(
DbDatabaseMapping databaseMapping,
EntityType entityType,
ColumnMappingBuilder pm)
{
EntityType baseType = (EntityType)entityType.BaseType;
for (MappingFragment mappingFragment = (MappingFragment)null; baseType != null && mappingFragment == null; baseType = (EntityType)baseType.BaseType)
{
EntityTypeMapping entityTypeMapping = databaseMapping.GetEntityTypeMapping(baseType);
if (entityTypeMapping != null)
{
mappingFragment = entityTypeMapping.MappingFragments.SingleOrDefault <MappingFragment>((Func <MappingFragment, bool>)(f => f.ColumnMappings.Any <ColumnMappingBuilder>((Func <ColumnMappingBuilder, bool>)(bpm => bpm.PropertyPath.SequenceEqual <EdmProperty>((IEnumerable <EdmProperty>)pm.PropertyPath)))));
if (mappingFragment != null)
{
return(mappingFragment.Table);
}
}
}
return((EntityType)null);
}
public void Configure_should_update_model_dateTime_precision()
{
var configuration = CreateConfiguration();
configuration.Precision = 255;
var property = EdmProperty.CreatePrimitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.DateTime));
configuration.Configure(property);
Assert.Equal((byte)255, property.Precision);
var edmPropertyMapping =
new ColumnMappingBuilder(
new EdmProperty(
"C", TypeUsage.Create(ProviderRegistry.Sql2008_ProviderManifest.GetStoreTypes().First(t => t.Name == "datetime2"))),
new List <EdmProperty>());
configuration.Configure(
new[] { Tuple.Create(edmPropertyMapping, new EntityType("T", XmlConstants.TargetNamespace_3, DataSpace.SSpace)) },
ProviderRegistry.Sql2008_ProviderManifest);
Assert.Equal((byte)255, edmPropertyMapping.ColumnProperty.Precision);
}
public static void SyncNullabilityCSSpace(
this ColumnMappingBuilder propertyMappingBuilder,
DbDatabaseMapping databaseMapping,
IEnumerable <EntitySet> entitySets,
EntityType toTable)
{
EdmProperty edmProperty = propertyMappingBuilder.PropertyPath.Last <EdmProperty>();
EntitySetMapping entitySetMapping = (EntitySetMapping)null;
EntityType baseType = (EntityType)edmProperty.DeclaringType.BaseType;
if (baseType != null)
{
entitySetMapping = ColumnMappingBuilderExtensions.GetEntitySetMapping(databaseMapping, baseType, entitySets);
}
for (; baseType != null; baseType = (EntityType)baseType.BaseType)
{
if (toTable == entitySetMapping.EntityTypeMappings.First <EntityTypeMapping>((Func <EntityTypeMapping, bool>)(m => m.EntityType == baseType)).GetPrimaryTable())
{
return;
}
}
propertyMappingBuilder.ColumnProperty.Nullable = edmProperty.Nullable;
}
public void Configure_should_update_IsUnicode()
{
var configuration = CreateConfiguration();
configuration.IsUnicode = true;
var property = EdmProperty.CreatePrimitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
configuration.Configure(property);
Assert.Equal(true, property.IsUnicode);
var edmPropertyMapping =
new ColumnMappingBuilder(
new EdmProperty(
"C", TypeUsage.Create(ProviderRegistry.Sql2008_ProviderManifest.GetStoreTypes().First(t => t.Name == "nvarchar"))),
new List <EdmProperty>());
configuration.Configure(
new[] { Tuple.Create(edmPropertyMapping, new EntityType("T", XmlConstants.TargetNamespace_3, DataSpace.SSpace)) },
ProviderRegistry.Sql2008_ProviderManifest);
Assert.Equal(true, edmPropertyMapping.ColumnProperty.IsUnicode);
}
public static void SyncNullabilityCSSpace(this ColumnMappingBuilder propertyMappingBuilder)
{
DebugCheck.NotNull(propertyMappingBuilder);
propertyMappingBuilder.ColumnProperty.Nullable = propertyMappingBuilder.PropertyPath.Last().Nullable;
}
public void SetColumnMapping <T>(ColumnMappingBuilder <T> builder)
{
builder.WithHeader(ColumnName);
}
