public Database DuplicateDatabase(Database db) { functionReferences = new Dictionary<TableFunction, int>(); processedTypes = new Dictionary<string, Type>(); db = VisitDatabase(db); return db; }
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; }
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(); }
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(); }
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; }
public static void FillInDefaults(Database db) { new DbmlDefaultValueAssigner().AssignDefaultValues(db); }
public static Database Duplicate(Database db) { Database database = new DbmlDuplicator().DuplicateDatabase(db); return database; }
public static Database CopyWithNulledOutDefaults(Database db) { Database database = new DbmlDuplicator().DuplicateDatabase(db); var nullifier = new DbmlDefaultValueNullifier(); return nullifier.NullifyDefaultValues(database); }
public static Database CopyWithFilledInDefaults(Database db) { Database database = new DbmlDuplicator().DuplicateDatabase(db); var assigner = new DbmlDefaultValueAssigner(); return assigner.AssignDefaultValues(database); }
public static void Verify(Database db, string message) { new VerifyDbml(message).VisitDatabase(db); }
public Database AssignDefaultValues(Database db) { associationPartners = GetAssociationPairs(db); return VisitDatabase(db); }
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; }
public static void ToFile(Database db, string dbmlFile) { ToFile(db, dbmlFile, Encoding.UTF8); }
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; }
public static void NullOutDefaults(Database db) { new DbmlDefaultValueNullifier().NullifyDefaultValues(db); }
public static Dictionary<string, Table> CreateLookup(Database db) { var lookup = new TypeTableLookup(); lookup.VisitDatabase(db); return lookup.typeToTable; }
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); }
public Database NullifyDefaultValues(Database db) { associationPartners = GetAssociationPairs(db); typeToTable = GetTablesByTypeName(db); return VisitDatabase(db); }
public static Dictionary<Association, Association> GetAssociationPairs(Database db) { return PairAssociations.Gather(db); }
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); }
public static Dictionary<string, Table> GetTablesByTypeName(Database db) { return TypeTableLookup.CreateLookup(db); }
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; }
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); }
public void GetTypeIds(Database db, ref Dictionary<Type, string> tyIds, ref Dictionary<Function, string> funIds) { VisitDatabase(db); tyIds = typeIds; funIds = functionIds; }
public static string ToText(Database db) { return ToText(db, Encoding.UTF8); }
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; }
public static string ToText(Database db, Encoding encoding) { var serializer = new DbmlSerializer(); return serializer.DbmlToString(db, encoding); }