public virtual void AppendConstraints(TableAttribute table, ConstraintExpression constraint)
{
var alter = new AlterTableExpression(new TableExpression(table));
alter.AddConstraint(constraint);
ExecuteNonQuery(alter);
}
public virtual DatabaseCommand GenerateAlterTable(AlterTableExpression model)
{
StringBuilder sb = new StringBuilder();
foreach (var column in model.DropColumns)
{
sb.AppendFormat(DropColumnFormat,
Dialect.QuoteTableName(model.TableName),
Dialect.QuoteColumnName(column));
sb.AppendLine(";");
}
foreach (var column in model.AlterColumns)
{
string columnDefinition = ColumnGenerator.Generate(column);
sb.AppendFormat(AlterColumnFormat,
Dialect.QuoteTableName(model.TableName),
columnDefinition);
sb.AppendLine(";");
}
foreach (var column in model.AddColumns)
{
string columnDefinition = ColumnGenerator.Generate(column);
sb.AppendFormat(AddColumnFormat,
Dialect.QuoteTableName(model.TableName),
columnDefinition);
sb.AppendLine(";");
}
return(new DatabaseCommand(sb.ToString()));
}
public override void Process(AlterTableExpression expression)
{
Truncator.Truncate(expression);
CheckTable(expression.TableName);
LockTable(expression.TableName);
InternalProcess(Generator.Generate(expression));
}
public override string Generate(AlterTableExpression expression)
{
var descriptionStatement = DescriptionGenerator.GenerateDescriptionStatement(expression);
return(string.Format("{0};",
string.IsNullOrEmpty(descriptionStatement)
? base.Generate(expression) : descriptionStatement));
}
public virtual string GenerateDescriptionStatement(AlterTableExpression expression)
{
if (string.IsNullOrEmpty(expression.TableDescription))
{
return(string.Empty);
}
return(GenerateTableDescription(
expression.SchemaName, expression.TableName, expression.TableDescription));
}
public IAlterTableSyntax Table(string tableName)
{
var expression = new AlterTableExpression {
TableName = tableName
};
//_context.Expressions.Add(expression);
return(new AlterTableBuilder(expression, _context));
}
/// <inheritdoc />
public IAlterTableBuilder Table(string tableName)
{
var expression = new AlterTableExpression(_context)
{
TableName = tableName
};
return(new AlterTableBuilder(_context, expression));
}
public override string Generate(AlterTableExpression expression)
{
if (string.IsNullOrEmpty(expression.TableDescription))
{
return(base.Generate(expression));
}
return(string.Format("ALTER TABLE {0} COMMENT {1}", Quoter.QuoteTableName(expression.TableName),
Quoter.QuoteValue(expression.TableDescription)));
}
public IAlterTableAddColumnOrAlterColumnOrSchemaOrDescriptionSyntax Table(string tableName)
{
var expression = new AlterTableExpression {
TableName = tableName
};
_context.Expressions.Add(expression);
return(new AlterTableExpressionBuilder(expression, _context));
}
public void ErrorIsNotReturnedWhenTableNameIsSet()
{
var expression = new AlterTableExpression {
TableName = "table1"
};
var errors = ValidationHelper.CollectErrors(expression);
Assert.That(errors.Count, Is.EqualTo(0));
}
public IAlterTableSyntax Table(string tableName)
{
var expression = new AlterTableExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax)
{
TableName = tableName
};
//_context.Expressions.Add(expression);
return(new AlterTableBuilder(_context, _databaseProviders, expression));
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsSetThenSchemaShouldNotBeChanged()
{
var expression = new AlterTableExpression {
SchemaName = "testschema", TableName = "table1"
};
expression.ApplyConventions(new MigrationConventions());
Assert.That(expression.SchemaName, Is.EqualTo("testschema"));
}
public override string Generate(AlterTableExpression expression)
{
var descriptionStatement = DescriptionGenerator.GenerateDescriptionStatement(expression);
if (string.IsNullOrEmpty(descriptionStatement))
{
return(base.Generate(expression));
}
return(descriptionStatement);
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var expression = new AlterTableExpression {
TableName = "table1"
};
var processed = expression.Apply(ConventionSets.WithSchemaName);
Assert.That(processed.SchemaName, Is.EqualTo("testdefault"));
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsSetThenSchemaShouldNotBeChanged()
{
var expression = new AlterTableExpression {
SchemaName = "testschema", TableName = "table1"
};
var processed = expression.Apply(ConventionSets.WithSchemaName);
Assert.That(processed.SchemaName, Is.EqualTo("testschema"));
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsNotSetThenSchemaShouldBeNull()
{
var expression = new AlterTableExpression {
TableName = "table1"
};
var processed = expression.Apply(ConventionSets.NoSchemaName);
Assert.That(processed.SchemaName, Is.Null);
}
public virtual void RemoveConstraint(TableAttribute table, IEnumerable <string> constraints)
{
var alter = new AlterTableExpression(new TableExpression(table));
foreach (var constraint in constraints)
{
alter.DropConstraint(constraint);
}
ExecuteNonQuery(alter);
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsNotSetThenSchemaShouldBeNull()
{
var expression = new AlterTableExpression {
TableName = "table1"
};
expression.ApplyConventions(new MigrationConventions());
Assert.That(expression.SchemaName, Is.Null);
}
public void ErrorIsReturnedWhenTableNameIsEmptyString()
{
var expression = new AlterTableExpression {
TableName = String.Empty
};
var errors = ValidationHelper.CollectErrors(expression);
errors.ShouldContain(ErrorMessages.TableNameCannotBeNullOrEmpty);
}
public override string Generate(AlterTableExpression expression)
{
var alterStatement = new StringBuilder();
var descriptionStatement = DescriptionGenerator.GenerateDescriptionStatement(expression);
alterStatement.Append(base.Generate(expression));
if (string.IsNullOrEmpty(descriptionStatement))
{
alterStatement.Append(descriptionStatement);
}
return(alterStatement.ToString());
}
internal static int[] GetErrorFilters(this AlterTableExpression expression)
{
var id = $"{expression.GetType().Name}_{expression.TableName}";
var errors = Array.Empty <int>();
if (ErrorFilter.TryGetValue($"{id}", out var tableErrors) && tableErrors.Any())
{
errors = errors.Union(tableErrors).Distinct().OrderBy(i => i).ToArray();
}
return(errors);
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var expression = new AlterTableExpression {
TableName = "table1"
};
var migrationConventions = new MigrationConventions {
GetDefaultSchema = () => "testdefault"
};
expression.ApplyConventions(migrationConventions);
Assert.That(expression.SchemaName, Is.EqualTo("testdefault"));
}
public override string GenerateDescriptionStatement(AlterTableExpression expression)
{
if (string.IsNullOrEmpty(expression.TableDescription))
{
return(string.Empty);
}
var formattedSchemaName = FormatSchemaName(expression.SchemaName);
// For this, we need to remove the extended property first if exists (or implement verification and use sp_updateextendedproperty)
var tableVerificationStatement = string.Format(TableDescriptionVerificationTemplate, formattedSchemaName, expression.TableName);
var removalStatement = string.Format("{0} {1}", tableVerificationStatement, GenerateTableDescriptionRemoval(formattedSchemaName, expression.TableName));
var newDescriptionStatement = GenerateTableDescription(formattedSchemaName, expression.TableName, expression.TableDescription);
return(string.Join(";", new[] { removalStatement, newDescriptionStatement }));
}
public virtual void Process(AlterTableExpression expression)
{
Process(Generator.Generate(expression));
}
public string Generate(AlterTableExpression expression)
{
// returns nothing because the individual AddColumn and AlterColumn calls
// create CreateColumnExpression and AlterColumnExpression respectively
return(string.Empty);
}
public override void Process(AlterTableExpression expression)
{
var sql = Generator.Generate(expression);
ProcessWithErrorFilter(sql, expression.GetErrorFilters());
}
public override void Process(AlterTableExpression expression)
{
base.Process(expression.ToLower());
}
public static AlterTableExpression ToLower(this AlterTableExpression expresstion)
{
expresstion.TableName = expresstion.TableName.ToLower();
return(expresstion);
}
public void Truncate(AlterTableExpression expression)
{
expression.TableName = Truncate(expression.TableName);
}
public virtual void AlterTable(AlterTableExpression model)
{
exec(Factory.GenerateAlterTable(model));
}
