/// <summary> /// Generate the needed alter table xxx set storage when needed. /// </summary> private static void AddAlterStorage(StreamWriter writer, PgTable oldTable, PgTable newTable, SearchPathHelper searchPathHelper) { foreach (PgColumn newColumn in newTable.Columns) { PgColumn oldColumn = oldTable.GetColumn(newColumn.Name); var oldStorage = (oldColumn == null || oldColumn.Storage == null || oldColumn.Storage == string.Empty) ? null : oldColumn.Storage; var newStorage = (newColumn.Storage == null || newColumn.Storage == string.Empty) ? null : newColumn.Storage; if (newStorage == null && oldStorage != null) { searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.WriteLine($"WarningUnableToDetermineStorageType {newTable.Name + '.' + newColumn.Name}"); continue; } if (newStorage == null || newStorage.Equals(oldStorage, StringComparison.CurrentCultureIgnoreCase)) { continue; } searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.Write("ALTER TABLE ONLY "); writer.Write(PgDiffStringExtension.QuoteName(newTable.Name)); writer.Write(" ALTER COLUMN "); writer.Write(PgDiffStringExtension.QuoteName(newColumn.Name)); writer.Write(" SET STORAGE "); writer.Write(newStorage); writer.Write(';'); } }
private static Collection <PgTable> GetTables(DataTable table) { Collection <PgTable> pgTables = new Collection <PgTable>(); if (table.Rows.Count > 0) { foreach (DataRow row in table.Rows) { PgTable pgTable = new PgTable { RowNumber = Conversion.TryCastLong(row["row_number"]), Name = Conversion.TryCastString(row["object_name"]), SchemaName = Conversion.TryCastString(row["object_schema"]), Tablespace = Conversion.TryCastString(row["tablespace"]), Owner = Conversion.TryCastString(row["owner"]), Description = Conversion.TryCastString(row["description"]) }; pgTables.Add(pgTable); } } return(pgTables); }
/// <summary> /// Checks whether OIDS are dropped from the new table. There is no way to add OIDS to existing table so we do not /// create SQL statement for addition of OIDS but we issue warning. /// </summary> private static void CheckWithOIDS(StreamWriter writer, PgTable oldTable, PgTable newTable, SearchPathHelper searchPathHelper) { if ((oldTable.With == null && newTable.With == null) || (oldTable.With != null && oldTable.With.Equals(newTable.With))) { return; } searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.WriteLine("ALTER TABLE " + PgDiffStringExtension.QuoteName(newTable.Name)); if (newTable.With == null || "OIDS=false".Equals(newTable.With, StringComparison.CurrentCultureIgnoreCase)) { writer.WriteLine("\tSET WITHOUT OIDS;"); } else if ("OIDS".Equals(newTable.With, StringComparison.CurrentCultureIgnoreCase) || "OIDS=true".Equals(newTable.With, StringComparison.CurrentCultureIgnoreCase)) { writer.WriteLine("\tSET WITH OIDS;"); } else { writer.WriteLine("\tSET " + newTable.With + ";"); } }
private static void ParseColumn(Parser parser, PgTable table) { var column = new PgColumn(ParserUtils.GetObjectName(parser.ParseIdentifier())); table.AddColumn(column); column.ParseDefinition(parser.GetExpression()); }
/// <summary> /// Parses ADD FOREIGN KEY action. /// </summary> private static void ParseAddForeignKey(Parser parser, PgTable table) { IList <string> columnNames = new List <string>(1); parser.Expect("("); while (!parser.ExpectOptional(")")) { columnNames.Add(ParserUtils.GetObjectName(parser.ParseIdentifier())); if (parser.ExpectOptional(")")) { break; } else { parser.Expect(","); } } var constraintName = ParserUtils.GenerateName(table.Name + "_", columnNames, "_fkey"); var constraint = new PgConstraint(constraintName); table.AddConstraint(constraint); constraint.Definition = parser.Expression(); constraint.TableName = table.Name; }
/// <summary> /// Returns list of indexes that should be added. /// </summary> private static IList <PgIndex> GetNewIndexes([NullGuard.AllowNull] PgTable oldTable, [NullGuard.AllowNull] PgTable newTable) { IList <PgIndex> indexes = new List <PgIndex>(); if (newTable == null) { return(indexes); } if (oldTable == null) { foreach (PgIndex index in newTable.Indexes) { indexes.Add(index); } } else { foreach (PgIndex index in newTable.Indexes) { if (!oldTable.ContainsIndex(index.Name) || !oldTable.GetIndex(index.Name).Equals(index)) { indexes.Add(index); } } } return(indexes); }
/// <summary> /// Returns list of constraints that should be dropped. /// </summary> /// <param name="oldTable">Original table or null.</param> /// <param name="newTable">New table or null.</param> /// <param name="primaryKey">Determines whether primary keys should be processed or any other constraints should be processed.</param> /// <returns>List of constraints that should be dropped.</returns> private static List <PgConstraint> GetDropConstraints([NullGuard.AllowNull] PgTable oldTable, [NullGuard.AllowNull] PgTable newTable, bool primaryKey) { // todo db Constraints that are depending on a removed field should not be added to drop because they are already removed. var constraints = new List <PgConstraint>(); var renamedConstraints = GetRenameConstraints(oldTable, newTable); if (newTable != null && oldTable != null) { foreach (var oldConstraint in oldTable.Constraints) { // we don't have to drop this constraint because its renamed if (renamedConstraints.ContainsKey(oldConstraint)) { continue; } if (oldConstraint.PrimaryKeyConstraint == primaryKey && (!newTable.ContainsConstraint(oldConstraint.Name) || !newTable.GetConstraint(oldConstraint.Name).Equals(oldConstraint))) { constraints.Add(oldConstraint); } } } return(constraints); }
private static void ParseConstraint(Parser parser, PgTable table) { var constraint = new PgConstraint(ParserUtils.GetObjectName(parser.ParseIdentifier())); table.AddConstraint(constraint); constraint.Definition = parser.GetExpression(); constraint.TableName = table.Name; }
/// <summary> /// Adds statements for modification of columns to the list of statements. /// </summary> private static void AddModifyTableColumns(IList <string> statements, PgTable oldTable, PgTable newTable, IList <PgColumn> dropDefaultsColumns, bool addDefaults) { foreach (PgColumn newColumn in newTable.Columns) { if (!oldTable.ContainsColumn(newColumn.Name)) { continue; } PgColumn oldColumn = oldTable.GetColumn(newColumn.Name); var newColumnName = PgDiffStringExtension.QuoteName(newColumn.Name); if (!oldColumn.Type.Equals(newColumn.Type)) { statements.Add($"\tALTER COLUMN {newColumnName} TYPE {newColumn.Type} /* TypeParameterChange of table {newTable.Name}. Old: {oldColumn.Type} New: {newColumn.Type} */"); } var oldDefault = oldColumn.DefaultValue ?? string.Empty; var newDefault = newColumn.DefaultValue ?? string.Empty; if (!oldDefault.Equals(newDefault)) { if (newDefault.Length == 0) { statements.Add("\tALTER COLUMN " + newColumnName + " DROP DEFAULT"); } else { statements.Add("\tALTER COLUMN " + newColumnName + " SET DEFAULT " + newDefault); } } if (oldColumn.NullValue != newColumn.NullValue) { if (newColumn.NullValue) { statements.Add("\tALTER COLUMN " + newColumnName + " DROP NOT NULL"); } else { if (addDefaults) { var defaultValue = PgColumnUtils.GetDefaultValue(newColumn.Type); if (defaultValue != null) { statements.Add("\tALTER COLUMN " + newColumnName + " SET DEFAULT " + defaultValue); dropDefaultsColumns.Add(newColumn); } } statements.Add("\tALTER COLUMN " + newColumnName + " SET NOT NULL"); } } } }
/// <summary> /// Outputs statements for tables and columns for which comments have /// changed. /// </summary> private static void AlterComments(StreamWriter writer, PgTable oldTable, PgTable newTable, SearchPathHelper searchPathHelper) { if ((oldTable.Comment == null && newTable.Comment != null) || (oldTable.Comment != null && newTable.Comment != null && !oldTable.Comment.Equals(newTable.Comment))) { searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.Write("COMMENT ON TABLE "); writer.Write(PgDiffStringExtension.QuoteName(newTable.Name)); writer.Write(" IS "); writer.Write(newTable.Comment); writer.WriteLine(';'); } else if (oldTable.Comment != null && newTable.Comment == null) { searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.Write("COMMENT ON TABLE "); writer.Write(PgDiffStringExtension.QuoteName(newTable.Name)); writer.WriteLine(" IS NULL;"); } foreach (PgColumn newColumn in newTable.Columns) { PgColumn oldColumn = oldTable.GetColumn(newColumn.Name); var oldComment = oldColumn?.Comment; var newComment = newColumn.Comment; if (newComment != null && (oldComment == null ? newComment != null : !oldComment.Equals(newComment))) { searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.Write("COMMENT ON COLUMN "); writer.Write(PgDiffStringExtension.QuoteName(newTable.Name)); writer.Write('.'); writer.Write(PgDiffStringExtension.QuoteName(newColumn.Name)); writer.Write(" IS "); writer.Write(newColumn.Comment); writer.WriteLine(';'); } else if (oldComment != null && newComment == null) { searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.Write("COMMENT ON COLUMN "); writer.Write(PgDiffStringExtension.QuoteName(newTable.Name)); writer.Write('.'); writer.Write(PgDiffStringExtension.QuoteName(newColumn.Name)); writer.WriteLine(" IS NULL;"); } } }
private static void AddDropTableColumns(List <string> statements, PgTable oldTable, PgTable newTable) { foreach (var column in oldTable.Columns) { if (!newTable.ContainsColumn(column.Name)) { statements.Add("\tDROP COLUMN " + PgDiffUtils.GetQuotedName(column.Name)); } } }
/// <summary> /// Adds statements for removal of columns to the list of statements. /// </summary> private static void AddDropTableColumns(IList <string> statements, PgTable oldTable, PgTable newTable) { foreach (PgColumn column in oldTable.Columns) { if (!newTable.ContainsColumn(column.Name)) { statements.Add("\tDROP COLUMN " + PgDiffStringExtension.QuoteName(column.Name)); } } }
private static void AlterComments(TextWriter writer, PgTable oldTable, PgTable newTable, SearchPathHelper searchPathHelper) { if (oldTable.Comment == null && newTable.Comment != null || oldTable.Comment != null && newTable.Comment != null && !oldTable.Comment.Equals(newTable.Comment)) { searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.Write("COMMENT ON TABLE "); writer.Write(PgDiffUtils.GetQuotedName(newTable.Name)); writer.Write(" IS "); writer.Write(newTable.Comment); writer.WriteLine(';'); } else if (oldTable.Comment != null && newTable.Comment == null) { searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.Write("COMMENT ON TABLE "); writer.Write(PgDiffUtils.GetQuotedName(newTable.Name)); writer.WriteLine(" IS NULL;"); } foreach (var newColumn in newTable.Columns) { var oldColumn = oldTable.GetColumn(newColumn.Name); var oldComment = oldColumn?.Comment; var newComment = newColumn.Comment; if (newComment != null && (!oldComment?.Equals(newComment) ?? newComment != null)) { searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.Write("COMMENT ON COLUMN "); writer.Write(PgDiffUtils.GetQuotedName(newTable.Name)); writer.Write('.'); writer.Write(PgDiffUtils.GetQuotedName(newColumn.Name)); writer.Write(" IS "); writer.Write(newColumn.Comment); writer.WriteLine(';'); } else if (oldComment != null && newComment == null) { searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.Write("COMMENT ON COLUMN "); writer.Write(PgDiffUtils.GetQuotedName(newTable.Name)); writer.Write('.'); writer.Write(PgDiffUtils.GetQuotedName(newColumn.Name)); writer.WriteLine(" IS NULL;"); } } }
public static PgTable Convert(string fileName, Dictionary <string, PgColumn> columns) { var assembly = typeof(CsvToPg).Assembly; var table = new PgTable(); using (var fs = assembly.GetManifestResourceStream("Raven.Server.Integrations.PostgreSQL.Npgsql." + fileName)) using (var parser = new TextFieldParser(fs)) { parser.TextFieldType = FieldType.Delimited; parser.SetDelimiters(","); var isFirstRow = true; while (!parser.EndOfData) { var fields = parser.ReadFields(); if (fields != null) { if (isFirstRow) { isFirstRow = false; HandleColumns(fields, columns, ref table); continue; } var row = new ReadOnlyMemory <byte>?[fields.Length]; for (var index = 0; index < fields.Length; index++) { var field = fields[index]; var obj = field switch { "NULL" => null, "False" => false, "True" => true, _ => table.Columns[index].PgType.FromString(field) }; if (obj == null) { row[index] = null; } else { row[index] = table.Columns[index].PgType.ToBytes(obj, table.Columns[index].FormatCode); } } table.Data.Add(new PgDataRow(row)); } } } return(table); }
private static void AddModifyTableColumns(List <string> statements, PgDiffArguments arguments, PgTable oldTable, PgTable newTable, List <PgColumn> dropDefaultsColumns) { foreach (var newColumn in newTable.Columns) { if (!oldTable.ContainsColumn(newColumn.Name)) { continue; } var oldColumn = oldTable.GetColumn(newColumn.Name); var newColumnName = PgDiffUtils.GetQuotedName(newColumn.Name); if (!oldColumn.Type.Equals(newColumn.Type)) { statements.Add("\tALTER COLUMN " + newColumnName + " TYPE " + newColumn.Type + " /* " + string.Format(Resources.TypeParameterChange, newTable.Name, oldColumn.Type, newColumn.Type) + " */"); } var oldDefault = oldColumn.DefaultValue ?? ""; var newDefault = newColumn.DefaultValue ?? ""; if (!oldDefault.Equals(newDefault)) { statements.Add(newDefault.Length == 0 ? $"\tALTER COLUMN {newColumnName} DROP DEFAULT" : $"\tALTER COLUMN {newColumnName} SET DEFAULT {newDefault}"); } if (oldColumn.NullValue == newColumn.NullValue) { continue; } if (newColumn.NullValue) { statements.Add($"\tALTER COLUMN {newColumnName} DROP NOT NULL"); } else { if (arguments.AddDefaults) { var defaultValue = PgColumnUtils.GetDefaultValue(newColumn.Type); if (defaultValue != null) { statements.Add($"\tALTER COLUMN {newColumnName} SET DEFAULT {defaultValue}"); dropDefaultsColumns.Add(newColumn); } } statements.Add($"\tALTER COLUMN {newColumnName} SET NOT NULL"); } } }
/// <summary> /// Outputs statements for trigger comments that have changed. /// </summary> public static void AlterComments(StreamWriter writer, [NullGuard.AllowNull] PgSchema oldSchema, PgSchema newSchema, SearchPathHelper searchPathHelper) { if (oldSchema == null) { return; } foreach (PgTable oldTable in oldSchema.Tables) { PgTable newTable = newSchema.GetTable(oldTable.Name); if (newTable == null) { continue; } foreach (PgTrigger oldTrigger in oldTable.Triggers) { PgTrigger newTrigger = newTable.GetTrigger(oldTrigger.Name); if (newTrigger == null) { continue; } if ((oldTrigger.Comment == null && newTrigger.Comment != null) || (oldTrigger.Comment != null && newTrigger.Comment != null && !oldTrigger.Comment.Equals(newTrigger.Comment))) { searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.Write("COMMENT ON TRIGGER "); writer.Write(PgDiffStringExtension.QuoteName(newTrigger.Name)); writer.Write(" ON "); writer.Write(PgDiffStringExtension.QuoteName(newTrigger.TableName)); writer.Write(" IS "); writer.Write(newTrigger.Comment); writer.WriteLine(';'); } else if (oldTrigger.Comment != null && newTrigger.Comment == null) { searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.Write("COMMENT ON TRIGGER "); writer.Write(PgDiffStringExtension.QuoteName(newTrigger.Name)); writer.Write(" ON "); writer.Write(PgDiffStringExtension.QuoteName(newTrigger.TableName)); writer.WriteLine(" IS NULL;"); } } } }
internal static void Run(PgTable table) { string content = FileHelper.ReadResource(TemplatePath); List <string> matches = HtmlHelper.GetMatch(content); if (matches == null) { return; } BuildDocumentation(content, matches, table); }
internal static IList <PgTrigger> CallPgDiffTriggersGetNewTriggers(PgTable newTable) { var pt = new Microsoft.VisualStudio.TestTools.UnitTesting.PrivateType(typeof(PgDiffTriggers)); try { return((IList <PgTrigger>)pt.InvokeStatic("GetNewTriggers", new object[] { newTable })); } catch (System.MissingMethodException missingMethodException) { throw new System.NotSupportedException("GetNewTriggers with requested parameters is not found. Rerun code generation.", missingMethodException); } }
internal static void CallPgDiffTablesAlterComments(StreamWriter writer, PgTable oldTable, PgTable newTable, SearchPathHelper searchPathHelper) { var pt = new Microsoft.VisualStudio.TestTools.UnitTesting.PrivateType(typeof(PgDiffTables)); try { pt.InvokeStatic("AlterComments", new object[] { writer, oldTable, newTable, searchPathHelper }); } catch (System.MissingMethodException missingMethodException) { throw new System.NotSupportedException("AlterComments with requested parameters is not found. Rerun code generation.", missingMethodException); } }
internal static void CallAlterTableParserParseAddForeignKey(Parser parser, PgTable table) { var pt = new Microsoft.VisualStudio.TestTools.UnitTesting.PrivateType(typeof(AlterTableParser)); try { pt.InvokeStatic("ParseAddForeignKey", new object[] { parser, table }); } catch (System.MissingMethodException missingMethodException) { throw new System.NotSupportedException("ParseAddForeignKey with requested parameters is not found. Rerun code generation.", missingMethodException); } }
internal static Collection <PgColumn> GetColumns(PgTable pgTable) { Collection <PgColumn> columns = new Collection <PgColumn>(); #region sql string sql = FileHelper.ReadSqlResource("columns.sql"); #endregion using (NpgsqlCommand command = new NpgsqlCommand(sql)) { command.Parameters.AddWithValue("@SchemaName", pgTable.SchemaName); command.Parameters.AddWithValue("@TableName", pgTable.Name); using (DataTable table = DbOperation.GetDataTable(command)) { if (table.Rows.Count.Equals(0)) { return(columns); } foreach (DataRow row in table.Rows) { PgColumn column = new PgColumn { SchemaName = pgTable.SchemaName, TableName = pgTable.Name, Name = Conversion.TryCastString(row["column_name"]), OrdinalPosition = Conversion.TryCastInteger(row["ordinal_position"]), DefaultValue = Conversion.TryCastString(row["column_default"]), DataType = Conversion.TryCastString(row["data_type"]), IsNullable = Conversion.TryCastBoolean(row["is_nullable"]), MaxLength = Conversion.TryCastInteger(row["character_maximum_length"]), Description = Conversion.TryCastString(row["description"]), PrimaryKeyConstraintName = Conversion.TryCastString(row["key"]), ForiegnKeyName = Conversion.TryCastString(row["constraint_name"]), ForeignSchemaName = Conversion.TryCastString(row["references_schema"]), ForeignTableName = Conversion.TryCastString(row["references_table"]), ForeignColumnName = Conversion.TryCastString(row["references_field"]) }; column.IsPrimaryKey = !string.IsNullOrWhiteSpace(column.PrimaryKeyConstraintName); columns.Add(column); } } } return(columns); }
/// <summary> /// Parses COMMENT ON COLUMN. /// </summary> private static void ParseColumn(Parser parser, PgDatabase database) { var columnName = parser.ParseIdentifier(); var objectName = ParserUtils.GetObjectName(columnName); var tableName = ParserUtils.GetSecondObjectName(columnName); var schemaName = ParserUtils.GetThirdObjectName(columnName); if (database.SchemaIsIgnored(schemaName)) { return; } PgSchema schema = database.GetSchema(schemaName); PgTable table = schema.GetTable(tableName); if (table == null) { PgView view = schema.GetView(tableName); parser.Expect("IS"); var comment = GetComment(parser); if (comment == null) { view.RemoveColumnComment(objectName); } else { view.AddColumnComment(objectName, comment); } parser.Expect(";"); } else { PgColumn column = table.GetColumn(objectName); if (column == null) { throw new TeamworkParserException($"CannotFindColumnInTable {columnName} from table {table.Name}"); } parser.Expect("IS"); column.Comment = GetComment(parser); parser.Expect(";"); } }
private static void CheckTablespace(TextWriter writer, PgTable oldTable, PgTable newTable, SearchPathHelper searchPathHelper) { if (oldTable.Tablespace == null && newTable.Tablespace == null || oldTable.Tablespace != null && oldTable.Tablespace.Equals(newTable.Tablespace)) { return; } searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.WriteLine("ALTER TABLE " + PgDiffUtils.GetQuotedName(newTable.Name)); writer.WriteLine("\tTABLESPACE " + newTable.Tablespace + ';'); }
/// <summary> /// Checks tablespace modification. /// </summary> private static void CheckTablespace(StreamWriter writer, PgTable oldTable, PgTable newTable, SearchPathHelper searchPathHelper) { if ((oldTable.Tablespace == null && newTable.Tablespace == null) || (oldTable.Tablespace != null && oldTable.Tablespace.Equals(newTable.Tablespace))) { return; } searchPathHelper.OutputSearchPath(writer); writer.WriteLine(); writer.WriteLine("ALTER TABLE " + PgDiffStringExtension.QuoteName(newTable.Name)); writer.WriteLine("\tTABLESPACE " + newTable.Tablespace + ';'); }
/// <summary> /// Parses CREATE INDEX statement. /// </summary> public static void Parse(PgDatabase database, string statement) { var parser = new Parser(statement); parser.Expect("CREATE"); var unique = parser.ExpectOptional("UNIQUE"); parser.Expect("INDEX"); parser.ExpectOptional("CONCURRENTLY"); var indexName = ParserUtils.GetObjectName(parser.ParseIdentifier()); parser.Expect("ON"); var tableName = parser.ParseIdentifier(); var definition = parser.Rest(); var schemaName = ParserUtils.GetSchemaName(tableName, database); if (database.SchemaIsIgnored(schemaName)) { return; } PgSchema schema = database.GetSchema(schemaName); if (schema == null) { throw new TeamworkParserException($"CannotFindSchema {schemaName} from {statement}"); } var objectName = ParserUtils.GetObjectName(tableName); PgTable table = schema.GetTable(objectName); if (table == null) { throw new TeamworkParserException($"CannotFindTable {tableName} from {statement}"); } var index = new PgIndex(indexName); table.AddIndex(index); schema.Add(index); index.Definition = definition.Trim(); index.TableName = table.Name; index.Unique = unique; }
private static IEnumerable <PgTrigger> GetNewTriggers(PgTable oldTable, PgTable newTable) { var list = new List <PgTrigger>(); if (newTable == null) { return(list); } list.AddRange(oldTable == null ? newTable.GetTriggers() : newTable.GetTriggers().Where(nt => oldTable.GetTriggers().All(t => !t.Equals(nt)))); return(list); }
private static IEnumerable <PgTrigger> GetDropTriggers(PgTable oldTable, PgTable newTable) { var list = new List <PgTrigger>(); if (newTable == null || oldTable == null) { return(list); } var newTriggers = newTable.GetTriggers(); list.AddRange(oldTable.GetTriggers().Where(ot => newTriggers.All(t => !t.Equals(ot)))); return(list); }
private static IEnumerable <PgIndex> GetDropIndexes(PgTable oldTable, PgTable newTable) { var list = new List <PgIndex>(); if (newTable == null || oldTable == null) { return(list); } list.AddRange(oldTable.GetIndexes() .Where(i => !newTable.ContainsIndex(i.Name) || !newTable.GetIndex(i.Name).Equals(i))); return(list); }
/// <summary> /// Adds statements for creation of new columns to the list of statements. /// </summary> private static void AddCreateTableColumns(IList <string> statements, PgTable oldTable, PgTable newTable, IList <PgColumn> dropDefaultsColumns, bool addDefaults) { foreach (PgColumn column in newTable.Columns) { if (!oldTable.ContainsColumn(column.Name)) { statements.Add("\tADD COLUMN " + column.GetFullDefinition(addDefaults)); if (addDefaults && !column.NullValue && (column.DefaultValue == null || column.DefaultValue == string.Empty)) { dropDefaultsColumns.Add(column); } } } }
private static void ParseInherits(Parser parser, PgTable table) { parser.Expect("("); while (!parser.ExpectOptional(")")) { table.AddInherits(ParserUtils.GetObjectName(parser.ParseIdentifier())); if (parser.ExpectOptional(")")) { break; } parser.Expect(","); } }