public override Table VisitTable(Table table) { Table table2; currentTable = table; try { table2 = base.VisitTable(table); } finally { currentTable = null; } return table2; }
private void CreateView(ViewSchema viewSchema) { Table table; if (Database.Tables.Contains(viewSchema.FullName)) { table = Database.Tables[viewSchema.FullName]; } else { Type type = new Type(ToClassName(viewSchema.Name)); table = new Table(viewSchema.FullName, type); Database.Tables.Add(table); } if (string.IsNullOrEmpty(table.Type.Name)) table.Type.Name = ToClassName(viewSchema.Name); if (string.IsNullOrEmpty(table.Member)) table.Member = table.Type.Name; foreach (ViewColumnSchema columnSchema in viewSchema.Columns) { Column column; if (table.Type.Columns.Contains(columnSchema.Name)) { column = table.Type.Columns[columnSchema.Name]; } else { column = new Column(GetSystemType(columnSchema)); column.Name = columnSchema.Name; table.Type.Columns.Add(column); } PopulateColumn(column, columnSchema, table.Type.Name); } table.Type.Columns.IsProcessed = true; table.Type.Associations.IsProcessed = true; table.IsProcessed = true; }
private Table CreateTable(TableSchema tableSchema) { Type type = new Type(ToClassName(tableSchema.Name)); Table t = new Table(tableSchema.FullName, type); t.Member = t.Type.Name; if (Array.BinarySearch(ExistingContextProperties, t.Type.Name) >= 1) t.Member += "Table"; Database.Tables.Add(t); return t; }
private void CreateColumns(Table table, TableSchema tableSchema) { foreach (ColumnSchema columnSchema in tableSchema.Columns) { // skip unsupported type if (Settings.IsUnsupportedDbType(columnSchema)) { Debug.WriteLine(string.Format("Skipping column '{0}' because it has an unsupported db type '{1}'.", columnSchema.Name, columnSchema.NativeType)); Trace.WriteLine(string.Format("Skipping column '{0}' because it has an unsupported db type '{1}'.", columnSchema.Name, columnSchema.NativeType)); continue; } Column column; bool isNew = !table.Type.TryFindColumn(columnSchema.Name, true, out column); if (isNew) { column = new Column(GetColumnType(columnSchema)); column.Name = columnSchema.Name; table.Type.Columns.Add(column); } PopulateColumn(column, columnSchema, table.Type.Name); if (column.IsPrimaryKey != true) column.IsPrimaryKey = columnSchema.IsPrimaryKeyMember; } table.Type.Columns.IsProcessed = true; }
private void CreateAssociations(Table table, TableSchema tableSchema) { foreach (TableKeySchema tableKey in tableSchema.ForeignKeys) { if (Settings.IsIgnored(tableKey.ForeignKeyTable.FullName) || Settings.IsIgnored(tableKey.PrimaryKeyTable.FullName) || Settings.IsEnum(tableKey.ForeignKeyTable) || Settings.IsEnum(tableKey.PrimaryKeyTable)) continue; CreateAssociation(table, tableKey); } table.Type.Associations.IsProcessed = true; }
private void CreateAssociation(Table foreignTable, TableKeySchema tableKeySchema) { if (Settings.IsIgnored(tableKeySchema.PrimaryKeyTable.FullName)) { Debug.WriteLine("Skipping Association because one of the tables is skipped: " + tableKeySchema.Name); Trace.WriteLine("Skipping Association because one of the tables is skipped: " + tableKeySchema.Name); return; } // skip unsupported type if (tableKeySchema.ForeignKeyMemberColumns.Any(c => Settings.IsUnsupportedDbType(c)) || tableKeySchema.PrimaryKeyMemberColumns.Any(c => Settings.IsUnsupportedDbType(c))) { Debug.WriteLine("Skipping Association because one of the associated columns is an unsupported db type: " + tableKeySchema.Name); Trace.WriteLine("Skipping Association because one of the associated columns is an unsupported db type: " + tableKeySchema.Name); return; } Table primaryTable = GetTable(tableKeySchema.PrimaryKeyTable, false); string primaryClass = primaryTable.Type.Name; string foreignClass = foreignTable.Type.Name; string name = string.Format("{0}_{1}", primaryClass, foreignClass); name = MakeUnique(AssociationNames, name); string foreignMembers = GetKeyMembers(foreignTable, tableKeySchema.ForeignKeyMemberColumns, tableKeySchema.Name); string primaryMembers = GetKeyMembers(primaryTable, tableKeySchema.PrimaryKeyMemberColumns, tableKeySchema.Name); AssociationKey key = AssociationKey.CreateForeignKey(name); bool isNew = !foreignTable.Type.Associations.Contains(key); Association foreignAssociation; if (isNew) foreignAssociation = new Association(name); else foreignAssociation = foreignTable.Type.Associations[key]; foreignAssociation.IsForeignKey = true; foreignAssociation.ThisKey = foreignMembers; foreignAssociation.OtherKey = primaryMembers; foreignAssociation.Type = primaryClass; string prefix = GetMemberPrefix(foreignAssociation, primaryClass, foreignClass); if (isNew) { foreignAssociation.Member = ToPropertyName(foreignTable.Type.Name, prefix + primaryClass); foreignAssociation.Storage = CommonUtility.GetFieldName(foreignAssociation.Member); foreignTable.Type.Associations.Add(foreignAssociation); } else { PropertyNames[foreignTable.Type.Name].Add(foreignAssociation.Member); } // add reverse association key = AssociationKey.CreatePrimaryKey(name); isNew = !primaryTable.Type.Associations.Contains(key); Association primaryAssociation; if (isNew) primaryAssociation = new Association(name); else primaryAssociation = primaryTable.Type.Associations[key]; primaryAssociation.IsForeignKey = false; primaryAssociation.ThisKey = foreignAssociation.OtherKey; primaryAssociation.OtherKey = foreignAssociation.ThisKey; primaryAssociation.Type = foreignClass; bool isOneToOne = IsOneToOne(tableKeySchema, foreignAssociation); if (primaryAssociation.Cardinality == null && isOneToOne) primaryAssociation.Cardinality = Cardinality.One; if (isNew) { string propertyName = prefix + foreignClass; if (!isOneToOne) { if (settings.AssociationNaming == AssociationNamingEnum.ListSuffix) propertyName += "List"; else if (settings.AssociationNaming == AssociationNamingEnum.Plural) propertyName = StringUtil.ToPlural(propertyName); } primaryAssociation.Member = ToPropertyName(primaryTable.Type.Name, propertyName); primaryAssociation.Storage = CommonUtility.GetFieldName(primaryAssociation.Member); primaryTable.Type.Associations.Add(primaryAssociation); } else { PropertyNames[primaryTable.Type.Name].Add(primaryAssociation.Member); } if (IsTableKeySchemaCascadeDelete(tableKeySchema)) { foreignAssociation.DeleteRule = "CASCADE"; } if (settings.IncludeDeleteOnNull || foreignTable.Type.IsManyToMany()) { if (!foreignAssociation.DeleteOnNull.HasValue && IsTableDeleteOnNull(tableKeySchema)) foreignAssociation.DeleteOnNull = true; } else foreignAssociation.DeleteOnNull = null; foreignAssociation.IsProcessed = true; primaryAssociation.IsProcessed = true; }
private static string GetKeyMembers(Table table, MemberColumnSchemaCollection members, string name) { StringBuilder keyMembers = new StringBuilder(); foreach (MemberColumnSchema member in members) { if (!table.Type.Columns.Contains(member.Name)) throw new InvalidOperationException(string.Format( "Could not find column {0} for assoication {1}.", member.Name, name)); Column column = table.Type.Columns[member.Name]; if (keyMembers.Length > 0) keyMembers.Append(','); keyMembers.Append(column.Member); } return keyMembers.ToString(); }
public override Table VisitTable(Table table) { if (table == null) return null; writer.WriteStartElement("Table"); if (table.Name != null) writer.WriteAttributeString("Name", table.Name); if (table.Member != null) writer.WriteAttributeString("Member", table.Member); if (table.AccessModifier.HasValue) writer.WriteAttributeString("AccessModifier", table.AccessModifier.ToString()); if (table.Modifier.HasValue) writer.WriteAttributeString("Modifier", table.Modifier.ToString()); isSubType = false; VisitType(table.Type); currentTableFun = "InsertFunction"; VisitTableFunction(table.InsertFunction); currentTableFun = "UpdateFunction"; VisitTableFunction(table.UpdateFunction); currentTableFun = "DeleteFunction"; VisitTableFunction(table.DeleteFunction); writer.WriteEndElement(); return table; }
public override Table VisitTable(Table table) { if (table.Name == table.Member) table.Member = null; if (table.AccessModifier.HasValue && table.AccessModifier.Value == AccessModifier.Public) table.AccessModifier = null; return base.VisitTable(table); }
public override Table VisitTable(Table table) { if (table == null) return null; if ((table.Name == null) && (table.Member != null)) table.Name = table.Member; if ((table.Member == null) && (table.Name != null)) table.Member = table.Name; if (!table.AccessModifier.HasValue) table.AccessModifier = 0; return base.VisitTable(table); }
public override Table VisitTable(Table table) { if (table == null) return null; return new Table(table.Name, VisitType(table.Type)) { Member = table.Member, AccessModifier = table.AccessModifier, Modifier = table.Modifier, Type = VisitType(table.Type), InsertFunction = VisitTableFunction(table.InsertFunction), UpdateFunction = VisitTableFunction(table.UpdateFunction), DeleteFunction = VisitTableFunction(table.DeleteFunction) }; }
private Table ReadTable(XmlTextReader reader) { ValidateAttributes(reader, new[] {"Name", "Member", "AccessModifier", "Modifier"}); var table = new Table("", new Type("")); string attribute = reader.GetAttribute("Name"); if (attribute == null) throw Error.RequiredAttributeMissingViolation("Name", reader.LineNumber); table.Name = attribute; table.Member = reader.GetAttribute("Member"); string convertAttribute = reader.GetAttribute("AccessModifier"); try { if (convertAttribute == null) table.AccessModifier = null; else table.AccessModifier = (AccessModifier) Enum.Parse(typeof (AccessModifier), convertAttribute, true); convertAttribute = reader.GetAttribute("Modifier"); if (convertAttribute == null) table.Modifier = null; else table.Modifier = (MemberModifier) Enum.Parse(typeof (MemberModifier), convertAttribute, true); } catch (ArgumentException) { throw Error.InvalidEnumAttributeValueViolation(convertAttribute, reader.LineNumber); } if (reader.IsEmptyElement) return table; int typeCount = 0; int insertCount = 0; int updateCount = 0; int deleteCount = 0; while (reader.Read()) { if ((reader.NodeType == XmlNodeType.Whitespace) || !IsInNamespace(reader)) continue; XmlNodeType nodeType = reader.NodeType; if (nodeType != XmlNodeType.Element) { if (nodeType == XmlNodeType.EndElement) { if (typeCount == 0) throw Error.RequiredElementMissingViolation("Type", reader.LineNumber); return table; } continue; } string name = reader.Name; switch (name) { case "Type": isTableType = true; table.Type = ReadType(reader); typeCount++; if (typeCount > 1) throw Error.ElementMoreThanOnceViolation("Type", reader.LineNumber); continue; case "InsertFunction": table.InsertFunction = ReadTableFunction(reader); insertCount++; if (insertCount > 1) throw Error.ElementMoreThanOnceViolation("InsertFunction", reader.LineNumber); continue; case "UpdateFunction": table.UpdateFunction = ReadTableFunction(reader); updateCount++; if (updateCount > 1) throw Error.ElementMoreThanOnceViolation("UpdateFunction", reader.LineNumber); continue; case "DeleteFunction": table.DeleteFunction = ReadTableFunction(reader); deleteCount++; if (deleteCount > 1) throw Error.ElementMoreThanOnceViolation("DeleteFunction", reader.LineNumber); continue; default: throw Error.SchemaUnexpectedElementViolation(reader.Name, "Table", reader.LineNumber); } } return table; }