public DropIndexOperation(SchemaQualifiedName tableName, [NotNull] string indexName)
{
Check.NotNull(indexName, "indexName");
_tableName = tableName;
_indexName = indexName;
}
public AddColumnOperation(SchemaQualifiedName tableName, [NotNull] Column column)
{
Check.NotNull(column, "column");
_tableName = tableName;
_column = column;
}
public AddColumnOperation(SchemaQualifiedName tableName, [NotNull] Column column)
{
Check.NotNull(column, "column");
_tableName = tableName;
_column = column;
}
private void HandleTransitiveRenames()
{
const string temporaryNamePrefix = "__mig_tmp__";
var temporaryNameIndex = 0;
_operations.Set(
HandleTransitiveRenames(
_operations.Get <RenameTableOperation>(),
getParentName: op => null,
getName: op => op.TableName,
getNewName: op => new SchemaQualifiedName(op.NewTableName, op.TableName.Schema),
generateTempName: (op) => new SchemaQualifiedName(temporaryNamePrefix + temporaryNameIndex++, op.TableName.Schema),
createRenameOperation: (parentName, name, newName)
=> new RenameTableOperation(name, SchemaQualifiedName.Parse(newName).Name)));
_operations.Set(
HandleTransitiveRenames(
_operations.Get <RenameColumnOperation>(),
getParentName: op => op.TableName,
getName: op => op.ColumnName,
getNewName: op => op.NewColumnName,
generateTempName: (op) => temporaryNamePrefix + temporaryNameIndex++,
createRenameOperation: (parentName, name, newName)
=> new RenameColumnOperation(parentName, name, newName)));
_operations.Set(
HandleTransitiveRenames(
_operations.Get <RenameIndexOperation>(),
getParentName: op => op.TableName,
getName: op => op.IndexName,
getNewName: op => op.NewIndexName,
generateTempName: (op) => temporaryNamePrefix + temporaryNameIndex++,
createRenameOperation: (parentName, name, newName)
=> new RenameIndexOperation(parentName, name, newName)));
}
public AlterSequenceOperation(SchemaQualifiedName sequenceName, int newIncrementBy)
{
Check.NotNull(newIncrementBy, "newIncrementBy");
_sequenceName = sequenceName;
_newIncrementBy = newIncrementBy;
}
public DropForeignKeyOperation(SchemaQualifiedName tableName, [NotNull] string foreignKeyName)
{
Check.NotEmpty(foreignKeyName, "foreignKeyName");
_tableName = tableName;
_foreignKeyName = foreignKeyName;
}
public DropColumnOperation(SchemaQualifiedName tableName, [NotNull] string columnName)
{
Check.NotEmpty(columnName, "columnName");
_tableName = tableName;
_columnName = columnName;
}
public DropPrimaryKeyOperation(SchemaQualifiedName tableName, [NotNull] string primaryKeyName)
{
Check.NotEmpty(primaryKeyName, "primaryKeyName");
_tableName = tableName;
_primaryKeyName = primaryKeyName;
}
public DropUniqueConstraintOperation(SchemaQualifiedName tableName, [NotNull] string uniqueConstraintName)
{
Check.NotEmpty(uniqueConstraintName, "uniqueConstraintName");
_tableName = tableName;
_uniqueConstraintName = uniqueConstraintName;
}
public RenameTableOperation(SchemaQualifiedName tableName, [NotNull] string newTableName)
{
Check.NotEmpty(newTableName, "newTableName");
_tableName = tableName;
_newTableName = newTableName;
}
public DropForeignKeyOperation(SchemaQualifiedName tableName, [NotNull] string foreignKeyName)
{
Check.NotEmpty(foreignKeyName, "foreignKeyName");
_tableName = tableName;
_foreignKeyName = foreignKeyName;
}
protected virtual void GenerateColumn(
SchemaQualifiedName tableName, [NotNull] Column column, [NotNull] IndentedStringBuilder stringBuilder)
{
Check.NotNull(column, "column");
Check.NotNull(stringBuilder, "stringBuilder");
stringBuilder
.Append(DelimitIdentifier(column.Name))
.Append(" ");
stringBuilder.Append(column.DataType ?? GenerateDataType(tableName, column));
if (!column.IsNullable)
{
stringBuilder.Append(" NOT NULL");
}
GenerateColumnTraits(column, stringBuilder);
if (column.DefaultSql != null)
{
stringBuilder
.Append(" DEFAULT ")
.Append(column.DefaultSql);
}
else if (column.DefaultValue != null)
{
stringBuilder
.Append(" DEFAULT ")
.Append(GenerateLiteral(column.DefaultValue));
}
}
public void Parse_parses_name_with_escaped_delimeters()
{
var schemaQualifiedName = SchemaQualifiedName.Parse("[a.]].]]].[.b.[c]]d]");
Assert.Equal("a.].]", schemaQualifiedName.Schema);
Assert.Equal(".b.[c]d", schemaQualifiedName.Name);
}
public RenameSequenceOperation(SchemaQualifiedName sequenceName, [NotNull] string newSequenceName)
{
Check.NotEmpty(newSequenceName, "newSequenceName");
_sequenceName = sequenceName;
_newSequenceName = newSequenceName;
}
public MoveSequenceOperation(SchemaQualifiedName sequenceName, [NotNull] string newSchema)
{
Check.NotEmpty(newSchema, "newSchema");
_sequenceName = sequenceName;
_newSchema = newSchema;
}
public MoveTableOperation(SchemaQualifiedName tableName, [NotNull] string newSchema)
{
Check.NotEmpty(newSchema, "newSchema");
_tableName = tableName;
_newSchema = newSchema;
}
public void Equals_returns_false_when_names_equal_and_schemas_not_equal()
{
var schemaQualifiedName1 = new SchemaQualifiedName("T", "S1");
var schemaQualifiedName2 = new SchemaQualifiedName("T", "S2");
Assert.NotEqual(schemaQualifiedName1, schemaQualifiedName2);
}
public DropPrimaryKeyOperation(SchemaQualifiedName tableName, [NotNull] string primaryKeyName)
{
Check.NotEmpty(primaryKeyName, "primaryKeyName");
_tableName = tableName;
_primaryKeyName = primaryKeyName;
}
public MoveTableOperation(SchemaQualifiedName tableName, [NotNull] string newSchema)
{
Check.NotEmpty(newSchema, "newSchema");
_tableName = tableName;
_newSchema = newSchema;
}
public void Parse_parses_table_name()
{
var schemaQualifiedName = SchemaQualifiedName.Parse("A");
Assert.Equal(null, schemaQualifiedName.Schema);
Assert.Equal("A", schemaQualifiedName.Name);
}
public virtual TableOperationHandler EnsureHandler(SchemaQualifiedName tableName, bool supported)
{
var handler = GetHandler(tableName);
if (handler == null)
{
var table = _generator.Database.TryGetTable(tableName);
var columnNames = table != null?table.Columns.Select(c => c.Name) : Enumerable.Empty <string>();
SetHandler(handler
= supported
? (TableOperationHandler) new AlterTableHandler(tableName, columnNames)
: new RebuildTableHandler(tableName, columnNames));
}
else if (!supported)
{
var alterTableHandler = handler as AlterTableHandler;
if (alterTableHandler != null)
{
SetHandler(handler = new RebuildTableHandler(alterTableHandler));
}
}
return(handler);
}
public DropColumnOperation(SchemaQualifiedName tableName, [NotNull] string columnName)
{
Check.NotEmpty(columnName, "columnName");
_tableName = tableName;
_columnName = columnName;
}
public override IEnumerable <MigrationOperation> HandleOperations(Context context)
{
Check.NotNull(context, "context");
context.Generator.DatabaseModelModifier.Modify(context.Database, Operations);
var targetTable = context.Database.GetTable(TableName);
var sourceTableName = InitialTableName;
var targetColumnNames
= targetTable.Columns
.Where(c => ColumnNamePairs.ContainsKey(c.Name))
.Select(c => c.Name)
.ToArray();
var sourceColumnNames
= targetColumnNames
.Select(n => ColumnNamePairs[n])
.ToArray();
if (sourceTableName == targetTable.Name)
{
sourceTableName = new SchemaQualifiedName("__mig_tmp__" + sourceTableName.Name, sourceTableName.Schema);
yield return(new RenameTableOperation(targetTable.Name, sourceTableName.Name));
}
yield return(new CreateTableOperation(targetTable));
yield return(new CopyDataOperation(
sourceTableName, sourceColumnNames, targetTable.Name, targetColumnNames));
context.AddDeferredOperation(new DropTableOperation(sourceTableName));
}
public void Equals_returns_false_when_names_equal_and_schemas_not_equal()
{
var schemaQualifiedName1 = new SchemaQualifiedName("T", "S1");
var schemaQualifiedName2 = new SchemaQualifiedName("T", "S2");
Assert.NotEqual(schemaQualifiedName1, schemaQualifiedName2);
}
public void Equals_returns_true_when_names_equal_and_no_schema_specified()
{
var schemaQualifiedName1 = new SchemaQualifiedName("T");
var schemaQualifiedName2 = new SchemaQualifiedName("T");
Assert.Equal(schemaQualifiedName1, schemaQualifiedName2);
}
public DropIndexOperation(SchemaQualifiedName tableName, [NotNull] string indexName)
{
Check.NotNull(indexName, "indexName");
_tableName = tableName;
_indexName = indexName;
}
public void Equals_returns_true_when_names_equal_and_no_schema_specified()
{
var schemaQualifiedName1 = new SchemaQualifiedName("T");
var schemaQualifiedName2 = new SchemaQualifiedName("T");
Assert.Equal(schemaQualifiedName1, schemaQualifiedName2);
}
public RenameTableOperation(SchemaQualifiedName tableName, [NotNull] string newTableName)
{
Check.NotEmpty(tableName, "tableName");
_tableName = tableName;
_newTableName = newTableName;
}
public override void AppendUpdateOperation(
StringBuilder commandStringBuilder,
SchemaQualifiedName schemaQualifiedName,
IReadOnlyList <ColumnModification> operations)
{
Check.NotNull(commandStringBuilder, "commandStringBuilder");
Check.NotNull(operations, "operations");
var writeOperations = operations.Where(o => o.IsWrite).ToArray();
var conditionOperations = operations.Where(o => o.IsCondition).ToArray();
var readOperations = operations.Where(o => o.IsRead).ToArray();
AppendUpdateCommandHeader(commandStringBuilder, schemaQualifiedName, writeOperations);
if (readOperations.Length > 0)
{
AppendOutputClause(commandStringBuilder, readOperations);
}
AppendWhereClause(commandStringBuilder, conditionOperations);
commandStringBuilder.Append(BatchCommandSeparator).AppendLine();
if (readOperations.Length == 0)
{
AppendSelectAffectedCountCommand(commandStringBuilder, schemaQualifiedName);
}
}
protected virtual void GenerateColumn(
SchemaQualifiedName tableName, [NotNull] Column column, [NotNull] SqlBatchBuilder batchBuilder)
{
Check.NotNull(column, "column");
Check.NotNull(batchBuilder, "batchBuilder");
if (column.IsComputed && column.DefaultSql != null)
{
GenerateComputedColumn(tableName, column, batchBuilder);
return;
}
batchBuilder
.Append(DelimitIdentifier(column.Name))
.Append(" ");
GenerateColumnType(tableName, column, batchBuilder);
GenerateNullConstraint(tableName, column, batchBuilder);
GenerateColumnTraits(tableName, column, batchBuilder);
GenerateDefaultConstraint(tableName, column, batchBuilder);
}
public void Parse_parses_schema_dot_table_name()
{
var schemaQualifiedName = SchemaQualifiedName.Parse("S.A");
Assert.Equal("S", schemaQualifiedName.Schema);
Assert.Equal("A", schemaQualifiedName.Name);
Assert.True(schemaQualifiedName.IsSchemaQualified);
}
protected TableOperationHandler(SchemaQualifiedName tableName, [NotNull] IEnumerable <string> columnNames)
{
Check.NotNull(columnNames, "columnNames");
TableName = _initialTableName = tableName;
_operations = new List <MigrationOperation>();
_columnNamePairs = columnNames.ToDictionary(n => n);
}
public override string DelimitIdentifier(SchemaQualifiedName schemaQualifiedName)
{
return(DelimitIdentifier(
(schemaQualifiedName.IsSchemaQualified
? schemaQualifiedName.Schema + "."
: string.Empty)
+ schemaQualifiedName.Name));
}
public ModificationCommand(SchemaQualifiedName schemaQualifiedName, [NotNull] ParameterNameGenerator parameterNameGenerator)
{
Check.NotEmpty(schemaQualifiedName, "schemaQualifiedName");
Check.NotNull(parameterNameGenerator, "parameterNameGenerator");
_schemaQualifiedName = schemaQualifiedName;
_parameterNameGenerator = parameterNameGenerator;
}
public virtual void AddUniqueConstraint(SchemaQualifiedName tableName, [NotNull] string uniqueConstraintName,
[NotNull] IReadOnlyList <string> columnNames)
{
Check.NotEmpty(uniqueConstraintName, "uniqueConstraintName");
Check.NotNull(columnNames, "columnNames");
AddOperation(new AddUniqueConstraintOperation(tableName, uniqueConstraintName, columnNames));
}
public virtual void RenameIndex(SchemaQualifiedName tableName, [NotNull] string indexName,
[NotNull] string newIndexName)
{
Check.NotEmpty(indexName, "indexName");
Check.NotEmpty(newIndexName, "newIndexName");
AddOperation(new RenameIndexOperation(tableName, indexName, newIndexName));
}
public virtual string DelimitIdentifier(SchemaQualifiedName schemaQualifiedName)
{
return
((schemaQualifiedName.IsSchemaQualified
? DelimitIdentifier(schemaQualifiedName.Schema) + "."
: string.Empty)
+ DelimitIdentifier(schemaQualifiedName.Name));
}
public virtual void CreateIndex(SchemaQualifiedName tableName, [NotNull] string indexName,
[NotNull] IReadOnlyList <string> columnNames, bool isUnique, bool isClustered)
{
Check.NotEmpty(indexName, "indexName");
Check.NotNull(columnNames, "columnNames");
AddOperation(new CreateIndexOperation(tableName, indexName, columnNames, isUnique, isClustered));
}
public AddUniqueConstraintOperation([NotNull] UniqueConstraint uniqueConstraint)
{
Check.NotNull(uniqueConstraint, "uniqueConstraint");
_tableName = uniqueConstraint.Table.Name;
_uniqueConstraintName = uniqueConstraint.Name;
_columnNames = uniqueConstraint.Columns.Select(c => c.Name).ToArray();
}
public RenameColumnOperation(SchemaQualifiedName tableName, [NotNull] string columnName, [NotNull] string newColumnName)
{
Check.NotEmpty(columnName, "columnName");
Check.NotEmpty(newColumnName, "newColumnName");
_tableName = tableName;
_columnName = columnName;
_newColumnName = newColumnName;
}
public Sequence(SchemaQualifiedName name, [NotNull] string dataType, int startWith, int incrementBy)
{
Check.NotEmpty(dataType, "dataType");
_name = name;
_dataType = dataType;
StartWith = startWith;
_incrementBy = incrementBy;
}
public Table(SchemaQualifiedName name, [NotNull] IEnumerable<Column> columns)
{
Check.NotNull(columns, "columns");
_name = name;
foreach (var column in columns)
{
AddColumn(column);
}
}
public AlterColumnOperation(
SchemaQualifiedName tableName,
[NotNull] Column newColumn,
bool isDestructiveChange)
{
Check.NotNull(newColumn, "newColumn");
_tableName = tableName;
_newColumn = newColumn;
_isDestructiveChange = isDestructiveChange;
}
public RenameIndexOperation(
SchemaQualifiedName tableName,
[NotNull] string indexName,
[NotNull] string newIndexName)
{
Check.NotEmpty(indexName, "indexName");
Check.NotEmpty(newIndexName, "newIndexName");
_tableName = tableName;
_indexName = indexName;
_newIndexName = newIndexName;
}
public AddPrimaryKeyOperation(
SchemaQualifiedName tableName,
[NotNull] string primaryKeyName,
[NotNull] IReadOnlyList<string> columnNames,
bool isClustered)
{
Check.NotEmpty(primaryKeyName, "primaryKeyName");
Check.NotNull(columnNames, "columnNames");
_tableName = tableName;
_primaryKeyName = primaryKeyName;
_columnNames = columnNames;
_isClustered = isClustered;
}
public AddDefaultConstraintOperation(
SchemaQualifiedName tableName,
[NotNull] string columnName,
[CanBeNull] object defaultValue,
[CanBeNull] string defaultSql)
{
Check.NotEmpty(columnName, "columnName");
// TODO: Validate input. Either defaultValue or defaultSql must not be null, but not both.
_tableName = tableName;
_columnName = columnName;
_defaultValue = defaultValue;
_defaultSql = defaultSql;
}
public CreateIndexOperation(
SchemaQualifiedName tableName,
[NotNull] string indexName,
[NotNull] IReadOnlyList<string> columnNames,
bool isUnique,
bool isClustered)
{
Check.NotEmpty(indexName, "indexName");
Check.NotNull(columnNames, "columnNames");
_tableName = tableName;
_indexName = indexName;
_columnNames = columnNames;
_isUnique = isUnique;
_isClustered = isClustered;
}
public AddForeignKeyOperation(
SchemaQualifiedName tableName,
[NotNull] string foreignKeyName,
[NotNull] IReadOnlyList<string> columnNames,
SchemaQualifiedName referencedTableName,
[NotNull] IReadOnlyList<string> referencedColumnNames,
bool cascadeDelete)
{
Check.NotEmpty(foreignKeyName, "foreignKeyName");
Check.NotNull(columnNames, "columnNames");
Check.NotNull(referencedColumnNames, "referencedColumnNames");
_foreignKeyName = foreignKeyName;
_tableName = tableName;
_referencedTableName = referencedTableName;
_columnNames = columnNames;
_referencedColumnNames = referencedColumnNames;
_cascadeDelete = cascadeDelete;
}
public Sequence(SchemaQualifiedName name)
{
_name = name;
}
public Table(SchemaQualifiedName name)
{
_name = name;
}
public void To_string_returns_schema_and_table_name_when_schema_specified()
{
var schemaQualifiedName = new SchemaQualifiedName("T", "S");
Assert.Equal("S.T", schemaQualifiedName.ToString());
}
public DropSequenceOperation(SchemaQualifiedName sequenceName)
{
_sequenceName = sequenceName;
}
protected virtual void GenerateColumn(
SchemaQualifiedName tableName, [NotNull] Column column, [NotNull] IndentedStringBuilder stringBuilder)
{
Check.NotNull(column, "column");
Check.NotNull(stringBuilder, "stringBuilder");
stringBuilder
.Append(DelimitIdentifier(column.Name))
.Append(" ");
stringBuilder.Append(column.DataType ?? GenerateDataType(tableName, column));
if (!column.IsNullable)
{
stringBuilder.Append(" NOT NULL");
}
GenerateColumnTraits(column, stringBuilder);
if (column.DefaultSql != null)
{
stringBuilder
.Append(" DEFAULT ")
.Append(column.DefaultSql);
}
else if (column.DefaultValue != null)
{
stringBuilder
.Append(" DEFAULT ")
.Append(GenerateLiteral(column.DefaultValue));
}
}
public void DelimitIdentifier_with_schema_qualified_name_works_when_no_schema()
{
var name = new SchemaQualifiedName("Pony");
var sql = CreateGenerator().DelimitIdentifier(name);
Assert.Equal("\"Pony\"", sql);
}
public void DelimitIdentifier_with_schema_qualified_name_concatenates_parts_when_schema()
{
var name = new SchemaQualifiedName("Pony", "my");
var sql = CreateGenerator().DelimitIdentifier(name);
Assert.Equal("\"my.Pony\"", sql);
}
public virtual string GenerateDataType(SchemaQualifiedName tableName, [NotNull] Column column)
{
Check.NotNull(column, "column");
if (!string.IsNullOrEmpty(column.DataType))
{
return column.DataType;
}
var isKey = false;
if (Database != null)
{
var table = Database.GetTable(tableName);
isKey = table.PrimaryKey != null
&& table.PrimaryKey.Columns.Contains(column)
|| table.ForeignKeys.SelectMany(k => k.Columns).Contains(column);
}
return _typeMapper.GetTypeMapping(column.DataType, column.Name, column.ClrType, isKey, column.IsTimestamp).StoreTypeName;
}
protected virtual void GenerateColumns(
SchemaQualifiedName tableName, [NotNull] IReadOnlyList<Column> columns, [NotNull] IndentedStringBuilder stringBuilder)
{
Check.NotNull(columns, "columns");
Check.NotNull(stringBuilder, "stringBuilder");
if (columns.Count == 0)
{
return;
}
GenerateColumn(tableName, columns[0], stringBuilder);
for (var i = 1; i < columns.Count; i++)
{
stringBuilder.AppendLine(",");
GenerateColumn(tableName, columns[i], stringBuilder);
}
}
public override string DelimitIdentifier(SchemaQualifiedName schemaQualifiedName)
{
return DelimitIdentifier(
(schemaQualifiedName.IsSchemaQualified
? schemaQualifiedName.Schema + "."
: string.Empty)
+ schemaQualifiedName.Name);
}
public DropTableOperation(SchemaQualifiedName tableName)
{
_tableName = tableName;
}
// TODO: Consider adding a base class for all SQL generators (DDL, DML),
// to avoid duplicating the five methods below.
public virtual string DelimitIdentifier(SchemaQualifiedName schemaQualifiedName)
{
return
(schemaQualifiedName.IsSchemaQualified
? DelimitIdentifier(schemaQualifiedName.Schema) + "."
: string.Empty)
+ DelimitIdentifier(schemaQualifiedName.Name);
}
