public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var expression = new CreateTableExpression {
TableName = "table1"
};
var processed = expression.Apply(ConventionSets.WithSchemaName);
Assert.That(processed.SchemaName, Is.EqualTo("testdefault"));
}
public void IsEscapingTableNameCorrectlyOnTableCreate()
{
var expression = new CreateTableExpression {
TableName = _tableNameThatMustBeEscaped
};
expression.Columns.Add(_column.Object);
Processor.Process(expression);
}
public void IsEscapingTableNameCorrectlyOnTableExists()
{
CreateTableExpression expression = new CreateTableExpression {
TableName = tableNameThanMustBeEscaped
};
expression.Columns.Add(column.Object);
processor.Process(expression);
processor.TableExists(null, tableNameThanMustBeEscaped).ShouldBeTrue();
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsNotSetThenSchemaShouldBeNull()
{
var expression = new CreateTableExpression {
TableName = "table1"
};
var processed = expression.Apply(ConventionSets.NoSchemaName);
Assert.That(processed.SchemaName, Is.Null);
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsSetThenSchemaShouldNotBeChanged()
{
var expression = new CreateTableExpression {
SchemaName = "testschema", TableName = "table1"
};
var processed = expression.Apply(ConventionSets.WithSchemaName);
Assert.That(processed.SchemaName, Is.EqualTo("testschema"));
}
public void ErrorIsReturnedWhenTableNameIsEmptyString()
{
var expression = new CreateTableExpression {
TableName = string.Empty
};
var errors = ValidationHelper.CollectErrors(expression);
errors.ShouldContain(ErrorMessages.TableNameCannotBeNullOrEmpty);
}
public void ErrorIsNotReturnedWhenTableNameIsSet()
{
var expression = new CreateTableExpression {
TableName = "table1"
};
var errors = ValidationHelper.CollectErrors(expression);
Assert.That(errors.Count, Is.EqualTo(0));
}
public void CanCreateTableWithDefaultValue()
{
string tableName = "NewTable";
CreateTableExpression expression = GetCreateTableExpression(tableName);
expression.Columns[0].DefaultValue = "abc";
string sql = generator.Generate(expression);
sql.ShouldBe("CREATE TABLE \"public\".\"NewTable\" (\"ColumnName1\" text NOT NULL DEFAULT 'abc', \"ColumnName2\" integer NOT NULL)");
}
public ICreateTableWithColumnSyntax Table(string tableName)
{
var expression = new CreateTableExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax)
{
TableName = tableName
};
_context.Expressions.Add(expression);
return(new CreateTableBuilder(_context, _databaseProviders, expression));
}
public void CanCreateTableInSchema()
{
string tableName = "NewTable";
CreateTableExpression expression = GetCreateTableExpression(tableName);
expression.SchemaName = "wibble";
string sql = generator.Generate(expression);
sql.ShouldBe("CREATE TABLE \"wibble\".\"NewTable\" (\"ColumnName1\" text NOT NULL, \"ColumnName2\" integer NOT NULL)");
}
public void CanCreateTableWithPrimaryKey()
{
string tableName = "NewTable";
CreateTableExpression expression = GetCreateTableExpression(tableName);
expression.Columns[0].IsPrimaryKey = true;
string sql = generator.Generate(expression);
sql.ShouldBe("CREATE TABLE \"public\".\"NewTable\" (\"ColumnName1\" text NOT NULL, \"ColumnName2\" integer NOT NULL, PRIMARY KEY (\"ColumnName1\"))");
}
public void IsEscapingTableNameCorrectlyOnReadTableData()
{
var expression = new CreateTableExpression {
TableName = tableNameThanMustBeEscaped
};
expression.Columns.Add(column.Object);
_processor.Process(expression);
_processor.ReadTableData(null, tableNameThanMustBeEscaped).Tables.Count.ShouldBe(1);
}
public void CanCreateTableWithDefaultValue()
{
string tableName = "NewTable";
CreateTableExpression expression = GetCreateTableExpression(tableName);
expression.Columns[0].DefaultValue = "abc";
string sql = generator.Generate(expression);
sql.ShouldBe("CREATE TABLE \"NewTable\" (\"ColumnName1\" BLOB SUB_TYPE TEXT DEFAULT 'abc' NOT NULL, \"ColumnName2\" INTEGER NOT NULL)");
}
public void CanCreateTableInSchema()
{
string tableName = "NewTable";
CreateTableExpression expression = GetCreateTableExpression(tableName);
expression.SchemaName = "wibble";
string sql = generator.Generate(expression);
sql.ShouldBe("CREATE TABLE \"NewTable\" (\"ColumnName1\" BLOB SUB_TYPE TEXT NOT NULL, \"ColumnName2\" INTEGER NOT NULL)");
}
public void CanCreateTableWithMultiColumnPrimaryKey()
{
string tableName = "NewTable";
CreateTableExpression expression = GetCreateTableExpression(tableName);
expression.Columns[0].IsPrimaryKey = true;
expression.Columns[1].IsPrimaryKey = true;
string sql = generator.Generate(expression);
sql.ShouldBe("CREATE TABLE \"NewTable\" (\"ColumnName1\" BLOB SUB_TYPE TEXT NOT NULL, \"ColumnName2\" INTEGER NOT NULL, PRIMARY KEY (\"ColumnName1\", \"ColumnName2\"))");
}
public override void Process(CreateTableExpression expression)
{
if (TableExists(expression.SchemaName, expression.TableName))
{
return;
}
var sql = Generator.Generate(expression);
ProcessWithErrorFilter(sql, expression.GetErrorFilters());
}
/// <summary>
/// Gets create table expression for entity type
/// </summary>
/// <param name="type">Entity type</param>
/// <returns>Expression to create a table</returns>
public virtual CreateTableExpression GetCreateTableExpression(Type type)
{
var expression = new CreateTableExpression {
TableName = NameCompatibilityManager.GetTableName(type)
};
var builder = new CreateTableExpressionBuilder(expression, CreateNullMigrationContext());
RetrieveTableExpressions(type, builder);
return(builder.Expression);
}
public void CanCreateTableExpression()
{
var expression = new CreateTableExpression {
TableName = _tableName
};
expression.Columns.Add(_column.Object);
Processor.Process(expression);
Processor.TableExists(null, _tableName).ShouldBeTrue();
Processor.ColumnExists(null, _tableName, _columnName).ShouldBeTrue();
}
public override string Generate(CreateTableExpression expression)
{
var descriptionStatements = DescriptionGenerator.GenerateDescriptionStatements(expression);
var createTableStatement = base.Generate(expression);
var descriptionStatementsArray = descriptionStatements as string[] ?? descriptionStatements.ToArray();
if (!descriptionStatementsArray.Any())
{
return(createTableStatement);
}
return(ComposeStatements(createTableStatement, descriptionStatementsArray));
}
public void NotLoadingConventionSetFromAssemblyWithScanForMigrations()
{
var services = new ServiceCollection()
.AddFluentMigratorCore()
.ConfigureRunner(rb => rb.AddSQLite().ScanIn(this.GetType().Assembly).For.Migrations())
.BuildServiceProvider(false);
var conventionSet = services.GetRequiredService <IConventionSet>();
ISchemaExpression expr = new CreateTableExpression();
conventionSet.SchemaConvention.Apply(expr);
Assert.AreEqual(null, expr.SchemaName);
}
public void CanCreateTableWithMultipartKey()
{
string tableName = "NewTable";
CreateTableExpression expression = GetCreateTableExpression(tableName);
expression.Columns[0].IsPrimaryKey = true;
expression.Columns[1].IsPrimaryKey = true;
string sql = generator.Generate(expression);
// See the note in OracleColumn about why the PK should not be named
sql.ShouldBe("CREATE TABLE \"public\".\"NewTable\" (\"ColumnName1\" text NOT NULL, \"ColumnName2\" integer NOT NULL, CONSTRAINT \"ColumnName1_ColumnName2_PK\" PRIMARY KEY (\"ColumnName1\",\"ColumnName2\"))");
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var expression = new CreateTableExpression {
TableName = "table1"
};
var migrationConventions = new MigrationConventions {
GetDefaultSchema = () => "testdefault"
};
expression.ApplyConventions(migrationConventions);
Assert.That(expression.SchemaName, Is.EqualTo("testdefault"));
}
public override string Generate(CreateTableExpression expression)
{
var descriptionStatements = DescriptionGenerator.GenerateDescriptionStatements(expression);
var createTableStatement = string.Format("CREATE TABLE {0}.{1}", Quoter.QuoteSchemaName(expression.SchemaName), base.Generate(expression));
var descriptionStatementsArray = descriptionStatements as string[] ?? descriptionStatements.ToArray();
if (!descriptionStatementsArray.Any())
{
return(createTableStatement);
}
return(ComposeStatements(createTableStatement, descriptionStatementsArray));
}
public void CanUseSystemMethodCurrentDateTimeAsADefaultValueForAColumn()
{
var expression = new CreateTableExpression {
TableName = "TestTable1"
};
expression.Columns.Add(new ColumnDefinition {
Name = "DateTimeCol", Type = DbType.DateTime, DefaultValue = SystemMethods.CurrentDateTime
});
var result = Generator.Generate(expression);
result.ShouldBe("CREATE TABLE \"TestTable1\" (\"DateTimeCol\" TEXT NOT NULL DEFAULT (datetime('now','localtime')))");
}
public static CreateTableExpression GetCreateTableWithAutoIncrementExpression()
{
var expression = new CreateTableExpression {
TableName = TestTableName1
};
expression.Columns.Add(new ColumnDefinition {
Name = TestColumnName1, IsIdentity = true, Type = DbType.Int32
});
expression.Columns.Add(new ColumnDefinition {
Name = TestColumnName2, Type = DbType.Int32
});
return(expression);
}
public static CreateTableExpression GetCreateTableWithNamedMultiColumnPrimaryKeyExpression()
{
var expression = new CreateTableExpression {
TableName = TestTableName1
};
expression.Columns.Add(new ColumnDefinition {
Name = TestColumnName1, IsPrimaryKey = true, PrimaryKeyName = "TestKey", Type = DbType.String
});
expression.Columns.Add(new ColumnDefinition {
Name = TestColumnName2, Type = DbType.Int32, IsPrimaryKey = true
});
return(expression);
}
public static CreateTableExpression GetCreateTableWithNullableColumn()
{
var expression = new CreateTableExpression {
TableName = TestTableName1
};
expression.Columns.Add(new ColumnDefinition {
Name = TestColumnName1, IsNullable = true, Type = DbType.String
});
expression.Columns.Add(new ColumnDefinition {
Name = TestColumnName2, Type = DbType.Int32
});
return(expression);
}
public void CanUseSystemMethodCurrentUTCDateTimeAsDefaultValueForColumn()
{
var expression = new CreateTableExpression {
TableName = "TestTable1"
};
expression.Columns.Add(new ColumnDefinition {
Name = "DateTimeCol", Type = DbType.DateTime, DefaultValue = SystemMethods.CurrentUTCDateTime
});
var result = Generator.Generate(expression);
result.ShouldBe("CREATE TABLE \"TestTable1\" (\"DateTimeCol\" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP)");
}
public void CanCreateTableWithIgnoredRowGuidCol()
{
var expression = new CreateTableExpression()
{
TableName = "TestTable1",
};
new CreateTableExpressionBuilder(expression, new MigrationContext(null, null, null, null))
.WithColumn("Id").AsGuid().PrimaryKey().RowGuid();
var result = Generator.Generate(expression);
result.ShouldBe("CREATE TABLE [dbo].[TestTable1] ([Id] UNIQUEIDENTIFIER NOT NULL ROWGUIDCOL, PRIMARY KEY ([Id]))");
}
private IEnumerable <DifferentialExpression> GetAlters(CreateTableExpression from, CreateTableExpression to)
{
if (from == null || to == null)
{
return(Enumerable.Empty <DifferentialExpression>());
}
var removedCols = from.Columns.Where(f => !to.Columns.Any(t => AreSameColumnName(f, t)))
.Select(c => new CreateColumnExpression
{
TableName = to.TableName,
SchemaName = to.SchemaName,
Column = c
}).Select(x => new DifferentialExpression(x.Reverse(), x));
var addedCols = to.Columns.Where(t => !from.Columns.Any(f => AreSameColumnName(f, t)))
.Select(c => new CreateColumnExpression
{
TableName = to.TableName,
SchemaName = to.SchemaName,
Column = c
}).Select(x => new DifferentialExpression(x));
var matches = from.Columns
.Select(f => new
{
From = f,
To = to.Columns.FirstOrDefault(t => AreSameColumnName(f, t))
}).Where(x => x.To != null) //if To == null, this is a dropped column
.Where(x => !AreSameColumnDef(x.From, x.To)).ToList();
var updatedCols = matches.Select(x => new DifferentialExpression(
new ExtendedAlterColumnExpression
{
SchemaName = to.SchemaName,
TableName = to.TableName,
Column = x.To,
Previous = x.From
},
new AlterColumnExpression
{
SchemaName = to.SchemaName,
TableName = to.TableName,
Column = x.From
}
));
return(addedCols.Concat(updatedCols).Concat(removedCols));
}
