Example #1
0
 public Database DuplicateDatabase(Database db)
 {
     functionReferences = new Dictionary<TableFunction, int>();
     processedTypes = new Dictionary<string, Type>();
     db = VisitDatabase(db);
     return db;
 }
Example #2
0
 public static Dictionary<Association, Association> Gather(Database db)
 {
     var associations = new PairAssociations();
     associations.VisitDatabase(db);
     var dictionary = new Dictionary<Association, Association>();
     foreach (string str in associations.associations.Keys)
     {
         Association[] associationArray = associations.associations[str].ToArray();
         int length = associationArray.Length;
         int num2 = 0;
         while (num2 != length)
         {
             int index = -1;
             int num4 = -1;
             MatchLevel noMatch = MatchLevel.NoMatch;
             for (int i = 0; i < (length - 1); i++)
             {
                 for (int j = i + 1; j < length; j++)
                 {
                     Association thisSide = associationArray[i];
                     Association otherSide = associationArray[j];
                     if ((thisSide != null) && (otherSide != null))
                     {
                         MatchLevel level2 = Compare(associations.associationTypes[thisSide], thisSide,
                                                     associations.associationTypes[otherSide], otherSide);
                         if (level2 > noMatch)
                         {
                             index = i;
                             num4 = j;
                             noMatch = level2;
                         }
                     }
                 }
             }
             if ((noMatch & MatchLevel.MinBar) == MatchLevel.MinBar)
             {
                 Association association3 = associationArray[index];
                 Association association4 = associationArray[num4];
                 dictionary[association3] = association4;
                 dictionary[association4] = association3;
                 associationArray[index] = null;
                 associationArray[num4] = null;
                 num2 += 2;
             }
             else
             {
                 foreach (Association association5 in associationArray)
                 {
                     if (association5 != null)
                     {
                         dictionary[association5] = null;
                         num2++;
                     }
                 }
             }
         }
     }
     return dictionary;
 }
Example #3
0
 public void DbmlToFile(Database db, string filename, Encoding encoding)
 {
     var settings = new XmlWriterSettings {Indent = true, Encoding = encoding};
     writer = XmlWriter.Create(filename, settings);
     VisitDatabase(db);
     writer.Flush();
     writer.Close();
 }
Example #4
0
 private static int FindReferencedFunctionIndex(Database db, Function function)
 {
     int num = 0;
     foreach (Function f in db.Functions)
     {
         if (function == f)
             return num;
         
         num++;
     }
     throw new InvalidOperationException();
 }
Example #5
0
 public string DbmlToString(Database db, Encoding encoding)
 {
     string str;
     using (var stream = new MemoryStream())
     using (var streamWriter = new StreamWriter(stream, encoding))
     {
         var settings = new XmlWriterSettings {Indent = true, Encoding = encoding};
         writer = XmlWriter.Create(streamWriter, settings);
         VisitDatabase(db);
         writer.Flush();
         writer.Close();
         using (var reader = new StreamReader(stream, encoding))
         {
             stream.Position = 0L;
             str = reader.ReadToEnd();
         }
     }
     return str;
 }
Example #6
0
 public static void FillInDefaults(Database db)
 {
     new DbmlDefaultValueAssigner().AssignDefaultValues(db);
 }
Example #7
0
 public static Database Duplicate(Database db)
 {
     Database database = new DbmlDuplicator().DuplicateDatabase(db);
     return database;
 }
Example #8
0
 public static Database CopyWithNulledOutDefaults(Database db)
 {
     Database database = new DbmlDuplicator().DuplicateDatabase(db);
     var nullifier = new DbmlDefaultValueNullifier();
     return nullifier.NullifyDefaultValues(database);
 }
Example #9
0
 public static Database CopyWithFilledInDefaults(Database db)
 {
     Database database = new DbmlDuplicator().DuplicateDatabase(db);
     var assigner = new DbmlDefaultValueAssigner();
     return assigner.AssignDefaultValues(database);
 }
Example #10
0
 public static void Verify(Database db, string message)
 {
     new VerifyDbml(message).VisitDatabase(db);
 }
 public Database AssignDefaultValues(Database db)
 {
     associationPartners = GetAssociationPairs(db);
     return VisitDatabase(db);
 }
