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; }
public void Serialize(DbDatabaseMapping databaseMapping, XmlWriter xmlWriter) { DebugCheck.NotNull(xmlWriter); DebugCheck.NotNull(databaseMapping); Debug.Assert(databaseMapping.Model != null); Debug.Assert(databaseMapping.Database != null); _xmlWriter = xmlWriter; _databaseMapping = databaseMapping; _version = databaseMapping.Model.SchemaVersion; _namespace = Equals(_version, XmlConstants.EdmVersionForV3) ? EdmXmlNamespaceV3 : (Equals(_version, XmlConstants.EdmVersionForV2) ? EdmXmlNamespaceV2 : EdmXmlNamespaceV1); _xmlWriter.WriteStartDocument(); using (Element("Edmx", "Version", string.Format(CultureInfo.InvariantCulture, "{0:F1}", _version))) { WriteEdmxRuntime(); WriteEdmxDesigner(); } _xmlWriter.WriteEndDocument(); _xmlWriter.Flush(); }
public void Configure_should_update_table_name_when_base_type_is_null() { var entityMappingConfiguration = new EntityMappingConfiguration { TableName = new DatabaseName("Foo") }; var entityTypeMapping = new EntityTypeMapping(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 MappingFragment(entitySet, entityTypeMapping, false)); entityMappingConfiguration.Configure( databaseMapping, databaseMapping.Model.Container.EntitySets, ProviderRegistry.Sql2008_ProviderManifest, entityTypeMapping.EntityType, ref entityTypeMapping, false, 0, 1, new Dictionary<string, object>()); Assert.Equal("Foo", table.GetTableName().Name); }
private static void GenerateForeignKeyAssociationType( AssociationType associationType, DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(associationType); DebugCheck.NotNull(databaseMapping); Debug.Assert(associationType.Constraint != null); var dependentEnd = associationType.Constraint.DependentEnd; var principalEnd = associationType.GetOtherEnd(dependentEnd); var principalEntityTypeMapping = GetEntityTypeMappingInHierarchy(databaseMapping, principalEnd.GetEntityType()); var dependentEntityTypeMapping = GetEntityTypeMappingInHierarchy(databaseMapping, dependentEnd.GetEntityType()); var foreignKeyConstraint = new ForeignKeyBuilder(databaseMapping.Database, associationType.Name) { PrincipalTable = principalEntityTypeMapping.MappingFragments.Single().Table, DeleteAction = principalEnd.DeleteBehavior != OperationAction.None ? principalEnd.DeleteBehavior : OperationAction.None }; dependentEntityTypeMapping .MappingFragments .Single() .Table .AddForeignKey(foreignKeyConstraint); foreignKeyConstraint.DependentColumns = associationType.Constraint.ToProperties.Select( dependentProperty => dependentEntityTypeMapping.GetPropertyMapping(dependentProperty).ColumnProperty); foreignKeyConstraint.SetAssociationType(associationType); }
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; }
internal void WriteSchema(DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(databaseMapping); WriteSchemaElementHeader(); WriteDbModelElement(databaseMapping); WriteEndElement(); }
internal void WriteSchema(DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(databaseMapping); WriteSchemaElementHeader(); WriteDbModelElement(databaseMapping); WriteEndElement(); }
// <summary> // Initializes a new instance of the <see cref="DbModel" /> class. // </summary> internal DbModel(DbDatabaseMapping databaseMapping, DbModelBuilder modelBuilder) { DebugCheck.NotNull(databaseMapping); DebugCheck.NotNull(modelBuilder); _databaseMapping = databaseMapping; _cachedModelBuilder = modelBuilder; }
internal DbModel(DbProviderInfo providerInfo, DbProviderManifest providerManifest) { DebugCheck.NotNull(providerInfo); DebugCheck.NotNull(providerManifest); _databaseMapping = new DbDatabaseMapping().Initialize( EdmModel.CreateConceptualModel(), EdmModel.CreateStoreModel(providerInfo, providerManifest)); }
private void WriteDbModelElement(DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(databaseMapping); _entityTypeNamespace = databaseMapping.Model.NamespaceNames.SingleOrDefault(); _dbSchemaName = databaseMapping.Database.Containers.Single().Name; WriteEntityContainerMappingElement(databaseMapping.EntityContainerMappings.First()); }
private void WriteDbModelElement(DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(databaseMapping); _entityTypeNamespace = databaseMapping.Model.NamespaceNames.SingleOrDefault(); _dbSchemaName = databaseMapping.Database.Containers.Single().Name; WriteEntityContainerMappingElement(databaseMapping.EntityContainerMappings.First()); }
private static DbDatabaseMapping InitializeDatabaseMapping(EdmModel model) { DebugCheck.NotNull(model); var databaseMapping = new DbDatabaseMapping() .Initialize(model, new EdmModel(DataSpace.SSpace, model.SchemaVersion)); return databaseMapping; }
// <summary> // Serialize the <see cref="DbModel" /> to the XmlWriter // </summary> // <param name="databaseMapping"> The DbModel to serialize </param> // <param name="xmlWriter"> The XmlWriter to serialize to </param> public virtual bool Serialize(DbDatabaseMapping databaseMapping, XmlWriter xmlWriter) { Check.NotNull(databaseMapping, "databaseMapping"); Check.NotNull(xmlWriter, "xmlWriter"); var schemaWriter = new MslXmlSchemaWriter(xmlWriter, databaseMapping.Model.SchemaVersion); schemaWriter.WriteSchema(databaseMapping); return(true); }
public void Can_set_and_get_Model() { var mapping = new DbDatabaseMapping(); Assert.Null(mapping.Model); var model = new EdmModel(DataSpace.CSpace); mapping.Model = model; Assert.Same(model, mapping.Model); }
/// <summary> /// Serialize the <see cref="DbModel" /> to the XmlWriter /// </summary> /// <param name="databaseMapping"> The DbModel to serialize </param> /// <param name="xmlWriter"> The XmlWriter to serialize to </param> public virtual bool Serialize(DbDatabaseMapping databaseMapping, XmlWriter xmlWriter) { Check.NotNull(databaseMapping, "databaseMapping"); Check.NotNull(xmlWriter, "xmlWriter"); var schemaWriter = new MslXmlSchemaWriter(xmlWriter, databaseMapping.Model.SchemaVersion); schemaWriter.WriteSchema(databaseMapping); return true; }
public void Can_set_and_get_Database() { var mapping = new DbDatabaseMapping(); Assert.Null(mapping.Database); var storeModel = new EdmModel(DataSpace.SSpace); mapping.Database = storeModel; Assert.Same(storeModel, mapping.Database); }
public void Can_add_container_mappings() { var mapping = new DbDatabaseMapping(); Assert.Empty(mapping.EntityContainerMappings); var containerMapping = new EntityContainerMapping(new EntityContainer()); mapping.AddEntityContainerMapping(containerMapping); Assert.Same(containerMapping, mapping.EntityContainerMappings.Single()); }
public void Can_set_and_get_Model() { var mapping = new DbDatabaseMapping(); Assert.Null(mapping.Model); var model = new EdmModel(DataSpace.CSpace); mapping.Model = model; Assert.Same(model, mapping.Model); }
public void Can_add_container_mappings() { var mapping = new DbDatabaseMapping(); Assert.Empty(mapping.EntityContainerMappings); var containerMapping = new EntityContainerMapping(new EntityContainer()); mapping.AddEntityContainerMapping(containerMapping); Assert.Same(containerMapping, mapping.EntityContainerMappings.Single()); }
public void Can_set_and_get_Database() { var mapping = new DbDatabaseMapping(); Assert.Null(mapping.Database); var storeModel = new EdmModel(DataSpace.SSpace); mapping.Database = storeModel; Assert.Same(storeModel, mapping.Database); }
void IDbMappingConvention.Apply(DbDatabaseMapping databaseMapping) { Check.NotNull(databaseMapping, "databaseMapping"); databaseMapping.EntityContainerMappings .SelectMany(ecm => ecm.AssociationSetMappings) .Where( asm => asm.AssociationSet.ElementType.IsManyToMany() && !asm.AssociationSet.ElementType.IsSelfReferencing()) .SelectMany(asm => asm.Table.ForeignKeyBuilders) .Each(fk => fk.DeleteAction = OperationAction.Cascade); }
// <summary> // Builds and stores the workspace based on the given code first configuration. // </summary> // <param name="databaseMapping"> The code first EDM model. </param> public CodeFirstCachedMetadataWorkspace(DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(databaseMapping); _providerInfo = databaseMapping.ProviderInfo; _metadataWorkspace = databaseMapping.ToMetadataWorkspace(); _assemblies = databaseMapping.Model.GetClrTypes().Select(t => t.Assembly()).Distinct().ToList(); Debug.Assert(databaseMapping.Model.Containers.Count() == 1, "Expecting Code First to create only one container."); _defaultContainerName = databaseMapping.Model.Containers.First().Name; }
internal static string SerializeToString(DbDatabaseMapping databaseMapping) { var edmx = new StringBuilder(); new EdmxSerializer().Serialize( databaseMapping, XmlWriter.Create( edmx, new XmlWriterSettings { Indent = true })); return edmx.ToString(); }
private void GenerateEntityTypes(DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(databaseMapping); foreach (var entityType in databaseMapping.Model.EntityTypes) { if (!entityType.Abstract) { new TableMappingGenerator(_providerManifest). Generate(entityType, databaseMapping); } } }
public void GetComplexParameterBindings_should_return_all_complex_parameter_bindings_for_type() { var databaseMapping = new DbDatabaseMapping() .Initialize( new EdmModel(DataSpace.CSpace), new EdmModel(DataSpace.SSpace)); var entityType = new EntityType("E", "N", DataSpace.CSpace); var entitySet = databaseMapping.Model.AddEntitySet("ES", entityType); var entitySetMapping = databaseMapping.AddEntitySetMapping(entitySet); var complexType1 = new ComplexType(); complexType1.Annotations.SetClrType(typeof(string)); var complexType2 = new ComplexType(); complexType2.Annotations.SetClrType(typeof(object)); var storageModificationFunctionMapping = new StorageModificationFunctionMapping( entitySet, entityType, new EdmFunction("F", "N", DataSpace.SSpace), new[] { new StorageModificationFunctionParameterBinding( new FunctionParameter(), new StorageModificationFunctionMemberPath( new EdmMember[] { EdmProperty.Complex("C1", complexType1), EdmProperty.Complex("C2", complexType2), new EdmProperty("M") }, null), true ) }, null, null); entitySetMapping.AddModificationFunctionMapping( new StorageEntityTypeModificationFunctionMapping( entityType, storageModificationFunctionMapping, storageModificationFunctionMapping, storageModificationFunctionMapping)); Assert.Equal(3, databaseMapping.GetComplexParameterBindings(typeof(string)).Count()); Assert.Equal(3, databaseMapping.GetComplexParameterBindings(typeof(object)).Count()); }
public void UpdateEdmxFromModel_updates_csdl_ssdl_msl() { var inputXml = XDocument.Parse("<root />"); var databaseMapping = new DbDatabaseMapping { Model = new EdmModel(DataSpace.CSpace), Database = new EdmModel(DataSpace.SSpace) }; var model = new DbModel(databaseMapping, new DbModelBuilder()); var mockEdmxHelper = new Mock<EdmxHelper>(inputXml); mockEdmxHelper.Setup( h => h.UpdateStorageModels( It.Is<EdmModel>(m => m == databaseMapping.Database), It.Is<string>(n => n == "storeNamespace"), It.Is<DbProviderInfo>(i => i == model.ProviderInfo), It.IsAny<List<EdmSchemaError>>())) .Returns(true); mockEdmxHelper.Setup( h => h.UpdateConceptualModels( It.Is<EdmModel>(m => m == databaseMapping.Model), It.Is<string>(n => n == "entityModelNamespace"))) .Returns(true); mockEdmxHelper.Setup( h => h.UpdateMapping( It.Is<DbModel>(m => m == model))) .Returns(true); mockEdmxHelper.Object.UpdateEdmxFromModel( model, "storeNamespace", "entityModelNamespace", new List<EdmSchemaError>()); mockEdmxHelper .Verify( h => h.UpdateStorageModels( It.Is<EdmModel>(m => m == databaseMapping.Database), It.Is<string>(n => n == "storeNamespace"), It.Is<DbProviderInfo>(i => i == model.ProviderInfo), It.IsAny<List<EdmSchemaError>>()), Times.Once()); mockEdmxHelper .Verify( h => h.UpdateConceptualModels( It.Is<EdmModel>(m => m == databaseMapping.Model), It.Is<string>(n => n == "entityModelNamespace")), Times.Once()); mockEdmxHelper .Verify( h => h.UpdateMapping( It.Is<DbModel>(m => m == model)), Times.Once()); }
public static DbModel Build(SimpleMappingContext mappingContext) { Debug.Assert(mappingContext != null, "mappingContext != null"); var databaseMapping = new DbDatabaseMapping { Database = mappingContext.StoreModel, Model = BuildEntityModel(mappingContext) }; databaseMapping.AddEntityContainerMapping(BuildEntityContainerMapping(mappingContext)); return new DbModel(databaseMapping, new DbModelBuilder()); }
private static void GenerateEntityTypes(DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(databaseMapping); foreach (var entityType in databaseMapping.Model.EntityTypes) { if (entityType.Abstract && databaseMapping.Model.EntityTypes.All(e => e.BaseType != entityType)) { throw new InvalidOperationException(Strings.UnmappedAbstractType(entityType.GetClrType())); } new TableMappingGenerator(databaseMapping.ProviderManifest). Generate(entityType, databaseMapping); } }
private static void GenerateDiscriminators(DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(databaseMapping); foreach (var entitySetMapping in databaseMapping.GetEntitySetMappings()) { if (entitySetMapping.EntityTypeMappings.Count() <= 1) { continue; } var typeUsage = databaseMapping.ProviderManifest.GetStoreType(DiscriminatorTypeUsage); var discriminatorColumn = new EdmProperty(DiscriminatorColumnName, typeUsage) { Nullable = false, DefaultValue = "(Undefined)" }; entitySetMapping .EntityTypeMappings .First() .MappingFragments .Single() .Table .AddColumn(discriminatorColumn); foreach (var entityTypeMapping in entitySetMapping.EntityTypeMappings) { // Abstract classes don't need a discriminator as they won't be directly materialized if (entityTypeMapping.EntityType.Abstract) { continue; } var entityTypeMappingFragment = entityTypeMapping.MappingFragments.Single(); entityTypeMappingFragment.SetDefaultDiscriminator(discriminatorColumn); entityTypeMappingFragment .AddDiscriminatorCondition(discriminatorColumn, entityTypeMapping.EntityType.Name); } } }
private static EntitySetMapping GetEntitySetMapping( DbDatabaseMapping databaseMapping, EntityType cSpaceEntityType, IEnumerable<EntitySet> entitySets) { while (cSpaceEntityType.BaseType != null) { cSpaceEntityType = (EntityType)cSpaceEntityType.BaseType; } var cSpaceEntitySet = entitySets.First(s => s.ElementType == cSpaceEntityType); return databaseMapping .EntityContainerMappings .First() .EntitySetMappings .First(m => m.EntitySet == cSpaceEntitySet); }
public void Generate(AssociationType associationType, DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(associationType); DebugCheck.NotNull(databaseMapping); if (associationType.Constraint != null) { GenerateForeignKeyAssociationType(associationType, databaseMapping); } else if (associationType.IsManyToMany()) { GenerateManyToManyAssociation(associationType, databaseMapping); } else { GenerateIndependentAssociationType(associationType, databaseMapping); } }
public void Apply(DbDatabaseMapping databaseMapping) { Check.NotNull(databaseMapping, "databaseMapping"); databaseMapping.EntityContainerMappings .SelectMany(ecm => ecm.EntitySetMappings) .Each( esm => { foreach (var etm in esm.EntityTypeMappings) { if (RemapsInheritedProperties(databaseMapping, etm) && HasBaseWithIsTypeOf(esm, etm.EntityType)) { throw Error.UnsupportedHybridInheritanceMapping(etm.EntityType.Name); } } }); }
internal void Configure( DbDatabaseMapping databaseMapping, MappingFragment fragment, EntityType entityType) { DebugCheck.NotNull(fragment); var edmPropertyPath = EntityMappingConfiguration.PropertyPathToEdmPropertyPath(PropertyPath, entityType); if (edmPropertyPath.Count() > 1) { throw Error.InvalidNotNullCondition(PropertyPath.ToString(), entityType.Name); } var column = fragment.ColumnMappings .Where(pm => pm.PropertyPath.SequenceEqual(edmPropertyPath.Single())) .Select(pm => pm.ColumnProperty) .SingleOrDefault(); if (column == null || !fragment.Table.Properties.Contains(column)) { throw Error.InvalidNotNullCondition(PropertyPath.ToString(), entityType.Name); } if (ValueConditionConfiguration.AnyBaseTypeToTableWithoutColumnCondition( databaseMapping, entityType, fragment.Table, column)) { column.Nullable = true; } // Make the property required var newConfiguration = new Properties.Primitive.PrimitivePropertyConfiguration { IsNullable = false, OverridableConfigurationParts = OverridableConfigurationParts.OverridableInSSpace }; newConfiguration.Configure(edmPropertyPath.Single().Last()); fragment.AddNullabilityCondition(column, isNull: 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 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()); }
private void GenerateDiscriminators(DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(databaseMapping); foreach (var entitySetMapping in databaseMapping.GetEntitySetMappings()) { if (entitySetMapping.EntityTypeMappings.Count() <= 1) { continue; } var typeUsage = _providerManifest.GetStoreType(DiscriminatorTypeUsage); var discriminatorColumn = new EdmProperty(DiscriminatorColumnName, typeUsage) { Nullable = false }; entitySetMapping .EntityTypeMappings .First() .MappingFragments .Single() .Table .AddColumn(discriminatorColumn); foreach (var entityTypeMapping in entitySetMapping.EntityTypeMappings) { var entityTypeMappingFragment = entityTypeMapping.MappingFragments.Single(); entityTypeMappingFragment.SetDefaultDiscriminator(discriminatorColumn); entityTypeMappingFragment .AddDiscriminatorCondition(discriminatorColumn, entityTypeMapping.EntityType.Name); } } }
internal void WriteSchema(DbDatabaseMapping databaseMapping) { this.WriteSchemaElementHeader(); this.WriteDbModelElement(databaseMapping); this.WriteEndElement(); }
private void WriteDbModelElement(DbDatabaseMapping databaseMapping) { this._entityTypeNamespace = databaseMapping.Model.NamespaceNames.SingleOrDefault <string>(); this._dbSchemaName = databaseMapping.Database.Containers.Single <EntityContainer>().Name; this.WriteEntityContainerMappingElement(databaseMapping.EntityContainerMappings.First <EntityContainerMapping>()); }