public void TestReferencedTableViaConstraintName()
{
//create a schema
var schema = new DatabaseSchema(null, SqlType.SqlServer);
schema.AddTable("Products")
.AddColumn("ProductId").AddPrimaryKey()
.AddColumn("ProductName")
.AddColumn("CategoryId")
.AddTable("Categories")
.AddColumn("CategoryId").AddPrimaryKey("CategoryPK")
.AddColumn("CategoryName")
;
//look at the schema
var categories = schema.FindTableByName("Categories");
var products = schema.FindTableByName("Products");
//from the database we normally get a RefersToTable defined.
//sometimes we don't- we just get the name of the pk constraint
//so here we simulate that
var fk = new DatabaseConstraint
{
ConstraintType = ConstraintType.ForeignKey,
TableName = "Categories",
RefersToConstraint = "CategoryPK"
};
fk.Columns.Add("CategoryId");
products.AddConstraint(fk);
//act
var referencedTable = fk.ReferencedTable(schema);
//assert
Assert.AreEqual(categories, referencedTable);
}
/// <summary>
/// Returns the name of a foreign key property for a given foreign key.
/// </summary>
/// <param name="table">The table.</param>
/// <param name="foreignKey">The foreign key.</param>
/// <returns></returns>
/// <remarks>
/// If it is a simple foreign key, it is the NetName of the column
/// if it is a composite foreign key, it is the NetName of the foreign table
/// if there is a collision with the class name, append "Key"
/// If there are multiple foreign keys to one table, ensure they are unique.
/// </remarks>
public virtual string ForeignKeyName(DatabaseTable table, DatabaseConstraint foreignKey)
{
var refTable = foreignKey.ReferencedTable(table.DatabaseSchema);
if (refTable == null)
{
//we can't find the foreign key table, so just write the columns
return null;
}
//This is a name for the foreign key. Only used for composite keys.
var propertyName = refTable.NetName;
//if there is only one column (not composite) use the netName of that column
if (foreignKey.Columns.Count == 1)
{
var columnName = foreignKey.Columns.Single();
var column = table.FindColumn(columnName);
//if it is a primary key, we've used the original name for a scalar property
if (!column.IsPrimaryKey)
propertyName = column.NetName;
}
else //composite keys
{
// Check whether the referenced table is used in any other key. This ensures that the property names
// are unique.
if (table.ForeignKeys.Count(x => x.RefersToTable == foreignKey.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 += foreignKey.Name;
}
}
// Ensures that property name cannot be the same as class name
if (propertyName == table.NetName)
{
propertyName += "Key";
}
return propertyName;
}
private string ForeignKeyTableName(DatabaseConstraint foreignKey)
{
var foreignKeyTable = foreignKey.ReferencedTable(Table.DatabaseSchema);
return (foreignKeyTable != null)
? TableName(foreignKeyTable)
: EscapeName(foreignKey.RefersToTable);
}
/// <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);
}
}