public virtual void Apply(InternalEntityTypeBuilder entityTypeBuilder, ForeignKey foreignKey)
{
Check.NotNull(entityTypeBuilder, nameof(entityTypeBuilder));
Check.NotNull(foreignKey, nameof(foreignKey));
var properties = foreignKey.Properties;
if (properties.Any(e => e.GenerateValueOnAdd == true))
{
ConfigureValueGenerationStrategy(entityTypeBuilder, properties, true);
}
}
public IEnumerable<string> AddForeignKey(string tableName, string referencedTableName, IEnumerable<ColumnReference> columnNames, string constraintName)
{
Table table = GetTable(tableName);
ForeignKey foreignKey = new ForeignKey(table, constraintName) { ReferencedTable = referencedTableName };
foreach (ColumnReference columnReference in columnNames)
{
var fromColumn = new Microsoft.SqlServer.Management.Smo.Column(table, columnReference.ColumnName);
table.Columns.Add(fromColumn);
var foreignKeyColumn = new ForeignKeyColumn(foreignKey, columnReference.ColumnName, columnReference.ReferencedColumnName);
foreignKey.Columns.Add(foreignKeyColumn);
}
foreignKey.Create();
return ScriptChanges(table.Parent.Parent);
}
public void Can_create_foreign_key()
{
var entityType = new Model().AddEntityType("E");
var dependentProp = entityType.AddProperty("P", typeof(int));
var principalProp = entityType.AddProperty("Id", typeof(int));
entityType.GetOrSetPrimaryKey(principalProp);
var foreignKey
= new ForeignKey(new[] { dependentProp }, entityType.GetPrimaryKey(), entityType, entityType)
{
IsUnique = true
};
Assert.Same(entityType, foreignKey.PrincipalEntityType);
Assert.Same(principalProp, foreignKey.PrincipalKey.Properties.Single());
Assert.Same(dependentProp, foreignKey.Properties.Single());
Assert.True(foreignKey.IsUnique.Value);
Assert.Same(entityType.GetPrimaryKey(), foreignKey.PrincipalKey);
}
public IList<ForeignKey> DetermineForeignKeyReferences(Table table)
{
var constraints = table.Columns.Where(x => x.IsForeignKey.Equals(true)).Select(x => x.ConstraintName).Distinct().ToList();
var foreignKeys = new List<ForeignKey>();
constraints.ForEach(c =>
{
var fkColumns = table.Columns.Where(x => x.ConstraintName.Equals(c)).ToArray();
var fk = new ForeignKey
{
Name = fkColumns[0].Name,
References = GetForeignKeyReferenceTableName(table.Owner, table.Name, fkColumns[0].Name),
Columns = fkColumns
};
foreignKeys.Add(fk);
});
Table.SetUniqueNamesForForeignKeyProperties(foreignKeys);
return foreignKeys;
}
//My Method
public MetaDataPhysical getMetaDataPhysical()
{
//Convert tất cả shape qua MetaDataPhysical
MetaDataPhysical mdp = new MetaDataPhysical();
//Duyệt tất cả controls trên Panel
foreach (Control ctr in this.Controls)
{
TableShape tShape = (TableShape)ctr;
mdp.Tables.Add(tShape.table);
foreach (FKShape fkShape in tShape.listFK)
{
ForeignKey fk = new ForeignKey();
fk.Name = fkShape.fkName;
fk.ParentTable = tShape.table.name;
fk.ParentColumn = fkShape.parentColumn;
fk.ChildTable = fkShape.tableReference.table.name;
fk.ChildColumn = fkShape.childColumn;
mdp.ForeignKeys.Add(fk);
}
}
return mdp;
}
bool IsSelfReference(ForeignKey foreignKey, ForeignKey refTableForeignKey) {
return refTableForeignKey.Parent.Name==foreignKey.Parent.Name;
}
public bool IsOneToOne(ForeignKey foreignKey, string referenceColumn) {
var refTableForeignKey = GetRefTableForeignKey(foreignKey, referenceColumn);
return refTableForeignKey != null&&!IsSelfReference(foreignKey, refTableForeignKey);
}
protected override IEnumerable<DbParameter> CoreGetForeignKeyColumnParameters(Type connectionType, string dataSourceTag, Server server, Database database, Schema schema, Table table, ForeignKey foreignKey)
{
if ((object)connectionType == null)
throw new ArgumentNullException(nameof(connectionType));
if ((object)dataSourceTag == null)
throw new ArgumentNullException(nameof(dataSourceTag));
if ((object)server == null)
throw new ArgumentNullException(nameof(server));
if ((object)database == null)
throw new ArgumentNullException(nameof(database));
if ((object)schema == null)
throw new ArgumentNullException(nameof(schema));
if ((object)table == null)
throw new ArgumentNullException(nameof(table));
if ((object)foreignKey == null)
throw new ArgumentNullException(nameof(foreignKey));
if (dataSourceTag.SafeToString().ToLower() == ODBC_SQL_SERVER_DATA_SOURCE_TAG)
{
return new DbParameter[]
{
//DatazoidLegacyInstanceAccessor.AdoNetBufferingLegacyInstance.CreateParameter(connectionType, null,ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@P1", server.ServerName),
//DatazoidLegacyInstanceAccessor.AdoNetBufferingLegacyInstance.CreateParameter(connectionType, null,ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@P2", database.DatabaseName),
DatazoidLegacyInstanceAccessor.AdoNetBufferingLegacyInstance.CreateParameter(connectionType, null, ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@P3", schema.SchemaName),
//DatazoidLegacyInstanceAccessor.AdoNetBufferingLegacyInstance.CreateParameter(connectionType, null,ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@P4", table.TableName),
DatazoidLegacyInstanceAccessor.AdoNetBufferingLegacyInstance.CreateParameter(connectionType, null, ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@P5", foreignKey.ForeignKeyName)
};
}
throw new ArgumentOutOfRangeException(string.Format("dataSourceTag: '{0}'", dataSourceTag));
}
public virtual ForeignKey AddForeignKey(ForeignKey foreignKey)
{
if (ConstraintExists(foreignKey.ForeignTable, foreignKey.Name))
throw new ForeignKeyAlreadyExistsException(foreignKey.ForeignTable, foreignKey.Name);
foreignKey.PrimaryTable = QuoteTableNameIfRequired(foreignKey.PrimaryTable);
foreignKey.ForeignTable = QuoteTableNameIfRequired(foreignKey.ForeignTable);
QuoteColumnNames(foreignKey.ForeignColumns);
QuoteColumnNames(foreignKey.PrimaryColumns);
string constraintResolved = _constraintMapper.SqlForConstraint(foreignKey.ConstraintType);
ExecuteNonQuery(
String.Format(
"ALTER TABLE {0} ADD CONSTRAINT {1} FOREIGN KEY ({2}) REFERENCES {3} ({4}) ON UPDATE {5} ON DELETE {6}",
foreignKey.ForeignTable, foreignKey.Name, String.Join(",", foreignKey.ForeignColumns),
foreignKey.PrimaryTable, String.Join(",", foreignKey.PrimaryColumns), constraintResolved,
constraintResolved));
return foreignKey;
}
protected override IEnumerable <DbParameter> CoreGetForeignKeyColumnParameters(Type connectionType, string dataSourceTag, Server server, Database database, Schema schema, Table table, ForeignKey foreignKey)
{
if ((object)connectionType == null)
{
throw new ArgumentNullException(nameof(connectionType));
}
if ((object)dataSourceTag == null)
{
throw new ArgumentNullException(nameof(dataSourceTag));
}
if ((object)server == null)
{
throw new ArgumentNullException(nameof(server));
}
if ((object)database == null)
{
throw new ArgumentNullException(nameof(database));
}
if ((object)schema == null)
{
throw new ArgumentNullException(nameof(schema));
}
if ((object)table == null)
{
throw new ArgumentNullException(nameof(table));
}
if ((object)foreignKey == null)
{
throw new ArgumentNullException(nameof(foreignKey));
}
if (dataSourceTag.SafeToString().ToLower() == NET_SQL_SERVER_DATA_SOURCE_TAG)
{
return(new DbParameter[]
{
SolderFascadeAccessor.AdoNetBufferingFascade.CreateParameter(connectionType, null, ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@ServerName", server.ServerName),
SolderFascadeAccessor.AdoNetBufferingFascade.CreateParameter(connectionType, null, ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@DatabaseName", database.DatabaseName),
SolderFascadeAccessor.AdoNetBufferingFascade.CreateParameter(connectionType, null, ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@SchemaName", schema.SchemaName),
SolderFascadeAccessor.AdoNetBufferingFascade.CreateParameter(connectionType, null, ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@TableName", table.TableName),
SolderFascadeAccessor.AdoNetBufferingFascade.CreateParameter(connectionType, null, ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@ForeignKeyName", foreignKey.ForeignKeyName)
});
}
throw new ArgumentOutOfRangeException(string.Format("dataSourceTag: '{0}'", dataSourceTag));
}
public void IsRequired_false_for_composite_FK_by_default()
{
var entityType = new Model().AddEntityType("E");
var property = entityType.AddProperty("Id1", typeof(int));
var property1 = entityType.AddProperty("Id2", typeof(string));
entityType.GetOrSetPrimaryKey(new[]
{
property,
property1
});
var dependentProp1 = entityType.AddProperty("P1", typeof(int));
var dependentProp2 = entityType.AddProperty("P2", typeof(string));
var foreignKey = new ForeignKey(new[] { dependentProp1, dependentProp2 }, entityType.GetPrimaryKey(), entityType, entityType);
Assert.Null(foreignKey.IsRequired);
Assert.False(((IForeignKey)foreignKey).IsRequired);
}
public void Main()
{
string query = "\n create table B1 (b_id int primary key)" +
"\n create table A1 (b_id int references B1(b_id))" +
"\n create table B2 (" +
"\n b_id_1 int, " +
"\n b_id_2 int, " +
"\n CONSTRAINT [B2_PK] PRIMARY KEY CLUSTERED (b_id_1, b_id_2) ON [PRIMARY])" +
"\n create table A2 (" +
"\n b_id_1 int, " +
"\n b_id_2 int, " +
"\n constraint [A2_FK] FOREIGN KEY (b_id_1, b_id_2) " +
"\n REFERENCES B2 (b_id_1, b_id_2) ON DELETE CASCADE ON UPDATE NO ACTION)" +
"\n create table B3 (" +
"\n b_id_1 int," +
"\n b_id_2 int," +
"\n b_id_3 int," +
"\n CONSTRAINT [B3_PK] PRIMARY KEY CLUSTERED (b_id_1, b_id_2, b_id_3) ON [PRIMARY])" +
"\n create table A3 (" +
"\n A_col1 int," +
"\n b_id_3 int," +
"\n b_id_1 int," +
"\n b_id_2 int," +
"\n constraint [A3_FK] FOREIGN KEY (b_id_1, b_id_2, b_id_3) " +
"\n REFERENCES B3 (b_id_1, b_id_2, b_id_3) ON DELETE NO ACTION ON UPDATE CASCADE)";
ExecuteQuery(query);
var model = ExtractCatalog();
Schema schema = model.DefaultSchema;
// Validating.
ForeignKey fk1 = (ForeignKey)schema.Tables["A1"].TableConstraints[0];
Assert.IsNotNull(fk1);
Assert.IsTrue(fk1.Columns[0].Name == "b_id");
Assert.IsTrue(fk1.ReferencedColumns[0].Name == "b_id");
Assert.IsTrue(fk1.ReferencedColumns.Count == 1);
Assert.IsTrue(fk1.Columns.Count == 1);
ForeignKey fk2 = (ForeignKey)schema.Tables["A2"].TableConstraints[0];
Assert.IsNotNull(fk1);
Assert.IsTrue(fk2.Name == "A2_FK");
Assert.IsTrue(fk2.Columns[0].Name == "b_id_1");
Assert.IsTrue(fk2.ReferencedColumns[0].Name == "b_id_1");
Assert.IsTrue(fk2.Columns[1].Name == "b_id_2");
Assert.IsTrue(fk2.ReferencedColumns[1].Name == "b_id_2");
Assert.IsTrue(fk2.ReferencedColumns.Count == 2);
Assert.IsTrue(fk2.Columns.Count == 2);
Assert.IsTrue(fk2.OnDelete == ReferentialAction.Cascade);
Assert.IsTrue(fk2.OnUpdate == ReferentialAction.NoAction);
ForeignKey fk3 = (ForeignKey)schema.Tables["A3"].TableConstraints[0];
Assert.IsNotNull(fk3);
Assert.IsTrue(fk3.Name == "A3_FK");
Assert.IsTrue(fk3.Columns[0].Name == "b_id_1");
Assert.IsTrue(fk3.ReferencedColumns[0].Name == "b_id_1");
Assert.IsTrue(fk3.Columns[1].Name == "b_id_2");
Assert.IsTrue(fk3.ReferencedColumns[1].Name == "b_id_2");
Assert.IsTrue(fk3.Columns[2].Name == "b_id_3");
Assert.IsTrue(fk3.ReferencedColumns[2].Name == "b_id_3");
Assert.IsTrue(fk3.ReferencedColumns.Count == 3);
Assert.IsTrue(fk3.Columns.Count == 3);
Assert.IsTrue(fk3.OnDelete == ReferentialAction.NoAction);
Assert.IsTrue(fk3.OnUpdate == ReferentialAction.Cascade);
}
private IReadOnlyList <Property> TryFindMatchingClrProperties(ForeignKey foreignKey, string baseName, bool onDependent)
{
var entityType = onDependent
? foreignKey.EntityType
: foreignKey.PrincipalEntityType;
var propertiesToReference = onDependent
? foreignKey.PrincipalKey.Properties
: foreignKey.EntityType.FindPrimaryKey()?.Properties;
if (propertiesToReference == null)
{
return(null);
}
var foreignKeyProperties = new List <Property>();
foreach (var referencedProperty in propertiesToReference)
{
var property = TryGetProperty(entityType, baseName
+ referencedProperty.Name, referencedProperty.ClrType.UnwrapNullableType());
if (property != null)
{
foreignKeyProperties.Add(property);
}
}
if (propertiesToReference.Count == 1 &&
foreignKeyProperties.Count == 0)
{
var property = TryGetProperty(entityType, baseName + "Id", propertiesToReference.Single().ClrType.UnwrapNullableType());
if (property != null)
{
foreignKeyProperties.Add(property);
}
}
if (foreignKeyProperties.Count < propertiesToReference.Count)
{
return(null);
}
if (foreignKey.IsRequired == false &&
foreignKeyProperties.All(p => !((IProperty)p).IsNullable))
{
return(null);
}
var primaryKey = entityType.FindPrimaryKey();
if (primaryKey != null)
{
if (foreignKeyProperties.All(property => primaryKey.Properties.Contains(property)))
{
return(null);
}
}
return(foreignKeyProperties);
}
internal void Add(Table table, ForeignKey foreignKey)
{
Association fromAssociation = new Association();
AssociationProperty associationProperty = foreignKey.AssociationProperty;
if (associationProperty == null)
{
// Create the default association property
associationProperty = new AssociationProperty();
}
// Figure out the assocation name
bool isUnique = false;
int count = 0;
while (!isUnique)
{
fromAssociation.Name =
string.Format(CultureInfo.InvariantCulture, "{0}_{1}{2}",
NameHelper.GetTypeName(foreignKey.ToTable),
NameHelper.GetTypeName(table),
count > 0 ? count.ToString(System.Globalization.CultureInfo.InvariantCulture) : string.Empty);
isUnique = !names.Contains(fromAssociation.Name);
count++;
}
names.Add(fromAssociation.Name);
string baseName = GetMemberName(table, foreignKey.ToTable, false);
// Set FROM table association properties
if (associationProperty.Parent.Name == null)
{
// Automatically create the name
fromAssociation.Member = baseName;
}
else
{
fromAssociation.Member = associationProperty.Parent.Name;
//fromAssociation.Storage = "_" + baseName;
var members = GetMembersOfTable(table);
members.Add(fromAssociation.Member);
}
// AccessModifier="Internal" Modifier="NewVirtual"
fromAssociation.ThisKey = foreignKey.FromColumnsToString();
fromAssociation.OtherKey = foreignKey.ToColumnsToString();
fromAssociation.Type = NameHelper.GetTypeName(foreignKey.ToTable);
fromAssociation.IsForeignKey = true;
fromAssociation.AccessModifier = associationProperty.Parent.Access;
fromAssociation.Modifier = associationProperty.Parent.InheritanceModifier;
AddAssociation(table.Name, fromTableAssociations, fromAssociation);
if (associationProperty.Child != null)
{
// Create TO table association
Association toAssociation = new Association();
toAssociation.Name = fromAssociation.Name;
baseName = GetMemberName(foreignKey.ToTable, table, true);
if (associationProperty.Child.Name == null)
{
// Automatically create the name
toAssociation.Member = baseName;
}
else
{
toAssociation.Member = associationProperty.Child.Name;
//toAssociation.Storage = "_" + baseName;
var members = GetMembersOfTable(foreignKey.ToTable);
members.Add(toAssociation.Member);
}
toAssociation.ThisKey = foreignKey.ToColumnsToString();
toAssociation.OtherKey = foreignKey.FromColumnsToString();
toAssociation.Type = NameHelper.GetTypeName(table);
toAssociation.AccessModifier = associationProperty.Child.Access;
toAssociation.Modifier = associationProperty.Child.InheritanceModifier;
AddAssociation(foreignKey.ToTable.Name, toTableAssociations, toAssociation);
}
}
//----------------------------------------------------------------------------------------------------
public static string BuildSql__ForeignKey_Create(ForeignKey foreignKey, bool autoFixName, Dictionary <string, string> allConstraints)
{
AjaxService.ASPdatabaseService.GetSetVal();
foreignKey.Validate(Enums.ValidationTypes.Create);
string optionalSQL_ConstraintName = "";
string sql_FK_Columns = "";
string sql_PK_Columns = "";
string sql_DeleteRule = "";
string sql_UpdateRule = "";
//----------//----------//----------//
if (autoFixName && allConstraints != null)
{
if (String.IsNullOrEmpty(foreignKey.ConstraintName))
{
foreignKey.ConstraintName = String.Format("FK_{0}_{1}", foreignKey.ForeignKey_Schema, foreignKey.ForeignKey_TableName);
}
if (allConstraints.ContainsKey(foreignKey.ConstraintName.ToLower()))
{
int loopMax = 10000;
for (int i = 1; i < loopMax; i++)
{
string tryName = foreignKey.ConstraintName + "_" + i.ToString("0000");
if (!allConstraints.ContainsKey(tryName.ToLower()))
{
foreignKey.ConstraintName = tryName;
i = loopMax + 1;
}
}
}
}
//----------//----------//----------//
if (!String.IsNullOrEmpty(foreignKey.ConstraintName))
{
ASPdb.Framework.Validation.ValidateTextForSql1(foreignKey.ConstraintName, true);
optionalSQL_ConstraintName = "CONSTRAINT " + foreignKey.ConstraintName;
}
//----------//----------//----------//
foreignKey.Columns = (from c in foreignKey.Columns
orderby c.OrdinalPosition
select c).ToArray();
foreach (var col in foreignKey.Columns)
{
if (sql_FK_Columns != "")
{
sql_FK_Columns += ", ";
sql_PK_Columns += ", ";
}
ASPdb.Framework.Validation.ValidateTextForSql1(col.ForeignKey_ColumnName, true);
ASPdb.Framework.Validation.ValidateTextForSql1(col.PrimaryKey_ColumnName, true);
sql_FK_Columns += "[" + col.ForeignKey_ColumnName + "]";
sql_PK_Columns += "[" + col.PrimaryKey_ColumnName + "]";
}
//----------//----------//----------//
switch (foreignKey.DeleteRule)
{
case ForeignKey.E_CascadeOptions.NoAction: sql_DeleteRule = "ON DELETE No Action"; break;
case ForeignKey.E_CascadeOptions.Cascade: sql_DeleteRule = "ON DELETE Cascade"; break;
case ForeignKey.E_CascadeOptions.SetDefault: sql_DeleteRule = "ON DELETE Set Default"; break;
case ForeignKey.E_CascadeOptions.SetNull: sql_DeleteRule = "ON DELETE Set Null"; break;
}
//----------//----------//----------//
switch (foreignKey.UpdateRule)
{
case ForeignKey.E_CascadeOptions.NoAction: sql_UpdateRule = "ON UPDATE No Action"; break;
case ForeignKey.E_CascadeOptions.Cascade: sql_UpdateRule = "ON UPDATE Cascade"; break;
case ForeignKey.E_CascadeOptions.SetDefault: sql_UpdateRule = "ON UPDATE Set Default"; break;
case ForeignKey.E_CascadeOptions.SetNull: sql_UpdateRule = "ON UPDATE Set Null"; break;
}
//----------//----------//----------//
//----------//----------//----------//
string sql = String.Format(@"
ALTER TABLE [{0}].[{1}]
ADD
{2}
FOREIGN KEY
({3})
REFERENCES [{4}].[{5}]({6})
{7}
{8};
",
foreignKey.ForeignKey_Schema, foreignKey.ForeignKey_TableName,
optionalSQL_ConstraintName,
sql_FK_Columns,
foreignKey.PrimaryKey_Schema, foreignKey.PrimaryKey_TableName, sql_PK_Columns,
sql_DeleteRule,
sql_UpdateRule);
return(sql);
}
public override ForeignKey AddForeignKey(ForeignKey foreignKey)
{
throw new NotImplementedException();
}
public Column(string name, ForeignKey fk)
{
Name = name;
fk.SetHost(this);
}
public void AddForeignKey(string name, string column, string foreignTable, string foreignColumns, ForeignKeyReference onDelete, ForeignKeyReference onUpdate)
{
ForeignKey foreignKey = new ForeignKey(name, column, foreignTable, foreignColumns, onDelete, onUpdate);
AddForeignKey(foreignKey);
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual void OnForeignKeyRemoved([NotNull] InternalEntityTypeBuilder entityTypeBuilder, [NotNull] ForeignKey foreignKey)
=> _scope.OnForeignKeyRemoved(
Check.NotNull(entityTypeBuilder, nameof(entityTypeBuilder)),
Check.NotNull(foreignKey, nameof(foreignKey)));
private IReadOnlyList <Property> FindMatchingProperties(
ForeignKey foreignKey, string baseName, bool onDependent, bool matchPK = false)
{
var dependentEntityType = onDependent
? foreignKey.DeclaringEntityType
: foreignKey.PrincipalEntityType;
var principalEntityType = onDependent
? foreignKey.PrincipalEntityType
: foreignKey.DeclaringEntityType;
var propertiesToReference = onDependent
? foreignKey.PrincipalKey.Properties
: foreignKey.DeclaringEntityType.FindPrimaryKey()?.Properties;
if (propertiesToReference == null)
{
return(null);
}
var foreignKeyProperties = new Property[propertiesToReference.Count];
var matchFound = true;
for (var i = 0; i < propertiesToReference.Count; i++)
{
var referencedProperty = propertiesToReference[i];
var property = TryGetProperty(
dependentEntityType,
baseName, referencedProperty.Name);
if (property == null)
{
matchFound = false;
continue;
}
foreignKeyProperties[i] = property;
}
if (!matchFound &&
propertiesToReference.Count == 1)
{
var property = TryGetProperty(
dependentEntityType,
baseName, "Id");
if (property != null)
{
foreignKeyProperties[0] = property;
matchFound = true;
}
}
if (!matchFound)
{
return(null);
}
if (!ForeignKey.AreCompatible(
propertiesToReference,
foreignKeyProperties,
principalEntityType,
dependentEntityType,
false))
{
_logger.IncompatibleMatchingForeignKeyProperties(foreignKeyProperties, propertiesToReference);
return(new Property[0]);
}
foreach (var key in dependentEntityType.GetKeys())
{
if (key.Properties.All(property => foreignKeyProperties.Contains(property)) &&
(!foreignKey.IsUnique ||
(key.IsPrimaryKey() && !matchPK)))
{
return(new Property[0]);
}
}
return(foreignKeyProperties);
}
protected override bool IsForeignKeyExist(ForeignKey foreignKey)
{
return(IsForeignKeyExist(foreignKey.Entity.GetNameInStore(), foreignKey.ForeignEntityInfo.GetNameInStore()));
}
public override string CreateForeignKey(ForeignKey foreignKey)
{
return(string.Empty); // Not supported yet - needs to drop and recreate tables etc
}
public static IServiceCollection AddNHibernate(this IServiceCollection services, string cnString)
{
var sessionFactory = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2008.ConnectionString(cnString))
.Mappings(m => m.FluentMappings.AddFromAssemblyOf <OrderMap>().Conventions.Add(ForeignKey.EndsWith("Id")))
.BuildSessionFactory();
services.AddSingleton <ISessionFactory>(sessionFactory);
services.AddSingleton <IUnitOfWorkProvider, UnitOfWorkProvider>();
return(services);
}
public override string DropForeignKey(ForeignKey foreignKey)
{
throw new System.NotImplementedException();
}
public void AddForeignKey(ForeignKey foreignKey)
{
if (ForeignKeys == null) ForeignKeys = new ForeignKeyList();
if (foreignKey.Name == null)
{
foreignKey.Name = @"FK_";
foreignKey.Name += Name + @"_";
foreignKey.Name += foreignKey.ForeignTable + @"_";
for (int idx = 0; idx < foreignKey.Columns.Length; idx++)
{
if (idx > 0) foreignKey.Name += @"_";
foreignKey.Name += foreignKey.Columns[idx];
}
}
ForeignKeys.Add(foreignKey);
}
internal void PopulateArray(DataTable dataTableFk, DataTable dataTablePk)
{
DataTable metaData = new DataTable();
metaData.Columns.AddRange(
new DataColumn[] {
new DataColumn("PK_TABLE_CATALOG"),
new DataColumn("PK_TABLE_SCHEMA"),
new DataColumn("PK_TABLE_NAME"),
new DataColumn("FK_TABLE_CATALOG"),
new DataColumn("FK_TABLE_SCHEMA"),
new DataColumn("FK_TABLE_NAME"),
new DataColumn("ORDINAL"),
new DataColumn("PK_NAME"),
new DataColumn("FK_NAME"),
new DataColumn("UPDATE_RULE"),
new DataColumn("DELETE_RULE"),
new DataColumn("DEFERRABILITY")
}
);
this.BindToColumns(metaData);
ForeignKey key = null;
int j = 0;
for (int i = 0; i < dataTableFk.Rows.Count; i++)
{
DataRow rowPk = dataTablePk.Rows[i];
DataRow rowFk = dataTableFk.Rows[i];
try
{
string pkschema = rowPk["TABLE_SCHEMA"].ToString();
string pktable = rowPk["TABLE_NAME"].ToString();
string pkcolumn = rowPk["COLUMN_NAME"].ToString();
string fkschema = rowPk["TABLE_SCHEMA"].ToString();
string fktable = rowFk["TABLE_NAME"].ToString();
string fkcolumn = rowFk["COLUMN_NAME"].ToString();
string fkKeyName = rowFk["CONSTRAINT_NAME"].ToString();
string pkKeyName = rowFk["PK_CONSTRAINT_NAME"].ToString();
//DataRow row = rowView.Row;
key = this.GetByName(fkKeyName);
if (null == key)
{
DataRow row = metaData.NewRow();
row["PK_TABLE_CATALOG"] = pkschema;
row["PK_TABLE_SCHEMA"] = pkschema;
row["PK_TABLE_NAME"] = pktable;
row["FK_TABLE_CATALOG"] = fkschema;
row["FK_TABLE_SCHEMA"] = fkschema;
row["FK_TABLE_NAME"] = fktable;
row["ORDINAL"] = j++.ToString();
row["PK_NAME"] = pkKeyName;
row["FK_NAME"] = fkKeyName;
row["UPDATE_RULE"] = "";
row["DELETE_RULE"] = "";
row["DEFERRABILITY"] = 0;
metaData.Rows.Add(row);
key = (ForeignKey)this.dbRoot.ClassFactory.CreateForeignKey();
key.dbRoot = this.dbRoot;
key.ForeignKeys = this;
key.Row = row;
this._array.Add(key);
}
key.AddForeignColumn(pkschema, pkschema, pktable, pkcolumn, true);
key.AddForeignColumn(fkschema, fkschema, fktable, fkcolumn, false);
}
catch (Exception ex)
{
string tmp = ex.Message;
}
}
}
public void Setting_IsRequired_to_false_will_set_all_FK_properties_as_nullable()
{
var entityType = new Model().AddEntityType("E");
var property = entityType.AddProperty("Id1", typeof(int));
var property1 = entityType.AddProperty("Id2", typeof(string));
entityType.GetOrSetPrimaryKey(new[]
{
property,
property1
});
var dependentProp1 = entityType.AddProperty("P1", typeof(int?));
var dependentProp2 = entityType.AddProperty("P2", typeof(string));
var foreignKey = new ForeignKey(new[] { dependentProp1, dependentProp2 }, entityType.GetPrimaryKey(), entityType, entityType) { IsRequired = false };
Assert.False(foreignKey.IsRequired.Value);
Assert.True(dependentProp1.IsNullable.Value);
Assert.True(dependentProp2.IsNullable.Value);
}
public List <String> GetForeignKeys(Schema s)
{
var h = new HashSet <ForeignKey>();
var l = new List <String>();
foreach (var t in s.Types)
{
if (t.OnEntity)
{
foreach (var f in t.Entity.Fields)
{
if (f.Attribute.OnNavigation)
{
if (!f.Attribute.Navigation.IsUnique)
{
continue;
}
if (f.Attribute.Navigation.IsReverse)
{
EntityDef ThisTable = null;
if (f.Type.OnTypeRef)
{
ThisTable = Records[f.Type.TypeRef.Value];
}
else if (f.Type.OnOptional)
{
ThisTable = Records[f.Type.Optional.Value];
}
else if (f.Type.OnList)
{
ThisTable = Records[f.Type.List.Value];
}
else
{
throw new InvalidOperationException();
}
var fk = new ForeignKey {
ThisTableName = ThisTable.CollectionName, ThisKeyColumns = f.Attribute.Navigation.OtherKey, OtherTableName = t.Entity.CollectionName, OtherKeyColumns = f.Attribute.Navigation.ThisKey
};
if (!h.Contains(fk))
{
var Name = fk.GetLimitedName(MaxNameLength);
l.AddRange(GetForeignKey(Name, fk.ThisTableName, fk.ThisKeyColumns, fk.OtherTableName, fk.OtherKeyColumns));
h.Add(fk);
}
}
else
{
var fk = new ForeignKey {
ThisTableName = t.Entity.CollectionName, ThisKeyColumns = f.Attribute.Navigation.ThisKey, OtherTableName = Records[f.Type.TypeRef.Value].CollectionName, OtherKeyColumns = f.Attribute.Navigation.OtherKey
};
if (!h.Contains(fk))
{
var Name = fk.GetLimitedName(MaxNameLength);
l.AddRange(GetForeignKey(Name, fk.ThisTableName, fk.ThisKeyColumns, fk.OtherTableName, fk.OtherKeyColumns));
h.Add(fk);
}
}
}
}
}
}
return(l);
}
/// <summary>
/// There are no comments for TableForeignKeys in the schema.
/// </summary>
public void AddToTableForeignKeys(ForeignKey foreignKey)
{
base.AddObject("TableForeignKeys", foreignKey);
}
public void IdentifyMappingTable(List <ForeignKey> fkList, Tables tables, bool checkForFkNameClashes)
{
IsMapping = false;
var nonReadOnlyColumns = Columns.Where(c => !c.IsIdentity && !c.IsRowVersion && !c.IsStoreGenerated && !c.Hidden).ToList();
// Ignoring read-only columns, it must have only 2 columns to be a mapping table
if (nonReadOnlyColumns.Count != 2)
{
return;
}
// Must have 2 primary keys
if (nonReadOnlyColumns.Count(x => x.IsPrimaryKey) != 2)
{
return;
}
// No columns should be nullable
if (nonReadOnlyColumns.Any(x => x.IsNullable))
{
return;
}
// Find the foreign keys for this table
var foreignKeys = fkList.Where(x =>
string.Compare(x.FkTableName, Name, StringComparison.OrdinalIgnoreCase) == 0 &&
string.Compare(x.FkSchema, Schema, StringComparison.OrdinalIgnoreCase) == 0)
.ToList();
// Each column must have a foreign key, therefore check column and foreign key counts match
if (foreignKeys.Select(x => x.FkColumn).Distinct().Count() != 2)
{
return;
}
ForeignKey left = foreignKeys[0];
ForeignKey right = foreignKeys[1];
if (!left.IncludeReverseNavigation || !right.IncludeReverseNavigation)
{
return;
}
Table leftTable = tables.GetTable(left.PkTableName, left.PkSchema);
if (leftTable == null)
{
return;
}
Table rightTable = tables.GetTable(right.PkTableName, right.PkSchema);
if (rightTable == null)
{
return;
}
var leftPropName = leftTable.GetUniqueColumnName(rightTable.NameHumanCase, right, checkForFkNameClashes, false, Relationship.ManyToOne); // relationship from the mapping table to each side is Many-to-One
leftPropName = Settings.MappingTableRename(Name, leftTable.NameHumanCase, leftPropName);
var rightPropName = rightTable.GetUniqueColumnName(leftTable.NameHumanCase, left, checkForFkNameClashes, false, Relationship.ManyToOne); // relationship from the mapping table to each side is Many-to-One
rightPropName = Settings.MappingTableRename(Name, rightTable.NameHumanCase, rightPropName);
leftTable.AddMappingConfiguration(left, right, leftPropName, rightPropName);
IsMapping = true;
rightTable.AddReverseNavigation(Relationship.ManyToMany, rightTable.NameHumanCase, leftTable, rightPropName, null, null, this);
leftTable.AddReverseNavigation(Relationship.ManyToMany, leftTable.NameHumanCase, rightTable, leftPropName, null, null, this);
}
/// <summary>
/// Deserialzes the provided binary data of the object. This is the full data block which follows the data
/// signature and data block length.
/// </summary>
/// <param name="inData">The binary data containing the object.</param>
public void LoadBinaryData(byte[] inData)
{
using (MemoryStream ms = new MemoryStream(inData))
{
using (BinaryReader br = new BinaryReader(ms))
{
this.GroupNameOffset = br.ReadUInt32();
this.DescriptiveGroupNameOffset = br.ReadUInt32();
this.Flags = (GroupFlags)br.ReadUInt32();
this.BoundingBox = br.ReadBox();
this.PortalReferenceStartingIndex = br.ReadUInt16();
this.PortalReferenceCount = br.ReadUInt16();
this.RenderBatchCountA = br.ReadUInt16();
this.RenderBatchCountInterior = br.ReadUInt16();
this.RenderBatchCountExterior = br.ReadUInt16();
this.Unknown = br.ReadUInt16();
for (int i = 0; i < 4; ++i)
{
this.FogIndices.Add(br.ReadByte());
}
this.LiquidType = br.ReadUInt32();
this.GroupID = new ForeignKey <uint>(DatabaseName.WMOAreaTable, nameof(WMOAreaTableRecord.WMOGroupID), br.ReadUInt32());
this.UnknownFlags = br.ReadUInt32();
this.Unused = br.ReadUInt32();
// Required subchunks
this.PolygonMaterials = br.ReadIFFChunk <ModelPolygonMaterials>();
this.VertexIndices = br.ReadIFFChunk <ModelVertexIndices>();
this.Vertices = br.ReadIFFChunk <ModelVertices>();
this.Normals = br.ReadIFFChunk <ModelNormals>();
this.TextureCoordinates = br.ReadIFFChunk <ModelTextureCoordinates>();
this.RenderBatches = br.ReadIFFChunk <ModelRenderBatches>();
// Optional chunks
if (br.PeekChunkSignature() == MOBS.Signature)
{
this.mobs = br.ReadIFFChunk <MOBS>();
}
if (this.Flags.HasFlag(GroupFlags.HasLights))
{
this.LightReferences = br.ReadIFFChunk <ModelLightReferences>();
}
if (this.Flags.HasFlag(GroupFlags.HasDoodads))
{
this.DoodadReferences = br.ReadIFFChunk <ModelDoodadReferences>();
}
if (this.Flags.HasFlag(GroupFlags.HasBSP))
{
this.BSPNodes = br.ReadIFFChunk <ModelBSPNodes>();
this.BSPFaceIndices = br.ReadIFFChunk <ModelBSPFaceIndices>();
}
if (this.Flags.HasFlag(GroupFlags.UnknownLODRelated))
{
this.mpbv = br.ReadIFFChunk <MPBV>();
this.mpbp = br.ReadIFFChunk <MPBP>();
this.mpbi = br.ReadIFFChunk <MPBI>();
this.mpbg = br.ReadIFFChunk <MPBG>();
}
if (this.Flags.HasFlag(GroupFlags.HasVertexColours))
{
this.VertexColours = br.ReadIFFChunk <ModelVertexColours>();
}
if (this.Flags.HasFlag(GroupFlags.HasLiquids))
{
this.Liquids = br.ReadIFFChunk <ModelLiquids>();
}
if (this.Flags.HasFlag(GroupFlags.HasTriangleStrips))
{
this.TriangleStripIndices = br.ReadIFFChunk <ModelTriangleStripIndices>();
this.TriangleStrips = br.ReadIFFChunk <ModelTriangleStrips>();
}
if (this.Flags.HasFlag(GroupFlags.HasTwoTextureCoordinateSets))
{
this.AdditionalTextureCoordinates = br.ReadIFFChunk <ModelTextureCoordinates>();
}
if (this.Flags.HasFlag(GroupFlags.HasTwoVertexShadingSets))
{
this.AdditionalVertexColours = br.ReadIFFChunk <ModelVertexColours>();
}
if (this.Flags.HasFlag(GroupFlags.HasThreeTextureCoordinateSets))
{
this.SecondAddtionalTextureCoordinates = br.ReadIFFChunk <ModelTextureCoordinates>();
}
}
}
}
public string GetUniqueColumnName(string tableNameHumanCase, ForeignKey foreignKey, bool checkForFkNameClashes, bool makeSingular, Relationship relationship)
{
var addReverseNavigationUniquePropName = (checkForFkNameClashes || Name == foreignKey.FkTableName || (Name == foreignKey.PkTableName && foreignKey.IncludeReverseNavigation));
if (ReverseNavigationUniquePropName.Count == 0)
{
ReverseNavigationUniquePropName.Add(NameHumanCase);
ReverseNavigationUniquePropName.AddRange(Columns.Select(c => c.NameHumanCase));
}
if (!makeSingular)
{
tableNameHumanCase = Inflector.MakePlural(tableNameHumanCase);
}
if (checkForFkNameClashes && ReverseNavigationUniquePropName.Contains(tableNameHumanCase) && !ReverseNavigationUniquePropNameClashes.Contains(tableNameHumanCase))
{
ReverseNavigationUniquePropNameClashes.Add(tableNameHumanCase); // Name clash
}
// Attempt 1
string fkName = (Settings.UsePascalCase ? Inflector.ToTitleCase(foreignKey.FkColumn) : foreignKey.FkColumn).Replace(" ", "").Replace("$", "");
string name = Settings.ForeignKeyName(tableNameHumanCase, foreignKey, fkName, relationship, 1);
string col;
if (!ReverseNavigationUniquePropNameClashes.Contains(name) && !ReverseNavigationUniquePropName.Contains(name))
{
if (addReverseNavigationUniquePropName)
{
ReverseNavigationUniquePropName.Add(name);
}
return(name);
}
if (Name == foreignKey.FkTableName)
{
// Attempt 2
if (fkName.ToLowerInvariant().EndsWith("id"))
{
col = Settings.ForeignKeyName(tableNameHumanCase, foreignKey, fkName, relationship, 2);
if (checkForFkNameClashes && ReverseNavigationUniquePropName.Contains(col) &&
!ReverseNavigationUniquePropNameClashes.Contains(col))
{
ReverseNavigationUniquePropNameClashes.Add(col); // Name clash
}
if (!ReverseNavigationUniquePropNameClashes.Contains(col) &&
!ReverseNavigationUniquePropName.Contains(col))
{
if (addReverseNavigationUniquePropName)
{
ReverseNavigationUniquePropName.Add(col);
}
return(col);
}
}
// Attempt 3
col = Settings.ForeignKeyName(tableNameHumanCase, foreignKey, fkName, relationship, 3);
if (checkForFkNameClashes && ReverseNavigationUniquePropName.Contains(col) &&
!ReverseNavigationUniquePropNameClashes.Contains(col))
{
ReverseNavigationUniquePropNameClashes.Add(col); // Name clash
}
if (!ReverseNavigationUniquePropNameClashes.Contains(col) &&
!ReverseNavigationUniquePropName.Contains(col))
{
if (addReverseNavigationUniquePropName)
{
ReverseNavigationUniquePropName.Add(col);
}
return(col);
}
}
// Attempt 4
col = Settings.ForeignKeyName(tableNameHumanCase, foreignKey, fkName, relationship, 4);
if (checkForFkNameClashes && ReverseNavigationUniquePropName.Contains(col) && !ReverseNavigationUniquePropNameClashes.Contains(col))
{
ReverseNavigationUniquePropNameClashes.Add(col); // Name clash
}
if (!ReverseNavigationUniquePropNameClashes.Contains(col) && !ReverseNavigationUniquePropName.Contains(col))
{
if (addReverseNavigationUniquePropName)
{
ReverseNavigationUniquePropName.Add(col);
}
return(col);
}
// Attempt 5
for (int n = 1; n < 99; ++n)
{
col = Settings.ForeignKeyName(tableNameHumanCase, foreignKey, fkName, relationship, 5) + n;
if (ReverseNavigationUniquePropName.Contains(col))
{
continue;
}
if (addReverseNavigationUniquePropName)
{
ReverseNavigationUniquePropName.Add(col);
}
return(col);
}
// Give up
return(Settings.ForeignKeyName(tableNameHumanCase, foreignKey, fkName, relationship, 6));
}
public ForeignKey GetRefTableForeignKey(ForeignKey foreignKey, string referencedColumn)
{
return foreignKey.Parent.Parent.Tables[foreignKey.ReferencedTable].ForeignKeys.OfType<ForeignKey>().Where(
key => key.ReferencedTable == foreignKey.Parent.Name&&key.Columns.OfType<ForeignKeyColumn>().Any(column => column.ReferencedColumn==referencedColumn)).FirstOrDefault();
}
public void OnForeignKeyRemoved_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
var foreignKeyRemoved = false;
var convention = new Mock<IForeignKeyRemovedConvention>();
convention.Setup(c => c.Apply(It.IsAny<InternalEntityTypeBuilder>(), It.IsAny<ForeignKey>())).Callback(() => foreignKeyRemoved = true);
conventions.ForeignKeyRemovedConventions.Add(convention.Object);
var builder = new InternalModelBuilder(new Model(), conventions);
var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention);
var foreignKey = new ForeignKey(
new[] { entityBuilder.Property("FK", typeof(int), ConfigurationSource.Convention).Metadata },
entityBuilder.HasKey(new[] { "OrderId" }, ConfigurationSource.Convention).Metadata,
entityBuilder.Metadata,
entityBuilder.Metadata);
var conventionDispatcher = new ConventionDispatcher(conventions);
conventionDispatcher.OnForeignKeyRemoved(entityBuilder, foreignKey);
Assert.True(foreignKeyRemoved);
}
public DB2ForeignKeyTransformer(ForeignKey foreignKey, UTF_EA.AssociationEnd associationEnd, NameTranslator nameTranslator) : base(foreignKey, associationEnd, nameTranslator)
{
}
public static RelationalForeignKeyAnnotations Relational([NotNull] this ForeignKey foreignKey) => new RelationalForeignKeyAnnotations(Check.NotNull(foreignKey, nameof(foreignKey)));
protected override void CreateForeignKey(ForeignKey foreignKey)
{
// Not supported by sqlite
// https://www.sqlite.org/omitted.html
}
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> public virtual void Apply(InternalEntityTypeBuilder entityTypeBuilder, ForeignKey foreignKey) => SetKeyValueGeneration(foreignKey.Properties, entityTypeBuilder.Metadata);
public static NpgsqlForeignKeyAnnotations Npgsql([NotNull] this ForeignKey foreignKey)
{
Check.NotNull(foreignKey, nameof(foreignKey));
return(new NpgsqlForeignKeyAnnotations(foreignKey));
}
public static NpgsqlForeignKeyExtensions Npgsql([NotNull] this ForeignKey foreignKey)
{
Check.NotNull(foreignKey, "foreignKey");
return(new NpgsqlForeignKeyExtensions(foreignKey));
}
public static List <Database> GetAllData()
{
List <Database> databases = new List <Database>();
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(filePath);
XmlNodeList nodelistDB = xmlDoc.DocumentElement.SelectNodes("/Databases/DataBase");
if (nodelistDB != null)
{
foreach (XmlNode nodeDB in nodelistDB)
{
Database database = new Database();
XmlNode DatabaseName = nodeDB.Attributes.GetNamedItem("dataBaseName");
if (DatabaseName != null)
{
database.DatabaseName = DatabaseName.Value;
}
XmlNodeList nodelistTB = xmlDoc.DocumentElement.SelectNodes("/Databases/DataBase/Tables/Table");
List <Table> tablesList = new List <Table>();
foreach (XmlNode nodeTB in nodelistTB)
{
if (nodeTB != null && nodeTB.ParentNode.ParentNode == nodeDB)
{
Table table = new Table();
XmlNode tablename = nodeTB.Attributes.GetNamedItem("tableName");
if (tablename != null)
{
table.TableName = tablename.Value;
}
XmlNode fileName = nodeTB.Attributes.GetNamedItem("fileName");
if (fileName != null)
{
table.FileName = fileName.Value;
}
XmlNode rowLength = nodeTB.Attributes.GetNamedItem("rowLength");
if (rowLength != null)
{
table.RowLength = int.Parse(rowLength.Value);
}
XmlNodeList nodeListCo = xmlDoc.DocumentElement.SelectNodes("/Databases/DataBase/Tables/Table/Structure/Attribute");
List <Column> columnsList = new List <Column>();
foreach (XmlNode nodeCo in nodeListCo)
{
if (nodeCo != null && nodeCo.ParentNode.ParentNode == nodeTB)
{
Column column = new Column();
XmlNode ColumnName = nodeCo.Attributes.GetNamedItem("attributeName");
if (ColumnName != null)
{
column.ColumnName = ColumnName.Value;
}
XmlNode Type = nodeCo.Attributes.GetNamedItem("type");
if (Type != null)
{
column.Type = Type.Value;
}
XmlNode Length = nodeCo.Attributes.GetNamedItem("length");
if (Type != null)
{
column.Length = int.Parse(Length.Value);
}
XmlNode isnull = nodeCo.Attributes.GetNamedItem("isnull");
if (Type != null)
{
column.IsNull = Utilities.GetBoolValueFromString(isnull.Value);
}
columnsList.Add(column);
}
}
table.Columns = columnsList;
XmlNodeList nodeListPK = xmlDoc.DocumentElement.SelectNodes("/Databases/DataBase/Tables/Table/primaryKey/pkAttribute");
if (nodeListPK != null)
{
List <PrimaryKey> primaryKeysList = new List <PrimaryKey>();
foreach (XmlNode nodePK in nodeListPK)
{
if (nodePK != null && nodePK.ParentNode.ParentNode == nodeTB)
{
PrimaryKey primaryKey = new PrimaryKey();
primaryKey.Key = nodePK.InnerText;
primaryKeysList.Add(primaryKey);
}
}
table.PrimaryKey = primaryKeysList;
}
XmlNodeList nodeListUK = xmlDoc.DocumentElement.SelectNodes("/Databases/DataBase/Tables/Table/uniqueKeys/UniqueAttribute");
if (nodeListUK.Count > 0)
{
List <UniqueKey> uniqueKeysList = new List <UniqueKey>();
foreach (XmlNode nodeUK in nodeListUK)
{
if (nodeUK != null && nodeUK.ParentNode.ParentNode == nodeTB)
{
UniqueKey uniqueKey = new UniqueKey();
uniqueKey.Key = nodeUK.InnerText;
uniqueKeysList.Add(uniqueKey);
}
}
table.UniqueKey = uniqueKeysList;
}
XmlNodeList nodeListIF = xmlDoc.DocumentElement.SelectNodes("/Databases/DataBase/Tables/Table/IndexFiles/IndexFile");
if (nodeListIF.Count > 0)
{
List <IndexFile> indexfilelist = new List <IndexFile>();
foreach (XmlNode nodeIF in nodeListIF)
{
if (nodeIF != null && nodeIF.ParentNode.ParentNode == nodeTB)
{
IndexFile indexfile = new IndexFile();
XmlNode IndexName = nodeIF.Attributes.GetNamedItem("indexName");
if (IndexName != null)
{
indexfile.IndexName = IndexName.Value;
}
XmlNode KeyLength = nodeIF.Attributes.GetNamedItem("keyLength");
if (KeyLength != null)
{
indexfile.KeyLength = int.Parse(KeyLength.Value);
}
XmlNode IsUnique = nodeIF.Attributes.GetNamedItem("isUnique");
if (IsUnique != null)
{
indexfile.IsUnique = Utilities.GetBoolValueFromString(IsUnique.Value);
}
XmlNode IndexType = nodeIF.Attributes.GetNamedItem("indexType");
if (IndexType != null)
{
indexfile.IndexType = IndexType.Value;
}
XmlNode IndexAttributeNode = nodeIF.FirstChild.FirstChild;
if (IndexAttributeNode.Name == "IAttribute" && IndexAttributeNode.InnerText != "")
{
indexfile.IndexAttribute = IndexAttributeNode.InnerText;
}
indexfilelist.Add(indexfile);
}
}
table.IndexFile = indexfilelist;
}
XmlNodeList nodeListFK = xmlDoc.DocumentElement.SelectNodes("/Databases/DataBase/Tables/Table/foreignKeys/foreignKey");
if (nodeListFK.Count > 0)
{
List <ForeignKey> FKlist = new List <ForeignKey>();
foreach (XmlNode nodeFK in nodeListFK)
{
if (nodeFK.ParentNode.ParentNode == nodeTB)
{
ForeignKey fk = new ForeignKey();
fk.Key = nodeFK.FirstChild.InnerText;
XmlNode nodeFKRef = nodeFK.LastChild;
fk.RefTable = nodeFKRef.FirstChild.InnerText;
fk.RefAttribute = nodeFKRef.LastChild.InnerText;
FKlist.Add(fk);
}
}
table.ForeignKey = FKlist;
}
tablesList.Add(table);
}
}
database.Tables = tablesList;
databases.Add(database);
}
}
return(databases);
}
protected static void AddForeignKeyColumn(ForeignKey foreignKey, string name, string refColumnName)
{
var foreignKeyColumn = Isolate.Fake.Instance<ForeignKeyColumn>();
Isolate.WhenCalled(() => foreignKeyColumn.ReferencedColumn).WillReturn(refColumnName);
Isolate.WhenCalled(() => foreignKeyColumn.Name).WillReturn(name);
if (foreignKey.Columns.Count==0)
Isolate.WhenCalled(() => foreignKey.Columns).WillReturnCollectionValuesOf(new List<ForeignKeyColumn> { foreignKeyColumn });
else {
foreignKey.Columns.Add(foreignKeyColumn);
}
}
public void DropParentShouldDropFKs()
{
ForeignKey getForeignKey(Table table, string fkColumn, Table parentTable, string parentColumn)
{
var fk = new ForeignKey()
{
Parent = table,
Name = $"FK_{table.Name}_{fkColumn}",
ReferencedTable = parentTable,
Columns = new ForeignKey.Column[]
{
new ForeignKey.Column()
{
ReferencingName = fkColumn, ReferencedName = parentColumn
}
}
};
return(fk);
};
var parentTbl = ModelBuilder.BuildTable("parent", "this", "that", "other", "Id");
var child1 = ModelBuilder.BuildTable("child1", "parentId", "hello", "whatever", "chunga");
var child2 = ModelBuilder.BuildTable("child2", "parentId", "yowza", "plimza", "faruga");
var srcModel = new DataModel()
{
Tables = new Table[] { child1, child2 },
ForeignKeys = new ForeignKey[]
{
getForeignKey(child1, "parentId", parentTbl, "Id"),
getForeignKey(child2, "parentId", parentTbl, "Id")
}
};
var destModel = new DataModel()
{
Tables = new Table[] { parentTbl, child1, child2 },
ForeignKeys = new ForeignKey[]
{
getForeignKey(child1, "parentId", parentTbl, "Id"),
getForeignKey(child2, "parentId", parentTbl, "Id")
}
};
var diff = DataModel.Compare(srcModel, destModel);
Assert.IsTrue(diff.Contains(new ScriptAction()
{
Type = ActionType.Drop,
Object = parentTbl,
Commands = new string[]
{
"ALTER TABLE <child1> DROP CONSTRAINT <FK_child1_parentId>",
"ALTER TABLE <child2> DROP CONSTRAINT <FK_child2_parentId>",
"DROP TABLE <parent>"
}
}));
var script = new SqlServerDialect().FormatScript(diff);
Debug.Write(script);
}
public void IsRequired_true_when_dependent_property_not_nullable()
{
var entityType = new Model().AddEntityType("E");
entityType.GetOrSetPrimaryKey(entityType.GetOrAddProperty("Id", typeof(int), shadowProperty: true));
var dependentProp = entityType.GetOrAddProperty("P", typeof(int), shadowProperty: true);
dependentProp.IsNullable = false;
var foreignKey = new ForeignKey(new[] { dependentProp }, entityType.GetPrimaryKey(), entityType);
Assert.Null(foreignKey.IsRequired);
Assert.True(((IForeignKey)foreignKey).IsRequired);
}
protected override IEnumerable<IDataParameter> CoreGetForeignKeyColumnParameters(IUnitOfWorkContext unitOfWorkContext, string dataSourceTag, Database database, Schema schema, Table table, ForeignKey foreignKey)
{
if ((object)unitOfWorkContext == null)
throw new ArgumentNullException("unitOfWorkContext");
if ((object)dataSourceTag == null)
throw new ArgumentNullException("dataSourceTag");
if ((object)database == null)
throw new ArgumentNullException("database");
if ((object)schema == null)
throw new ArgumentNullException("schema");
if ((object)table == null)
throw new ArgumentNullException("table");
if ((object)foreignKey == null)
throw new ArgumentNullException("foreignKey");
if (dataSourceTag.SafeToString().ToLower() == "odbc.sqlserver")
{
return new IDataParameter[]
{
unitOfWorkContext.CreateParameter(ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@P1", schema.SchemaName),
unitOfWorkContext.CreateParameter(ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@P2", table.TableName),
unitOfWorkContext.CreateParameter(ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@P3", foreignKey.ForeignKeyName)
};
}
else if (dataSourceTag.SafeToString().ToLower() == "odbc.sybaseiq")
{
return new IDataParameter[]
{
unitOfWorkContext.CreateParameter(ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@P1", schema.SchemaName),
unitOfWorkContext.CreateParameter(ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@P2", table.TableName),
unitOfWorkContext.CreateParameter(ParameterDirection.Input, DbType.String, 100, 0, 0, true, "@P3", foreignKey.ForeignKeyName)
};
}
throw new ArgumentOutOfRangeException(string.Format("dataSourceTag: '{0}'", dataSourceTag));
}
public void Can_create_foreign_key_with_non_pk_principal()
{
var entityType = new Model().AddEntityType("E");
var keyProp = entityType.GetOrAddProperty("Id", typeof(int), shadowProperty: true);
var dependentProp = entityType.GetOrAddProperty("P", typeof(int), shadowProperty: true);
var principalProp = entityType.GetOrAddProperty("U", typeof(int), shadowProperty: true);
entityType.GetOrSetPrimaryKey(keyProp);
var principalKey = entityType.AddKey(principalProp);
var foreignKey
= new ForeignKey(new[] { dependentProp }, principalKey, entityType)
{
IsUnique = false
};
Assert.Same(entityType, foreignKey.PrincipalEntityType);
Assert.Same(principalProp, foreignKey.PrincipalKey.Properties.Single());
Assert.Same(dependentProp, foreignKey.Properties.Single());
Assert.False(foreignKey.IsUnique.Value);
Assert.Same(principalKey, foreignKey.PrincipalKey);
}
/// <summary>
/// Создаём таблицу из схемы модуля
/// </summary>
/// <param name="module">Метаданные модуля</param>
public void CreateTableFromModuleSchema(ModuleMetadata module)
{
if (!_database.Tables.Contains(module.ModuleName))
{
try
{
// создаём таблицу
Table targetTable = new Table(_database, module.ModuleName);
//
// добавляем базовые столбцы в таблицу
//
#region Внешниый ключ
Column plowMachineIdColumn = new Column(targetTable, "PlowMachineId");
plowMachineIdColumn.DataType = DataType.UniqueIdentifier;
plowMachineIdColumn.RowGuidCol = true;
plowMachineIdColumn.Nullable = false;
ForeignKey fk = new ForeignKey(targetTable, "FK_" + module.ModuleName + "_PlowMachine");
ForeignKeyColumn fk_column = new ForeignKeyColumn(fk, "PlowMachineId");
fk_column.ReferencedColumn = "PlowMachineId";
fk.ReferencedTable = "PlowMachines";
fk.Columns.Add(fk_column);
targetTable.ForeignKeys.Add(fk);
targetTable.Columns.Add(plowMachineIdColumn);
#endregion
//
// добавляем столбцы в таблицу
//
foreach (FieldMetadata f in module.MetadataFields)
{
Column column = CreateColumn(targetTable, f);
targetTable.Columns.Add(column);
}
targetTable.Create();
#region Первичный ключ
Index idx = new Index(targetTable, "PK_" + module.ModuleName);
IndexedColumn idxc = new IndexedColumn(idx, plowMachineIdColumn.Name);
idx.IndexedColumns.Add(idxc);
idx.IndexKeyType = IndexKeyType.DriPrimaryKey;
idx.IsClustered = true;
idx.IsUnique = true;
idx.Create();
#endregion
}
catch (Microsoft.SqlServer.Management.Smo.InvalidSmoOperationException)
{
throw;
}
}
else
{
throw new InvalidOperationException("Таблица с именем '" + module.ModuleName + "' уже существует в БД.");
}
}
public ForeignKeySavedEventArgs(ForeignKey key, Constraint constraint)
{
this.Constraint = constraint;
this.Key = key;
}
public void IsRequired_false_when_dependent_property_nullable()
{
var entityType = new Model().AddEntityType("E");
var property = entityType.AddProperty("Id", typeof(int));
entityType.GetOrSetPrimaryKey(property);
var dependentProp = entityType.AddProperty("P", typeof(int?));
dependentProp.IsNullable = true;
var foreignKey = new ForeignKey(new[] { dependentProp }, entityType.GetPrimaryKey(), entityType, entityType);
Assert.False(foreignKey.IsRequired);
Assert.False(((IForeignKey)foreignKey).IsRequired);
}
private static string GetPropertyBaseName(ForeignKey foreignKey) => foreignKey.DependentToPrincipal?.Name ?? foreignKey.PrincipalEntityType.ShortName();
public void IsRequired_and_IsUnique_null_when_dependent_property_nullable_by_default()
{
var entityType = new Model().AddEntityType("E");
var property = entityType.AddProperty("Id", typeof(int));
entityType.GetOrSetPrimaryKey(property);
var dependentProp = entityType.AddProperty("P", typeof(int?));
var foreignKey = new ForeignKey(new[] { dependentProp }, entityType.GetPrimaryKey(), entityType, entityType);
Assert.Null(foreignKey.IsRequired);
Assert.False(((IForeignKey)foreignKey).IsRequired);
Assert.Null(foreignKey.IsUnique);
Assert.False(((IForeignKey)foreignKey).IsUnique);
}
private InternalRelationshipBuilder ReuniquifyTemporaryProperties(ForeignKey foreignKey, bool force)
{
if (!force &&
(foreignKey.GetForeignKeyPropertiesConfigurationSource() != null ||
!foreignKey.DeclaringEntityType.Builder.ShouldReuniquifyTemporaryProperties(
foreignKey.Properties,
foreignKey.PrincipalKey.Properties,
foreignKey.IsRequired,
GetPropertyBaseName(foreignKey))))
{
return(foreignKey.Builder);
}
var relationshipBuilder = foreignKey.Builder;
using (var batch = foreignKey.DeclaringEntityType.Model.ConventionDispatcher.StartBatch())
{
var temporaryProperties = foreignKey.Properties.Where(
p =>
p.IsShadowProperty &&
ConfigurationSource.Convention.Overrides(p.GetConfigurationSource())).ToList();
var keysToDetach = temporaryProperties.SelectMany(
p => p.GetContainingKeys()
.Where(k => ConfigurationSource.Convention.Overrides(k.GetConfigurationSource())))
.Distinct().ToList();
List <RelationshipSnapshot> detachedRelationships = null;
foreach (var key in keysToDetach)
{
foreach (var referencingForeignKey in key.GetReferencingForeignKeys().ToList())
{
if (detachedRelationships == null)
{
detachedRelationships = new List <RelationshipSnapshot>();
}
detachedRelationships.Add(InternalEntityTypeBuilder.DetachRelationship(referencingForeignKey));
}
}
var detachedKeys = InternalEntityTypeBuilder.DetachKeys(keysToDetach);
var detachedIndexes = InternalEntityTypeBuilder.DetachIndexes(
temporaryProperties.SelectMany(p => p.GetContainingIndexes()).Distinct());
relationshipBuilder = relationshipBuilder.HasForeignKey((IReadOnlyList <Property>)null, ConfigurationSource.Convention);
if (detachedIndexes != null)
{
foreach (var indexBuilderTuple in detachedIndexes)
{
indexBuilderTuple.Attach(indexBuilderTuple.Metadata.DeclaringEntityType.Builder);
}
}
if (detachedKeys != null)
{
foreach (var detachedKeyTuple in detachedKeys)
{
detachedKeyTuple.Item1.Attach(foreignKey.DeclaringEntityType.RootType().Builder, detachedKeyTuple.Item2);
}
}
if (detachedRelationships != null)
{
foreach (var detachedRelationship in detachedRelationships)
{
detachedRelationship.Attach();
}
}
return(batch.Run(relationshipBuilder));
}
}
public void IsRequired_false_when_any_part_of_composite_FK_is_nullable()
{
var entityType = new Model().AddEntityType("E");
var property = entityType.AddProperty("Id1", typeof(int));
var property1 = entityType.AddProperty("Id2", typeof(string));
entityType.GetOrSetPrimaryKey(new[]
{
property,
property1
});
var dependentProp1 = entityType.AddProperty("P1", typeof(int));
var dependentProp2 = entityType.AddProperty("P2", typeof(string));
dependentProp2.IsNullable = true;
var foreignKey = new ForeignKey(new[] { dependentProp1, dependentProp2 }, entityType.GetPrimaryKey(), entityType, entityType);
Assert.False(foreignKey.IsRequired);
Assert.False(((IForeignKey)foreignKey).IsRequired);
dependentProp2.IsNullable = false;
Assert.True(foreignKey.IsRequired);
Assert.True(((IForeignKey)foreignKey).IsRequired);
}
private bool TryFindMatchingProperties(
ForeignKey foreignKey, string baseName, bool onDependent, bool matchPK, out IReadOnlyList <Property> match)
{
match = null;
var dependentEntityType = onDependent
? foreignKey.DeclaringEntityType
: foreignKey.PrincipalEntityType;
var principalEntityType = onDependent
? foreignKey.PrincipalEntityType
: foreignKey.DeclaringEntityType;
var propertiesToReference = onDependent
? foreignKey.PrincipalKey.Properties
: foreignKey.DeclaringEntityType.FindPrimaryKey()?.Properties;
if (propertiesToReference == null)
{
return(false);
}
var foreignKeyProperties = new Property[propertiesToReference.Count];
var matchFound = true;
for (var i = 0; i < propertiesToReference.Count; i++)
{
var referencedProperty = propertiesToReference[i];
var property = TryGetProperty(
dependentEntityType,
baseName, referencedProperty.Name);
if (property == null)
{
matchFound = false;
continue;
}
foreignKeyProperties[i] = property;
}
if (!matchFound &&
propertiesToReference.Count == 1 &&
baseName.Length > 0)
{
var property = TryGetProperty(
dependentEntityType,
baseName, "Id");
if (property != null)
{
foreignKeyProperties[0] = property;
matchFound = true;
}
}
if (!matchFound)
{
return(false);
}
if (!ForeignKey.AreCompatible(
propertiesToReference,
foreignKeyProperties,
principalEntityType,
dependentEntityType,
false))
{
if (propertiesToReference.All(
p => !p.IsShadowProperty ||
p.GetConfigurationSource().Overrides(ConfigurationSource.DataAnnotation)))
{
_logger.IncompatibleMatchingForeignKeyProperties(foreignKeyProperties, propertiesToReference);
}
// Stop searching if match found, but is incompatible
return(true);
}
foreach (var key in dependentEntityType.GetKeys())
{
var isKeyContainedInForeignKey = true;
// ReSharper disable once LoopCanBeConvertedToQuery
// ReSharper disable once ForCanBeConvertedToForeach
for (var i = 0; i < key.Properties.Count; i++)
{
if (!foreignKeyProperties.Contains(key.Properties[i]))
{
isKeyContainedInForeignKey = false;
break;
}
if (!foreignKey.IsUnique)
{
// Stop searching if match found, but is incompatible
return(true);
}
}
if (isKeyContainedInForeignKey &&
key.IsPrimaryKey() &&
!matchPK)
{
// Stop searching if match found, but is incompatible
return(true);
}
}
match = foreignKeyProperties;
return(true);
}
public void Can_change_cascade_delete_flag()
{
var entityType = new Model().AddEntityType("E");
var keyProp = entityType.AddProperty("Id", typeof(int));
var dependentProp = entityType.AddProperty("P", typeof(int));
var principalProp = entityType.AddProperty("U", typeof(int));
entityType.GetOrSetPrimaryKey(keyProp);
var principalKey = entityType.AddKey(principalProp);
var foreignKey
= new ForeignKey(new[] { dependentProp }, principalKey, entityType, entityType);
Assert.Null(foreignKey.DeleteBehavior);
Assert.Equal(DeleteBehavior.None, ((IForeignKey)foreignKey).DeleteBehavior);
foreignKey.DeleteBehavior = DeleteBehavior.Cascade;
Assert.Equal(DeleteBehavior.Cascade, foreignKey.DeleteBehavior);
Assert.Equal(DeleteBehavior.Cascade, ((IForeignKey)foreignKey).DeleteBehavior);
foreignKey.DeleteBehavior = DeleteBehavior.None;
Assert.Equal(DeleteBehavior.None, foreignKey.DeleteBehavior);
Assert.Equal(DeleteBehavior.None, ((IForeignKey)foreignKey).DeleteBehavior);
foreignKey.DeleteBehavior = null;
Assert.Null(foreignKey.DeleteBehavior);
Assert.Equal(DeleteBehavior.None, ((IForeignKey)foreignKey).DeleteBehavior);
}
/// <summary>
/// Sets a database record values with values retrieved from data file.
/// </summary>
/// <param name="rowValues"></param>
/// <param name="record"></param>
private bool UpdateColumnValuesInRecord(string[] rowValues, IRecord record, bool isResolvedForeignKeysChecked)
{
int j = 0;
bool isRecordUpdated = false;
ColumnCount = 1;
foreach (string data in rowValues)
{
ColumnCount++;
if (j > this.ImportList.Count - 1)
{
return(isRecordUpdated);
}
try
{
if (this.ColumnNameList[j].ToString() != "" && ((CheckBox)this.ImportList[j]).Checked)
{
ForeignKey fkColumn = null;
BaseColumn currentColumn = this.DBTable.TableDefinition.ColumnList.GetByAnyName((string)this.ColumnNameList[j]);
if (isResolvedForeignKeysChecked)
{
fkColumn = this.DBTable.TableDefinition.GetForeignKeyByColumnName(currentColumn.InternalName);
}
String colValue = "";
// Check if the foreign key has DFKA. If so, then check the calue from csv file agains the DFKA column in the parent/foreign key table.
// If a match is found retrieve its ID and set that as value to be insterted in the current table where you are adding records.
if (fkColumn != null)
{
TableDefinition originalTableDef = fkColumn.PrimaryKeyTableDefinition;
BaseTable originalBaseTable = originalTableDef.CreateBaseTable();
WhereClause wc = null;
ArrayList records = new ArrayList();
BaseColumn pkColumn = (BaseColumn)originalTableDef.PrimaryKey.Columns[0];//Index is zero because we handle only those tables which has single PK column not composite keys.
if (fkColumn.PrimaryKeyDisplayColumns != null && fkColumn.PrimaryKeyDisplayColumns != "" && (!fkColumn.PrimaryKeyDisplayColumns.Trim().StartsWith("=")))
{
wc = new WhereClause(originalTableDef.ColumnList.GetByAnyName(fkColumn.PrimaryKeyDisplayColumns), BaseFilter.ComparisonOperator.EqualsTo, data);
}
else if (fkColumn.PrimaryKeyDisplayColumns != null && fkColumn.PrimaryKeyDisplayColumns != "" && (fkColumn.PrimaryKeyDisplayColumns.Trim().StartsWith("=")))
{
string primaryKeyDisplay = GetDFKA(fkColumn);
if (primaryKeyDisplay != null)
{
wc = new WhereClause(originalTableDef.ColumnList.GetByAnyName(primaryKeyDisplay), BaseFilter.ComparisonOperator.EqualsTo, data);
}
else
{
wc = new WhereClause(pkColumn, BaseFilter.ComparisonOperator.EqualsTo, data);
}
}
else
{
// if the foreign key does not have DFKA then just check in the foreign key table if the id exists. If not create a record with the specified ID
// before adding to current table
wc = new WhereClause(pkColumn, BaseFilter.ComparisonOperator.EqualsTo, data);
}
BaseClasses.Data.BaseFilter join = null;
records = originalBaseTable.GetRecordList(join, wc.GetFilter(), null, null, 0, 100);
if (records.Count > 0)
{
// take the first record and retrieve its ID.
BaseRecord rec = (BaseRecord)records[0];
colValue = (rec.GetValue(pkColumn)).ToString();
}
else
{
// IF there is not match found then you have to create a record in the foreign key table with DFKA value and then retreive its ID
if (data != null & data != "")
{
IRecord tempRec;
if (fkColumn.PrimaryKeyDisplayColumns != null && fkColumn.PrimaryKeyDisplayColumns != "" && (!fkColumn.PrimaryKeyDisplayColumns.Trim().StartsWith("=")))
{
tempRec = originalBaseTable.CreateRecord();
TableDefinition tableDef = originalBaseTable.TableDefinition;
foreach (BaseColumn newCol in tableDef.Columns)
{
if (fkColumn.PrimaryKeyDisplayColumns == newCol.InternalName)
{
tempRec.SetValue(data, newCol.UniqueName);
}
}
}
else
{
tempRec = originalBaseTable.CreateRecord(data);
}
tempRec.Save();
colValue = (tempRec.GetValue(pkColumn)).ToString();
}
// colValue = data;
}
}
else
{
colValue = data;
}
// set the table row's column for value
record.SetValue(colValue, currentColumn.UniqueName);
isRecordUpdated = true;
}
j++;
}
catch (Exception ex)
{
throw new Exception(ex.InnerException.Message);
}
}
return(isRecordUpdated);
}
/// <summary>
/// Create a new ForeignKey object.
/// </summary>
/// <param name="id">Initial value of Id.</param>
/// <param name="ordinal">Initial value of Ordinal.</param>
public static ForeignKey CreateForeignKey(string id, int ordinal)
{
ForeignKey foreignKey = new ForeignKey();
foreignKey.Id = id;
foreignKey.Ordinal = ordinal;
return foreignKey;
}
public TableForeignKeyPair(Table table, ForeignKey foreignKey)
{
Table = table;
ForeignKey = foreignKey;
}
/// <summary>
/// There are no comments for ViewForeignKeys in the schema.
/// </summary>
public void AddToViewForeignKeys(ForeignKey foreignKey)
{
base.AddObject("ViewForeignKeys", foreignKey);
}
private bool TryFindMatchingProperties(
IConventionForeignKey foreignKey,
string baseName,
bool onDependent,
bool matchPk,
out IReadOnlyList <IConventionProperty>?match)
{
match = null;
var dependentEntityType = onDependent
? foreignKey.DeclaringEntityType
: foreignKey.PrincipalEntityType;
var principalEntityType = onDependent
? foreignKey.PrincipalEntityType
: foreignKey.DeclaringEntityType;
var propertiesToReference = onDependent
? foreignKey.PrincipalKey.Properties
: foreignKey.DeclaringEntityType.FindPrimaryKey()?.Properties;
if (propertiesToReference == null)
{
return(false);
}
var foreignKeyProperties = new IConventionProperty[propertiesToReference.Count];
var matchFound = true;
for (var i = 0; i < propertiesToReference.Count; i++)
{
var referencedProperty = propertiesToReference[i];
var property = TryGetProperty(
dependentEntityType,
baseName, referencedProperty.Name);
if (property == null)
{
matchFound = false;
continue;
}
foreignKeyProperties[i] = property;
}
if (!matchFound &&
propertiesToReference.Count == 1 &&
baseName.Length > 0)
{
var property = TryGetProperty(
dependentEntityType,
baseName, "Id");
if (property != null)
{
foreignKeyProperties[0] = property;
matchFound = true;
}
}
if (!matchFound)
{
return(false);
}
if (!ForeignKey.AreCompatible(
propertiesToReference,
foreignKeyProperties,
principalEntityType,
dependentEntityType,
shouldThrow: false))
{
if (propertiesToReference.All(
p => !p.IsImplicitlyCreated() ||
p.GetConfigurationSource().Overrides(ConfigurationSource.DataAnnotation)))
{
var dependentNavigationSpec = onDependent
? foreignKey.DependentToPrincipal?.Name
: foreignKey.PrincipalToDependent?.Name;
dependentNavigationSpec = dependentEntityType.DisplayName()
+ (string.IsNullOrEmpty(dependentNavigationSpec)
? string.Empty
: "." + dependentNavigationSpec);
var principalNavigationSpec = onDependent
? foreignKey.PrincipalToDependent?.Name
: foreignKey.DependentToPrincipal?.Name;
principalNavigationSpec = principalEntityType.DisplayName()
+ (string.IsNullOrEmpty(principalNavigationSpec)
? string.Empty
: "." + principalNavigationSpec);
Dependencies.Logger.IncompatibleMatchingForeignKeyProperties(
dependentNavigationSpec, principalNavigationSpec,
foreignKeyProperties, propertiesToReference);
}
// Stop searching if match found, but is incompatible
return(true);
}
foreach (var key in dependentEntityType.GetKeys())
{
var isKeyContainedInForeignKey = true;
// ReSharper disable once LoopCanBeConvertedToQuery
// ReSharper disable once ForCanBeConvertedToForeach
for (var i = 0; i < key.Properties.Count; i++)
{
if (!foreignKeyProperties.Contains(key.Properties[i]))
{
isKeyContainedInForeignKey = false;
break;
}
}
if (isKeyContainedInForeignKey &&
(!foreignKey.IsUnique ||
(key.IsPrimaryKey() &&
!matchPk)))
{
// Stop searching if match found, but is incompatible
return(true);
}
}
match = foreignKeyProperties;
return(true);
}
