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); } }