public static RenameColumnExpression ToLower(this RenameColumnExpression expresstion)
{
expresstion.TableName = expresstion.TableName.ToLower();
expresstion.NewName = expresstion.NewName.ToLower();
expresstion.OldName = expresstion.OldName.ToLower();
return(expresstion);
}
public override void Process(RenameColumnExpression expression)
{
var columnDefinitionSql = string.Format(@"
SELECT CONCAT(
CAST(COLUMN_TYPE AS CHAR),
IF(ISNULL(CHARACTER_SET_NAME),
'',
CONCAT(' CHARACTER SET ', CHARACTER_SET_NAME)),
IF(ISNULL(COLLATION_NAME),
'',
CONCAT(' COLLATE ', COLLATION_NAME)),
' ',
IF(IS_NULLABLE = 'NO', 'NOT NULL ', ''),
IF(IS_NULLABLE = 'NO' AND COLUMN_DEFAULT IS NULL,
'',
CONCAT('DEFAULT ', IF(COLUMN_DEFAULT = 'NULL', 'NULL', QUOTE(COLUMN_DEFAULT)), ' ')),
IF(COLUMN_COMMENT = '', '', CONCAT('COMMENT ', QUOTE(COLUMN_COMMENT), ' ')),
UPPER(extra))
FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_NAME = '{0}' AND COLUMN_NAME = '{1}'", FormatHelper.FormatSqlEscape(expression.TableName), FormatHelper.FormatSqlEscape(expression.OldName));
var fieldValue = Read(columnDefinitionSql).Tables[0].Rows[0][0];
var columnDefinition = fieldValue as string;
Process(Generator.Generate(expression) + columnDefinition);
}
public void ToStringIsDescriptive()
{
var expression = new RenameColumnExpression {
TableName = "Bacon", OldName = "BaconId", NewName = "ChunkyBaconId"
};
expression.ToString().ShouldBe("RenameColumn Bacon BaconId to ChunkyBaconId");
}
public override string Generate(RenameColumnExpression expression)
{
return(string.Format(RenameColumn,
Quoter.QuoteTableName(expression.TableName, expression.SchemaName),
Quoter.QuoteColumnName(expression.OldName),
Quoter.QuoteColumnName(expression.NewName)
));
}
public override string Generate(RenameColumnExpression expression)
{
return(string.Format(
"ALTER TABLE {0} RENAME COLUMN {1} TO {2};",
Quoter.QuoteTableName(expression.TableName, expression.SchemaName),
Quoter.QuoteColumnName(expression.OldName),
Quoter.QuoteColumnName(expression.NewName)));
}
public override string Generate(RenameColumnExpression expression)
{
var tableName = Quoter.QuoteTableName(expression.TableName, expression.SchemaName);
var columnName = Quoter.QuoteColumnName(expression.OldName);
var sourceParam = Quoter.QuoteValue($"{tableName}.{columnName}");
var destinationParam = Quoter.QuoteValue(expression.NewName);
return(string.Format(RenameColumn, sourceParam, destinationParam));
}
public override string Generate(RenameColumnExpression expression)
{
// may need to add definition to end. blerg
//return String.Format("ALTER TABLE `{0}` CHANGE COLUMN {1} {2}", expression.TableName, expression.OldName, expression.NewName);
// NOTE: The above does not work, as the CHANGE COLUMN syntax in Mysql requires the column definition to be re-specified,
// even if it has not changed; so marking this as not working for now
return(compatabilityMode.HandleCompatabilty("Renaming of columns is not supporteed for MySql"));
}
public void ReverseReturnsRenameColumnExpression()
{
var expression = new RenameColumnExpression {
TableName = "Bacon", OldName = "BaconId", NewName = "ChunkyBaconId"
};
var reverse = expression.Reverse();
reverse.ShouldBeOfType <RenameColumnExpression>();
}
public void ErrorIsNotReturnedWhenNewNameIsNotNullOrEmptyString()
{
var expression = new RenameColumnExpression {
NewName = "Bacon"
};
var errors = ValidationHelper.CollectErrors(expression);
errors.ShouldNotContain(ErrorMessages.NewColumnNameCannotBeNullOrEmpty);
}
public IRenameColumnTableSyntax Column(string oldName)
{
var expression = new RenameColumnExpression {
OldName = oldName
};
_context.Expressions.Add(expression);
return(new RenameColumnExpressionBuilder(expression));
}
public override string Generate(RenameColumnExpression expression)
{
return(String.Format(RenameColumn,
Quoter.QuoteTableName(expression.TableName),
Quoter.QuoteColumnName(expression.OldName),
Quoter.QuoteColumnName(expression.NewName),
CommandDelimiter
));
}
/// <inheritdoc />
public IRenameColumnBuilder Column(string oldName)
{
var expression = new RenameColumnExpression(_context)
{
OldName = oldName
};
return(new RenameColumnBuilder(expression));
}
public void ErrorIsReturnedWhenOldNameIsEmptyString()
{
var expression = new RenameColumnExpression {
OldName = String.Empty
};
var errors = ValidationHelper.CollectErrors(expression);
errors.ShouldContain(ErrorMessages.OldColumnNameCannotBeNullOrEmpty);
}
public override void Process(RenameColumnExpression expression)
{
Truncator.Truncate(expression);
CheckColumn(expression.TableName, expression.OldName);
CheckColumn(expression.TableName, expression.NewName);
LockColumn(expression.TableName, expression.OldName);
LockColumn(expression.TableName, expression.NewName);
InternalProcess(Generator.Generate(expression));
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsSetThenSchemaShouldNotBeChanged()
{
var expression = new RenameColumnExpression {
SchemaName = "testschema", TableName = "Bacon", OldName = "BaconId", NewName = "ChunkyBaconId"
};
expression.ApplyConventions(new MigrationConventions());
Assert.That(expression.SchemaName, Is.EqualTo("testschema"));
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsNotSetThenSchemaShouldBeNull()
{
var expression = new RenameColumnExpression {
TableName = "Bacon", OldName = "BaconId", NewName = "ChunkyBaconId"
};
expression.ApplyConventions(new MigrationConventions());
Assert.That(expression.SchemaName, Is.Null);
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var expression = new RenameColumnExpression {
TableName = "Bacon", OldName = "BaconId", NewName = "ChunkyBaconId"
};
var processed = expression.Apply(ConventionSets.WithSchemaName);
Assert.That(processed.SchemaName, Is.EqualTo("testdefault"));
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsNotSetThenSchemaShouldBeNull()
{
var expression = new RenameColumnExpression {
TableName = "Bacon", OldName = "BaconId", NewName = "ChunkyBaconId"
};
var processed = expression.Apply(ConventionSets.NoSchemaName);
Assert.That(processed.SchemaName, Is.Null);
}
public IRenameColumnTableSyntax Column(string oldName)
{
var expression = new RenameColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax)
{
OldName = oldName
};
_context.Expressions.Add(expression);
return(new RenameColumnBuilder(expression));
}
public void ReverseSetsTableNameOldNameAndNewNameOnGeneratedExpression()
{
var expression = new RenameColumnExpression {
TableName = "Bacon", OldName = "BaconId", NewName = "ChunkyBaconId"
};
var reverse = expression.Reverse() as RenameColumnExpression;
reverse.TableName.ShouldBe("Bacon");
reverse.OldName.ShouldBe("ChunkyBaconId");
reverse.NewName.ShouldBe("BaconId");
}
public void CanRenameColumn()
{
var expression = new RenameColumnExpression();
expression.TableName = "Table1";
expression.OldName = "Column1";
expression.NewName = "Column2";
string sql = generator.Generate(expression);
sql.ShouldBe("ALTER TABLE \"public\".\"Table1\" RENAME COLUMN \"Column1\" TO \"Column2\"");
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var expression = new RenameColumnExpression {
TableName = "Bacon", OldName = "BaconId", NewName = "ChunkyBaconId"
};
var migrationConventions = new MigrationConventions {
GetDefaultSchema = () => "testdefault"
};
expression.ApplyConventions(migrationConventions);
Assert.That(expression.SchemaName, Is.EqualTo("testdefault"));
}
public override string Generate(RenameColumnExpression expression)
{
if (CompatibilityMode == CompatibilityMode.STRICT)
{
return(CompatibilityMode.HandleCompatibilty("SQLite does not support renaming of columns"));
}
return(string.Format(
RenameColumn,
Quoter.QuoteTableName(expression.TableName, expression.SchemaName),
Quoter.QuoteColumnName(expression.OldName),
Quoter.QuoteColumnName(expression.NewName)
));
}
public override void Process(RenameColumnExpression expression)
{
var tableDefinition = GetTableSchema(expression.TableName);
var oldColumnDefinitions = tableDefinition.Columns.ToList();
var columnDefinitions = tableDefinition.Columns.ToList();
var columnIndex = columnDefinitions.FindIndex(c => c.Name == expression.OldName);
if (columnIndex == -1)
{
throw new ApplicationException(string.Format("Column {0} does not exist on table {1}.", expression.OldName, expression.TableName));
}
if (columnDefinitions.Any(c => c.Name == expression.NewName))
{
throw new ApplicationException(string.Format("Column {0} already exists on table {1}.", expression.NewName, expression.TableName));
}
oldColumnDefinitions[columnIndex] = (ColumnDefinition)columnDefinitions[columnIndex].Clone();
columnDefinitions[columnIndex].Name = expression.NewName;
foreach (var index in tableDefinition.Indexes)
{
if (index.Name.StartsWith("IX_"))
{
index.Name = Regex.Replace(index.Name, "(?<=_)" + Regex.Escape(expression.OldName) + "(?=_|$)", Regex.Escape(expression.NewName));
}
foreach (var column in index.Columns)
{
if (column.Name == expression.OldName)
{
column.Name = expression.NewName;
}
}
}
ProcessAlterTable(tableDefinition, oldColumnDefinitions);
}
public override string Generate(RenameColumnExpression expression)
{
Truncator.Truncate(expression);
return(base.Generate(expression));
}
public virtual void Process(RenameColumnExpression expression)
{
Process(Generator.Generate(expression));
}
public override string Generate(RenameColumnExpression expression)
{
throw new DatabaseOperationNotSupportedException();
}
public override string Generate(RenameColumnExpression expression)
{
return(string.Format("sp_rename '{0}.{1}", Quoter.QuoteSchemaName(expression.SchemaName), base.Generate(expression)));
}
public override string Generate(RenameColumnExpression expression)
{
return(CompatibilityMode.HandleCompatibilty("SQLite does not support renaming of columns"));
}
public abstract string Generate(RenameColumnExpression expression);
public override string Generate(RenameColumnExpression expression)
{
return string.Format("ALTER TABLE {0} CHANGE {1} {2} ", Quoter.QuoteTableName(expression.TableName), Quoter.QuoteColumnName(expression.OldName), Quoter.QuoteColumnName(expression.NewName));
}
