/// <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(",");
}
}
