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;
        }