public void Can_get_and_set_column_properties()
{
var column = new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "C",
IsNullable = true,
IsIdentity = true,
IsFixedLength = true,
IsUnicode = true,
MaxLength = 42,
Precision = 23,
Scale = 1,
StoreType = "foobar"
};
Assert.Equal("C", column.Name);
Assert.Equal(PrimitiveTypeKind.Guid, column.Type);
Assert.True(column.IsNullable.Value);
Assert.True(column.IsIdentity);
Assert.True(column.IsFixedLength.Value);
Assert.True(column.IsUnicode.Value);
Assert.Equal(42, column.MaxLength);
Assert.Equal((byte)23, column.Precision);
Assert.Equal((byte)1, column.Scale);
Assert.Equal("foobar", column.StoreType);
}
public void IsNarrowerThan_should_return_true_when_max_length_narrower()
{
var columnModel1 = new ColumnModel(PrimitiveTypeKind.String)
{
MaxLength = 1
};
var columnModel2 = new ColumnModel(PrimitiveTypeKind.String)
{
MaxLength = 2
};
Assert.True(columnModel1.IsNarrowerThan(columnModel2, _providerManifest));
columnModel1 = new ColumnModel(PrimitiveTypeKind.String)
{
MaxLength = 1
};
columnModel2 = new ColumnModel(PrimitiveTypeKind.String);
Assert.True(columnModel1.IsNarrowerThan(columnModel2, _providerManifest));
columnModel1 = new ColumnModel(PrimitiveTypeKind.String);
columnModel2 = new ColumnModel(PrimitiveTypeKind.String)
{
MaxLength = 1
};
Assert.False(columnModel1.IsNarrowerThan(columnModel2, _providerManifest));
}
private static void AddDefaultValue(ColumnModel Column)
{
if (Column.Annotations.Any(o => o.Key == "DefaultValue"))
{
Column.DefaultValueSql = Column.Annotations["DefaultValue"].NewValue.ToString();
}
}
public void IsNarrowerThan_should_return_true_when_nullable_narrower()
{
var columnModel1 = new ColumnModel(PrimitiveTypeKind.String)
{
IsNullable = false
};
var columnModel2 = new ColumnModel(PrimitiveTypeKind.String)
{
IsNullable = true
};
Assert.True(columnModel1.IsNarrowerThan(columnModel2, _providerManifest));
columnModel1 = new ColumnModel(PrimitiveTypeKind.String)
{
IsNullable = false
};
columnModel2 = new ColumnModel(PrimitiveTypeKind.String);
Assert.True(columnModel1.IsNarrowerThan(columnModel2, _providerManifest));
columnModel1 = new ColumnModel(PrimitiveTypeKind.String);
columnModel2 = new ColumnModel(PrimitiveTypeKind.String)
{
IsNullable = false
};
Assert.False(columnModel1.IsNarrowerThan(columnModel2, _providerManifest));
}
public void Inverse_should_produce_change_column_operation()
{
var column = new ColumnModel(PrimitiveTypeKind.Boolean);
var inverse = new AlterColumnOperation("T", column, isDestructiveChange: false);
var alterColumnOperation = new AlterColumnOperation("T", column, isDestructiveChange: false, inverse: inverse);
Assert.Same(inverse, alterColumnOperation.Inverse);
}
public void Can_get_and_set_table_and_column_info()
{
var column = new ColumnModel(PrimitiveTypeKind.Boolean);
var alterColumnOperation = new AlterColumnOperation("T", column, isDestructiveChange: false);
Assert.Equal("T", alterColumnOperation.Table);
Assert.Same(column, alterColumnOperation.Column);
}
public void Can_get_and_set_table_and_column_info()
{
var column = new ColumnModel(PrimitiveTypeKind.Decimal);
var addColumnOperation = new AddColumnOperation("T", column);
Assert.Equal("T", addColumnOperation.Table);
Assert.Same(column, addColumnOperation.Column);
}
public AlterColumnOperation(
string table, ColumnModel column, bool isDestructiveChange, AlterColumnOperation inverse,
object anonymousArguments = null)
: this(table, column, isDestructiveChange, anonymousArguments)
{
Check.NotNull(inverse, "inverse");
_inverse = inverse;
}
public AddColumnOperation(string table, ColumnModel column, object anonymousArguments = null)
: base(anonymousArguments)
{
//Contract.Requires(!string.IsNullOrWhiteSpace(table));
//Contract.Requires(column != null);
_table = table;
_column = column;
}
public AlterColumnOperation(
string table, ColumnModel column, bool isDestructiveChange, AlterColumnOperation inverse,
object anonymousArguments = null)
: this(table, column, isDestructiveChange, anonymousArguments)
{
//Contract.Requires(inverse != null);
_inverse = inverse;
}
public AddColumnOperation(string table, ColumnModel column, object anonymousArguments = null)
: base(anonymousArguments)
{
Check.NotEmpty(table, "table");
Check.NotNull(column, "column");
_table = table;
_column = column;
}
public void Inverse_should_produce_drop_column_operation()
{
var column = new ColumnModel(PrimitiveTypeKind.Decimal) { Name = "C" };
var addColumnOperation = new AddColumnOperation("T", column);
var dropColumnOperation = (DropColumnOperation)addColumnOperation.Inverse;
Assert.Equal("C", dropColumnOperation.Name);
Assert.Equal("T", dropColumnOperation.Table);
}
private void SetDefaultValue(System.Data.Entity.Migrations.Model.ColumnModel columnModel)
{
if (_columns.Contains(columnModel.Name))
{
columnModel.DefaultValueSql = "GETUTCDATE()";
}
if (columnModel.ClrType == typeof(Guid) && columnModel.Name.EndsWith("Id"))
{
columnModel.DefaultValueSql = "NEWID()";
}
}
public AlterColumnOperation(
string table, ColumnModel column, bool isDestructiveChange, object anonymousArguments = null)
: base(anonymousArguments)
{
Check.NotEmpty(table, "table");
Check.NotNull(column, "column");
_table = table;
_column = column;
_destructiveChange = isDestructiveChange;
}
public AlterColumnOperation(
string table, ColumnModel column, bool isDestructiveChange, object anonymousArguments = null)
: base(anonymousArguments)
{
//Contract.Requires(!string.IsNullOrWhiteSpace(table));
//Contract.Requires(column != null);
_table = table;
_column = column;
_destructiveChange = isDestructiveChange;
}
public void Can_get_and_set_annotations()
{
var column = new ColumnModel(PrimitiveTypeKind.Guid);
Assert.Empty(column.Annotations);
column.Annotations = new Dictionary<string, AnnotationValues> { { "A1", new AnnotationValues("V1", "V2") } };
Assert.Equal("V1", column.Annotations["A1"].OldValue);
Assert.Equal("V2", column.Annotations["A1"].NewValue);
column.Annotations = null;
Assert.Empty(column.Annotations);
}
protected override string BuildColumnType(ColumnModel columnModel)
{
if (columnModel == null)
{
throw new ArgumentNullException("columnModel");
}
TableColumnType tableColumnType = this.GetTableColumnType(columnModel);
if (tableColumnType != TableColumnType.None)
{
this.UpdateTableColumn(columnModel, tableColumnType);
}
return base.BuildColumnType(columnModel);
}
public void GenerateCanOutputAddColumnStatementWhenNonNullableAndNoDefaultProvided()
{
var migrationSqlGenerator = new PostgreSqlMigrationSqlGenerator();
var column = new ColumnModel(PrimitiveTypeKind.Int32)
{
Name = "Bar",
IsNullable = false
};
var addColumnOperation = new AddColumnOperation("Foo", column);
var sql = migrationSqlGenerator.Generate(new[] { addColumnOperation }, "9.2").Join(s => s.Sql, Environment.NewLine);
Assert.True(sql.Contains("ALTER TABLE \"Foo\" ADD \"Bar\" integer NOT NULL DEFAULT 0"));
}
public void Generate_can_output_add_column_statement_for_GUID_and_uses_newid()
{
var migrationSqlGenerator = new SqlCeMigrationSqlGenerator();
var column = new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Bar",
IsIdentity = true
};
var addColumnOperation = new AddColumnOperation("Foo", column);
var sql = migrationSqlGenerator.Generate(new[] { addColumnOperation }, "4.0").Join(s => s.Sql, Environment.NewLine);
Assert.Contains("ALTER TABLE [Foo] ADD [Bar] [uniqueidentifier] DEFAULT newid()", sql);
}
public void GenerateCanOutputAddColumnStatement(PrimitiveTypeKind type, string typeName)
{
var migrationSqlGenerator = new PostgreSqlMigrationSqlGenerator();
var column = new ColumnModel(type)
{
Name = "Bar",
IsIdentity = true
};
var addColumnOperation = new AddColumnOperation("Foo", column);
var sql = migrationSqlGenerator.Generate(
new[] { addColumnOperation }, "9.2").Join(s => s.Sql, Environment.NewLine);
Assert.True(sql.Contains(string.Format("ALTER TABLE \"Foo\" ADD \"Bar\" {0}", typeName)));
}
public void Inverse_should_produce_drop_column_operation()
{
var column = new ColumnModel(PrimitiveTypeKind.Decimal)
{
Name = "C",
Annotations = new Dictionary<string, AnnotationValues> { { "A1", new AnnotationValues(null, "V1") } }
};
var addColumnOperation
= new AddColumnOperation("T", column);
var dropColumnOperation = (DropColumnOperation)addColumnOperation.Inverse;
Assert.Equal("C", dropColumnOperation.Name);
Assert.Equal("T", dropColumnOperation.Table);
Assert.Equal("V1", dropColumnOperation.RemovedAnnotations["A1"]);
}
public void AddColumnOperationMigration()
{
var migrationOperations = new List<MigrationOperation>();
if (ProviderManifest == null)
ProviderManifest = new MySqlProviderManifest(Version.ToString());
TypeUsage tu = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
TypeUsage result = ProviderManifest.GetStoreType(tu);
var intColumn = new ColumnModel(PrimitiveTypeKind.Int32, result)
{
Name = "TotalPosts",
IsNullable = false
};
var addColumnMigratioOperation = new AddColumnOperation("Blogs", intColumn);
migrationOperations.Add(addColumnMigratioOperation);
using (BlogContext context = new BlogContext())
{
if (context.Database.Exists()) context.Database.Delete();
context.Database.Create();
using (MySqlConnection conn = new MySqlConnection(context.Database.Connection.ConnectionString))
{
if (conn.State == System.Data.ConnectionState.Closed) conn.Open();
Assert.AreEqual(true, GenerateAndExecuteMySQLStatements(migrationOperations));
MySqlCommand query = new MySqlCommand("Select Column_name, Is_Nullable, Data_Type from information_schema.Columns where table_schema ='" + conn.Database + "' and table_name = 'Blogs' and column_name ='TotalPosts'" , conn);
MySqlDataReader reader = query.ExecuteReader();
while (reader.Read())
{
Assert.AreEqual("TotalPosts", reader[0].ToString());
Assert.AreEqual("NO", reader[1].ToString());
Assert.AreEqual("int", reader[2].ToString());
}
reader.Close();
conn.Close();
}
}
}
protected override void Generate(ColumnModel column, IndentedTextWriter writer)
{
writer.Write(Quote(column.Name));
writer.Write(" ");
writer.Write(BuildColumnType(column));
var collation = TryGetCollation(column.Annotations);
if (collation != null && column.ClrType == typeof(string))
{
writer.Write(" COLLATE " + collation.CollationName + " ");
}
if ((column.IsNullable != null)
&& !column.IsNullable.Value)
{
writer.Write(" NOT NULL");
}
if (column.DefaultValue != null)
{
writer.Write(" DEFAULT ");
writer.Write(Generate((dynamic)column.DefaultValue));
}
else if (!string.IsNullOrWhiteSpace(column.DefaultValueSql))
{
writer.Write(" DEFAULT ");
writer.Write(column.DefaultValueSql);
}
else if (column.IsIdentity)
{
if ((column.Type == PrimitiveTypeKind.Guid)
&& (column.DefaultValue == null))
{
writer.Write(" DEFAULT " + GuidColumnDefault);
}
else
{
writer.Write(" IDENTITY");
}
}
}
public void GenerateAlterDecimalColumn(bool? nullable, string contain, string notContain)
{
var migrationProvider = new PostgreSqlMigrationSqlGenerator();
var column = new ColumnModel(PrimitiveTypeKind.Decimal)
{
Name = "C",
IsNullable = nullable
};
var alterColumnOperation = new AlterColumnOperation("dbo.T", column, false);
var sql = migrationProvider.Generate(new[] { alterColumnOperation }, "9.2").Join(s => s.Sql, Environment.NewLine);
const string returnSqlBase = "ALTER TABLE \"dbo\".\"T\" ALTER COLUMN \"C\" ";
Assert.IsNotNull(sql);
Assert.True(sql.Contains(returnSqlBase));
Assert.True(sql.Contains(returnSqlBase + "TYPE decimal"));
Assert.True(sql.Contains(returnSqlBase + contain));
Assert.False(sql.Contains(returnSqlBase + notContain));
}
protected virtual void UpdateTableColumn(ColumnModel columnModel, TableColumnType tableColumnType)
{
if (columnModel == null)
{
throw new ArgumentNullException("columnModel");
}
// We don't try to set default value if the user has already set it or the store type has been set explicitly.
if (columnModel == null || columnModel.ClrType == null || columnModel.DefaultValueSql != null || columnModel.StoreType != null)
{
return;
}
switch (tableColumnType)
{
case TableColumnType.Id:
columnModel.DefaultValueSql = "NEWID()";
break;
case TableColumnType.CreatedAt:
columnModel.DefaultValueSql = "SYSUTCDATETIME()";
break;
}
}
string BuildColumnType(ColumnModel columnModel)
{
return BuildPropertyType(columnModel);
}
protected virtual string Generate(ColumnModel column)
{
var result = new StringBuilder();
result.Append(Quote(column.Name));
result.Append(" ");
result.Append(BuildColumnType(column));
if ((column.IsNullable != null)
&& !column.IsNullable.Value)
{
result.Append(" NOT NULL");
}
if (column.DefaultValue != null)
{
result.Append(" DEFAULT ");
result.Append(WriteValue((dynamic)column.DefaultValue));
}
else if (!string.IsNullOrWhiteSpace(column.DefaultValueSql))
{
result.Append(" DEFAULT ");
result.Append(column.DefaultValueSql);
}
else if (column.IsIdentity)
{
if (column.Type == PrimitiveTypeKind.Guid && column.DefaultValue == null)
{
result.Append(" DEFAULT " + Guid.NewGuid().ToNuoDbString());
}
else
{
result.Append(" GENERATED BY DEFAULT AS IDENTITY");
}
}
return result.ToString();
}
public void Generate_can_output_alter_column_with_default_constraint()
{
var migrationSqlGenerator = new SqlCeMigrationSqlGenerator();
var column = new ColumnModel(PrimitiveTypeKind.Int32)
{
Name = "Bar",
DefaultValue = 42
};
var alterColumnOperation = new AlterColumnOperation("Foo", column, false);
var sql = migrationSqlGenerator
.Generate(new[] { alterColumnOperation }, "4.0").Join(s => s.Sql, Environment.NewLine);
Assert.Equal(@"ALTER TABLE [Foo] ALTER COLUMN [Bar] [int]
ALTER TABLE [Foo] ALTER COLUMN [Bar] DROP DEFAULT
ALTER TABLE [Foo] ALTER COLUMN [Bar] SET DEFAULT 42", sql);
}
public void Generate_can_output_add_column_statement_when_non_nullable_and_no_default_provided()
{
var migrationSqlGenerator = new SqlCeMigrationSqlGenerator();
var column = new ColumnModel(PrimitiveTypeKind.Int32)
{
Name = "Bar",
IsNullable = false
};
var addColumnOperation = new AddColumnOperation("Foo", column);
var sql = migrationSqlGenerator.Generate(new[] { addColumnOperation }, "4.0").Join(s => s.Sql, Environment.NewLine);
Assert.Contains("ALTER TABLE [Foo] ADD [Bar] [int] NOT NULL DEFAULT 0", sql);
}
public void Generate_can_output_add_column_statement_with_explicit_default_value_sql()
{
var migrationSqlGenerator = new SqlCeMigrationSqlGenerator();
var column = new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Bar",
IsNullable = false,
DefaultValueSql = "42"
};
var addColumnOperation = new AddColumnOperation("Foo", column);
var sql = migrationSqlGenerator.Generate(new[] { addColumnOperation }, "4.0").Join(s => s.Sql, Environment.NewLine);
Assert.Contains("ALTER TABLE [Foo] ADD [Bar] [uniqueidentifier] NOT NULL DEFAULT 42", sql);
}
public void Generate_can_output_add_column_statement_with_custom_store_type()
{
var migrationSqlGenerator = new SqlCeMigrationSqlGenerator();
var column = new ColumnModel(PrimitiveTypeKind.String)
{
Name = "Bar",
StoreType = "varchar",
MaxLength = 15
};
var addColumnOperation = new AddColumnOperation("Foo", column);
var sql = migrationSqlGenerator.Generate(new[] { addColumnOperation }, "4.0").Join(s => s.Sql, Environment.NewLine);
Assert.Contains("ALTER TABLE [Foo] ADD [Bar] [varchar](15)", sql);
}
public void ToFacetValues_returns_empty_by_default()
{
var columnModel = new ColumnModel(PrimitiveTypeKind.Boolean);
Assert.True(FacetValuesHelpers.Equal<int>(new FacetValues(), columnModel.ToFacetValues()));
}
