public void ErrorIsReturnedWhenNewNameIsNull()
{
var expression = new RenameTableExpression {
NewName = null
};
var errors = ValidationHelper.CollectErrors(expression);
errors.ShouldContain(ErrorMessages.NewTableNameCannotBeNullOrEmpty);
}
public void ErrorIsNotReturnedWhenOldNameIsNotNullEmptyString()
{
var expression = new RenameTableExpression {
OldName = "Bacon"
};
var errors = ValidationHelper.CollectErrors(expression);
errors.ShouldNotContain(ErrorMessages.OldTableNameCannotBeNullOrEmpty);
}
public void ReverseSetsOldNameAndNewNameOnGeneratedExpression()
{
var expression = new RenameTableExpression {
OldName = "Bacon", NewName = "ChunkyBacon"
};
var reverse = (RenameTableExpression)expression.Reverse();
reverse.OldName.ShouldBe("ChunkyBacon");
reverse.NewName.ShouldBe("Bacon");
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsNotSetThenSchemaShouldBeNull()
{
var expression = new RenameTableExpression {
OldName = "Bacon", NewName = "ChunkyBacon"
};
var processed = expression.Apply(ConventionSets.NoSchemaName);
Assert.That(processed.SchemaName, Is.Null);
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsSetThenSchemaShouldNotBeChanged()
{
var expression = new RenameTableExpression {
SchemaName = "testschema", OldName = "Bacon", NewName = "ChunkyBacon"
};
var processed = expression.Apply(ConventionSets.WithSchemaName);
Assert.That(processed.SchemaName, Is.EqualTo("testschema"));
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsSetThenSchemaShouldNotBeChanged()
{
var expression = new RenameTableExpression {
SchemaName = "testschema", OldName = "Bacon", NewName = "ChunkyBacon"
};
expression.ApplyConventions(new MigrationConventions());
Assert.That(expression.SchemaName, Is.EqualTo("testschema"));
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsNotSetThenSchemaShouldBeNull()
{
var expression = new RenameTableExpression {
OldName = "Bacon", NewName = "ChunkyBacon"
};
expression.ApplyConventions(new MigrationConventions());
Assert.That(expression.SchemaName, Is.Null);
}
public IRenameTableSyntax Table(string oldName)
{
var expression = new RenameTableExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax)
{
OldName = oldName
};
_context.Expressions.Add(expression);
return(new RenameTableBuilder(expression));
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var expression = new RenameTableExpression {
OldName = "Bacon", NewName = "ChunkyBacon"
};
var processed = expression.Apply(ConventionSets.WithSchemaName);
Assert.That(processed.SchemaName, Is.EqualTo("testdefault"));
}
public void CanRenameTable()
{
var expression = new RenameTableExpression();
expression.OldName = "Table1";
expression.NewName = "Table2";
string sql = generator.Generate(expression);
sql.ShouldBe(String.Empty);
}
public void CanRenameTable()
{
var expression = new RenameTableExpression {
OldName = this.TestTableName1, NewName = this.TestTableName2
};
ApplyDefaultConventions(expression);
var sql = generator.Generate(expression);
sql.ShouldBe(string.Format("ALTER TABLE [{0}] RENAME TO [{1}]", this.TestTableName1, this.TestTableName2));
}
public void CanRenameTable()
{
var expression = new RenameTableExpression();
expression.OldName = "Table1";
expression.NewName = "Table2";
string sql = generator.Generate(expression);
sql.ShouldBe("ALTER TABLE \"public\".\"Table1\" RENAME TO \"Table2\"");
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var expression = new RenameTableExpression {
OldName = "Bacon", NewName = "ChunkyBacon"
};
var migrationConventions = new MigrationConventions {
GetDefaultSchema = () => "testdefault"
};
expression.ApplyConventions(migrationConventions);
Assert.That(expression.SchemaName, Is.EqualTo("testdefault"));
}
public virtual void Process(RenameTableExpression expression)
{
Process(Generator.Generate(expression));
}
public override string Generate(RenameTableExpression expression)
{
return(String.Format("sp_rename {0}, {1}", Quoter.QuoteValue(expression.OldName), Quoter.QuoteValue(expression.NewName)));
}
public override string Generate(RenameTableExpression expression)
{
return(string.Format("sp_rename '{0}.{1}", Quoter.QuoteSchemaName(expression.SchemaName), base.Generate(expression)));
}
public abstract string Generate(RenameTableExpression expression);
public override string Generate(RenameTableExpression expression)
{
return(string.Format(RenameTable, Quoter.QuoteTableName(expression.OldName, expression.SchemaName),
Quoter.Quote(expression.NewName)));
}
public override string Generate(RenameTableExpression expression)
{
return(String.Format(RenameTable, Quoter.QuoteTableName(expression.OldName), Quoter.QuoteTableName(expression.NewName), CommandDelimiter));
}
public void ToStringIsDescriptive()
{
var expression = new RenameTableExpression { OldName = "Bacon", NewName = "ChunkyBacon" };
expression.ToString().ShouldBe("RenameTable Bacon ChunkyBacon");
}
public override string Generate(RenameTableExpression expression)
{
var sql = $"ALTER TABLE {Quoter.QuoteTableName(expression.OldName, expression.SchemaName)} RENAME TO {Quoter.Quote(expression.NewName)};";
return(sql);
}
public override string Generate(RenameTableExpression expression)
{
return(string.Format("ALTER TABLE {0}.{1} RENAME TO {2}", FormatSchema(expression.SchemaName), FormatIdentifier(expression.OldName), FormatIdentifier(expression.NewName)));
}
public static RenameTableExpression ToLower(this RenameTableExpression expresstion)
{
expresstion.NewName = expresstion.NewName.ToLower();
expresstion.OldName = expresstion.OldName.ToLower();
return(expresstion);
}
public void Truncate(RenameTableExpression expression)
{
expression.OldName = Truncate(expression.OldName);
expression.NewName = Truncate(expression.NewName);
}
public override string Generate(RenameTableExpression expression)
{
return(compatabilityMode.HandleCompatabilty("Renaming of tables is not supported for Jet"));
}
public override string Generate(RenameTableExpression expression)
{
return(string.Format("{0};", base.Generate(expression)));
}
public override string Generate(RenameTableExpression expression)
{
Truncator.Truncate(expression);
return(CompatibilityMode.HandleCompatibilty("Rename table is not supported"));
}
public override void Process(RenameTableExpression expression)
{
Truncator.Truncate(expression);
FirebirdSchemaProvider schema = new FirebirdSchemaProvider(this, _quoter);
FirebirdTableDefinition firebirdTableDef = schema.GetTableDefinition(expression.OldName);
firebirdTableDef.Name = expression.NewName;
CreateTableExpression createNew = new CreateTableExpression()
{
TableName = expression.NewName,
SchemaName = string.Empty
};
//copy column definitions (nb: avoid to copy key names, because in firebird they must be globally unique, so let it rename)
firebirdTableDef.Columns.ToList().ForEach(x => createNew.Columns.Add(new ColumnDefinition()
{
Name = x.Name,
DefaultValue = x.DefaultValue,
IsForeignKey = x.IsForeignKey,
IsIdentity = x.IsIdentity,
IsIndexed = x.IsIndexed,
IsNullable = x.IsNullable,
IsPrimaryKey = x.IsPrimaryKey,
IsUnique = x.IsUnique,
ModificationType = x.ModificationType,
Precision = x.Precision,
Size = x.Size,
Type = x.Type,
CustomType = x.CustomType
}));
Process(createNew);
int columnCount = firebirdTableDef.Columns.Count;
string[] columns = firebirdTableDef.Columns.Select(x => x.Name).ToArray();
InsertDataExpression data = new InsertDataExpression();
data.TableName = firebirdTableDef.Name;
data.SchemaName = firebirdTableDef.SchemaName;
using (DataSet ds = ReadTableData(string.Empty, expression.OldName))
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
InsertionDataDefinition insert = new InsertionDataDefinition();
for (int i = 0; i < columnCount; i++)
{
insert.Add(new KeyValuePair <string, object>(columns[i], dr.ItemArray[i]));
}
data.Rows.Add(insert);
}
}
Process(data);
DeleteTableExpression delTable = new DeleteTableExpression()
{
TableName = expression.OldName,
SchemaName = string.Empty
};
Process(delTable);
}
public override string Generate(RenameTableExpression expression)
{
return(string.Format("ALTER TABLE {0} RENAME TO {1};",
Quoter.QuoteTableName(expression.OldName, expression.SchemaName), Quoter.Quote(expression.NewName)));
}
public void ReverseReturnsRenameTableExpression()
{
var expression = new RenameTableExpression { OldName = "Bacon", NewName = "ChunkyBacon" };
var reverse = expression.Reverse();
reverse.ShouldBeOfType<RenameTableExpression>();
}
