public void Apply_should_introduce_cascade_delete_on_constraints() { var databaseMapping = new DbDatabaseMapping() .Initialize(new EdmModel().Initialize(), new DbDatabaseMetadata().Initialize()); var foreignKeyConstraint = new DbForeignKeyConstraintMetadata(); Assert.Equal(DbOperationAction.None, foreignKeyConstraint.DeleteAction); var table = new DbTableMetadata(); table.ForeignKeyConstraints.Add(foreignKeyConstraint); var associationType = new EdmAssociationType().Initialize(); associationType.SourceEnd.EndKind = EdmAssociationEndKind.Many; associationType.SourceEnd.EntityType = new EdmEntityType(); associationType.TargetEnd.EndKind = EdmAssociationEndKind.Many; associationType.TargetEnd.EntityType = new EdmEntityType(); var associationSetMapping = databaseMapping.AddAssociationSetMapping(new EdmAssociationSet { ElementType = associationType }); associationSetMapping.Table = table; ((IDbMappingConvention)new ManyToManyCascadeDeleteConvention()).Apply(databaseMapping); Assert.Equal(DbOperationAction.Cascade, foreignKeyConstraint.DeleteAction); }
internal void WriteForeignKeyConstraintElement( DbTableMetadata dbTableMetadata, DbForeignKeyConstraintMetadata tableFKConstraint) { _xmlWriter.WriteStartElement(SsdlConstants.Element_Association); _xmlWriter.WriteAttributeString(SsdlConstants.Attribute_Name, tableFKConstraint.Name); var multiplicity = DetermineMultiplicity(dbTableMetadata, tableFKConstraint); // If the FK is a Self Ref, then we need to append a suffix to the second role name var roleNames = DbModelSsdlHelper.GetRoleNamePair(tableFKConstraint.PrincipalTable, dbTableMetadata); // End WriteAssociationEndElementHeader(roleNames[0], tableFKConstraint.PrincipalTable, multiplicity.Key); if (tableFKConstraint.DeleteAction != DbOperationAction.None) { WriteOperationActionElement(SsdlConstants.Element_OnDelete, tableFKConstraint.DeleteAction); } WriteEndElement(); WriteAssociationEndElementHeader(roleNames[1], dbTableMetadata, multiplicity.Value); WriteEndElement(); // ReferentialConstraint WriteReferentialConstraintElementHeader(); WriteReferentialConstraintRoleElement( SsdlConstants.Element_PrincipalRole, roleNames[0], tableFKConstraint.PrincipalTable.KeyColumns); WriteReferentialConstraintRoleElement( SsdlConstants.Element_DependentRole, roleNames[1], tableFKConstraint.DependentColumns); WriteEndElement(); WriteEndElement(); }
public void Configure_should_update_table_name_when_base_type_is_null() { var entityMappingConfiguration = new EntityMappingConfiguration { TableName = new DatabaseName("Foo") }; var entityTypeMapping = new DbEntityTypeMapping { EntityType = new EdmEntityType() }; var table = new DbTableMetadata { Name = "foo" }; entityTypeMapping.TypeMappingFragments.Add( new DbEntityTypeMappingFragment { Table = table }); var databaseMapping = new DbDatabaseMapping().Initialize(new EdmModel().Initialize(), new DbDatabaseMetadata().Initialize()); databaseMapping.Database.AddTable("foo"); entityMappingConfiguration.Configure( databaseMapping, ProviderRegistry.Sql2008_ProviderManifest, entityTypeMapping.EntityType, ref entityTypeMapping, false, 0, 1); Assert.Equal("Foo", table.GetTableName().Name); }
internal void WriteAssociationSetEndElement(DbTableMetadata end, string roleName) { _xmlWriter.WriteStartElement(SsdlConstants.Element_End); _xmlWriter.WriteAttributeString(SsdlConstants.Attribute_Role, roleName); _xmlWriter.WriteAttributeString(SsdlConstants.Attribute_EntitySet, end.Name); _xmlWriter.WriteEndElement(); }
public static DbTableColumnMetadata IncludeColumn( DbTableMetadata table, DbTableColumnMetadata templateColumn, bool useExisting) { Contract.Requires(table != null); Contract.Requires(templateColumn != null); var existingColumn = table.Columns.SingleOrDefault(c => string.Equals(c.Name, templateColumn.Name, StringComparison.Ordinal)); if (existingColumn == null) { templateColumn = templateColumn.Clone(); } else if (!useExisting && !existingColumn.IsPrimaryKeyColumn) { templateColumn = templateColumn.Clone(); } else { templateColumn = existingColumn; } return AddColumn(table, templateColumn); }
public TableMapping(DbTableMetadata table) { //Contract.Requires(table != null); _table = table; _entityTypes = new SortedEntityTypeIndex(); _columns = new List<ColumnMapping>(); }
/// <summary> /// Return role name pair /// </summary> /// <param name="firstTable"> </param> /// <param name="secondTable"> </param> /// <returns> </returns> internal static string[] GetRoleNamePair(DbTableMetadata firstTable, DbTableMetadata secondTable) { return new[] { firstTable.Name, firstTable != secondTable ? secondTable.Name : secondTable.Name + selfRefRoleNameSuffix }; }
protected override void VisitKeyColumns(DbTableMetadata item, IEnumerable<DbTableColumnMetadata> keyColumns) { _schemaWriter.WriteDelaredKeyPropertiesElementHeader(); foreach (var keyColumn in keyColumns) { _schemaWriter.WriteDelaredKeyPropertyRefElement(keyColumn); } _schemaWriter.WriteEndElement(); }
public void Apply_should_ignore_current_table() { var database = new DbDatabaseMetadata().Initialize(); var table = new DbTableMetadata { DatabaseIdentifier = "Customers" }; database.Schemas.Single().Tables.Add(table); ((IDbConvention<DbTableMetadata>)new PluralizingTableNameConvention()).Apply(table, database); Assert.Equal("Customers", table.DatabaseIdentifier); }
public void AddColumn_should_set_properties_and_add_to_columns() { var table = new DbTableMetadata(); var tableColumn = table.AddColumn("Foo"); Assert.NotNull(tableColumn); Assert.Equal("Foo", tableColumn.Name); Assert.True(table.Columns.Contains(tableColumn)); }
public void Apply_should_order_by_annotation_if_given() { var table = new DbTableMetadata(); table.AddColumn("C").SetOrder(2); table.AddColumn("Id").SetOrder(1); ((IDbConvention<DbTableMetadata>)new ColumnOrderingConvention()).Apply(table, new DbDatabaseMetadata()); Assert.Equal(2, table.Columns.Count); Assert.Equal("Id", table.Columns.First().Name); }
public void Apply_should_sort_unannotated_in_given_order() { var table = new DbTableMetadata(); table.AddColumn("C"); table.AddColumn("Id"); ((IDbConvention<DbTableMetadata>)new ColumnOrderingConvention()).Apply(table, new DbDatabaseMetadata()); Assert.Equal(2, table.Columns.Count); Assert.Equal("C", table.Columns.First().Name); }
public void Apply_should_uniquify_names() { var database = new DbDatabaseMetadata().Initialize(); var tableA = new DbTableMetadata { DatabaseIdentifier = "Customers" }; var tableB = new DbTableMetadata { DatabaseIdentifier = "Customer" }; database.Schemas.Single().Tables.Add(tableA); database.Schemas.Single().Tables.Add(tableB); ((IDbConvention<DbTableMetadata>)new PluralizingTableNameConvention()).Apply(tableB, database); Assert.Equal("Customers1", tableB.DatabaseIdentifier); }
public void Apply_should_ignored_configured_tables() { var database = new DbDatabaseMetadata().Initialize(); var table = new DbTableMetadata { DatabaseIdentifier = "Customer" }; table.SetTableName(new DatabaseName("Foo")); database.Schemas.Single().Tables.Add(table); ((IDbConvention<DbTableMetadata>)new PluralizingTableNameConvention()).Apply(table, database); Assert.Equal("Customer", table.DatabaseIdentifier); Assert.Equal("Foo", table.GetTableName().Name); }
public static DbTableColumnMetadata RemoveColumn(DbTableMetadata table, DbTableColumnMetadata column) { Contract.Requires(table != null); Contract.Requires(column != null); if (!column.IsPrimaryKeyColumn) { table.Columns.Remove(column); } return column; }
internal void WriteEntitySetElementHeader(DbSchemaMetadata containingSchema, DbTableMetadata entitySet) { _xmlWriter.WriteStartElement(SsdlConstants.Element_EntitySet); _xmlWriter.WriteAttributeString(SsdlConstants.Attribute_Name, entitySet.Name); _xmlWriter.WriteAttributeString( SsdlConstants.Attribute_EntityType, GetQualifiedTypeName(SsdlConstants.Value_Self, entitySet.Name)); if (containingSchema.DatabaseIdentifier != null) { _xmlWriter.WriteAttributeString(SsdlConstants.Attribute_Schema, containingSchema.DatabaseIdentifier); } if (entitySet.DatabaseIdentifier != null) { _xmlWriter.WriteAttributeString(SsdlConstants.Attribute_Table, entitySet.DatabaseIdentifier); } }
protected override void ValidateColumns(DbTableMetadata table) { var hasDuplicates = table.Columns .Select(c => c.GetOrder()) .Where(o => o != null) .GroupBy(o => o) .Where(g => g.Count() > 1) .Any(); if (hasDuplicates) { throw Error.DuplicateConfiguredColumnOrder(table.DatabaseIdentifier); } }
protected virtual void VisitDbTableMetadata(DbTableMetadata item) { VisitDbSchemaMetadataItem(item); if (item != null) { if (item.HasColumns) { VisitKeyColumns(item, item.KeyColumns); VisitColumns(item, item.Columns); } if (item.HasForeignKeyConstraints) { VisitForeignKeyConstraints(item, item.ForeignKeyConstraints); } } }
public static DbTableMetadata AddTable(this DbDatabaseMetadata database, string name) { //Contract.Requires(database != null); //Contract.Requires(!string.IsNullOrWhiteSpace(name)); Contract.Assert(database.Schemas.Count == 1); var schema = database.Schemas.Single(); var uniqueIdentifier = schema.Tables.UniquifyName(name); var table = new DbTableMetadata { Name = uniqueIdentifier, DatabaseIdentifier = uniqueIdentifier }; schema.Tables.Add(table); return table; }
private static DbTableColumnMetadata AddColumn(DbTableMetadata table, DbTableColumnMetadata column) { Contract.Requires(table != null); Contract.Requires(column != null); if (!table.Columns.Contains(column)) { var configuration = column.GetConfiguration() as PrimitivePropertyConfiguration; if ((configuration == null) || string.IsNullOrWhiteSpace(configuration.ColumnName)) { var preferredName = column.GetPreferredName() ?? column.Name; column.SetUnpreferredUniqueName(column.Name); column.Name = table.Columns.UniquifyName(preferredName); } table.Columns.Add(column); } return column; }
public static DbTableColumnMetadata IncludeColumn(DbTableMetadata table, string columnName, bool useExisting) { Contract.Requires(table != null); Contract.Requires(columnName != null); var existingColumn = table.Columns.SingleOrDefault(c => string.Equals(c.Name, columnName, StringComparison.Ordinal)); DbTableColumnMetadata column = null; if (existingColumn == null) { column = table.AddColumn(columnName); } else if (!useExisting && !existingColumn.IsPrimaryKeyColumn) { column = table.AddColumn(columnName); } else { column = existingColumn; } return AddColumn(table, column); }
protected override void VisitForeignKeyConstraints( DbTableMetadata item, IEnumerable<DbForeignKeyConstraintMetadata> foreignKeyConstraints) { _foreignKeyConstraintList.Add(item, foreignKeyConstraints); }
protected override void VisitDbTableMetadata(DbTableMetadata item) { _schemaWriter.WriteEntityTypeElementHeader(item); base.VisitDbTableMetadata(item); _schemaWriter.WriteEndElement(); }
protected override void VisitDbTableMetadata(DbTableMetadata item) { _containerSchemaWriter.WriteEntitySetElementHeader(currentSchema, item); VisitForeignKeyConstraints(item, item.ForeignKeyConstraints); _schemaWriter.WriteEndElement(); }
public static void AddTypeConstraint( EdmEntityType entityType, DbTableMetadata principalTable, DbTableMetadata dependentTable, bool isSplitting) { Contract.Requires(principalTable != null); Contract.Requires(dependentTable != null); Contract.Requires(entityType != null); var foreignKeyConstraintMetadata = new DbForeignKeyConstraintMetadata { Name = String.Format( CultureInfo.InvariantCulture, "{0}_TypeConstraint_From_{1}_To_{2}", entityType.Name, principalTable.Name, dependentTable.Name), PrincipalTable = principalTable }; if (isSplitting) { foreignKeyConstraintMetadata.SetIsSplitConstraint(); } else { foreignKeyConstraintMetadata.SetIsTypeConstraint(); } dependentTable.Columns .Where(c => c.IsPrimaryKeyColumn) .Each(c => foreignKeyConstraintMetadata.DependentColumns.Add(c)); dependentTable.ForeignKeyConstraints.Add(foreignKeyConstraintMetadata); //If "DbStoreGeneratedPattern.Identity" was copied from the parent table, it should be removed dependentTable.Columns.Where(c => c.IsPrimaryKeyColumn).Each(c => c.RemoveStoreGeneratedIdentityPattern()); }
public static bool UsesOtherTables(this DbEntityTypeMapping entityTypeMapping, DbTableMetadata table) { return entityTypeMapping.TypeMappingFragments.Any(f => f.Table != table); }
protected virtual void VisitForeignKeyConstraints( DbTableMetadata item, IEnumerable<DbForeignKeyConstraintMetadata> foreignKeyConstraints) { VisitCollection(foreignKeyConstraints, VisitDbForeignKeyConstraintMetadata); }
protected virtual void VisitColumns(DbTableMetadata item, IEnumerable<DbTableColumnMetadata> columns) { VisitCollection(columns, VisitDbTableColumnMetadata); }
private void MarkColumnsAsNonNullableIfNoTableSharing( EdmEntitySet entitySet, DbTableMetadata table, EdmEntityType dependentEndEntityType, IEnumerable<DbTableColumnMetadata> columns) { // determine if base entities share this table, if not, the foreign keys can be non-nullable var mappedBaseTypes = _tableMappings[table].EntityTypes.GetEntityTypes(entitySet).Where( et => et != dependentEndEntityType && (et.IsAncestorOf(dependentEndEntityType) || !dependentEndEntityType.IsAncestorOf(et))); if (mappedBaseTypes.Count() == 0 || mappedBaseTypes.All(et => et.IsAbstract)) { columns.Each(c => c.IsNullable = false); } }
private TableMapping FindOrCreateTableMapping(DbTableMetadata table) { TableMapping tableMapping; if (!_tableMappings.TryGetValue(table, out tableMapping)) { tableMapping = new TableMapping(table); _tableMappings.Add(table, tableMapping); } return tableMapping; }