Example #12
0
            public override Database VisitDatabase(Database db)
            {
                if (db == null)
                    return null;

                creater.GetTypeIds(db, ref typeIds, ref functionIds);
                writer.WriteStartElement("Database", "http://schemas.microsoft.com/linqtosql/dbml/2007");

                if (db.Name != null)
                    writer.WriteAttributeString("Name", db.Name);

                if (db.EntityNamespace != null)
                    writer.WriteAttributeString("EntityNamespace", db.EntityNamespace);

                if (db.ContextNamespace != null)
                    writer.WriteAttributeString("ContextNamespace", db.ContextNamespace);

                if (db.Class != null)
                    writer.WriteAttributeString("Class", db.Class);

                if (db.AccessModifier.HasValue)
                    writer.WriteAttributeString("AccessModifier", db.AccessModifier.ToString());

                if (db.Modifier.HasValue)
                    writer.WriteAttributeString("Modifier", db.Modifier.ToString());

                if (db.BaseType != null)
                    writer.WriteAttributeString("BaseType", db.BaseType);

                if (db.Provider != null)
                    writer.WriteAttributeString("Provider", db.Provider);

                if (db.ExternalMapping.HasValue)
                    writer.WriteAttributeString("ExternalMapping", ToXmlBooleanString(db.ExternalMapping));

                if (db.Serialization.HasValue)
                    writer.WriteAttributeString("Serialization", db.Serialization.ToString());

                if (db.EntityBase != null)
                    writer.WriteAttributeString("EntityBase", db.EntityBase);

                base.VisitDatabase(db);
                writer.WriteEndElement();
                return db;
            }
Example #13
0
 public static void ToFile(Database db, string dbmlFile)
 {
     ToFile(db, dbmlFile, Encoding.UTF8);
 }
Example #14
0
            public override Database VisitDatabase(Database db)
            {
                if (db == null)
                    return null;

                var database = new Database();
                originalDb = db;
                database.Name = db.Name;
                database.EntityNamespace = db.EntityNamespace;
                database.ContextNamespace = db.ContextNamespace;
                database.Class = db.Class;
                database.AccessModifier = db.AccessModifier;
                database.Modifier = db.Modifier;
                database.BaseType = db.BaseType;
                database.Provider = db.Provider;
                database.ExternalMapping = db.ExternalMapping;
                database.Serialization = db.Serialization;
                database.EntityBase = db.EntityBase;
                database.Connection = VisitConnection(db.Connection);

                foreach (Table table in db.Tables)
                    database.Tables.Add(VisitTable(table));

                foreach (Function function in db.Functions)
                    database.Functions.Add(VisitFunction(function));

                foreach (TableFunction function in functionReferences.Keys)
                    function.MappedFunction = database.Functions[functionReferences[function]];

                return database;
            }
Example #15
0
 public static void NullOutDefaults(Database db)
 {
     new DbmlDefaultValueNullifier().NullifyDefaultValues(db);
 }
Example #16
0
 public static Dictionary<string, Table> CreateLookup(Database db)
 {
     var lookup = new TypeTableLookup();
     lookup.VisitDatabase(db);
     return lookup.typeToTable;
 }
Example #17
0
            public override Database VisitDatabase(Database db)
            {
                if (db == null)
                    return null;
                
                if (db.Class == db.Name)
                    db.Class = null;
                
                if (db.BaseType == "System.Data.Linq.DataContext")
                    db.BaseType = null;

                if (db.AccessModifier.HasValue && db.AccessModifier.Value == AccessModifier.Public)
                    db.AccessModifier = null;

                if (db.ExternalMapping == false)
                    db.ExternalMapping = null;

                if (db.Serialization.HasValue && db.Serialization.Value == SerializationMode.None)
                    db.Serialization = null;
                
                return base.VisitDatabase(db);
            }
Example #18
0
 public Database NullifyDefaultValues(Database db)
 {
     associationPartners = GetAssociationPairs(db);
     typeToTable = GetTablesByTypeName(db);
     return VisitDatabase(db);
 }
Example #19
0
 public static Dictionary<Association, Association> GetAssociationPairs(Database db)
 {
     return PairAssociations.Gather(db);
 }
