protected override void Generate(DropIndexOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append("DROP INDEX ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name))
.AppendLine(SqlGenerationHelper.StatementTerminator)
.EndCommand();
}
protected override void Generate(
AlterColumnOperation operation,
IModel model,
MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
DropDefaultConstraint(operation.Schema, operation.Table, operation.Name, builder);
builder
.Append("ALTER TABLE ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema))
.Append(" ALTER COLUMN ");
ColumnDefinition(
operation.Schema,
operation.Table,
operation.Name,
operation.ClrType,
operation.ColumnType,
operation.IsUnicode,
operation.MaxLength,
operation.IsRowVersion,
operation.IsNullable,
/*defaultValue:*/ null,
/*defaultValueSql:*/ null,
operation.ComputedColumnSql,
/*identity:*/ false,
operation,
model,
builder);
builder.AppendLine(SqlGenerationHelper.StatementTerminator);
if ((operation.DefaultValue != null)
|| (operation.DefaultValueSql != null))
{
builder
.Append("ALTER TABLE ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema))
.Append(" ADD");
DefaultValue(operation.DefaultValue, operation.DefaultValueSql, builder);
builder
.Append(" FOR ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name))
.AppendLine(SqlGenerationHelper.StatementTerminator);
}
EndStatement(builder);
}
public virtual IReadOnlyList<MigrationCommand> Generate(
IReadOnlyList<MigrationOperation> operations,
IModel model = null)
{
Check.NotNull(operations, nameof(operations));
var builder = new MigrationCommandListBuilder(_commandBuilderFactory);
foreach (var operation in operations)
{
Generate(operation, model, builder);
}
return builder.GetCommandList();
}
protected override void Generate(RenameTableOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
if (operation.NewName != null)
{
builder
.Append("ALTER TABLE ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name))
.Append(" RENAME TO ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.NewName))
.AppendLine(SqlGenerationHelper.StatementTerminator)
.EndCommand();
}
}
protected override void Generate(
MigrationOperation operation,
IModel model,
Microsoft.EntityFrameworkCore.Migrations.MigrationCommandListBuilder builder)
{
if (operation is AddColumnOperation addColumnOperation)
{
Generate(addColumnOperation, builder);
}
else if (operation is CreateTableOperation createTableOperation)
{
Generate(createTableOperation, builder);
}
else
{
base.Generate(operation, model, builder);
}
}
protected override void Generate(MigrationOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var createDatabaseOperation = operation as SqlServerCreateDatabaseOperation;
var dropDatabaseOperation = operation as SqlServerDropDatabaseOperation;
if (createDatabaseOperation != null)
{
Generate(createDatabaseOperation, model, builder);
}
else if (dropDatabaseOperation != null)
{
Generate(dropDatabaseOperation, model, builder);
}
else
{
base.Generate(operation, model, builder);
}
}
protected override void Generate(CreateTableOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
// Lifts a primary key definition into the typename.
// This handles the quirks of creating integer primary keys using autoincrement, not default rowid behavior.
if (operation.PrimaryKey?.Columns.Length == 1)
{
var columnOp = operation.Columns.FirstOrDefault(o => o.Name == operation.PrimaryKey.Columns[0]);
if (columnOp != null)
{
columnOp.AddAnnotation(SqliteFullAnnotationNames.Instance.InlinePrimaryKey, true);
if (!string.IsNullOrEmpty(operation.PrimaryKey.Name))
{
columnOp.AddAnnotation(SqliteFullAnnotationNames.Instance.InlinePrimaryKeyName, operation.PrimaryKey.Name);
}
operation.PrimaryKey = null;
}
}
base.Generate(operation, model, builder);
}
protected override void Generate(
DropColumnOperation operation,
IModel model,
MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
DropDefaultConstraint(operation.Schema, operation.Table, operation.Name, builder);
base.Generate(operation, model, builder);
}
protected override void ColumnDefinition(
string schema,
string table,
string name,
Type clrType,
string type,
bool? unicode,
int? maxLength,
bool rowVersion,
bool nullable,
object defaultValue,
string defaultValueSql,
string computedColumnSql,
IAnnotatable annotatable,
IModel model,
MigrationCommandListBuilder builder)
{
var valueGenerationStrategy = annotatable[
SqlServerFullAnnotationNames.Instance.ValueGenerationStrategy] as SqlServerValueGenerationStrategy?;
ColumnDefinition(
schema,
table,
name,
clrType,
type,
unicode,
maxLength,
rowVersion,
nullable,
defaultValue,
defaultValueSql,
computedColumnSql,
valueGenerationStrategy == SqlServerValueGenerationStrategy.IdentityColumn,
annotatable,
model,
builder);
}
protected override void Generate([NotNull] AddPrimaryKeyOperation operation, [CanBeNull] IModel model, [NotNull] MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append("ALTER TABLE ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema))
.Append(" ADD ");
PrimaryKeyConstraint(operation, model, builder);
builder.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
var annotations = model.GetAnnotations();
if (operation.Columns.Count() == 1)
{
builder.Append(@"DROP PROCEDURE IF EXISTS POMELO_AFTER_ADD_PRIMARY_KEY;
CREATE PROCEDURE POMELO_AFTER_ADD_PRIMARY_KEY(IN `SCHEMA_NAME_ARGUMENT` VARCHAR(255), IN `TABLE_NAME_ARGUMENT` VARCHAR(255), IN `COLUMN_NAME_ARGUMENT` VARCHAR(255))
BEGIN
DECLARE HAS_AUTO_INCREMENT_ID INT(11);
DECLARE PRIMARY_KEY_COLUMN_NAME VARCHAR(255);
DECLARE PRIMARY_KEY_TYPE VARCHAR(255);
DECLARE SQL_EXP VARCHAR(1000);
SELECT COUNT(*)
INTO HAS_AUTO_INCREMENT_ID
FROM `information_schema`.`COLUMNS`
WHERE `TABLE_SCHEMA` = (SELECT IFNULL(SCHEMA_NAME_ARGUMENT, SCHEMA()))
AND `TABLE_NAME` = TABLE_NAME_ARGUMENT
AND `COLUMN_NAME` = COLUMN_NAME_ARGUMENT
AND `COLUMN_TYPE` LIKE '%int%'
AND `COLUMN_KEY` = 'PRI';
IF HAS_AUTO_INCREMENT_ID THEN
SELECT `COLUMN_TYPE`
INTO PRIMARY_KEY_TYPE
FROM `information_schema`.`COLUMNS`
WHERE `TABLE_SCHEMA` = (SELECT IFNULL(SCHEMA_NAME_ARGUMENT, SCHEMA()))
AND `TABLE_NAME` = TABLE_NAME_ARGUMENT
AND `COLUMN_NAME` = COLUMN_NAME_ARGUMENT
AND `COLUMN_TYPE` LIKE '%int%'
AND `COLUMN_KEY` = 'PRI';
SELECT `COLUMN_NAME`
INTO PRIMARY_KEY_COLUMN_NAME
FROM `information_schema`.`COLUMNS`
WHERE `TABLE_SCHEMA` = (SELECT IFNULL(SCHEMA_NAME_ARGUMENT, SCHEMA()))
AND `TABLE_NAME` = TABLE_NAME_ARGUMENT
AND `COLUMN_NAME` = COLUMN_NAME_ARGUMENT
AND `COLUMN_TYPE` LIKE '%int%'
AND `COLUMN_KEY` = 'PRI';
SET SQL_EXP = CONCAT('ALTER TABLE `', (SELECT IFNULL(SCHEMA_NAME_ARGUMENT, SCHEMA())), '`.`', TABLE_NAME_ARGUMENT, '` MODIFY COLUMN `', PRIMARY_KEY_COLUMN_NAME, '` ', PRIMARY_KEY_TYPE, ' NOT NULL AUTO_INCREMENT;');
SET @SQL_EXP = SQL_EXP;
PREPARE SQL_EXP_EXECUTE FROM @SQL_EXP;
EXECUTE SQL_EXP_EXECUTE;
DEALLOCATE PREPARE SQL_EXP_EXECUTE;
END IF;
END;");
builder.AppendLine();
if (operation.Schema == null)
{
builder.Append($"CALL POMELO_AFTER_ADD_PRIMARY_KEY(NULL, '{ operation.Table }', '{ operation.Columns.First() }');");
}
else
{
builder.Append($"CALL POMELO_AFTER_ADD_PRIMARY_KEY('{ operation.Schema }', '{ operation.Table }', '{ operation.Columns.First() }');");
}
builder.AppendLine();
builder.Append($"DROP PROCEDURE IF EXISTS POMELO_AFTER_ADD_PRIMARY_KEY;");
builder.AppendLine();
}
EndStatement(builder);
}
protected override void Generate(EnsureSchemaOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
if (string.Equals(operation.Name, "DBO", StringComparison.OrdinalIgnoreCase))
{
return;
}
builder
.Append("IF SCHEMA_ID(")
.Append(SqlGenerationHelper.GenerateLiteral(operation.Name))
.Append(") IS NULL EXEC(N'CREATE SCHEMA ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name))
.Append("')")
.AppendLine(SqlGenerationHelper.StatementTerminator);
EndStatement(builder);
}
protected override void Generate(CreateIndexOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
base.Generate(operation, model, builder, terminate: false);
var clustered = operation[SqlServerFullAnnotationNames.Instance.Clustered] as bool?;
if (operation.IsUnique &&
(clustered != true))
{
builder.Append(" WHERE ");
for (var i = 0; i < operation.Columns.Length; i++)
{
if (i != 0)
{
builder.Append(" AND ");
}
builder
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Columns[i]))
.Append(" IS NOT NULL");
}
}
EndStatement(builder);
}
protected override void ForeignKeyAction(ReferentialAction referentialAction, MigrationCommandListBuilder builder)
{
Check.NotNull(builder, nameof(builder));
if (referentialAction == ReferentialAction.Restrict)
{
builder.Append("NO ACTION");
}
else
{
base.ForeignKeyAction(referentialAction, builder);
}
}
protected override void Generate(InsertDataOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var sqlBuilder = new StringBuilder();
foreach (var modificationCommand in operation.GenerateModificationCommands(model))
{
SqlGenerator.AppendInsertOperation(
sqlBuilder,
modificationCommand,
0);
}
builder
.AppendLine("BEGIN")
.Append(sqlBuilder)
.Append("END")
.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
builder.EndCommand();
}
protected override void Generate(DropSequenceOperation operation, IModel model, MigrationCommandListBuilder builder)
{
throw new NotSupportedException(SqliteStrings.SequencesNotSupported);
}
protected override void Generate(EnsureSchemaOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
if (string.Equals(operation.Name, "DBO", StringComparison.OrdinalIgnoreCase))
{
return;
}
var stringTypeMapping = Dependencies.TypeMappingSource.GetMapping(typeof(string));
builder
.Append("IF SCHEMA_ID(")
.Append(stringTypeMapping.GenerateSqlLiteral(operation.Name))
.Append(") IS NULL EXEC(N'CREATE SCHEMA ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name))
.Append(Dependencies.SqlGenerationHelper.StatementTerminator)
.Append("')")
.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator)
.EndCommand();
}
protected override void Generate(
DropIndexOperation operation,
IModel model,
MigrationCommandListBuilder builder)
=> Generate(operation, model, builder, terminate: true);
protected override void ColumnDefinition(AddColumnOperation operation, IModel model, MigrationCommandListBuilder builder)
=> ColumnDefinition(
operation.Schema,
operation.Table,
operation.Name,
operation.ClrType,
operation.ColumnType,
operation.IsUnicode,
operation.MaxLength,
operation.IsFixedLength,
operation.IsRowVersion,
operation.IsNullable,
operation.DefaultValue,
operation.DefaultValueSql,
operation.ComputedColumnSql,
operation,
model,
builder);
protected override void IndexTraits(MigrationOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var clustered = operation[SqlServerFullAnnotationNames.Instance.Clustered] as bool?;
if (clustered.HasValue)
{
builder.Append(clustered.Value ? "CLUSTERED " : "NONCLUSTERED ");
}
}
protected override void Generate(EnsureSchemaOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
if (string.Equals(operation.Name, "DBO", StringComparison.OrdinalIgnoreCase))
{
return;
}
builder
.Append("IF SCHEMA_ID(")
.Append(SqlGenerationHelper.GenerateLiteral(operation.Name))
.Append(") IS NULL EXEC(N'CREATE SCHEMA ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name))
.Append("')");
EndStatement(builder);
}
protected override void Generate(AlterTableOperation operation, IModel model, MigrationCommandListBuilder builder)
{
var madeChanges = false;
// Storage parameters
var oldStorageParameters = GetStorageParameters(operation.OldTable);
var newStorageParameters = GetStorageParameters(operation);
var newOrChanged = newStorageParameters.Where(p =>
!oldStorageParameters.ContainsKey(p.Key) ||
oldStorageParameters[p.Key] != p.Value
).ToList();
if (newOrChanged.Count > 0)
{
builder
.Append("ALTER TABLE ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name, operation.Schema));
builder
.Append(" SET (")
.Append(string.Join(", ", newOrChanged.Select(p => $"{p.Key}={p.Value}")))
.Append(")");
builder.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
madeChanges = true;
}
var removed = oldStorageParameters
.Select(p => p.Key)
.Where(pn => !newStorageParameters.ContainsKey(pn))
.ToList();
if (removed.Count > 0)
{
builder
.Append("ALTER TABLE ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name, operation.Schema));
builder
.Append(" RESET (")
.Append(string.Join(", ", removed))
.Append(")");
builder.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
madeChanges = true;
}
// Comment
var oldComment = operation.OldTable[NpgsqlAnnotationNames.Comment] as string;
var newComment = operation[NpgsqlAnnotationNames.Comment] as string;
if (oldComment != newComment)
{
var stringTypeMapping = Dependencies.TypeMapper.GetMapping(typeof(string));
builder
.Append("COMMENT ON TABLE ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name, operation.Schema))
.Append(" IS ")
.Append(stringTypeMapping.GenerateSqlLiteral(newComment));
builder.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
madeChanges = true;
}
if (madeChanges)
{
EndStatement(builder);
}
}
protected override void Generate(CreateTableOperation operation, IModel model, MigrationCommandListBuilder builder)
{
base.Generate(operation, model, builder);
var rowVersionColumns = operation.Columns.Where(c => c.IsRowVersion).ToArray();
if (rowVersionColumns.Length > 0)
{
builder
.Append("CREATE OR REPLACE TRIGGER ")
.AppendLine(Dependencies.SqlGenerationHelper.DelimitIdentifier("rowversion_" + operation.Name, operation.Schema))
.Append("BEFORE INSERT OR UPDATE ON ")
.AppendLine(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name, operation.Schema))
.AppendLine("FOR EACH ROW")
.AppendLine("BEGIN");
foreach (var rowVersionColumn in rowVersionColumns)
{
builder
.Append(" :NEW.")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(rowVersionColumn.Name))
.Append(" := UTL_RAW.CAST_FROM_BINARY_INTEGER(UTL_RAW.CAST_TO_BINARY_INTEGER(NVL(:OLD.")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(rowVersionColumn.Name))
.Append(", '00000000')) + 1)")
.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
}
builder
.Append("END")
.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
}
EndStatement(builder);
}
protected override void Generate(AlterColumnOperation operation, IModel model, MigrationCommandListBuilder builder)
{
throw new NotSupportedException(SqliteStrings.InvalidMigrationOperation(operation.GetType().Name));
}
protected override void Generate(
AlterColumnOperation operation,
IModel model,
MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var property = FindProperty(model, operation.Schema, operation.Table, operation.Name);
if (operation.ComputedColumnSql != null)
{
var dropColumnOperation = new DropColumnOperation {
Schema = operation.Schema,
Table = operation.Table,
Name = operation.Name
};
var addColumnOperation = new AddColumnOperation {
Schema = operation.Schema,
Table = operation.Table,
Name = operation.Name,
ClrType = operation.ClrType,
ColumnType = operation.ColumnType,
IsUnicode = operation.IsUnicode,
MaxLength = operation.MaxLength,
IsRowVersion = operation.IsRowVersion,
IsNullable = operation.IsNullable,
DefaultValue = operation.DefaultValue,
DefaultValueSql = operation.DefaultValueSql,
ComputedColumnSql = operation.ComputedColumnSql,
IsFixedLength = operation.IsFixedLength
};
addColumnOperation.AddAnnotations(operation.GetAnnotations());
Generate(dropColumnOperation, model, builder);
Generate(addColumnOperation, model, builder);
return;
}
var valueGenerationStrategy = operation[
OracleAnnotationNames.ValueGenerationStrategy] as OracleValueGenerationStrategy?;
var identity = valueGenerationStrategy == OracleValueGenerationStrategy.IdentityColumn;
if (IsOldColumnSupported(model))
{
var oldValueGenerationStrategy = operation.OldColumn[
OracleAnnotationNames.ValueGenerationStrategy] as OracleValueGenerationStrategy?;
var oldIdentity = oldValueGenerationStrategy == OracleValueGenerationStrategy.IdentityColumn;
if (oldIdentity &&
!identity)
{
DropIdentity(operation, builder);
}
if (operation.OldColumn.DefaultValue != null ||
operation.OldColumn.DefaultValueSql != null &&
(operation.DefaultValue == null ||
operation.DefaultValueSql == null))
{
DropDefaultConstraint(operation.Schema, operation.Table, operation.Name, builder);
}
}
else
{
if (!identity)
{
DropIdentity(operation, builder);
}
if (operation.DefaultValue == null &&
operation.DefaultValueSql == null)
{
DropDefaultConstraint(operation.Schema, operation.Table, operation.Name, builder);
}
}
builder
.Append("ALTER TABLE ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema))
.Append(" MODIFY ");
ColumnDefinition(
operation.Schema,
operation.Table,
operation.Name,
operation.ClrType,
operation.ColumnType,
operation.IsUnicode,
operation.MaxLength,
operation.IsFixedLength,
operation.IsRowVersion,
operation.IsNullable,
operation.DefaultValue,
operation.DefaultValueSql,
operation.ComputedColumnSql,
identity,
operation,
model,
builder);
builder.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
builder.EndCommand();
}
protected override void Generate([NotNull] DropPrimaryKeyOperation operation, [CanBeNull] IModel model, [NotNull] MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder.Append(@"DROP PROCEDURE IF EXISTS POMELO_BEFORE_DROP_PRIMARY_KEY;
DELIMITER //
CREATE PROCEDURE POMELO_BEFORE_DROP_PRIMARY_KEY(IN `SCHEMA_NAME_ARGUMENT` VARCHAR(255), IN `TABLE_NAME_ARGUMENT` VARCHAR(255))
BEGIN
DECLARE HAS_AUTO_INCREMENT_ID TINYINT(1);
DECLARE PRIMARY_KEY_COLUMN_NAME VARCHAR(255);
DECLARE PRIMARY_KEY_TYPE VARCHAR(255);
DECLARE SQL_EXP VARCHAR(1000);
SELECT COUNT(*)
INTO HAS_AUTO_INCREMENT_ID
FROM `information_schema`.`COLUMNS`
WHERE `TABLE_SCHEMA` = (SELECT IFNULL(SCHEMA_NAME_ARGUMENT, SCHEMA()))
AND `TABLE_NAME` = TABLE_NAME_ARGUMENT
AND `Extra` = 'auto_increment'
AND `COLUMN_KEY` = 'PRI'
LIMIT 1;
IF HAS_AUTO_INCREMENT_ID THEN
SELECT `COLUMN_TYPE`
INTO PRIMARY_KEY_TYPE
FROM `information_schema`.`COLUMNS`
WHERE `TABLE_SCHEMA` = (SELECT IFNULL(SCHEMA_NAME_ARGUMENT, SCHEMA()))
AND `TABLE_NAME` = TABLE_NAME_ARGUMENT
AND `COLUMN_KEY` = 'PRI'
LIMIT 1;
SELECT `COLUMN_NAME`
INTO PRIMARY_KEY_COLUMN_NAME
FROM `information_schema`.`COLUMNS`
WHERE `TABLE_SCHEMA` = (SELECT IFNULL(SCHEMA_NAME_ARGUMENT, SCHEMA()))
AND `TABLE_NAME` = TABLE_NAME_ARGUMENT
AND `COLUMN_KEY` = 'PRI'
LIMIT 1;
SET SQL_EXP = CONCAT('ALTER TABLE `', (SELECT IFNULL(SCHEMA_NAME_ARGUMENT, SCHEMA())), '`.`', TABLE_NAME_ARGUMENT, '` MODIFY COLUMN `', PRIMARY_KEY_COLUMN_NAME, '` ', PRIMARY_KEY_TYPE, ' NOT NULL;');
SET @SQL_EXP = SQL_EXP;
PREPARE SQL_EXP_EXECUTE FROM @SQL_EXP;
EXECUTE SQL_EXP_EXECUTE;
DEALLOCATE PREPARE SQL_EXP_EXECUTE;
END IF;
END //
DELIMITER ;
");
builder.AppendLine();
if (String.IsNullOrWhiteSpace(operation.Schema))
{
builder.Append($"CALL POMELO_BEFORE_DROP_PRIMARY_KEY(NULL, '{ operation.Table }');");
}
else
{
builder.Append($"CALL POMELO_BEFORE_DROP_PRIMARY_KEY('{ operation.Schema }', '{ operation.Table }');");
}
builder.AppendLine();
builder.Append($"DROP PROCEDURE IF EXISTS POMELO_BEFORE_DROP_PRIMARY_KEY;");
builder.AppendLine();
builder
.Append("ALTER TABLE ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema))
.Append(" DROP PRIMARY KEY;")
.AppendLine();
EndStatement(builder);
}
protected virtual void Rename(
[NotNull] string name,
[NotNull] string newName,
[NotNull] MigrationCommandListBuilder builder) => Rename(name, newName, /*type:*/ null, builder);
public virtual void Generate(MyCatDropDatabaseOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var dbName = SqlGenerationHelper.DelimitIdentifier(operation.Name);
builder
.Append("DROP DATABASE ")
.Append(dbName);
}
protected override void Generate(AlterTableOperation operation, IModel model, MigrationCommandListBuilder builder)
{
var oldStorageParameters = GetStorageParameters(operation.OldTable);
var newStorageParameters = GetStorageParameters(operation);
var newOrChanged = newStorageParameters.Where(p =>
!oldStorageParameters.ContainsKey(p.Key) ||
oldStorageParameters[p.Key] != p.Value
).ToList();
if (newOrChanged.Count > 0)
{
builder
.Append("ALTER TABLE ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name, operation.Schema));
builder
.Append(" SET (")
.Append(string.Join(", ", newOrChanged.Select(p => $"{p.Key}={p.Value}")))
.Append(")");
builder.AppendLine(SqlGenerationHelper.StatementTerminator);
EndStatement(builder);
}
var removed = oldStorageParameters
.Select(p => p.Key)
.Where(pn => !newStorageParameters.ContainsKey(pn))
.ToList();
if (removed.Count > 0)
{
builder
.Append("ALTER TABLE ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name, operation.Schema));
builder
.Append(" RESET (")
.Append(string.Join(", ", removed))
.Append(")");
builder.AppendLine(SqlGenerationHelper.StatementTerminator);
EndStatement(builder);
}
base.Generate(operation, model, builder);
}
protected override void Generate(AlterColumnOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
// TODO: There is probably duplication here with other methods. See ColumnDefinition.
//TODO: this should provide feature parity with the EF6 provider, check if there's anything missing for EF7
var type = operation.ColumnType;
if (operation.ColumnType == null)
{
var property = FindProperty(model, operation.Schema, operation.Table, operation.Name);
type = property != null
? TypeMapper.GetMapping(property).StoreType
: TypeMapper.GetMapping(operation.ClrType).StoreType;
}
var serial = operation.FindAnnotation(MyCatAnnotationNames.Prefix + MyCatAnnotationNames.Serial);
var isSerial = serial != null && (bool)serial.Value;
var identifier = SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema);
var alterBase = $"ALTER TABLE {identifier} MODIFY COLUMN {SqlGenerationHelper.DelimitIdentifier(operation.Name)}";
// TYPE
builder.Append(alterBase)
.Append(" ")
.Append(type)
.Append(operation.IsNullable ? " NULL" : " NOT NULL")
.AppendLine(SqlGenerationHelper.StatementTerminator);
alterBase = $"ALTER TABLE {identifier} ALTER COLUMN {SqlGenerationHelper.DelimitIdentifier(operation.Name)}";
builder.Append(alterBase);
if (operation.DefaultValue != null)
{
builder.Append(" SET DEFAULT ")
.Append(SqlGenerationHelper.GenerateLiteral((dynamic)operation.DefaultValue))
.AppendLine(SqlGenerationHelper.BatchTerminator);
}
else if (!string.IsNullOrWhiteSpace(operation.DefaultValueSql))
{
builder.Append(" SET DEFAULT ")
.Append(operation.DefaultValueSql)
.AppendLine(SqlGenerationHelper.BatchTerminator);
}
else if (isSerial)
{
builder.Append(" SET DEFAULT ");
switch (type)
{
case "smallint":
case "int":
case "bigint":
case "real":
case "double precision":
case "numeric":
//TODO: need function CREATE SEQUENCE IF NOT EXISTS and set to it...
//Until this is resolved changing IsIdentity from false to true
//on types int2, int4 and int8 won't switch to type serial2, serial4 and serial8
throw new NotImplementedException("Not supporting creating sequence for integer types");
case "char(38)":
case "uuid":
case "uniqueidentifier":
builder.Append("UUID()");
break;
default:
throw new NotImplementedException($"Not supporting creating IsIdentity for {type}");
}
}
else
{
builder.Append(" DROP DEFAULT ");
}
}
protected override void Generate(AlterColumnOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
// Never touch system columns
if (IsSystemColumn(operation.Name))
{
return;
}
var type = operation.ColumnType ?? GetColumnType(operation.Schema, operation.Table, operation.Name, operation.ClrType, null, operation.MaxLength, false, model);
string sequenceName = null;
var defaultValueSql = operation.DefaultValueSql;
CheckForOldAnnotation(operation);
var valueGenerationStrategy = operation[NpgsqlFullAnnotationNames.Instance.ValueGenerationStrategy] as NpgsqlValueGenerationStrategy?;
if (valueGenerationStrategy == NpgsqlValueGenerationStrategy.SerialColumn)
{
switch (type)
{
case "int":
case "int4":
case "bigint":
case "int8":
case "smallint":
case "int2":
sequenceName = $"{operation.Table}_{operation.Name}_seq";
Generate(new CreateSequenceOperation
{
Name = sequenceName,
ClrType = typeof(long)
}, model, builder, false);
defaultValueSql = $@"nextval('{SqlGenerationHelper.DelimitIdentifier(sequenceName)}')";
// Note: we also need to set the sequence ownership, this is done below
// after the ALTER COLUMN
break;
}
}
var identifier = SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema);
var alterBase = $"ALTER TABLE {identifier} ALTER COLUMN {SqlGenerationHelper.DelimitIdentifier(operation.Name)} ";
// TYPE
builder.Append(alterBase)
.Append("TYPE ")
.Append(type)
.AppendLine(SqlGenerationHelper.StatementTerminator);
// NOT NULL
builder.Append(alterBase)
.Append(operation.IsNullable ? "DROP NOT NULL" : "SET NOT NULL")
.AppendLine(SqlGenerationHelper.StatementTerminator);
// DEFAULT
builder.Append(alterBase);
if (operation.DefaultValue != null || defaultValueSql != null)
{
builder.Append("SET");
DefaultValue(operation.DefaultValue, defaultValueSql, builder);
}
else
{
builder.Append("DROP DEFAULT");
}
// ALTER SEQUENCE
if (sequenceName != null)
{
// Terminate the DEFAULT above
builder.AppendLine(SqlGenerationHelper.StatementTerminator);
builder
.Append("ALTER SEQUENCE ")
.Append(SqlGenerationHelper.DelimitIdentifier(sequenceName))
.Append(" OWNED BY ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Table))
.Append('.')
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name));
}
EndStatement(builder);
}
protected override void Generate(CreateIndexOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
base.Generate(operation, model, builder, terminate: false);
var clustered = operation[SqlServerFullAnnotationNames.Instance.Clustered] as bool?;
if (operation.IsUnique
&& (clustered != true))
{
builder.Append(" WHERE ");
for (var i = 0; i < operation.Columns.Length; i++)
{
if (i != 0)
{
builder.Append(" AND ");
}
builder
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Columns[i]))
.Append(" IS NOT NULL");
}
}
builder.AppendLine(SqlGenerationHelper.StatementTerminator);
EndStatement(builder);
}
protected override void Generate(CreateSequenceOperation operation, [CanBeNull] IModel model, MigrationCommandListBuilder builder)
{
Generate(operation, model, builder, true);
}
protected override void Generate(
CreateTableOperation operation,
IModel model,
MigrationCommandListBuilder builder,
bool terminate)
{
// Filter out any system columns
if (operation.Columns.Any(c => IsSystemColumn(c.Name)))
{
var filteredOperation = new CreateTableOperation
{
Name = operation.Name,
Schema = operation.Schema,
PrimaryKey = operation.PrimaryKey,
};
filteredOperation.Columns.AddRange(operation.Columns.Where(c => !_systemColumnNames.Contains(c.Name)));
filteredOperation.ForeignKeys.AddRange(operation.ForeignKeys);
filteredOperation.UniqueConstraints.AddRange(operation.UniqueConstraints);
operation = filteredOperation;
}
base.Generate(operation, model, builder, false);
// CockroachDB "interleave in parent" (https://www.cockroachlabs.com/docs/stable/interleave-in-parent.html)
var interleaveInParentStr = operation[CockroachDbAnnotationNames.InterleaveInParent] as string;
if (interleaveInParentStr != null)
{
var interleaveInParent = new CockroachDbInterleaveInParent(operation);
var parentTableSchema = interleaveInParent.ParentTableSchema;
var parentTableName = interleaveInParent.ParentTableName;
var interleavePrefix = interleaveInParent.InterleavePrefix;
builder
.AppendLine()
.Append("INTERLEAVE IN PARENT ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(parentTableName, parentTableSchema))
.Append(" (")
.Append(string.Join(", ", interleavePrefix.Select(c => Dependencies.SqlGenerationHelper.DelimitIdentifier(c))))
.Append(')');
}
var storageParameters = GetStorageParameters(operation);
if (storageParameters.Count > 0)
{
builder
.AppendLine()
.Append("WITH (")
.Append(string.Join(", ", storageParameters.Select(p => $"{p.Key}={p.Value}")))
.Append(')');
}
// Comment on the table
var comment = operation[NpgsqlAnnotationNames.Comment] as string;
if (comment != null)
{
builder.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
var stringTypeMapping = Dependencies.TypeMapper.GetMapping(typeof(string));
builder
.Append("COMMENT ON TABLE ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name, operation.Schema))
.Append(" IS ")
.Append(stringTypeMapping.GenerateSqlLiteral(comment));
}
// Comments on the columns
foreach (var columnOp in operation.Columns.Where(c => c[NpgsqlAnnotationNames.Comment] != null))
{
var columnComment = columnOp[NpgsqlAnnotationNames.Comment];
builder.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
var stringTypeMapping = Dependencies.TypeMapper.GetMapping(typeof(string));
builder
.Append("COMMENT ON COLUMN ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name, operation.Schema))
.Append('.')
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(columnOp.Name))
.Append(" IS ")
.Append(stringTypeMapping.GenerateSqlLiteral(columnComment));
}
if (terminate)
{
builder.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
EndStatement(builder);
}
}
protected override void Generate(RenameIndexOperation operation, [CanBeNull] IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var qualifiedName = new StringBuilder();
if (operation.Schema != null)
{
qualifiedName
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Schema))
.Append(".");
}
qualifiedName.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name));
// TODO: Rename across schema will break, see #44
Rename(qualifiedName.ToString(), SqlGenerationHelper.DelimitIdentifier(operation.NewName), "INDEX", builder);
EndStatement(builder);
}
protected override void Generate(
RenameColumnOperation operation,
IModel model,
MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var qualifiedName = new StringBuilder();
if (operation.Schema != null)
{
qualifiedName
.Append(operation.Schema)
.Append(".");
}
qualifiedName
.Append(operation.Table)
.Append(".")
.Append(operation.Name);
Rename(qualifiedName.ToString(), operation.NewName, "COLUMN", builder);
EndStatement(builder);
}
protected override void Generate(RenameTableOperation operation, [CanBeNull] IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var name = operation.Name;
if (operation.NewName != null)
{
var qualifiedName = new StringBuilder();
if (operation.Schema != null)
{
qualifiedName
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Schema))
.Append(".");
}
qualifiedName.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name));
Rename(qualifiedName.ToString(), SqlGenerationHelper.DelimitIdentifier(operation.NewName), "TABLE", builder);
name = operation.NewName;
}
if (operation.NewSchema != null)
{
Transfer(operation.NewSchema, operation.Schema, name, "TABLE", builder);
}
EndStatement(builder);
}
protected override void IndexTraits(MigrationOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var clustered = operation[SqlServerFullAnnotationNames.Instance.Clustered] as bool?;
if (clustered.HasValue)
{
builder.Append(clustered.Value ? "CLUSTERED " : "NONCLUSTERED ");
}
}
protected override void Generate(EnsureSchemaOperation operation, IModel model, MigrationCommandListBuilder builder)
{
}
protected override void ColumnDefinition(
string schema,
string table,
string name,
Type clrType,
string type,
bool? unicode,
int? maxLength,
bool rowVersion,
bool nullable,
object defaultValue,
string defaultValueSql,
string computedColumnSql,
IAnnotatable annotatable,
IModel model,
MigrationCommandListBuilder builder)
{
base.ColumnDefinition(
schema, table, name, clrType, type, unicode, maxLength, rowVersion, nullable,
defaultValue, defaultValueSql, computedColumnSql, annotatable, model, builder);
var inlinePk = annotatable[SqliteFullAnnotationNames.Instance.InlinePrimaryKey] as bool?;
if (inlinePk == true)
{
var inlinePkName = annotatable[
SqliteFullAnnotationNames.Instance.InlinePrimaryKeyName] as string;
if (!string.IsNullOrEmpty(inlinePkName))
{
builder
.Append(" CONSTRAINT ")
.Append(SqlGenerationHelper.DelimitIdentifier(inlinePkName));
}
builder.Append(" PRIMARY KEY");
var autoincrement = annotatable[SqliteFullAnnotationNames.Instance.Autoincrement] as bool?;
if (autoincrement == true)
{
builder.Append(" AUTOINCREMENT");
}
}
}
protected override void Generate(AlterColumnOperation operation, IModel model, MigrationCommandListBuilder builder)
{
}
protected override void Generate(EnsureSchemaOperation operation, IModel model, MigrationCommandListBuilder builder)
{
throw new NotSupportedException(SqliteStrings.SchemasNotSupported);
}
protected override void Generate(RenameSequenceOperation operation, IModel model, MigrationCommandListBuilder builder)
{
throw new NotSupportedException("MyCat doesn't support sequence operation.");
}
protected override void Generate(AlterColumnOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var type = operation.ColumnType;
if (operation.ColumnType == null)
{
var property = FindProperty(model, operation.Schema, operation.Table, operation.Name);
type = property != null
? Dependencies.TypeMapper.GetMapping(property).StoreType
: Dependencies.TypeMapper.GetMapping(operation.ClrType).StoreType;
}
var identifier = Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema);
var alterBase = $"ALTER TABLE {identifier} MODIFY COLUMN {Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name)}";
// TYPE
builder.Append(alterBase)
.Append(" ")
.Append(type)
.Append(operation.IsNullable ? " NULL" : " NOT NULL")
.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
switch (type)
{
case "tinyblob":
case "blob":
case "mediumblob":
case "longblob":
case "tinytext":
case "text":
case "mediumtext":
case "longtext":
case "geometry":
case "point":
case "linestring":
case "polygon":
case "multipoint":
case "multilinestring":
case "multipolygon":
case "geometrycollection":
case "json":
if (operation.DefaultValue != null || !string.IsNullOrWhiteSpace(operation.DefaultValueSql))
{
throw new NotSupportedException($"{type} column can't have a default value");
}
break;
default:
alterBase = $"ALTER TABLE {identifier} ALTER COLUMN {Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name)}";
builder.Append(alterBase);
if (operation.DefaultValue != null)
{
var typeMapping = Dependencies.TypeMapper.GetMapping(operation.DefaultValue.GetType());
builder.Append(" SET DEFAULT ")
.Append(typeMapping.GenerateSqlLiteral(operation.DefaultValue))
.AppendLine(Dependencies.SqlGenerationHelper.BatchTerminator);
}
else if (!string.IsNullOrWhiteSpace(operation.DefaultValueSql))
{
builder.Append(" SET DEFAULT ")
.Append(operation.DefaultValueSql)
.AppendLine(Dependencies.SqlGenerationHelper.BatchTerminator);
}
else
{
builder.Append(" DROP DEFAULT;");
}
break;
}
EndStatement(builder);
}
protected override void Generate(EnsureSchemaOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.AppendLine($"CREATE OR REPLACE FUNCTION MyCat_ef_ensure_schema() RETURNS VOID")
.AppendLine($"BEGIN")
.AppendLine($" IF NOT EXISTS(SELECT 1 FROM `information_schema`.`SCHEMATA` where `SCHEMA_NAME` = '{ operation.Name }')")
.AppendLine($" THEN")
.AppendLine($" CREATE SCHEMA { operation.Name };")
.AppendLine($" END IF;")
.AppendLine($"END")
.AppendLine(SqlGenerationHelper.BatchTerminator);
}
protected override void Generate(EnsureSchemaOperation operation, [CanBeNull] IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
// PostgreSQL 9.2 and below unfortunately doesn't have CREATE SCHEMA IF NOT EXISTS.
// An attempted workaround by creating a function which checks and creates the schema, and then invoking it, failed because
// of #641 (pg_temp doesn't exist yet).
// So the only workaround for pre-9.3 PostgreSQL, at least for now, is to define all tables in the public schema.
// TODO: Since Npgsql 3.1 we can now ensure schema with a function in pg_temp
// NOTE: Technically the public schema can be dropped so we should also be ensuring it, but this is a rare case and
// we want to allow pre-9.3
if (operation.Name == "public")
{
return;
}
builder
.Append("CREATE SCHEMA IF NOT EXISTS ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name))
.AppendLine(SqlGenerationHelper.StatementTerminator);
EndStatement(builder);
}
protected override void Generate(RenameSequenceOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var separate = false;
var name = operation.Name;
if (operation.NewName != null)
{
var qualifiedName = new StringBuilder();
if (operation.Schema != null)
{
qualifiedName
.Append(operation.Schema)
.Append(".");
}
qualifiedName.Append(operation.Name);
Rename(qualifiedName.ToString(), operation.NewName, builder);
separate = true;
name = operation.NewName;
}
if (operation.NewSchema != null)
{
if (separate)
{
builder.AppendLine(SqlGenerationHelper.StatementTerminator);
}
Transfer(operation.NewSchema, operation.Schema, name, builder);
}
EndStatement(builder);
}
protected override void Generate(RenameIndexOperation operation, IModel model, MigrationCommandListBuilder builder)
{
}
public virtual void Generate(NpgsqlCreateDatabaseOperation operation, [CanBeNull] IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append("CREATE DATABASE ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name));
if (operation.Template != null)
{
builder
.Append(" TEMPLATE ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Template));
}
builder.AppendLine(SqlGenerationHelper.StatementTerminator);
EndStatement(builder, suppressTransaction: true);
}
protected override void Generate(RenameIndexOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
if (operation.NewName != null)
{
Rename(operation.Schema, operation.Name, operation.NewName, "INDEX", builder);
}
}
public virtual void Generate(NpgsqlDropDatabaseOperation operation, [CanBeNull] IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var dbName = SqlGenerationHelper.DelimitIdentifier(operation.Name);
builder
// TODO: The following revokes connection only for the public role, what about other connecting roles?
.Append("REVOKE CONNECT ON DATABASE ")
.Append(dbName)
.Append(" FROM PUBLIC")
.AppendLine(SqlGenerationHelper.StatementTerminator)
// TODO: For PG <= 9.1, the column name is prodpic, not pid (see http://stackoverflow.com/questions/5408156/how-to-drop-a-postgresql-database-if-there-are-active-connections-to-it)
.Append(
"SELECT pg_terminate_backend(pg_stat_activity.pid) FROM pg_stat_activity WHERE datname = '")
.Append(operation.Name)
.Append("'")
.AppendLine(SqlGenerationHelper.StatementTerminator)
.EndCommand(suppressTransaction: true)
.Append("DROP DATABASE ")
.Append(dbName)
.AppendLine(SqlGenerationHelper.StatementTerminator);
EndStatement(builder, suppressTransaction: true);
}
protected override void Generate(RenameTableOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var separate = false;
var name = operation.Name;
if (operation.NewName != null)
{
Rename(operation.Schema, operation.Name, operation.NewName, "TABLE", builder);
separate = true;
name = operation.NewName;
}
if (operation.NewSchema != null)
{
if (separate)
{
builder.AppendLine(SqlGenerationHelper.BatchTerminator);
}
Transfer(operation.NewSchema, operation.Schema, name, "TABLE", builder);
}
}
protected override void Generate(MigrationOperation operation, [CanBeNull] IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var createDatabaseOperation = operation as NpgsqlCreateDatabaseOperation;
if (createDatabaseOperation != null)
{
Generate(createDatabaseOperation, model, builder);
return;
}
var dropDatabaseOperation = operation as NpgsqlDropDatabaseOperation;
if (dropDatabaseOperation != null)
{
Generate(dropDatabaseOperation, model, builder);
return;
}
base.Generate(operation, model, builder);
}
public virtual void Generate(MyCatCreateDatabaseOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append("CREATE SCHEMA ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name))
.AppendLine(SqlGenerationHelper.BatchTerminator);
}
protected override void Generate(DropIndexOperation operation, [CanBeNull] IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append("DROP INDEX ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name, operation.Schema))
.AppendLine(SqlGenerationHelper.StatementTerminator);
EndStatement(builder);
}
protected override void DefaultValue(object defaultValue, string defaultValueSql, MigrationCommandListBuilder builder)
{
Check.NotNull(builder, nameof(builder));
if (defaultValueSql != null)
{
builder
.Append(" DEFAULT ")
.Append(defaultValueSql);
}
else if (defaultValue != null)
{
builder
.Append(" DEFAULT ")
.Append(SqlGenerationHelper.GenerateLiteral(defaultValue));
}
}
protected override void ColumnDefinition(
[CanBeNull] string schema,
[NotNull] string table,
[NotNull] string name,
[NotNull] Type clrType,
[CanBeNull] string type,
[CanBeNull] bool?unicode,
[CanBeNull] int?maxLength,
bool rowVersion,
bool nullable,
[CanBeNull] object defaultValue,
[CanBeNull] string defaultValueSql,
[CanBeNull] string computedColumnSql,
[NotNull] IAnnotatable annotatable,
[CanBeNull] IModel model,
[NotNull] MigrationCommandListBuilder builder)
{
Check.NotEmpty(name, nameof(name));
Check.NotNull(annotatable, nameof(annotatable));
Check.NotNull(clrType, nameof(clrType));
Check.NotNull(builder, nameof(builder));
if (type == null)
{
type = GetColumnType(schema, table, name, clrType, unicode, maxLength, rowVersion, model);
}
CheckForOldAnnotation(annotatable);
var valueGenerationStrategy = annotatable[NpgsqlFullAnnotationNames.Instance.ValueGenerationStrategy] as NpgsqlValueGenerationStrategy?;
if (valueGenerationStrategy == NpgsqlValueGenerationStrategy.SerialColumn)
{
switch (type)
{
case "int":
case "int4":
type = "serial";
break;
case "bigint":
case "int8":
type = "bigserial";
break;
case "smallint":
case "int2":
type = "smallserial";
break;
}
}
base.ColumnDefinition(
schema,
table,
name,
clrType,
type,
unicode,
maxLength,
rowVersion,
nullable,
defaultValue,
defaultValueSql,
computedColumnSql,
annotatable,
model,
builder);
}
protected override void Generate(DropColumnOperation operation, IModel model, MigrationCommandListBuilder builder)
{
var identifier = SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema);
var alterBase = $"ALTER TABLE {identifier} DROP COLUMN {SqlGenerationHelper.DelimitIdentifier(operation.Name)}";
builder.Append(alterBase).Append(SqlGenerationHelper.StatementTerminator);
}
protected override void ForeignKeyAction(ReferentialAction referentialAction, MigrationCommandListBuilder builder)
{
Check.NotNull(builder, nameof(builder));
if (referentialAction == ReferentialAction.Restrict)
{
builder.Append("NO ACTION");
}
else
{
base.ForeignKeyAction(referentialAction, builder);
}
}
protected override void Generate(
RenameTableOperation operation,
IModel model,
MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var name = operation.Name;
if (operation.NewName != null)
{
var qualifiedName = new StringBuilder();
if (operation.Schema != null)
{
qualifiedName
.Append(operation.Schema)
.Append(".");
}
qualifiedName.Append(operation.Name);
Rename(qualifiedName.ToString(), operation.NewName, builder);
name = operation.NewName;
}
if (operation.NewSchema != null)
{
Transfer(operation.NewSchema, operation.Schema, name, builder);
}
EndStatement(builder);
}
protected override void Generate(DropColumnOperation operation, IModel model, MigrationCommandListBuilder builder)
{
var identifier = Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema);
var alterBase = $"ALTER TABLE {identifier} DROP COLUMN {Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name)}";
builder.Append(alterBase).Append(Dependencies.SqlGenerationHelper.StatementTerminator);
EndStatement(builder);
}