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 void RemoveRedundantTables(DbDatabaseMapping databaseMapping)
        {
            Contract.Assert(databaseMapping != null);

            var tables
                = (from t in databaseMapping.Database.Schemas.SelectMany(s => s.Tables)
                   where !databaseMapping.GetEntitySetMappings()
                              .SelectMany(esm => esm.EntityTypeMappings)
                              .SelectMany(etm => etm.TypeMappingFragments)
                              .Any(etmf => etmf.Table == t)
                         && !databaseMapping.GetAssociationSetMappings()
                                 .Any(asm => asm.Table == t)
                   select t).ToList();

            tables.Each(
                t =>
                    {
                        var tableName = t.GetTableName();

                        if (tableName != null)
                        {
                            throw Error.OrphanedConfiguredTableDetected(tableName);
                        }

                        databaseMapping.Database.RemoveTable(t);
                    });
        }
        private static void RemoveRedundantColumnConditions(DbDatabaseMapping databaseMapping)
        {
            //Contract.Requires(databaseMapping != null);

            // Remove all the default discriminators where there is only one table using it
            (from esm in databaseMapping.GetEntitySetMappings()
             select new
                 {
                     Set = esm,
                     Fragments =
                 (from etm in esm.EntityTypeMappings
                  from etmf in etm.TypeMappingFragments
                  group etmf by etmf.Table
                  into g
                  where g.Count(x => x.GetDefaultDiscriminator() != null) == 1
                  select g.Single(x => x.GetDefaultDiscriminator() != null))
                 })
                .Each(x => x.Fragments.Each(f => f.RemoveDefaultDiscriminator(x.Set)));
        }