Example #20
0
        private void RemoveExtraMembers(Database database)
        {
            List<Table> removedTables = new List<Table>();
            List<Column> removedColumns = new List<Column>();
            List<Association> removedAssociations = new List<Association>();
            List<Function> removedFunctions = new List<Function>();
            List<Type> removedFunctionTypes = new List<Type>();
            List<Column> removedFunctionColumns = new List<Column>();

            foreach (Table table in database.Tables)
            {
                if (!table.IsProcessed)
                {
                    removedTables.Add(table);
                    continue;
                }

                removedColumns.Clear();
                foreach (Column c in table.Type.Columns)
                    if (!c.IsProcessed)
                        removedColumns.Add(c);

                removedAssociations.Clear();
                foreach (Association a in table.Type.Associations)
                    if (!a.IsProcessed && !Settings.UserDefinedAssociations.Contains(a.Name))
                        removedAssociations.Add(a);

                foreach (Column c in removedColumns)
                    table.Type.Columns.Remove(c);

                foreach (Association a in removedAssociations)
                    table.Type.Associations.Remove(a);
            }

            foreach (Table t in removedTables)
                database.Tables.Remove(t);

            foreach (Function f in database.Functions)
            {
                if (!f.IsProcessed)
                {
                    removedFunctions.Add(f);
                    continue;
                }

                foreach (var t in f.Types)
                {
                    if (!t.IsProcessed)
                    {
                        removedFunctionTypes.Add(t);
                        continue;
                    }

                    foreach (var c in t.Columns)
                        if (!c.IsProcessed)
                            removedFunctionColumns.Add(c);

                    foreach (var c in removedFunctionColumns)
                        t.Columns.Remove(c);
                }

                foreach (var t in removedFunctionTypes)
                    f.Types.Remove(t);
            }

            foreach (Function f in removedFunctions)
                database.Functions.Remove(f);
        }
Example #21
0
 public static Dictionary<string, Table> GetTablesByTypeName(Database db)
 {
     return TypeTableLookup.CreateLookup(db);
 }
Example #22
0
            private Database ReadDatabase(XmlTextReader reader)
            {
                ValidateAttributes(reader,
                                   new[]
                                       {
                                           "Name", "Class", "EntityNamespace", "ContextNamespace", "BaseType",
                                           "Provider",
                                           "AccessModifier", "Modifier", "ExternalMapping", "EntityBase",
                                           "Serialization"
                                       });

                var database = new Database
                                   {
                                       Name = reader.GetAttribute("Name"),
                                       Class = reader.GetAttribute("Class")
                                   };

                if ((database.Name == null) && (database.Class == null))
                    throw Error.SchemaOrRequirementViolation("Database", "Name", "Class", reader.LineNumber);

                database.EntityNamespace = reader.GetAttribute("EntityNamespace");
                database.ContextNamespace = reader.GetAttribute("ContextNamespace");
                database.BaseType = reader.GetAttribute("BaseType");
                database.Provider = reader.GetAttribute("Provider");
                database.EntityBase = reader.GetAttribute("EntityBase");

                string attribute = reader.GetAttribute("AccessModifier");
                try
                {
                    if (attribute == null)
                        database.AccessModifier = null;
                    else
                        database.AccessModifier = (AccessModifier) Enum.Parse(typeof (AccessModifier), attribute, true);

                    attribute = reader.GetAttribute("Modifier");
                    if (attribute == null)
                        database.Modifier = null;
                    else
                        database.Modifier = (ClassModifier) Enum.Parse(typeof (ClassModifier), attribute, true);

                    attribute = reader.GetAttribute("ExternalMapping");
                    database.ExternalMapping = (attribute == null) ? null : new bool?(bool.Parse(attribute));

                    attribute = reader.GetAttribute("Serialization");
                    if (attribute == null)
                        database.Serialization = null;
                    else
                        database.Serialization =
                            (SerializationMode) Enum.Parse(typeof (SerializationMode), attribute, true);
                }
                catch (FormatException)
                {
                    throw Error.InvalidBooleanAttributeValueViolation(attribute, reader.LineNumber);
                }
                catch (ArgumentException)
                {
                    throw Error.InvalidEnumAttributeValueViolation(attribute, reader.LineNumber);
                }

                if (reader.IsEmptyElement)
                    return database;

                int elementCount = 0;
                while (reader.Read())
                {
                    if ((reader.NodeType == XmlNodeType.Whitespace) || !IsInNamespace(reader))
                        continue;

                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        string name = reader.Name;

                        switch (name)
                        {
                            case "Table":
                                database.Tables.Add(ReadTable(reader));
                                break;
                            case "Function":
                                database.Functions.Add(ReadFunction(reader));
                                break;
                            case "Connection":
                                database.Connection = ReadConnection(reader);
                                elementCount++;
                                if (elementCount > 1)
                                    throw Error.ElementMoreThanOnceViolation("Connection", reader.LineNumber);
                                break;
                            default:
                                throw Error.SchemaUnexpectedElementViolation(reader.Name, "Database", reader.LineNumber);
                        }
                    }
                    else if (reader.NodeType == XmlNodeType.EndElement)
                    {
                        return database;
                    }

                    continue;
                }
                return database;
            }
