protected override void VisitDefaultConstraint(DefaultConstraint item)
{
if (item.Value != null)
{
int?defaultVal = null;
((IVisitableBuilder)item.Value).Accept(this);
if (CurrentNumericLiteralValue != null)
{
defaultVal = Convert.ToInt32(CurrentNumericLiteralValue);
CurrentNumericLiteralValue = null;
}
if (defaultVal.HasValue)
{
if (defaultVal == 1)
{
CurrentDefaultBooleanAttributeValue = true;
}
else if (defaultVal == 0)
{
CurrentDefaultBooleanAttributeValue = false;
}
}
}
base.VisitDefaultConstraint(item);
}
/// <summary>
/// Enumerates the SQL commands that are necessary to drop
/// the specified <paramref name="defaultConstraint"/>.
/// </summary>
/// <param name="defaultConstraint">The default constraint.</param>
/// <returns>The SQL commands.</returns>
protected virtual IEnumerable <string> DropDefaultConstraint(DefaultConstraint defaultConstraint)
{
yield return(string.Format("ALTER TABLE {0} ALTER COLUMN {1} DROP DEFAULT;",
EscapeTableName(defaultConstraint.Table.Name),
EscapeConstraintName(defaultConstraint.Name)
));
}
/// <summary>
/// Enumerates the SQL commands that are necessary to drop
/// the specified <paramref name="defaultConstraint"/>.
/// </summary>
/// <param name="defaultConstraint">The default constraint.</param>
/// <returns>The SQL commands.</returns>
protected override IEnumerable <string> DropDefaultConstraint(DefaultConstraint defaultConstraint)
{
IEnumerable <string> sql = null;
if (string.IsNullOrEmpty(defaultConstraint.Name))
{
sql = new string[]
{
string.Format("DECLARE @{0}DefaultName VARCHAR(MAX);", defaultConstraint.ColumnName) +
Environment.NewLine +
string.Format("SELECT @{0}DefaultName = o2.name " +
"FROM syscolumns c " +
"JOIN sysobjects o ON c.id = o.id " +
"JOIN sysobjects o2 ON c.cdefault = o2.id " +
"WHERE o.name = {1} AND c.name = {2};",
defaultConstraint.ColumnName,
FormatValue(defaultConstraint.Table.Name),
FormatValue(defaultConstraint.ColumnName)
) +
Environment.NewLine +
string.Format("EXEC('ALTER TABLE {0} DROP CONSTRAINT ' + @{1}DefaultName);",
EscapeTableName(string.Format(defaultConstraint.Table.Name)),
defaultConstraint.ColumnName
)
};
}
else
{
sql = base.DropDefaultConstraint(defaultConstraint);
}
return(sql);
}
public IEnumerable <string> RenameColumn(string tableName, string oldName, string newName)
{
Table table = GetTable(tableName);
var column = new Microsoft.SqlServer.Management.Smo.Column(table, oldName);
// rename default constraint
string oldDefaultConstraintName = ObjectNameHelper.GetObjectName(tableName, "DF", MaximumDbObjectNameLength, oldName);
string constraintName = oldDefaultConstraintName;
DefaultConstraint defaultConstraint = column.AddDefaultConstraint(constraintName);
defaultConstraint.Rename(ObjectNameHelper.GetObjectName(tableName, "DF", MaximumDbObjectNameLength, newName));
// rename column
table.Columns.Add(column);
column.Rename(newName);
// script changes
IEnumerable <string> commandTexts = ScriptChanges(table.Parent.Parent);
string renameDefaultConstraintCommandText = string.Format(CultureInfo.InvariantCulture, "IF OBJECT_ID('{0}') IS NOT NULL ", oldDefaultConstraintName) + commandTexts.First();
yield return(Regex.Replace(renameDefaultConstraintCommandText, @"EXEC \[\w+\]\.dbo\.sp_rename", @"EXEC dbo.sp_rename")); // for some reason SMO is putting the server name in front of dbo.sp_rename which we do not have in the SqlServerProvider
foreach (string commandText in commandTexts.Skip(1))
{
yield return(commandText);
}
}
public IEnumerable <string> AlterColumn(string tableName, Column column)
{
// drop (possibly) existing default constraint
Table table = GetTable(tableName);
var c = new Microsoft.SqlServer.Management.Smo.Column(table, column.Name)
{
Nullable = column.IsNullable,
DataType = Convert(column.DataType),
};
DefaultConstraint defaultConstraint = AddDefaultConstraint(c, tableName, "dummy");
defaultConstraint.Drop();
foreach (string command in ScriptChanges(table.Parent.Parent))
{
yield return(string.Format(CultureInfo.InvariantCulture, "IF OBJECT_ID('{0}') IS NOT NULL ", defaultConstraint.Name) + command);
}
// alter column
table = GetTable(tableName);
c = new Microsoft.SqlServer.Management.Smo.Column(table, column.Name)
{
Nullable = column.IsNullable,
DataType = Convert(column.DataType),
};
if (column.DefaultValue != null)
{
AddDefaultConstraint(c, tableName, column.DefaultValue);
}
c.Alter();
foreach (string command in ScriptChanges(table.Parent.Parent))
{
yield return(command);
}
}
/// <summary>
/// Devuelve el schema de la columna en formato SQL.
/// </summary>
public string ToSql(Boolean sqlConstraint)
{
string sql = "";
sql += "[" + Name + "] ";
if (!IsComputed)
{
if (this.IsUserDefinedType)
sql += Type;
else
sql += "[" + Type + "]";
if (Type.Equals("binary") || Type.Equals("varbinary") || Type.Equals("varchar") || Type.Equals("char") || Type.Equals("nchar") || Type.Equals("nvarchar"))
{
if (Size == -1)
sql += " (max)";
else
{
if (Type.Equals("nchar") || Type.Equals("nvarchar"))
sql += " (" + (Size / 2).ToString(CultureInfo.InvariantCulture) + ")";
else
sql += " (" + Size.ToString(CultureInfo.InvariantCulture) + ")";
}
}
if (Type.Equals("xml"))
{
if (!String.IsNullOrEmpty(XmlSchema))
{
if (IsXmlDocument)
sql += "(DOCUMENT " + XmlSchema + ")";
else
sql += "(CONTENT " + XmlSchema + ")";
}
}
if (Type.Equals("numeric") || Type.Equals("decimal")) sql += " (" + Precision.ToString(CultureInfo.InvariantCulture) + "," + Scale.ToString(CultureInfo.InvariantCulture) + ")";
if (((Database)Parent.Parent).Info.Version >= DatabaseInfo.VersionTypeEnum.SQLServer2008)
{
if (Type.Equals("datetime2") || Type.Equals("datetimeoffset") || Type.Equals("time")) sql += "(" + Scale.ToString(CultureInfo.InvariantCulture) + ")";
}
if ((!String.IsNullOrEmpty(Collation)) && (!IsUserDefinedType)) sql += " COLLATE " + Collation;
if (IsIdentity) sql += " IDENTITY (" + IdentitySeed.ToString(CultureInfo.InvariantCulture) + "," + IdentityIncrement.ToString(CultureInfo.InvariantCulture) + ")";
if (IsIdentityForReplication) sql += " NOT FOR REPLICATION";
if (IsSparse) sql += " SPARSE";
if (IsFileStream) sql += " FILESTREAM";
if (IsNullable)
sql += " NULL";
else
sql += " NOT NULL";
if (IsRowGuid) sql += " ROWGUIDCOL";
}
else
{
sql += "AS " + ComputedFormula;
if (IsPersisted) sql += " PERSISTED";
}
if ((sqlConstraint) && (DefaultConstraint != null))
{
if (DefaultConstraint.Status != ObjectStatus.Drop)
sql += " " + DefaultConstraint.ToSql().Replace("\t", "").Trim();
}
return sql;
}
public void ConstraintAndSinglePoint()
{
Constraint c = new DefaultConstraint(new double[] { 0, 0, 0 }, new double[] { 1, 1, 1 });
Assert.IsTrue(c.ContainsSubspace(new double[] { 0.5, 0.5, 0.5 }));
Assert.IsTrue(c.ContainsSubspace(new double[] { -0.5, -0.5, -0.5 }));
Assert.IsFalse(c.ContainsSubspace(new double[] { 1, 1, 2 }));
}
public virtual void AddDefaultConstraint(SchemaQualifiedName tableName, [NotNull] string columnName,
DefaultConstraint defaultConstraint)
{
Check.NotEmpty(columnName, "columnName");
AddOperation(new AddDefaultConstraintOperation(tableName, columnName,
defaultConstraint.GetValue(), defaultConstraint.GetSql()));
}
private static DefaultConstraint AddDefaultConstraint(Microsoft.SqlServer.Management.Smo.Column column, string tableName, object value)
{
string constraintName = ObjectNameHelper.GetObjectName(tableName, "DF", MaximumDbObjectNameLength, column.Name);
DefaultConstraint defaultConstraint = column.AddDefaultConstraint(constraintName);
defaultConstraint.Text = GetDefaultValueAsString(value);
return(defaultConstraint);
}
public static string ScriptDefault(
DefaultConstraint defaultConstraint,
string tableSchema,
string tableName,
string columnName
)
{
return("ALTER TABLE [" + tableSchema + "].[" + tableName + "] ADD CONSTRAINT [" + defaultConstraint.Name +
"] DEFAULT " + defaultConstraint.Text + " FOR [" + columnName + "];");
}
public SQLScriptList RebuildConstraint(Boolean Check)
{
SQLScriptList list = new SQLScriptList();
if (DefaultConstraint != null)
{
if ((!Check) || (DefaultConstraint.CanCreate)) list.Add(DefaultConstraint.Create());
list.Add(DefaultConstraint.Drop());
}
return list;
}
/// <summary>
/// Enumerates the SQL commands that are necessary to create
/// the specified <paramref name="defaultConstraint"/>.
/// </summary>
/// <param name="defaultConstraint">The default constraint.</param>
/// <returns>The SQL commands.</returns>
protected virtual IEnumerable <string> AddDefaultConstraint(DefaultConstraint defaultConstraint)
{
yield return(string.Format(
"ALTER TABLE {0} ADD CONSTRAINT {1} DEFAULT({2}) FOR {3};",
EscapeTableName(defaultConstraint.Table.Name),
EscapeConstraintName(defaultConstraint.Name),
FormatValue(defaultConstraint.Value),
EscapeColumnName(defaultConstraint.ColumnName)
));
}
public void Equals_Object_SameInstance_True()
{
// Arrange
var instance = new DefaultConstraint("a", "b", "c", "d");
// Act
var equals = instance.Equals((object)instance);
// Assert
Assert.IsTrue(equals);
}
public void Equals_Object_Null_False()
{
// Arrange
var instance = new DefaultConstraint("a", "b", "c", "d");
// Act
var equals = instance.Equals(null as object);
// Assert
Assert.IsFalse(equals);
}
public void Equals_Object_DifferentType_False()
{
// Arrange
var instance = new DefaultConstraint("a", "b", "c", "d");
// Act
var equals = instance.Equals(new Version(1, 0));
// Assert
Assert.IsFalse(equals);
}
public static SubSpace FromPoint(params double[] coordinates)
{
//foreach coordinate, one constraint x[i]=coordinate[y], and the term??
Constraint[] constraints=new Constraint[coordinates.Length];
for (int i = 0; i < coordinates.Length; i++)
{
double[] constraintCoeffs=new double[coordinates.Length];
constraintCoeffs[i] = coordinates[i];
constraints[i] = new DefaultConstraint(constraintCoeffs);
}
return new SubSpace(constraints);
}
public void Equals_Typed_TwoInstances(string tableSchema, string tableName, string columnName, string constraintName, bool expectedEquals)
{
// Arrange
var instance1 = new DefaultConstraint("a", "b", "c", "d");
var instance2 = new DefaultConstraint(tableSchema, tableName, columnName, constraintName);
// Act
var equals = instance1.Equals(instance2);
// Assert
Assert.AreEqual(expectedEquals, equals);
}
public void InequalityOperator(string tableSchema, string tableName, string columnName, string constraintName, bool expectedInequality)
{
// Arrange
var instance1 = new DefaultConstraint("a", "b", "c", "d");
var instance2 = new DefaultConstraint(tableSchema, tableName, columnName, constraintName);
// Act
var inequality = instance1 != instance2;
// Assert
Assert.AreEqual(expectedInequality, inequality);
}
public static SubSpace FromPoint(params double[] coordinates)
{
//foreach coordinate, one constraint x[i]=coordinate[y], and the term??
Constraint[] constraints = new Constraint[coordinates.Length];
for (int i = 0; i < coordinates.Length; i++)
{
double[] constraintCoeffs = new double[coordinates.Length];
constraintCoeffs[i] = coordinates[i];
constraints[i] = new DefaultConstraint(constraintCoeffs);
}
return(new SubSpace(constraints));
}
public IEnumerable <string> DropDefault(string tableName, Column column)
{
Table table = GetTable(tableName);
var c = new Microsoft.SqlServer.Management.Smo.Column(table, column.Name)
{
DataType = Convert(column.DataType),
Nullable = column.IsNullable,
};
DefaultConstraint defaultConstraint = AddDefaultConstraint(c, tableName, column.DefaultValue);
defaultConstraint.Drop();
return(ScriptChanges(table.Parent.Parent));
}
public void GetHashCode_HashCodeComparison(string tableSchema, string tableName, string columnName, string constraintName, bool expectedSameHashCode)
{
// Arrange
var instance1 = new DefaultConstraint("a", "b", "c", "d");
var instance2 = new DefaultConstraint(tableSchema, tableName, columnName, constraintName);
// Act
var i1HashCode = instance1.GetHashCode();
var i2HashCode = instance2.GetHashCode();
var sameHashCode = i1HashCode == i2HashCode;
// Assert
Assert.AreEqual(expectedSameHashCode, sameHashCode);
}
private void AddDefaultItem(DefaultConstraint defaultItem)
{
builder.AppendLine(ScriptHelper.KeyIsNull(defaultItem.Name));
builder.Begin();
var foreignScripts = defaultItem.Script();
foreach (string script in foreignScripts)
{
builder.AppendLine(script);
}
builder.AddEndGo();
builder.NewLine();
}
public void AddDefaultConstraint_adds_operation()
{
var builder = new MigrationBuilder();
builder.AddDefaultConstraint("dbo.MyTable", "Foo", DefaultConstraint.Value(5));
Assert.Equal(1, builder.Operations.Count);
Assert.IsType <AddDefaultConstraintOperation>(builder.Operations[0]);
var operation = (AddDefaultConstraintOperation)builder.Operations[0];
Assert.Equal("dbo.MyTable", operation.TableName);
Assert.Equal("Foo", operation.ColumnName);
Assert.Equal(5, operation.DefaultValue);
}
public void Constructor_CorrectInitialization(string constraintName)
{
// Arrange
const string tableSchema = "dbo";
const string tableName = "Author";
const string columnName = "Name";
// Act
var dc = new DefaultConstraint(tableSchema, tableName, columnName, constraintName);
// Assert
Assert.AreEqual(tableSchema, dc.TableSchema);
Assert.AreEqual(tableName, dc.TableName);
Assert.AreEqual(columnName, dc.ColumnName);
Assert.AreEqual(constraintName, dc.ConstraintName);
Assert.AreEqual($"[dbo].[Author].[Name].[{(constraintName ?? "<UNNAMED>")}]", dc.DisplayName);
}
public static string CreateColumn(IColumn c, DefaultConstraint constraint)
{
string fullType = GetColumnType(c);
var generatedAlways = c is SystemVersionedInfo.Column svc ?
$"GENERATED ALWAYS AS ROW {(svc.SystemVersionColumnType == SystemVersionedInfo.ColumnType.Start ? "START" : "END")} HIDDEN" :
null;
var defaultConstraint = constraint != null ? $"CONSTRAINT {constraint.Name} DEFAULT " + constraint.QuotedDefinition : null;
return($" ".CombineIfNotEmpty(
c.Name.SqlEscape(),
fullType,
c.Identity ? "IDENTITY " : null,
generatedAlways,
c.Collation != null ? ("COLLATE " + c.Collation) : null,
c.Nullable.ToBool() ? "NULL" : "NOT NULL",
defaultConstraint
));
}
//----------------------------------------------------------------------------------------------------
public static DefaultConstraint DefaultConstraint__Get(Column column)
{
AjaxService.ASPdatabaseService.GetSetVal();
var dict = new Dictionary <string, DefaultConstraint>();
string sql = SQLServer_SQLBuilders.BuildSql__DefaultConstraint_Select(column);
using (DbConnectionCommand command = UniversalADO.OpenConnectionCommand(column.ConnectionId, sql))
{
using (DbReaderWrapper reader = command.ExecuteReaderWrapper())
{
while (reader.Read())
{
string columnName = reader.Get("ColumnName", "");
string columnName_L = columnName.ToLower();
var defaultConstraint = new DefaultConstraint()
{
ConnectionId = column.ConnectionId,
Schema = column.Schema,
TableName = column.TableName,
ColumnName = reader.Get("ColumnName", ""),
DefaultConstraintName = reader.Get("DefaultConstraintName", ""),
DefaultDefinition = reader.Get("DefaultDefinition", "")
};
if (!dict.ContainsKey(columnName_L))
{
dict.Add(columnName_L, defaultConstraint);
}
}
}
}
if (dict.ContainsKey(column.ColumnName.ToLower()))
{
return(dict[column.ColumnName.ToLower()]);
}
else
{
return(null);
}
}
public void CreateDefaultConstraint(
Dictionary <string, UserTable> userTables,
IDataRecord reader)
{
var schemaName = Convert.ToString(reader[SchemaNameOrdinal]);
var tableName = Convert.ToString(reader[TableNameOrdinal]);
var userTableNamespaceBuilder = new StringBuilder(schemaName.Length + tableName.Length + 1);
userTableNamespaceBuilder.Append(schemaName).
Append(Constants.Dot).
Append(tableName);
var userTableNamespace = userTableNamespaceBuilder.ToString();
if (!userTables.ContainsKey(userTableNamespace))
{
return;
}
var userTable = userTables[userTableNamespace];
if (userTable == null)
{
return;
}
var defaultConstraint = new DefaultConstraint
{
UserTable = userTable,
ColumnName = Convert.ToString(reader[ColumnNameOrdinal]),
ObjectName = Convert.ToString(reader[ObjectNameOrdinal]),
Definition = Convert.ToString(reader[DefinitionOrdinal]),
IsSystemNamed = Convert.ToBoolean(reader[IsSystemNamedOrdinal])
};
userTable.DefaultConstraints.Add(defaultConstraint);
}
protected string TranslateExecDropDefaultConstraint(SqlCompilerContext context, SqlAlterTable node, DefaultConstraint defaultConstraint)
{
var resultBuilder = new StringBuilder();
var column = defaultConstraint.Column;
var table = defaultConstraint.Table;
var schema = defaultConstraint.Column.DataTable.Schema;
var gettingNameOfDefaultConstraintScript = GetCurentNameOfDefaultConstraintScript();
var sqlVariableName = RemoveFromStringInvalidCharacters(string.Format("var_{0}_{1}_{2}", schema.DbName,
table.DbName,
column.DbName));
resultBuilder.Append(string.Format(gettingNameOfDefaultConstraintScript,
sqlVariableName,
QuoteIdentifier(schema.Catalog.DbName),
schema.DbName,
table.DbName,
column.DbName));
resultBuilder.Append(" ");
resultBuilder.Append("Exec(N'");
resultBuilder.Append(Translate(context, node, AlterTableSection.Entry));
resultBuilder.Append(Translate(context, node, AlterTableSection.DropConstraint));
resultBuilder.AppendFormat(" CONSTRAINT [' + @{0} + N']')", sqlVariableName);
return(resultBuilder.ToString());
}
public virtual string Translate(SqlCompilerContext context, SqlAlterTable node, DefaultConstraint constraint)
{
return(TranslateExecDropDefaultConstraint(context, node, constraint));
}
/// <summary>
/// Enumerates the SQL commands that are necessary to drop
/// the specified <paramref name="defaultConstraint"/>.
/// </summary>
/// <param name="defaultConstraint">The default constraint.</param>
/// <returns>The SQL commands.</returns>
protected override IEnumerable<string> DropDefaultConstraint(DefaultConstraint defaultConstraint)
{
IEnumerable<string> sql = null;
if (string.IsNullOrEmpty(defaultConstraint.Name))
{
sql = new string[]
{
string.Format("DECLARE @{0}DefaultName VARCHAR(MAX);", defaultConstraint.ColumnName) +
Environment.NewLine +
string.Format("SELECT @{0}DefaultName = o2.name " +
"FROM syscolumns c " +
"JOIN sysobjects o ON c.id = o.id " +
"JOIN sysobjects o2 ON c.cdefault = o2.id " +
"WHERE o.name = {1} AND c.name = {2};",
defaultConstraint.ColumnName,
FormatValue(defaultConstraint.Table.Name),
FormatValue(defaultConstraint.ColumnName)
) +
Environment.NewLine +
string.Format("EXEC('ALTER TABLE {0} DROP CONSTRAINT ' + @{1}DefaultName);",
EscapeTableName(string.Format(defaultConstraint.Table.Name)),
defaultConstraint.ColumnName
)
};
}
else
{
sql = base.DropDefaultConstraint(defaultConstraint);
}
return sql;
}
private bool WriteDefaultValue(TableRef tblName, string colName, DefaultConstraint def, IEnumerable<string> discriminatorFilter)
{
if (def is NewGuidDefaultConstraint)
{
db.WriteGuidDefaultValue(tblName, colName, discriminatorFilter);
return true;
}
else if (def is DateTimeDefaultConstraint)
{
if (((DateTimeDefaultConstraint)def).Precision == DateTimeDefaultConstraintPrecision.Date)
db.WriteDefaultValue(tblName, colName, DateTime.Today, discriminatorFilter);
else
db.WriteDefaultValue(tblName, colName, DateTime.Now, discriminatorFilter);
return true;
}
else if (def is BoolDefaultConstraint)
{
db.WriteDefaultValue(tblName, colName, ((BoolDefaultConstraint)def).Value, discriminatorFilter);
return true;
}
else if (def is IntDefaultConstraint)
{
db.WriteDefaultValue(tblName, colName, ((IntDefaultConstraint)def).Value, discriminatorFilter);
return true;
}
else if (def is DecimalDefaultConstraint)
{
db.WriteDefaultValue(tblName, colName, ((DecimalDefaultConstraint)def).Value, discriminatorFilter);
return true;
}
return false;
}
/// <summary>
/// Drops the <see cref="DefaultConstraint"/> of the specified <paramref name="columnName"/>.
/// </summary>
/// <param name="columnName">Name of the column.</param>
/// <returns>The constraint.</returns>
public DefaultConstraint DropDefaultConstraintByColumnName(string columnName)
{
var c = new DefaultConstraint(this, null, Modifier.Drop)
{
ColumnName = columnName
};
Database.MigrationSteps.EnqueueBefore(c, (e => e == this));
return c;
}
public override string CreateDefaultConstraint(DataContext sourceDataContext, DataContext targetDataContext, DefaultConstraint defaultConstraint)
{
var builder = new StringBuilder();
builder.Append("ALTER TABLE ");
builder.Append(CreateIdentifier(defaultConstraint.UserTable));
builder.Append(" ADD CONSTRAINT `");
builder.Append(defaultConstraint.ObjectName);
builder.Append("` DEFAULT ");
builder.Append(defaultConstraint.Definition);
builder.Append(" FOR `");
builder.Append(defaultConstraint.ColumnName);
builder.Append("`");
return(builder.ToString());
}
/// <summary>
/// Enumerates the SQL commands that are necessary to create
/// the specified <paramref name="defaultConstraint"/>.
/// </summary>
/// <param name="defaultConstraint">The default constraint.</param>
/// <returns>The SQL commands.</returns>
protected virtual IEnumerable<string> AddDefaultConstraint(DefaultConstraint defaultConstraint)
{
yield return string.Format(
"ALTER TABLE {0} ADD CONSTRAINT {1} DEFAULT({2}) FOR {3};",
EscapeTableName(defaultConstraint.Table.Name),
EscapeConstraintName(defaultConstraint.Name),
FormatValue(defaultConstraint.Value),
EscapeColumnName(defaultConstraint.ColumnName)
);
}
/// <summary>
/// Enumerates the SQL commands that are necessary to drop
/// the specified <paramref name="defaultConstraint"/>.
/// </summary>
/// <param name="defaultConstraint">The default constraint.</param>
/// <returns>The SQL commands.</returns>
protected virtual IEnumerable<string> DropDefaultConstraint(DefaultConstraint defaultConstraint)
{
yield return string.Format("ALTER TABLE {0} ALTER COLUMN {1} DROP DEFAULT;",
EscapeTableName(defaultConstraint.Table.Name),
EscapeConstraintName(defaultConstraint.Name)
);
}
private void CheckColumn(TableRef tblName, string colName, System.Data.DbType type, int size, int scale, bool isNullable, DefaultConstraint defConstr)
{
if (db.CheckColumnExists(tblName, colName))
{
// TODO: Add DataType Check
{
var colIsNullable = db.GetIsColumnNullable(tblName, colName);
if (colIsNullable != isNullable)
{
Log.WarnFormat("Column '{0}'.'{1}' nullable mismatch. Column is {2} but should be {3}", tblName, colName,
colIsNullable ? "NULLABLE" : "NOT NULLABLE",
isNullable ? "NULLABLE" : "NOT NULLABLE");
if (repair)
{
if (isNullable || (!isNullable && !db.CheckColumnContainsNulls(tblName, colName)))
{
db.AlterColumn(tblName, colName, type, size, scale, isNullable, defConstr);
Log.Info("Fixed");
}
else if (!isNullable && db.CheckColumnContainsNulls(tblName, colName))
{
Log.WarnFormat("Column '{0}.{1}' contains NULL values, cannot set NOT NULLABLE", tblName, colName);
}
}
}
}
if (type == System.Data.DbType.String)
{
int colSize = db.GetColumnMaxLength(tblName, colName);
// TODO: Introduce TextProperty
if (size == int.MaxValue)
{
// TODO: Check if nvarchar(max) or text
}
else if (colSize != size)
{
Log.WarnFormat("Column '{0}'.'{1}' length mismatch. Columns length is {2} but should be {3}", tblName, colName, colSize, size);
}
}
{
bool colHasDefValue = db.GetHasColumnDefaultValue(tblName, colName);
bool hasDefValue = defConstr != null;
if (colHasDefValue != hasDefValue)
{
Log.WarnFormat("Column '{0}'.'{1}' default value mismatch. Column {2} a default value but should {3}have one", tblName, colName,
colHasDefValue ? "has" : "does not have",
hasDefValue ? string.Empty : "not ");
if (repair)
{
db.AlterColumn(tblName, colName, type, size, scale, isNullable, defConstr);
}
}
}
}
else
{
Log.WarnFormat("Column '{0}'.'{1}' is missing", tblName, colName);
if (repair)
{
Log.Info("Fixing");
if (!isNullable && db.CheckTableContainsData(tblName))
{
Log.WarnFormat("Table '{0}' contains data, cannot create NOT NULLABLE column '{1}'", tblName, colName);
db.CreateColumn(tblName, colName, type, size, scale, true, defConstr);
}
else
{
db.CreateColumn(tblName, colName, type, size, scale, isNullable, defConstr);
}
}
}
}
/// <summary>
/// Adds the default <see cref="Constraint"/> to this <see cref="Table"/>.
/// </summary>
/// <param name="name">The constraint name.</param>
/// <param name="columnName">The name of the column that has the defaul constraint.</param>
/// <param name="value">The default value.</param>
/// <returns>The default constraint.</returns>
public DefaultConstraint AddDefaultConstraint(string name, string columnName, object value)
{
var c = new DefaultConstraint(this, name, Modifier.Add)
{
ColumnName = columnName,
Value = value
};
Database.MigrationSteps.Enqueue(c);
return c;
}
public override string DropDefaultConstraint(DataContext sourceDataContext, DataContext targetDataContext, DefaultConstraint defaultConstraint)
{
var builder = new StringBuilder();
builder.Append("ALTER TABLE ");
builder.Append(CreateIdentifier(defaultConstraint.UserTable));
builder.Append(" DROP CONSTRAINT `");
builder.Append(defaultConstraint.ObjectName);
builder.Append("`");
return(builder.ToString());
}
/// <summary>
/// Drops the <see cref="DefaultConstraint"/> with the specified <paramref name="name"/>.
/// </summary>
/// <param name="name">The constraint's name.</param>
/// <returns>The constraint.</returns>
public DefaultConstraint DropDefaultConstraint(string name)
{
var c = new DefaultConstraint(this, name, Modifier.Drop);
Database.MigrationSteps.EnqueueBefore(c, (e => e == this));
return c;
}
