public void TestAddPrimaryKeyNoEscapeNames()
{
//arrange
var migration = new DdlGeneratorFactory(SqlType.SqlServer).MigrationGenerator();
migration.EscapeNames = false;
var schema = new DatabaseSchema(null, SqlType.SqlServer);
var table = schema.AddTable("Test")
.AddColumn <int>("Id")
.AddColumn <string>("Name")
.Table;
var pk = new DatabaseConstraint
{
Name = "Test_PK",
ConstraintType = ConstraintType.PrimaryKey
};
pk.Columns.Add("Id");
//act
var sql = migration.AddConstraint(table, pk);
//assert
Assert.IsTrue(sql.IndexOf("ADD CONSTRAINT Test_PK PRIMARY KEY (Id)", StringComparison.OrdinalIgnoreCase) != -1, "adding a primary key");
}
public void GivenUniqueConstraintWithChangedColumn()
{
//arrange
DatabaseSchema schema1 = CreateSchema();
DatabaseConstraint constraint = GetUniqueConstraint();
schema1.Tables[0].AddConstraint(constraint);
DatabaseSchema schema2 = CreateSchema();
DatabaseConstraint constraint2 = GetUniqueConstraint();
constraint2.Columns[0] = "Desc";
schema2.Tables[0].AddConstraint(constraint2);
//act
var comparison = new CompareSchemas(schema1, schema2);
var result = comparison.ExecuteResult();
//assert
var changeConstraint = result.FirstOrDefault(x =>
x.ResultType == ResultType.Change &&
x.SchemaObjectType == SchemaObjectType.Constraint &&
x.TableName == "Orders" &&
x.Name == "UK_NAME");
Assert.IsNotNull(changeConstraint);
}
private static DatabaseSchema Arrange()
{
const string key1 = "OriginKey1";
const string key2 = "OriginKey2";
var schema = new DatabaseSchema(null, null);
var table = schema.AddTable("Products")
.AddColumn("ProductId", "INT").AddPrimaryKey().AddIdentity()
.AddColumn("ProductName", "NVARCHAR")
.AddColumn(key1, "NVARCHAR").AddForeignKey("Origin")
.AddColumn(key2, "NVARCHAR")
.Table;
table.ForeignKeys.Single().AddColumn(table.FindColumn(key2));
var pk = new DatabaseConstraint {
ConstraintType = ConstraintType.PrimaryKey,
};
pk.Columns.Add(key1);
pk.Columns.Add(key2);
schema.AddTable("Origin")
.AddColumn <string>(key1).AddPrimaryKey()
.AddColumn <string>(key2)
.Table.AddConstraint(pk);
schema.DataTypes.Add(new DataType("INT", "System.Int32"));
schema.DataTypes.Add(new DataType("NVARCHAR", "System.String"));
DatabaseSchemaFixer.UpdateDataTypes(schema);
//make sure .Net names are assigned
PrepareSchemaNames.Prepare(schema, new Namer());
return(schema);
}
public virtual string AddConstraint(DatabaseTable databaseTable, DatabaseConstraint constraint)
{
//we always use the named form.
var constraintName = constraint.Name;
if (string.IsNullOrEmpty(constraintName))
{
throw new InvalidOperationException("Constraint must have a name");
}
//primary, unique and foreign key constraints must have columns
if (constraint.Columns.Count == 0 && constraint.ConstraintType != ConstraintType.Check)
{
throw new InvalidOperationException("Constraint has no columns");
}
//use the standard constraint writer for the database
var constraintWriter = _ddlFactory.ConstraintWriter(databaseTable);
if (constraintWriter == null)
{
return(null);
}
constraintWriter.IncludeSchema = IncludeSchema; //cascade setting
constraintWriter.EscapeNames = EscapeNames;
return(constraintWriter.WriteConstraint(constraint));
}
public void TestSqlServerAddDefaultConstraint()
{
//arrange
var migration = new DdlGeneratorFactory(SqlType.SqlServer).MigrationGenerator();
var table = MigrationCommon.CreateTestTable("Orders");
table.SchemaOwner = "dbo";
var column = table.FindColumn("NAME");
column.Length = 40;
column.DefaultValue = "'?'";
//add a default constraint
var df = new DatabaseConstraint {
ConstraintType = ConstraintType.Default, Name = "DF_Orders_Name", Expression = "'?'"
};
df.Columns.Add("NAME");
table.AddConstraint(df);
//act
var sql = migration.AddConstraint(table, df);
//assert
//ALTER TABLE [dbo].[Orders] ADD CONSTRAINT [DF_Orders_Name] DEFAULT '?' FOR [NAME];
Assert.IsTrue(sql.Contains("ADD CONSTRAINT [DF_Orders_Name] DEFAULT '?' FOR [NAME]"), "add constraint");
}
public override string WritePrimaryKey(DatabaseConstraint constraint)
{
if (constraint == null)
{
return(null);
}
var columnList = GetColumnList(constraint.Columns);
var pkName = ConstraintName(constraint);
var nonClustered = "";
if (constraint.Columns.Count == 1)
{
//UNIQUEIDENTIFIERs may have NON CLUSTERED indexes
//the pk index will have IndexType of PRIMARY NONCLUSTERED
var pkIndex = Table.Indexes.Find(x => x.IndexType?.IndexOf("PRIMARY", StringComparison.OrdinalIgnoreCase) != -1);
if (pkIndex != null &&
pkIndex.IndexType?.IndexOf("NONCLUSTERED", StringComparison.OrdinalIgnoreCase) > -1)
{
nonClustered = "NONCLUSTERED";
}
}
return(string.Format(CultureInfo.InvariantCulture,
@"ALTER TABLE {0} ADD CONSTRAINT {1} PRIMARY KEY {2}({3})",
TableName(Table),
EscapeName(pkName),
nonClustered,
columnList) + SqlFormatProvider().LineEnding());
}
/// <summary>
/// KL:
/// Similar to WriteColumn. Will send the appropriate dataType and propertyName to
/// _cb.AppendAutomaticProperty to be written.
///
/// This method was needed to support composite foreign keys.
/// </summary>
/// <param name="fKey"></param>
private void WriteForeignKey(DatabaseConstraint fKey)
{
var propertyName = "Unknown";
// get the reference table
var refTable = _table.DatabaseSchema.FindTableByName(fKey.RefersToTable);
// get the parent table
var parentTable = _table.DatabaseSchema.FindTableByName(fKey.TableName);
if (refTable != null)
{
propertyName = refTable.NetName;
}
var dataType = propertyName;
// Check whether the referenced table is used in any other key. This ensures that the property names
// are unique.
if (parentTable.ForeignKeys.Count(x => x.RefersToTable == fKey.RefersToTable) > 1)
{
// Append the key name to the property name. In the event of multiple foreign keys to the same table
// This will give the consumer context.
propertyName += fKey.Name;
}
// Ensures that property name cannot be the same as class name
if (propertyName == parentTable.NetName)
{
propertyName += "Key";
}
_cb.AppendAutomaticProperty(dataType, propertyName);
}
public void TestSqlServerDropColumnWithDefault()
{
//arrange
var migration = new DdlGeneratorFactory(SqlType.SqlServer).MigrationGenerator();
var table = MigrationCommon.CreateTestTable("Orders");
table.SchemaOwner = "dbo";
var column = table.FindColumn("NAME");
column.Length = 40;
column.DefaultValue = "'?'";
//add a default constraint
var df = new DatabaseConstraint {
ConstraintType = ConstraintType.Default, Name = "DF_Orders_Name"
};
df.Columns.Add("NAME");
table.AddConstraint(df);
//act
var sql = migration.DropColumn(table, column);
//assert
// No longer true for SQL server - DROP CONSTRAINT is done by constraint deltas
//ALTER TABLE [dbo].[Orders] DROP CONSTRAINT [DF_Orders_Name];
//ALTER TABLE [dbo].[Orders] DROP COLUMN [NAME];
//Assert.IsTrue(sql.Contains("DROP CONSTRAINT [DF_Orders_Name]"), "drop constraint");
Assert.IsTrue(sql.Contains("DROP COLUMN [NAME]"), "drop column");
}
/// <summary>
/// KL:
/// Similar to WriteColumn. Will send the appropriate dataType and propertyName to
/// _cb.AppendAutomaticProperty to be written.
///
/// This method was needed to support composite foreign keys.
/// </summary>
/// <param name="foreignKey"></param>
private void WriteForeignKey(DatabaseConstraint foreignKey)
{
// get the reference table
var refTable = foreignKey.ReferencedTable(_table.DatabaseSchema);
//we inherit from it instead (problem with self-joins)
if (Equals(refTable, _inheritanceTable))
{
return;
}
if (refTable == null)
{
//we can't find the foreign key table, so just write the columns
WriteForeignKeyColumns(foreignKey, "");
return;
}
var propertyName = _codeWriterSettings.Namer.ForeignKeyName(_table, foreignKey);
var dataType = refTable.NetName;
_cb.AppendAutomaticProperty(dataType, propertyName);
if (IsEntityFramework() && _codeWriterSettings.UseForeignKeyIdProperties)
{
WriteForeignKeyColumns(foreignKey, propertyName);
}
}
public void TestCompositeKeys()
{
//arrange
var schema = new DatabaseSchema(null, null);
schema.AddTable("Store")
.AddColumn <int>("Store_Id").AddPrimaryKey("Store_PK")
.AddColumn <string>("Name").AddLength(10)
.AddTable("StoreSale")
.AddColumn <int>("Store_Id").AddForeignKey("Store_FK", "Store")
.AddColumn <int>("StoreSale_Id")
.AddTable("StoreSaleDetail")
.AddColumn <int>("Store_Id").AddForeignKey("Store_FK", "Store")
.AddColumn <int>("StoreSale_Id")
.AddColumn <int>("StoreSaleDetail_Id")
;
var store = schema.FindTableByName("Store");
var storeSale = schema.FindTableByName("StoreSale");
var storeSaleDetail = schema.FindTableByName("StoreSaleDetail");
var pk1 = new DatabaseConstraint {
ConstraintType = ConstraintType.PrimaryKey
};
pk1.Columns.Add("Store_Id");
pk1.Columns.Add("StoreSale_Id");
storeSale.AddConstraint(pk1);
var pk2 = new DatabaseConstraint {
ConstraintType = ConstraintType.PrimaryKey
};
pk2.Columns.Add("Store_Id");
pk2.Columns.Add("StoreSale_Id");
pk2.Columns.Add("StoreSaleDetail_Id");
storeSaleDetail.AddConstraint(pk2);
var fk = new DatabaseConstraint {
ConstraintType = ConstraintType.ForeignKey, RefersToTable = "StoreSale"
};
fk.Columns.Add("Store_Id");
fk.Columns.Add("StoreSale_Id");
storeSaleDetail.AddConstraint(fk);
//act
DatabaseSchemaFixer.UpdateReferences(schema);
//assert
Assert.AreEqual(2, store.ForeignKeyChildren.Count, "Store is target of foreign keys from StoreSale and StoreSaleDetail");
Assert.AreEqual(1, storeSale.ForeignKeyChildren.Count, "StoreSale is target of foreign key from StoreSaleDetail");
var storeId = storeSaleDetail.FindColumn("Store_Id");
Assert.AreEqual(2, storeId.ForeignKeyTableNames.Count, "StoreSaleDetail.StoreId is fk to both Store and StoreSale");
var storeSaleId = storeSaleDetail.FindColumn("StoreSale_Id");
Assert.AreEqual(1, storeSaleId.ForeignKeyTableNames.Count, "StoreSaleDetail.StoreSale_Id is fk to StoreSale");
}
public void TestAddPrimaryKeyWithGuid()
{
//arrange
var migration = new DdlGeneratorFactory(SqlType.SqlServer).MigrationGenerator();
var schema = new DatabaseSchema(null, SqlType.SqlServer);
var table = schema.AddTable("Test")
.AddColumn <Guid>("Id")
.AddColumn <string>("Name")
.Table;
var pk = new DatabaseConstraint
{
Name = "Test_PK",
ConstraintType = ConstraintType.PrimaryKey
};
pk.Columns.Add("Id");
table.Indexes.Add(new DatabaseIndex
{
IndexType = "PRIMARY NONCLUSTERED",
Columns = { new DatabaseColumn {
Name = "Id"
} }
});
//act
var sql = migration.AddConstraint(table, pk);
//assert
Assert.IsTrue(sql.IndexOf("ADD CONSTRAINT [Test_PK] PRIMARY KEY NONCLUSTERED([Id])", StringComparison.OrdinalIgnoreCase) != -1, "adding a primary key");
}
public void Ctor_StringStringString_Success()
{
DatabaseConstraint c = new DatabaseConstraint(Constants.EntityName, Constants.KeyName, Constants.DisplayName);
Assert.AreEqual(Constraint.DatabaseConstraintName, c.Name);
Assert.AreEqual(Constants.DisplayName, c.DisplayProperty);
Assert.AreEqual(Constants.EntityName, c.Entity);
Assert.AreEqual(Constants.KeyName, c.KeyProperty);
}
public void Ctor_NullNullNull_Success()
{
DatabaseConstraint c = new DatabaseConstraint(null, null, null);
Assert.AreEqual(Constraint.DatabaseConstraintName, c.Name);
Assert.AreEqual(string.Empty, c.DisplayProperty);
Assert.AreEqual(string.Empty, c.Entity);
Assert.AreEqual(string.Empty, c.KeyProperty);
}
private string ForeignKeyTableName(DatabaseConstraint foreignKey)
{
var foreignKeyTable = foreignKey.ReferencedTable(_table.DatabaseSchema);
return((foreignKeyTable != null)
? TableName(foreignKeyTable)
: EscapeName(foreignKey.RefersToTable));
}
private static bool ExcludeCheckConstraint(DatabaseConstraint check)
{
//don't allow SYSDATE in check constraints
if (check.Expression.IndexOf("getDate()", StringComparison.OrdinalIgnoreCase) != -1)
{
return(true);
}
return(false);
}
public MsSqlTable(string tableName, IEnumerable <SqlColumnSchema> columns, DatabaseConstraint tableSchemaPrimaryKey, List <DatabaseConstraint> tableSchemaUniqueKeys)
{
Name = tableName;
_columns = columns.ToDictionary(column => column.Name);
var primaryKey = tableSchemaPrimaryKey?.Columns;
var uniqueKeys = tableSchemaUniqueKeys.Select(x => x.Columns).ToList();
Keys = new[] { primaryKey }.Union(uniqueKeys).Where(x => x != null).ToArray();
}
public static DatabaseTable CreateTestTable(string tableName)
{
//we only need a schema because MySQL foreign key references do not allow just the foreign key table name- they need the columns too
var schema = new DatabaseSchema(null, null);
var testTable = new DatabaseTable {
Name = tableName, Description = "This is a test table"
};
schema.Tables.Add(testTable);
testTable.DatabaseSchema = schema; //the migration will discover this and know how to link the self referencing table
var intDataType = new DataType("INT", "System.Int32");
var idColumn = new DatabaseColumn
{
Name = "Id",
DbDataType = "int",
DataType = intDataType,
Nullable = false,
Description = "Primary key",
};
testTable.Columns.Add(idColumn);
var parentColumn = new DatabaseColumn
{
Name = "Parent", //for a self-referencing foreign key
DbDataType = "int",
DataType = intDataType,
Nullable = true,
Description = "Self referencing foreign key",
};
testTable.Columns.Add(parentColumn);
var nameColumn = new DatabaseColumn
{
Name = "NAME",
DbDataType = "VARCHAR",
Length = 10,
DataType = new DataType("VARCHAR", "string"),
Description = "Simple varchar column",
};
testTable.Columns.Add(nameColumn);
var primaryKey = new DatabaseConstraint {
ConstraintType = ConstraintType.PrimaryKey, Name = "PK_" + tableName
};
primaryKey.Columns.Add("Id");
testTable.PrimaryKey = primaryKey;
return(testTable);
}
public static DatabaseConstraint CreateUniqueConstraint(DatabaseColumn column)
{
var constraint = new DatabaseConstraint
{
Name = "UK_COUNTRY",
ConstraintType = ConstraintType.UniqueKey,
};
constraint.Columns.Add(column.Name);
return(constraint);
}
protected override string WriteDefaultConstraint(DatabaseConstraint constraint)
{
var column = EscapeName(constraint.Columns.FirstOrDefault());
return(string.Format(CultureInfo.InvariantCulture,
@"ALTER TABLE {0} ADD CONSTRAINT {1} DEFAULT {2} FOR {3}",
TableName(Table),
EscapeName(constraint.Name),
constraint.Expression,
column) + SqlFormatProvider().LineEnding());
}
private static DatabaseConstraint GetUniqueConstraint()
{
var constraint = new DatabaseConstraint
{
Name = "UK_NAME",
ConstraintType = ConstraintType.UniqueKey,
};
constraint.Columns.Add("Name");
return(constraint);
}
protected virtual string ConstraintName(DatabaseConstraint constraint)
{
var name = constraint.Name;
if (string.IsNullOrEmpty(name))
{
return("CON");
}
name = LimitNameToMaximumLength(name);
return(name);
}
public static DatabaseConstraint CreateForeignKey(DatabaseTable databaseTable)
{
var constraint = new DatabaseConstraint
{
Name = "FK_" + databaseTable.Name,
ConstraintType = ConstraintType.ForeignKey,
RefersToTable = databaseTable.Name
};
constraint.Columns.Add("Parent");
return(constraint);
}
private string WriteUniqueKey(DatabaseConstraint uniqueKey)
{
var columnList = GetColumnList(uniqueKey.Columns);
var name = ConstraintName(uniqueKey.Name);
return(string.Format(CultureInfo.InvariantCulture,
AddUniqueConstraintFormat,
TableName(_table),
EscapeName(name),
columnList) + SqlFormatProvider().LineEnding());
}
public void BuildDropConstraint(DatabaseTable databaseTable, DatabaseConstraint constraint)
{
try
{
var txt = _migrationGenerator.DropConstraint(databaseTable, constraint);
Clipboard.SetText(txt, TextDataFormat.UnicodeText);
}
catch (Exception exception)
{
Debug.WriteLine(exception.Message);
}
}
private static bool ConstraintColumnsEqual(DatabaseConstraint first, DatabaseConstraint second)
{
if (first.Columns == null && second.Columns == null)
{
return(true); //same, both null
}
if (first.Columns == null || second.Columns == null)
{
return(false); //one is null, they are different
}
return(first.Columns.SequenceEqual(second.Columns));
}
protected virtual string ConstraintName(DatabaseConstraint constraint)
{
var name = constraint.Name;
if (string.IsNullOrEmpty(name))
{
return(" PK_" + constraint.TableName);
}
//if (string.IsNullOrEmpty(name)) return constraint.TableName+"_CON";
name = LimitNameToMaximumLength(name);
return(name);
}
private void WriteForeignKey(DatabaseTable table, DatabaseConstraint foreignKey, StringBuilder sb)
{
sb.AppendLine("ALTER TABLE [" + table.Name + "]");
var cols = string.Join(", ", foreignKey.Columns.ToArray());
var referencedTableName = foreignKey.RefersToTable;
//find the referenced table's primary key
var refTable = _schema.Tables.Find(t => t.Name == referencedTableName);
var refPrimaryKey = refTable.PrimaryKey;
var refcols = string.Join(", ", refPrimaryKey.Columns.ToArray());
sb.AppendLine(" ADD CONSTRAINT [" + foreignKey.Name +
"] FOREIGN KEY (" + cols + ") REFERENCES " + referencedTableName + "(" + refcols + ")");
}
public string BuildAddConstraint(DatabaseTable databaseTable, DatabaseConstraint constraint)
{
StringBuilder sb = new StringBuilder();
try
{
sb.Append(m_migrationGenerator.AddConstraint(databaseTable, constraint));
}
catch (Exception exception)
{
Debug.WriteLine(exception.Message);
}
return(sb.ToString());
}
public void WriteWith(DatabaseConstraint foreignKey)
{
// TODO: refactor this method to be consistent with approach taken for other overload
var refTable = foreignKey.ReferencedTable(table.DatabaseSchema);
var dataType = refTable.NetName;
if (foreignKey.Columns.Count != foreignKey.ReferencedColumns(table.DatabaseSchema).Count())
{
throw new InvalidOperationException("Number of foreign key columns does not match number of columns referenced!");
}
classBuilder.BeginNest($"public virtual {CodeWriterUtils.GetWithMethodSignature(table, foreignKey, codeWriterSettings)}");
var methodCallParameters = new List <string>();
var propertyName = codeWriterSettings.Namer.ForeignKeyName(table, foreignKey);
foreach (var fkc in foreignKey.Columns)
{
var tc = table.Columns.Single(_tc => _tc.Name == fkc);
var parameter = $"{CodeWriterUtils.GetPropertyNameForDatabaseColumn(tc)}";
if (tc.Nullable && CodeWriterUtils.FindDataType(tc).EndsWith("?")) // KE: need the check for the "?" so that we correctly handle reference types like string
{
using (classBuilder.BeginNest($"if (!{parameter}.HasValue)"))
{
classBuilder.AppendLine($"{propertyName} = null;");
classBuilder.AppendLine("return this;");
}
classBuilder.AppendLine("");
parameter += ".Value";
}
methodCallParameters.Add(parameter);
}
var s = string.Join(", ", methodCallParameters);
var referencedColumnNames = foreignKey.ReferencedColumns(table.DatabaseSchema).ToList();
referencedColumnNames.Sort();
var referencedColumns = referencedColumnNames.Select(c => foreignKey.ReferencedTable(table.DatabaseSchema).FindColumn(c));
var methodParameters = CodeWriterUtils.GetMethodParametersForColumns(referencedColumns, codeWriterSettings);
var methodName = CodeWriterUtils.GetMethodName(methodParameters, codeWriterSettings, true, CodeWriterUtils.BaseMethodNameGet);
var fieldNameForFkTableRepository = NameFixer.ToCamelCase(CodeWriterUtils.GetRepositoryImplementationName(refTable));
classBuilder.AppendLine($"{propertyName} = _{fieldNameForFkTableRepository}.{methodName}({s});");
classBuilder.AppendLine("return this;");
classBuilder.EndNest();
classBuilder.AppendLine("");
}
private void WriteForeignKey(DatabaseConstraint foreignKey)
{
var propertyName = _codeWriterSettings.Namer.ForeignKeyName(_table, foreignKey);
if (string.IsNullOrEmpty(propertyName))
{
return;
}
var columnName = foreignKey.Columns.FirstOrDefault();
var columns = foreignKey.Columns.Select(colName => _table.FindColumn(colName)).ToList();
var optional = columns.All(col => col.Nullable);
//foreign key is a primary key = shared with another table
var isPrimaryKey = columns.All(col => col.IsPrimaryKey);
var sb = new StringBuilder();
sb.AppendFormat(CultureInfo.InvariantCulture, "Has{0}(x => x.{1})",
optional ? "Optional" : "Required",
propertyName);
//1:1 shared primary key
if (isPrimaryKey)
{
sb.Append(";");
_cb.AppendLine(sb.ToString());
return;
}
//then map the inverse with our foreign key children convention
var fkPropertyName = _codeWriterSettings.Namer.ForeignKeyCollectionName(foreignKey.RefersToTable, _table, foreignKey);
sb.AppendFormat(CultureInfo.InvariantCulture, ".WithMany(c => c.{0})", fkPropertyName);
if (_codeWriterSettings.UseForeignKeyIdProperties)
{
//for pk/fk we have a mirror property
//TODO: don't use Id here
var fkIdName = propertyName + "Id";
_cb.AppendFormat("Property(x => x.{0}).HasColumnName(\"{1}\");", fkIdName, columnName);
sb.AppendFormat(CultureInfo.InvariantCulture, ".HasForeignKey(c => c.{0})", fkIdName);
}
else
{
//otherwise specify the underlying column name
sb.AppendFormat(CultureInfo.InvariantCulture, ".Map(m => m.MapKey(\"{0}\"))", columnName);
}
//could look up cascade rule here
sb.Append(";");
_cb.AppendLine(sb.ToString());
}
public virtual string DropConstraint(DatabaseTable databaseTable, DatabaseConstraint constraint)
{
if (constraint.ConstraintType == ConstraintType.UniqueKey)
{
return(string.Format(CultureInfo.InvariantCulture,
DropUniqueFormat,
TableName(databaseTable),
Escape(constraint.Name)) + LineEnding());
}
return(string.Format(CultureInfo.InvariantCulture,
DropForeignKeyFormat,
TableName(databaseTable),
Escape(constraint.Name)) + LineEnding());
}
private A GetInFkLink(string sourceTable, DatabaseConstraint fk, IDictionary <string, object> o)
{
var filters = fk.Columns
.Select(c => KeyValuePair.Create(c, (object)_dbInspector.GetId(sourceTable, o)))
.ToList();
var name = $"Search '{fk.TableName}' where {filters.Select(kvp => kvp.Key + "=" + kvp.Value).JoinToString()}";
var rel = fk.TableName;
var url = _linkManager.LinkToQuery(fk.TableName, filters);
return(new A(url, name, rel)
{
Itemscope = true,
});
}
public void SetParameters_TooManyFewParams_Error()
{
CustomAssert.ThrowsException<ConstraintConfigurationException>(() =>
{
DatabaseConstraint c = new DatabaseConstraint();
c.SetParametersInternal(new string[0], ParameterDataType.Int32);
});
CustomAssert.ThrowsException<ConstraintConfigurationException>(() =>
{
DatabaseConstraint c = new DatabaseConstraint();
c.SetParametersInternal(new string[] { "1", "2", "3", "4" }, ParameterDataType.Int32);
});
}
public void SetParameters_Null_Success()
{
DatabaseConstraint c = new DatabaseConstraint();
c.SetParametersInternal(new string[] { null, null, null }, ParameterDataType.Int32);
Assert.AreEqual(string.Empty, c.DisplayProperty);
Assert.AreEqual(string.Empty, c.Entity);
Assert.AreEqual(string.Empty, c.KeyProperty);
}
public void SetParameters_Success()
{
DatabaseConstraint c = new DatabaseConstraint();
c.SetParametersInternal(new string[] { Constants.EntityName, Constants.KeyName, Constants.DisplayName }, ParameterDataType.Int32);
Assert.AreEqual(Constants.DisplayName, c.DisplayProperty);
Assert.AreEqual(Constants.EntityName, c.Entity);
Assert.AreEqual(Constants.KeyName, c.KeyProperty);
}
public void ToString_Success()
{
DatabaseConstraint c = new DatabaseConstraint(Constants.EntityName, Constants.KeyName, Constants.DisplayName);
Assert.AreEqual(string.Format("[Database({0},{1},{2})]", Constants.EntityName, Constants.KeyName, Constants.DisplayName), c.ToString());
}
public void Ctor_SerializationInfo_Success()
{
DatabaseConstraint c = new DatabaseConstraint(Constants.EntityName, Constants.KeyName, Constants.DisplayName);
System.IO.MemoryStream Buffer = SerializationHelper.Serialize(c);
DatabaseConstraint c2 = SerializationHelper.Deserialize<DatabaseConstraint>(Buffer);
Assert.AreEqual(Constraint.DatabaseConstraintName, c2.Name);
Assert.AreEqual(Constants.DisplayName, c2.DisplayProperty);
Assert.AreEqual(Constants.EntityName, c2.Entity);
Assert.AreEqual(Constants.KeyName, c2.KeyProperty);
}
private Constraint FindConstraint(string name, ParameterDataType type)
{
Constraint ReturnValue = null;
bool IsConstraintNameUnknown = false;
switch (name)
{
case Constraint.AllowedSchemeConstraintName:
ReturnValue = CreateAllowedSchemeConstraint(type);
break;
case Constraint.CharacterSetConstraintName:
ReturnValue = CreateCharacterSetConstraint(type);
break;
case Constraint.DatabaseConstraintName:
ReturnValue = new DatabaseConstraint();
break;
case Constraint.DecimalPlacesConstraintName:
ReturnValue = CreateDecimalPlacesConstraint(type);
break;
case Constraint.EncryptedConstraintName:
ReturnValue = new EncryptedConstraint();
break;
case Constraint.EndpointConstraintName:
ReturnValue = CreateEndpointConstraint(type);
break;
case Constraint.EnumValuesConstraintName:
ReturnValue = CreateEnumValuesConstraint(type);
break;
case Constraint.FileNameConstraintName:
ReturnValue = CreateFileNameConstraint(type);
break;
case Constraint.HostNameConstraintName:
ReturnValue = CreateHostnameConstraint(type);
break;
case Constraint.LengthConstraintName:
ReturnValue = CreateLengthConstraint(type);
break;
case Constraint.LowercaseConstraintName:
ReturnValue = CreateLowerCaseConstraint(type);
break;
case Constraint.MaximumLengthConstraintName:
ReturnValue = CreateMaximumLengthConstraint(type);
break;
case Constraint.MaximumValueConstraintName:
ReturnValue = CreateMaximumValueConstraint(type);
break;
case Constraint.MinimumLengthConstraintName:
ReturnValue = CreateMinimumLengthConstraint(type);
break;
case Constraint.MinimumValueConstraintName:
ReturnValue = CreateMinimumValueConstraint(type);
break;
case Constraint.NullConstraintName:
ReturnValue = new NullConstraint();
break;
case Constraint.PasswordConstraintName:
ReturnValue = CreatePasswordConstraint(type);
break;
case Constraint.PathConstraintName:
ReturnValue = CreatePathConstraint(type);
break;
case Constraint.RegexConstraintName:
ReturnValue = CreateRegexConstraint(type);
break;
case Constraint.StepConstraintName:
ReturnValue = CreateStepConstraint(type);
break;
case Constraint.TypeConstraintName:
ReturnValue = CreateTypeConstraint(type);
break;
case Constraint.UppercaseConstraintName:
ReturnValue = CreateUpperCaseConstraint(type);
break;
default:
// Constraint name is unknown
IsConstraintNameUnknown = true;
break;
}
if (ReturnValue == null)
{
ReturnValue = HandleUnknownConstraint(name, type, IsConstraintNameUnknown);
}
return ReturnValue;
}