Example #23
0
 public static void ToFile(Database db, string dbmlFile, Encoding encoding)
 {
     new DbmlSerializer().DbmlToFile(db, dbmlFile, encoding);
 }
            public override Database VisitDatabase(Database db)
            {
                if (db == null)
                    return null;

                if ((db.Class == null) && (db.Name == null))
                    db.Class = db.Connection != null ? db.Connection.ConnectionString : "Context";
                else if (db.Class == null)
                    db.Class = db.Name;

                if (!db.AccessModifier.HasValue)
                    db.AccessModifier = 0;

                if (db.BaseType == null)
                    db.BaseType = "System.Data.Linq.DataContext";

                if (!db.ExternalMapping.HasValue)
                    db.ExternalMapping = false;

                if (!db.Serialization.HasValue)
                    db.Serialization = 0;

                typeToTable = GetTablesByTypeName(db);
                return base.VisitDatabase(db);
            }
Example #25
0
 public void GetTypeIds(Database db, ref Dictionary<Type, string> tyIds,
     ref Dictionary<Function, string> funIds)
 {
     VisitDatabase(db);
     tyIds = typeIds;
     funIds = functionIds;
 }
Example #26
0
 public static string ToText(Database db)
 {
     return ToText(db, Encoding.UTF8);
 }
Example #27
0
        public Database Create(DatabaseSchema databaseSchema)
        {
            if (File.Exists(settings.MappingFile))
                _database = Dbml.CopyWithFilledInDefaults(Dbml.FromFile(settings.MappingFile));
            else
                _database = new Database();

            Database.Name = databaseSchema.Name;
            CreateContext(databaseSchema);

            _enumDatabase = new DbmlEnum.Database { Name = databaseSchema.Name };
            _existingEnumDatabase = DbmlEnum.Database.DeserializeFromFile(EnumXmlFileName) ?? new DbmlEnum.Database();

            foreach (TableSchema t in databaseSchema.Tables)
            {
                if (Settings.IsIgnored(t.FullName))
                {
                    Debug.WriteLine("Skipping Table: " + t.FullName);
                }
                else if (Settings.IsEnum(t))
                {
                    Debug.WriteLine("Getting Enum Table: " + t.FullName);
                    GetEnum(t);
                }
                else
                {
                    Debug.WriteLine("Getting Table Schema: " + t.FullName);
                    GetTable(t);
                }
                OnSchemaItemProcessed(t.FullName);
            }

            if (Settings.IncludeViews)
            {
                foreach (ViewSchema v in databaseSchema.Views)
                {
                    if (Settings.IsIgnored(v.FullName))
                    {
                        Debug.WriteLine("Skipping View: " + v.FullName);
                    }
                    else
                    {
                        Debug.WriteLine("Getting View Schema: " + v.FullName);
                        CreateView(v);
                    }
                    OnSchemaItemProcessed(v.FullName);
                }
            }

            if (Settings.IncludeFunctions)
            {
                foreach (CommandSchema c in databaseSchema.Commands)
                {
                    if (Settings.IsIgnored(c.FullName))
                    {
                        Debug.WriteLine("Skipping Function: " + c.FullName);
                    }
                    else
                    {
                        Debug.WriteLine("Getting Function Schema: " + c.FullName);
                        CreateFunction(c);
                    }
                    OnSchemaItemProcessed(c.FullName);
                }
            }

            //sync tables
            RemoveExtraMembers(_database);

            _database.Tables.Sort();
            Dbml.ToFile(Dbml.CopyWithNulledOutDefaults(_database),
                settings.MappingFile);

            if (_enumDatabase.Enums.Count > 0 || File.Exists(EnumXmlFileName))
                _enumDatabase.SerializeToFile(EnumXmlFileName);

            return _database;
        }
Example #28
0
 public static string ToText(Database db, Encoding encoding)
 {
     var serializer = new DbmlSerializer();
     return serializer.DbmlToString(db, encoding);
 }