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 bool DiscoverIsSharingWithBase( DbDatabaseMapping databaseMapping, EntityType entityType, EntityType toTable) { var isSharingTableWithBase = false; if (entityType.BaseType != null) { var baseType = entityType.BaseType; var anyBaseMappings = false; while (baseType != null && !isSharingTableWithBase) { var baseMappings = databaseMapping.GetEntityTypeMappings((EntityType)baseType); if (baseMappings.Any()) { isSharingTableWithBase = baseMappings.SelectMany(m => m.MappingFragments).Any(tmf => tmf.Table == toTable); anyBaseMappings = true; } baseType = baseType.BaseType; } if (!anyBaseMappings) { isSharingTableWithBase = TableName == null || string.IsNullOrWhiteSpace(TableName.Name); } } return(isSharingTableWithBase); }
public static void RemoveAllForeignKeyConstraintsForColumn( EntityType table, EdmProperty column, DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(table); DebugCheck.NotNull(column); DebugCheck.NotNull(databaseMapping); table.ForeignKeyBuilders .Where(fk => fk.DependentColumns.Contains(column)) .ToArray() .Each( fk => { table.RemoveForeignKey(fk); var copiedFk = databaseMapping.Database.EntityTypes .SelectMany(t => t.ForeignKeyBuilders) .SingleOrDefault(fk2 => Equals(fk2.GetPreferredName(), fk.Name)); if (copiedFk != null) { copiedFk.Name = copiedFk.GetPreferredName(); } }); }
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 static void AssertValid(this DbDatabaseMapping databaseMapping, bool shouldThrow) { var storageItemMappingCollection = databaseMapping.ToStorageMappingItemCollection(); IList <EdmSchemaError> errors; storageItemMappingCollection.GenerateEntitySetViews(out errors); if (errors.Any()) { var errorMessage = new StringBuilder(); errorMessage.AppendLine(); foreach (var error in errors) { errorMessage.AppendLine(error.ToString()); } if (shouldThrow) { throw new MappingException(errorMessage.ToString()); } Assert.True(false, errorMessage.ToString()); } }
private static void ConfigureUnconfiguredDerivedTypes( DbDatabaseMapping databaseMapping, ICollection <EntitySet> entitySets, DbProviderManifest providerManifest, EntityType entityType, IList <EntityTypeConfiguration> sortedEntityConfigurations) { var derivedTypes = databaseMapping.Model.GetDerivedTypes(entityType).ToList(); while (derivedTypes.Count > 0) { var currentType = derivedTypes[0]; derivedTypes.RemoveAt(0); // Configure the derived type if it is not abstract and is not otherwise configured // if the type is not configured, then also run through that type's derived types if (!currentType.Abstract && sortedEntityConfigurations.All(etc => etc.ClrType != currentType.GetClrType())) { // run through mapping configuration to make sure property mappings point to where the base type is now mapping them EntityTypeConfiguration.ConfigureUnconfiguredType(databaseMapping, entitySets, providerManifest, currentType, new Dictionary <string, object>()); derivedTypes.AddRange(databaseMapping.Model.GetDerivedTypes(currentType)); } } }
private static void ConfigureDependentKeys(DbDatabaseMapping databaseMapping, DbProviderManifest providerManifest) { DebugCheck.NotNull(databaseMapping); DebugCheck.NotNull(providerManifest); foreach (var foreignKeyConstraint in databaseMapping.Database.EntityTypes.SelectMany(t => t.ForeignKeyBuilders)) { foreignKeyConstraint .DependentColumns .Each( (c, i) => { var primitivePropertyConfiguration = c.GetConfiguration() as PrimitivePropertyConfiguration; if ((primitivePropertyConfiguration != null) && (primitivePropertyConfiguration.ColumnType != null)) { return; } var principalColumn = foreignKeyConstraint.PrincipalTable.KeyProperties.ElementAt(i); c.PrimitiveType = providerManifest.GetStoreTypeFromName(principalColumn.TypeName); c.CopyFrom(principalColumn); }); } }
internal void Configure( EntityType entityType, DbDatabaseMapping databaseMapping, DbProviderManifest providerManifest) { DebugCheck.NotNull(entityType); DebugCheck.NotNull(databaseMapping); DebugCheck.NotNull(providerManifest); var entityTypeMapping = databaseMapping.GetEntityTypeMapping(entityType.GetClrType()); if (entityTypeMapping != null) { VerifyAllCSpacePropertiesAreMapped( databaseMapping.GetEntityTypeMappings(entityType).ToList(), entityTypeMapping.EntityType.DeclaredProperties, new List <EdmProperty>()); } ConfigurePropertyMappings(databaseMapping, entityType, providerManifest); ConfigureIndexes(databaseMapping, entityType); ConfigureAssociationMappings(databaseMapping, entityType, providerManifest); ConfigureDependentKeys(databaseMapping, providerManifest); ConfigureModificationStoredProcedures(databaseMapping, entityType, providerManifest); }
protected static StorageEntityTypeMapping GetEntityTypeMappingInHierarchy( DbDatabaseMapping databaseMapping, EntityType entityType) { DebugCheck.NotNull(databaseMapping); DebugCheck.NotNull(entityType); var entityTypeMapping = databaseMapping.GetEntityTypeMapping(entityType); if (entityTypeMapping == null) { var entitySetMapping = databaseMapping.GetEntitySetMapping(databaseMapping.Model.GetEntitySet(entityType)); if (entitySetMapping != null) { entityTypeMapping = entitySetMapping .EntityTypeMappings .First( etm => entityType.DeclaredProperties.All( dp => etm.MappingFragments.First() .ColumnMappings.Select(pm => pm.PropertyPath.First()).Contains(dp))); } } if (entityTypeMapping == null) { throw Error.UnmappedAbstractType(entityType.GetClrType()); } return(entityTypeMapping); }
internal void ConfigureTablesAndConditions( EntityTypeMapping 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, _annotations); } } else { ConfigureUnconfiguredType(databaseMapping, providerManifest, entityType, _annotations); } }
internal void ApplyMapping(DbDatabaseMapping databaseMapping) { foreach (IConvention mappingConvention in this._conceptualToStoreMappingConventions) { (mappingConvention as IDbMappingConvention)?.Apply(databaseMapping); } }
private static void GenerateAssociationTypes(DbDatabaseMapping databaseMapping) { foreach (AssociationType associationType in databaseMapping.Model.AssociationTypes) { new AssociationTypeMappingGenerator(databaseMapping.ProviderManifest).Generate(associationType, databaseMapping); } }
internal static bool AnyBaseTypeToTableWithoutColumnCondition( DbDatabaseMapping databaseMapping, EntityType entityType, EntityType table, EdmProperty column) { var baseType = entityType.BaseType; while (baseType != null) { if (!baseType.Abstract) { var baseTypeTableFragments = databaseMapping.GetEntityTypeMappings((EntityType)baseType) .SelectMany(etm => etm.MappingFragments) .Where(tmf => tmf.Table == table) .ToList(); if (baseTypeTableFragments.Any() && baseTypeTableFragments .SelectMany(etmf => etmf.ColumnConditions) .All(cc => cc.Column != column)) { return(true); } } baseType = baseType.BaseType; } return(false); }
internal void Configure( AssociationSetMapping associationSetMapping, DbDatabaseMapping databaseMapping, DbProviderManifest providerManifest) { DebugCheck.NotNull(associationSetMapping); DebugCheck.NotNull(databaseMapping); DebugCheck.NotNull(providerManifest); // We may apply configuration twice from two different NavigationPropertyConfiguration objects, // but that should be okay since they were validated as consistent above. // We still apply twice because each object may have different pieces of the full configuration. if (AssociationMappingConfiguration != null) { // This may replace a configuration previously set, but that's okay since we validated // consistency when processing the configuration above. associationSetMapping.SetConfiguration(this); AssociationMappingConfiguration .Configure(associationSetMapping, databaseMapping.Database, _navigationProperty); } if (_modificationStoredProceduresConfiguration != null) { if (associationSetMapping.ModificationFunctionMapping == null) { new ModificationFunctionMappingGenerator(providerManifest) .Generate(associationSetMapping, databaseMapping); } _modificationStoredProceduresConfiguration .Configure(associationSetMapping.ModificationFunctionMapping, providerManifest); } }
public void UpdateMapping_updates_msl() { var edmx = XDocument.Parse(EdmxTemplate); var databaseMapping = new DbDatabaseMapping { Database = new EdmModel(DataSpace.SSpace), Model = new EdmModel(DataSpace.SSpace), }; var model = new DbModel(databaseMapping, new DbModelBuilder()); databaseMapping.AddEntityContainerMapping( new EntityContainerMapping( databaseMapping.Model.Containers.Single(), databaseMapping.Database.Containers.Single(), null, false, false)); new EdmxHelper(edmx).UpdateMapping(model); var storageModelsElements = edmx.Descendants(EdmxV3Namespace + "Mappings").Single(); Assert.Equal(1, storageModelsElements.Elements().Count()); Assert.Equal( XName.Get("Mapping", SchemaManager.GetMSLNamespaceName(EntityFrameworkVersion.Version3)), storageModelsElements.Elements().Single().Name); }
public void Serialize(DbDatabaseMapping databaseMapping, DbProviderInfo providerInfo, XmlWriter xmlWriter) { DebugCheck.NotNull(xmlWriter); DebugCheck.NotNull(databaseMapping); DebugCheck.NotNull(providerInfo); Debug.Assert(databaseMapping.Model != null); Debug.Assert(databaseMapping.Database != null); _xmlWriter = xmlWriter; _databaseMapping = databaseMapping; _version = databaseMapping.Model.SchemaVersion; _providerInfo = providerInfo; _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(); }
private void ConfigureEntityTypes(DbDatabaseMapping databaseMapping, DbProviderManifest providerManifest) { var sortedEntityConfigurations = SortEntityConfigurationsByInheritance(databaseMapping); foreach (var entityTypeConfiguration in sortedEntityConfigurations) { var entityTypeMapping = databaseMapping.GetEntityTypeMapping(entityTypeConfiguration.ClrType); entityTypeConfiguration.ConfigureTablesAndConditions( entityTypeMapping, databaseMapping, providerManifest); // run through all unconfigured derived types of the current entityType to make sure the property mappings now point to the right places ConfigureUnconfiguredDerivedTypes( databaseMapping, providerManifest, databaseMapping.Model.GetEntityType(entityTypeConfiguration.ClrType), sortedEntityConfigurations); } new EntityMappingService(databaseMapping).Configure(); foreach (var entityType in databaseMapping.Model.GetEntityTypes().Where(e => e.GetConfiguration() != null)) { var entityTypeConfiguration = (EntityTypeConfiguration)entityType.GetConfiguration(); entityTypeConfiguration.Configure(entityType, databaseMapping, providerManifest); } }
private void ConfigureAssociationMappings( DbDatabaseMapping databaseMapping, EntityType entityType, DbProviderManifest providerManifest) { DebugCheck.NotNull(databaseMapping); DebugCheck.NotNull(entityType); DebugCheck.NotNull(providerManifest); foreach (var configuration in _navigationPropertyConfigurations) { var propertyInfo = configuration.Key; var navigationPropertyConfiguration = configuration.Value; var navigationProperty = entityType.GetNavigationProperty(propertyInfo); if (navigationProperty == null) { throw Error.NavigationPropertyNotFound(propertyInfo.Name, entityType.Name); } var associationSetMapping = databaseMapping.GetAssociationSetMappings() .SingleOrDefault(asm => asm.AssociationSet.ElementType == navigationProperty.Association); if (associationSetMapping != null) { navigationPropertyConfiguration.Configure(associationSetMapping, databaseMapping, providerManifest); } } }
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 Configure(DbDatabaseMapping databaseMapping, DbProviderManifest providerManifest) { DebugCheck.NotNull(databaseMapping); DebugCheck.NotNull(providerManifest); foreach (var structuralTypeConfiguration in databaseMapping.Model.ComplexTypes .Select(ct => ct.GetConfiguration()) .Cast <StructuralTypeConfiguration>() .Where(c => c != null)) { structuralTypeConfiguration.ConfigurePropertyMappings( databaseMapping.GetComplexPropertyMappings(structuralTypeConfiguration.ClrType).ToList(), providerManifest); } ConfigureEntityTypes(databaseMapping, databaseMapping.Model.Container.EntitySets, providerManifest); RemoveRedundantColumnConditions(databaseMapping); RemoveRedundantTables(databaseMapping); ConfigureTables(databaseMapping.Database); ConfigureDefaultSchema(databaseMapping); UniquifyFunctionNames(databaseMapping); ConfigureFunctionParameters(databaseMapping); RemoveDuplicateTphColumns(databaseMapping); }
public void Initialize_should_add_default_entity_container_mapping() { var databaseMapping = new DbDatabaseMapping() .Initialize(new EdmModel().Initialize(), new EdmModel()); Assert.Equal(1, databaseMapping.EntityContainerMappings.Count); }
private static void RemoveRedundantTables(DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(databaseMapping); var tables = (from t in databaseMapping.Database.EntityTypes where databaseMapping.GetEntitySetMappings() .SelectMany(esm => esm.EntityTypeMappings) .SelectMany(etm => etm.MappingFragments) .All(etmf => etmf.Table != t) && databaseMapping.GetAssociationSetMappings().All(asm => asm.Table != t) select t).ToList(); tables.Each( t => { var tableName = t.GetTableName(); if (tableName != null) { throw Error.OrphanedConfiguredTableDetected(tableName); } databaseMapping.Database.RemoveEntityType(t); // Remove any FKs on the removed table var associationTypes = databaseMapping.Database.AssociationTypes .Where(at => at.SourceEnd.GetEntityType() == t || at.TargetEnd.GetEntityType() == t) .ToList(); associationTypes.Each(at => databaseMapping.Database.RemoveAssociationType(at)); }); }
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, 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); }
private void GenerateIndependentAssociationType( AssociationType associationType, DbDatabaseMapping databaseMapping) { AssociationEndMember principalEnd; AssociationEndMember dependentEnd; if (!associationType.TryGuessPrincipalAndDependentEnds(out principalEnd, out dependentEnd)) { if (!associationType.IsPrincipalConfigured()) { throw Error.UnableToDeterminePrincipal((object)EntityTypeExtensions.GetClrType(associationType.SourceEnd.GetEntityType()), (object)EntityTypeExtensions.GetClrType(associationType.TargetEnd.GetEntityType())); } principalEnd = associationType.SourceEnd; dependentEnd = associationType.TargetEnd; } EntityTypeMapping mappingInHierarchy = StructuralTypeMappingGenerator.GetEntityTypeMappingInHierarchy(databaseMapping, dependentEnd.GetEntityType()); EntityType table = mappingInHierarchy.MappingFragments.First <MappingFragment>().Table; AssociationSetMapping associationSetMapping = AssociationTypeMappingGenerator.GenerateAssociationSetMapping(associationType, databaseMapping, principalEnd, dependentEnd, table); this.GenerateIndependentForeignKeyConstraint(databaseMapping, principalEnd.GetEntityType(), dependentEnd.GetEntityType(), table, associationSetMapping, associationSetMapping.SourceEndMapping, associationType.Name, principalEnd, false); foreach (EdmProperty keyProperty in dependentEnd.GetEntityType().KeyProperties()) { associationSetMapping.TargetEndMapping.AddPropertyMapping(new ScalarPropertyMapping(keyProperty, mappingInHierarchy.GetPropertyMapping(keyProperty).ColumnProperty)); } }
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 Configure_should_configure_mapping() { var manyToManyAssociationMappingConfiguration = new ManyToManyAssociationMappingConfiguration(); manyToManyAssociationMappingConfiguration.ToTable("Foo"); var mockPropertyInfo = new MockPropertyInfo(typeof(AType1), "N"); var navigationPropertyConfiguration = new NavigationPropertyConfiguration(mockPropertyInfo) { AssociationMappingConfiguration = manyToManyAssociationMappingConfiguration }; var databaseMapping = new DbDatabaseMapping() .Initialize(new EdmModel(DataSpace.CSpace), new EdmModel(DataSpace.SSpace)); var associationSetMapping = databaseMapping.AddAssociationSetMapping( new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)), new EntitySet()); var dependentTable = databaseMapping.Database.AddTable("T"); associationSetMapping.StoreEntitySet = databaseMapping.Database.GetEntitySet(dependentTable); associationSetMapping.AssociationSet.ElementType.SetConfiguration(navigationPropertyConfiguration); associationSetMapping.SourceEndMapping.AssociationEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)); associationSetMapping.SourceEndMapping.AssociationEnd.SetClrPropertyInfo(mockPropertyInfo); navigationPropertyConfiguration.Configure(associationSetMapping, databaseMapping, ProviderRegistry.Sql2008_ProviderManifest); Assert.Equal("Foo", associationSetMapping.Table.GetTableName().Name); }
private static EntityType FindBaseTableForExtraPropertyMapping( DbDatabaseMapping databaseMapping, EntityType entityType, ColumnMappingBuilder pm) { var baseType = (EntityType)entityType.BaseType; StorageMappingFragment 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); }
internal static PropertyAssertions Assert <TStructuralType>( this DbDatabaseMapping databaseMapping, Expression <Func <TStructuralType, object> > propertyExpression) { var structuralType = databaseMapping.Model.Namespaces.Single().NamespaceItems .OfType <StructuralType>() .Single( i => i.Annotations.Any( a => a.Name == "ClrType" && (Type)a.Value == typeof(TStructuralType))); var property = databaseMapping.Model.Namespaces.Single().NamespaceItems.OfType <StructuralType>() .Where( i => i.Annotations.Any( a => a.Name == "ClrType" && ((Type)a.Value).IsAssignableFrom(typeof(TStructuralType)))) .SelectMany(th => th.Members.OfType <EdmProperty>()).Distinct().Single( i => i.Annotations.Any( a => a.Name == "ClrPropertyInfo" && (PropertyInfo)a.Value == GetPropertyInfo(propertyExpression))); var columns = databaseMapping.EntityContainerMappings.Single().EntitySetMappings .SelectMany(esm => esm.EntityTypeMappings) .Where(etm => !(structuralType is EntityType) || etm.EntityType == structuralType) .SelectMany(etm => etm.MappingFragments) .SelectMany(tmf => tmf.ColumnMappings) .Where(pm => pm.PropertyPath.Contains(property)) .Select(pm => pm.ColumnProperty); return(new PropertyAssertions(property, columns.First())); }
private static IEnumerable <Tuple <ModificationFunctionMemberPath, EdmProperty> > GetIndependentFkColumns( EntityType entityType, DbDatabaseMapping databaseMapping) { foreach (AssociationSetMapping associationSetMapping in databaseMapping.GetAssociationSetMappings()) { AssociationType associationType = associationSetMapping.AssociationSet.ElementType; if (!associationType.IsManyToMany()) { AssociationEndMember _; AssociationEndMember dependentEnd; if (!associationType.TryGuessPrincipalAndDependentEnds(out _, out dependentEnd)) { dependentEnd = associationType.TargetEnd; } EntityType dependentEntityType = dependentEnd.GetEntityType(); if (dependentEntityType == entityType || ModificationFunctionMappingGenerator.GetParents(entityType).Contains <EntityType>(dependentEntityType)) { EndPropertyMapping endPropertyMapping = associationSetMapping.TargetEndMapping.AssociationEnd != dependentEnd ? associationSetMapping.TargetEndMapping : associationSetMapping.SourceEndMapping; foreach (ScalarPropertyMapping propertyMapping in endPropertyMapping.PropertyMappings) { yield return(Tuple.Create <ModificationFunctionMemberPath, EdmProperty>(new ModificationFunctionMemberPath((IEnumerable <EdmMember>) new EdmMember[2] { (EdmMember)propertyMapping.Property, (EdmMember)dependentEnd }, associationSetMapping.AssociationSet), propertyMapping.Column)); } } } } }
internal static string SerializeToString(DbDatabaseMapping databaseMapping) { var edmx = new StringBuilder(); new EdmxSerializer().Serialize(databaseMapping, databaseMapping.Database.GetProviderInfo(), XmlWriter.Create(edmx, new XmlWriterSettings { Indent = true })); return edmx.ToString(); }
private void GenerateDiscriminators(DbDatabaseMapping databaseMapping) { Contract.Requires(databaseMapping != null); foreach (var entitySetMapping in databaseMapping.GetEntitySetMappings()) { if (entitySetMapping.EntityTypeMappings.Count == 1) { continue; } var discriminatorColumn = entitySetMapping .EntityTypeMappings .First() .TypeMappingFragments .Single() .Table .AddColumn(DiscriminatorColumnName); InitializeDefaultDiscriminatorColumn(discriminatorColumn); foreach (var entityTypeMapping in entitySetMapping.EntityTypeMappings) { var entityTypeMappingFragment = entityTypeMapping.TypeMappingFragments.Single(); entityTypeMappingFragment.SetDefaultDiscriminator(discriminatorColumn); entityTypeMappingFragment .AddDiscriminatorCondition(discriminatorColumn, entityTypeMapping.EntityType.Name); } } }
private static DbDatabaseMapping InitializeDatabaseMapping(EdmModel model) { Contract.Requires(model != null); var databaseMapping = new DbDatabaseMapping().Initialize( model, new DbDatabaseMetadata().Initialize(model.Version)); databaseMapping.EntityContainerMappings.Single().EntityContainer = model.Containers.Single(); return databaseMapping; }
/// <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) { Contract.Requires(databaseMapping != null); _providerInfo = databaseMapping.Database.GetProviderInfo(); _metadataWorkspace = databaseMapping.ToMetadataWorkspace(); _assemblies = databaseMapping.Model.GetClrTypes().Select(t => t.Assembly).Distinct().ToList(); Contract.Assert( databaseMapping.Model.Containers.Count() == 1, "Expecting Code First to create only one container."); _defaultContainerName = databaseMapping.Model.Containers.First().Name; }
private void GenerateEntityTypes(EdmModel model, DbDatabaseMapping databaseMapping) { Contract.Requires(model != null); Contract.Requires(databaseMapping != null); foreach (var entityType in model.GetEntityTypes()) { if (!entityType.IsAbstract) { new EntityTypeMappingGenerator(_providerManifest). Generate(entityType, databaseMapping); } } }
protected static DbEntityTypeMapping GetEntityTypeMappingInHierarchy( DbDatabaseMapping databaseMapping, EdmEntityType entityType) { Contract.Requires(databaseMapping != null); Contract.Requires(entityType != null); var entityTypeMapping = databaseMapping.GetEntityTypeMapping(entityType); if (entityTypeMapping == null) { var entitySetMapping = databaseMapping.GetEntitySetMapping(databaseMapping.Model.GetEntitySet(entityType)); if (entitySetMapping != null) { entityTypeMapping = entitySetMapping .EntityTypeMappings .First( etm => entityType.DeclaredProperties.All( dp => etm.TypeMappingFragments.First() .PropertyMappings.Select(pm => pm.PropertyPath.First()).Contains(dp))); } } if (entityTypeMapping == null) { throw Error.UnmappedAbstractType(entityType.GetClrType()); } return entityTypeMapping; }
internal static bool EdmxIsEqualTo(this DbDatabaseMapping databaseMapping, DbDatabaseMapping otherDatabaseMapping) { return SerializeToString(databaseMapping) == SerializeToString(otherDatabaseMapping); }
private void GenerateAssociationTypes(EdmModel model, DbDatabaseMapping databaseMapping) { Contract.Requires(model != null); Contract.Requires(databaseMapping != null); foreach (var associationType in model.GetAssociationTypes()) { new AssociationTypeMappingGenerator(_providerManifest) .Generate(associationType, databaseMapping); } }