Fix namings in ITransformationProvider and TransformationProvider

Ja bist du narrisch · Ja bist du narrisch · commit df90f1c91b9a · 2025-06-26T15:37:08.000+02:00
diff --git a/src/Migrator.Tests/Providers/SQLiteTransformationProviderTest.cs b/src/Migrator.Tests/Providers/SQLiteTransformationProviderTest.cs
@@ -11,6 +11,7 @@
 
 #endregion
 
+using System.Linq;
 using DotNetProjects.Migrator.Framework;
 using DotNetProjects.Migrator.Providers.Impl.SQLite;
 using Migrator.Providers.SQLite;
@@ -43,11 +44,20 @@ public void AddForeignKey()
             AddTableWithPrimaryKey();
 
             // Act
-            _provider.AddForeignKey("FK name is not supported by SQLite", foreignTable: "Test", foreignColumn: "Id", primaryTable: "TestTwo", primaryColumn: "TestId", ForeignKeyConstraintType.Cascade);
+            _provider.AddForeignKey("FK name is not supported by SQLite", parentTable: "Test", parentColumn: "Id", childTable: "TestTwo", childColumn: "TestId", ForeignKeyConstraintType.Cascade);
 
             // Assert
-            var foreignKeyConstraints = ((SQLiteTransformationProvider)_provider).GetForeignKeyConstraints("Test");
-            var tableSQLCreateScript = ((SQLiteTransformationProvider)_provider).GetSqlCreateTableScript("Test");
+            var foreignKeyConstraints = ((SQLiteTransformationProvider)_provider).GetForeignKeyConstraints("TestTwo");
+            var tableSQLCreateScript = ((SQLiteTransformationProvider)_provider).GetSqlCreateTableScript("TestTwo");
+
+            Assert.That(foreignKeyConstraints.Single().Name, Is.Null);
+            Assert.That(foreignKeyConstraints.Single().ChildTable, Is.EqualTo("TestTwo"));
+            Assert.That(foreignKeyConstraints.Single().ParentTable, Is.EqualTo("Test"));
+            Assert.That(foreignKeyConstraints.Single().ChildColumns.Single(), Is.EqualTo("TestId"));
+            Assert.That(foreignKeyConstraints.Single().ParentColumns.Single(), Is.EqualTo("Id"));
+
+            Assert.That(tableSQLCreateScript, Does.Contain("CREATE TABLE \"TestTwo\""));
+            Assert.That(tableSQLCreateScript, Does.Contain(", FOREIGN KEY (TestId) REFERENCES Test(Id))"));
         }
 
 
diff --git a/src/Migrator/Framework/ForeignKeyConstraint.cs b/src/Migrator/Framework/ForeignKeyConstraint.cs
@@ -7,13 +7,13 @@ public class ForeignKeyConstraint : IDbField
     public ForeignKeyConstraint()
     { }
 
-    public ForeignKeyConstraint(string name, string table, string[] columns, string pkTable, string[] pkColumns)
+    public ForeignKeyConstraint(string name, string parentTable, string[] parentcolumns, string childTable, string[] childColumns)
     {
         Name = name;
-        Table = table;
-        Columns = columns;
-        PkTable = pkTable;
-        PkColumns = pkColumns;
+        ParentTable = parentTable;
+        ParentColumns = parentcolumns;
+        ChildTable = childTable;
+        ChildColumns = childColumns;
     }
 
     /// <summary>
@@ -22,10 +22,10 @@ public ForeignKeyConstraint(string name, string table, string[] columns, string
     /// </summary>
     public int? Id { get; set; }
     public string Name { get; set; }
-    public string Table { get; set; }
-    public string[] Columns { get; set; }
-    public string PkTable { get; set; }
-    public string[] PkColumns { get; set; }
+    public string ParentTable { get; set; }
+    public string[] ParentColumns { get; set; }
+    public string ChildTable { get; set; }
+    public string[] ChildColumns { get; set; }
 
     /// <summary>
     /// Gets or sets the on update text. Currently only used for SQLite.
diff --git a/src/Migrator/Framework/ITransformationProvider.cs b/src/Migrator/Framework/ITransformationProvider.cs
@@ -162,44 +162,44 @@ public interface ITransformationProvider : IDisposable
         /// Add a foreign key constraint
         /// </summary>
         /// <param name="name">The name of the foreign key. e.g. FK_TABLE_REF</param>
-        /// <param name="foreignTable">The table that the foreign key will be created in (eg. Table.FK_id)</param>
-        /// <param name="foreignColumns">The columns that are the foreign keys (eg. FK_id)</param>
-        /// <param name="primaryTable">The table that holds the primary keys (eg. Table.PK_id)</param>
-        /// <param name="primaryColumns">The columns that are the primary keys (eg. PK_id)</param>
-        void AddForeignKey(string name, string foreignTable, string[] foreignColumns, string primaryTable, string[] primaryColumns);
+        /// <param name="parentTable">The table that the foreign key will be created in (eg. Table.FK_id)</param>
+        /// <param name="parentColumns">The columns that are the foreign keys (eg. FK_id)</param>
+        /// <param name="childTable">The table that holds the primary keys (eg. Table.PK_id)</param>
+        /// <param name="childColumns">The columns that are the primary keys (eg. PK_id)</param>
+        void AddForeignKey(string name, string parentTable, string[] parentColumns, string childTable, string[] childColumns);
 
         /// <summary>
         /// Add a foreign key constraint
         /// </summary>
         /// <param name="name">The name of the foreign key. e.g. FK_TABLE_REF</param>
-        /// <param name="foreignTable">The table that the foreign key will be created in (eg. Table.FK_id)</param>
-        /// <param name="foreignColumns">The columns that are the foreign keys (eg. FK_id)</param>
-        /// <param name="primaryTable">The table that holds the primary keys (eg. Table.PK_id)</param>
-        /// <param name="primaryColumns">The columns that are the primary keys (eg. PK_id)</param>
+        /// <param name="parentTable">The table that the foreign key will be created in (eg. Table.FK_id)</param>
+        /// <param name="parentColumns">The columns that are the foreign keys (eg. FK_id)</param>
+        /// <param name="childTable">The table that holds the primary keys (eg. Table.PK_id)</param>
+        /// <param name="childColumns">The columns that are the primary keys (eg. PK_id)</param>
         /// <param name="constraint">Constraint parameters</param>
-        void AddForeignKey(string name, string foreignTable, string[] foreignColumns, string primaryTable, string[] primaryColumns, ForeignKeyConstraintType constraint);
+        void AddForeignKey(string name, string parentTable, string[] parentColumns, string childTable, string[] childColumns, ForeignKeyConstraintType constraint);
 
         /// <summary>
         /// Add a foreign key constraint
         /// </summary>
         /// 
         /// <param name="name">The name of the foreign key. e.g. FK_TABLE_REF</param>
-        /// <param name="foreignTable">The table that the foreign key will be created in (eg. Table.FK_id)</param>
-        /// <param name="foreignColumn">The column that is the foreign key (eg. FK_id)</param>
-        /// <param name="primaryTable">The table that holds the primary keys (eg. Table.PK_id)</param>
-        /// <param name="primaryColumn">The column that is the primary key (eg. PK_id)</param>
-        void AddForeignKey(string name, string foreignTable, string foreignColumn, string primaryTable, string primaryColumn);
+        /// <param name="parentTable">The table that the foreign key will be created in (eg. Table.FK_id)</param>
+        /// <param name="parentColumn">The column that is the foreign key (eg. FK_id)</param>
+        /// <param name="childTable">The table that holds the primary keys (eg. Table.PK_id)</param>
+        /// <param name="childColumn">The column that is the primary key (eg. PK_id)</param>
+        void AddForeignKey(string name, string parentTable, string parentColumn, string childTable, string childColumn);
 
         /// <summary>
         /// Add a foreign key constraint
         /// </summary>
         /// <param name="name">The name of the foreign key. e.g. FK_TABLE_REF</param>
-        /// <param name="foreignTable">The table that the foreign key will be created in (eg. Table.FK_id)</param>
-        /// <param name="foreignColumn">The column that is the foreign key (eg. FK_id)</param>
-        /// <param name="primaryTable">The table that holds the primary key (eg. Table.PK_id)</param>
-        /// <param name="primaryColumn">The column that is the primary key (eg. PK_id)</param>
+        /// <param name="parentTable">The table that the foreign key will be created in (eg. Table.FK_id)</param>
+        /// <param name="parentColumn">The column that is the foreign key (eg. FK_id)</param>
+        /// <param name="childTable">The table that holds the primary key (eg. Table.PK_id)</param>
+        /// <param name="childColumn">The column that is the primary key (eg. PK_id)</param>
         /// <param name="constraint">Constraint parameters</param>
-        void AddForeignKey(string name, string foreignTable, string foreignColumn, string primaryTable, string primaryColumn, ForeignKeyConstraintType constraint);
+        void AddForeignKey(string name, string parentTable, string parentColumn, string childTable, string childColumn, ForeignKeyConstraintType constraint);
 
         /// <summary>
         /// Add a foreign key constraint when you don't care about the name of the constraint.
diff --git a/src/Migrator/Providers/Impl/SQLite/SQLiteTransformationProvider.cs b/src/Migrator/Providers/Impl/SQLite/SQLiteTransformationProvider.cs
@@ -44,19 +44,24 @@ protected virtual void CreateConnection(string providerName)
             _connection.Open();
         }
 
-        public override void AddForeignKey(string name, string primaryTable, string[] primaryColumns, string refTable,
-                                           string[] refColumns, ForeignKeyConstraintType constraint)
+        public override void AddForeignKey(
+            string name,
+            string parentTable,
+            string[] parentColumns,
+            string childTable,
+            string[] childColumns,
+            ForeignKeyConstraintType constraint)
         {
-            var sqliteTableInfo = GetTableData(primaryTable);
+            var sqliteTableInfo = GetTableData(childTable);
 
             var foreignKey = new ForeignKeyConstraint
             {
                 // SQLite does not support FK names
                 Name = null,
-                Table = primaryTable,
-                PkTable = refTable,
-                Columns = primaryColumns,
-                PkColumns = refColumns
+                ParentTable = parentTable,
+                ChildTable = childTable,
+                ParentColumns = parentColumns,
+                ChildColumns = childColumns
             };
 
             sqliteTableInfo.ForeignKeys.Add(foreignKey);
@@ -99,10 +104,10 @@ public override ForeignKeyConstraint[] GetForeignKeyConstraints(string tableName
                     Id = group.First().Id,
                     // SQLite does not support FK names.
                     Name = null,
-                    Table = tableName,
-                    Columns = group.OrderBy(x => x.Seq).Select(x => x.From).ToArray(),
-                    PkColumns = group.OrderBy(x => x.Seq).Select(x => x.To).ToArray(),
-                    PkTable = group.First().Table,
+                    ParentTable = group.First().Table,
+                    ParentColumns = group.OrderBy(x => x.Seq).Select(x => x.To).ToArray(),
+                    ChildColumns = group.OrderBy(x => x.Seq).Select(x => x.From).ToArray(),
+                    ChildTable = tableName,
                     OnDelete = group.First().OnDelete,
                     OnUpdate = group.First().OnUpdate,
                     Match = group.First().Match
@@ -778,11 +783,11 @@ public override void AddTable(string name, string engine, params IDbField[] fiel
                 // but not being stored in any way hence not being retrievable using foreign_key_list
                 // we leave it out in the following string.
 
-                var sourceColumnNamesQuotedString = string.Join(", ", fk.Columns.Select(QuoteColumnNameIfRequired));
-                var foreignColumnNamesQuotedString = string.Join(", ", fk.PkColumns.Select(QuoteColumnNameIfRequired));
-                var targetTableNameQuoted = QuoteTableNameIfRequired(fk.PkTable);
+                var sourceColumnNamesQuotedString = string.Join(", ", fk.ChildColumns.Select(QuoteColumnNameIfRequired));
+                var parentColumnNamesQuotedString = string.Join(", ", fk.ParentColumns.Select(QuoteColumnNameIfRequired));
+                var parentTableNameQuoted = QuoteTableNameIfRequired(fk.ParentTable);
 
-                var foreignKeyString = $", FOREIGN KEY ({sourceColumnNamesQuotedString}) REFERENCES {targetTableNameQuoted}({foreignColumnNamesQuotedString})";
+                var foreignKeyString = $", FOREIGN KEY ({sourceColumnNamesQuotedString}) REFERENCES {parentTableNameQuoted}({parentColumnNamesQuotedString})";
 
                 stringBuilder.Append(foreignKeyString);
             }
diff --git a/src/Migrator/Providers/TransformationProvider.cs b/src/Migrator/Providers/TransformationProvider.cs
@@ -140,9 +140,12 @@ public virtual Column[] GetColumns(string table)
         public virtual ForeignKeyConstraint[] GetForeignKeyConstraints(string table)
         {
             var constraints = new List<ForeignKeyConstraint>();
-            using (IDbCommand cmd = CreateCommand())
+            using (var cmd = CreateCommand())
             using (
-                IDataReader reader =
+                var reader =
+                    // TODO: 
+                    // In this statement the naming of alias PK is misleading since INFORMATION_SCHEMA.TABLE_CONSTRAINTS (alias PK) is the child
+                    // while INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS (alias C) is the parent
                     ExecuteQuery(
                         cmd, String.Format("SELECT K_Table = FK.TABLE_NAME, FK_Column = CU.COLUMN_NAME, PK_Table = PK.TABLE_NAME, PK_Column = PT.COLUMN_NAME, Constraint_Name = C.CONSTRAINT_NAME FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS C INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS FK ON C.CONSTRAINT_NAME = FK.CONSTRAINT_NAME INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS PK ON C.UNIQUE_CONSTRAINT_NAME = PK.CONSTRAINT_NAME INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE CU ON C.CONSTRAINT_NAME = CU.CONSTRAINT_NAME INNER JOIN ( SELECT i1.TABLE_NAME, i2.COLUMN_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS i1 INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE i2 ON i1.CONSTRAINT_NAME = i2.CONSTRAINT_NAME WHERE i1.CONSTRAINT_TYPE = 'PRIMARY KEY' ) PT ON PT.TABLE_NAME = PK.TABLE_NAME  WHERE FK.table_name = '{0}'", table)))
             {
@@ -151,10 +154,10 @@ public virtual ForeignKeyConstraint[] GetForeignKeyConstraints(string table)
                     var constraint = new ForeignKeyConstraint
                     {
                         Name = reader.GetString(4),
-                        Table = reader.GetString(0),
-                        Columns = new[] { reader.GetString(1) },
-                        PkTable = reader.GetString(2),
-                        PkColumns = new[] { reader.GetString(3) }
+                        ParentTable = reader.GetString(0),
+                        ParentColumns = [reader.GetString(1)],
+                        ChildTable = reader.GetString(2),
+                        ChildColumns = [reader.GetString(3)]
                     };
 
                     constraints.Add(constraint);
@@ -748,18 +751,18 @@ public virtual void GenerateForeignKey(string primaryTable, string[] primaryColu
 
         public virtual void AddForeignKey(string table, ForeignKeyConstraint fk)
         {
-            AddForeignKey(fk.Name, table, fk.Columns, fk.PkTable, fk.PkColumns);
+            AddForeignKey(fk.Name, table, fk.ParentColumns, fk.ChildTable, fk.ChildColumns);
         }
 
-        public virtual void AddForeignKey(string name, string primaryTable, string primaryColumn, string refTable, string refColumn)
+        public virtual void AddForeignKey(string name, string parentTable, string parentColumn, string childTable, string childColumn)
         {
             try
             {
-                AddForeignKey(name, primaryTable, new[] { primaryColumn }, refTable, new[] { refColumn });
+                AddForeignKey(name, parentTable, [parentColumn], childTable, [childColumn]);
             }
             catch (Exception ex)
             {
-                throw new Exception(string.Format("Error occured while adding foreign key: \"{0}\" between table: \"{1}\" and table: \"{2}\" - see inner exception for details", name, primaryTable, refTable), ex);
+                throw new Exception(string.Format("Error occured while adding foreign key: \"{0}\" between table: \"{1}\" and table: \"{2}\" - see inner exception for details", name, parentTable, childTable), ex);
             }
         }
 
@@ -768,32 +771,32 @@ public virtual void AddForeignKey(string name, string primaryTable, string prima
         /// AddForeignKey(string, string, string, string, string)
         /// </see>
         /// </summary>
-        public virtual void AddForeignKey(string name, string primaryTable, string[] primaryColumns, string refTable, string[] refColumns)
+        public virtual void AddForeignKey(string name, string parentTable, string[] parentColumns, string childTable, string[] childColumns)
         {
-            AddForeignKey(name, primaryTable, primaryColumns, refTable, refColumns, ForeignKeyConstraintType.NoAction);
+            AddForeignKey(name, parentTable, parentColumns, childTable, childColumns, ForeignKeyConstraintType.NoAction);
         }
 
-        public virtual void AddForeignKey(string name, string primaryTable, string primaryColumn, string refTable, string refColumn, ForeignKeyConstraintType constraint)
+        public virtual void AddForeignKey(string name, string parentTable, string parentColumn, string childTable, string childColumn, ForeignKeyConstraintType constraint)
         {
-            AddForeignKey(name, primaryTable, new[] { primaryColumn }, refTable, new[] { refColumn },
+            AddForeignKey(name, parentTable, new[] { parentColumn }, childTable, new[] { childColumn },
                           constraint);
         }
 
-        public virtual void AddForeignKey(string name, string primaryTable, string[] primaryColumns, string refTable,
-                                          string[] refColumns, ForeignKeyConstraintType constraint)
+        public virtual void AddForeignKey(string name, string parentTable, string[] parentColumns, string childTable,
+                                          string[] childColumns, ForeignKeyConstraintType constraint)
         {
-            refTable = QuoteTableNameIfRequired(refTable);
-            primaryTable = QuoteTableNameIfRequired(primaryTable);
-            QuoteColumnNames(primaryColumns);
-            QuoteColumnNames(refColumns);
+            childTable = QuoteTableNameIfRequired(childTable);
+            parentTable = QuoteTableNameIfRequired(parentTable);
+            QuoteColumnNames(parentColumns);
+            QuoteColumnNames(childColumns);
 
             string constraintResolved = constraintMapper.SqlForConstraint(constraint);
 
             ExecuteNonQuery(
                 String.Format(
                     "ALTER TABLE {0} ADD CONSTRAINT {1} FOREIGN KEY ({2}) REFERENCES {3} ({4}) ON UPDATE {5} ON DELETE {6}",
-                    primaryTable, name, String.Join(",", primaryColumns),
-                    refTable, String.Join(",", refColumns), constraintResolved, constraintResolved));
+                    parentTable, name, String.Join(",", parentColumns),
+                    childTable, String.Join(",", childColumns), constraintResolved, constraintResolved));
         }
 
         /// <summary>
diff --git a/src/Migrator/Tools/SchemaDumper.cs b/src/Migrator/Tools/SchemaDumper.cs
@@ -77,13 +77,17 @@ private string GetListString(string[] list)
             }
             return $"new []{String.Format("{{{0}}}", String.Join(",", list))}";
         }
+
         private void addForeignKeys(StringWriter writer)
         {
             foreach (var fk in this.foreignKeys)
             {
-                string[] fkCols = fk.Columns;
+                var fkCols = fk.ParentColumns;
+
                 foreach (var col in fkCols)
-                    writer.WriteLine($"\t\tDatabase.AddForeignKey(\"{fk.Name}\", \"{fk.Table}\", {this.GetListString(fk.Columns)}, \"{fk.PkTable}\", {this.GetListString(fk.PkColumns)});");
+                {
+                    writer.WriteLine($"\t\tDatabase.AddForeignKey(\"{fk.Name}\", \"{fk.ParentTable}\", {this.GetListString(fk.ParentColumns)}, \"{fk.ChildTable}\", {this.GetListString(fk.ChildColumns)});");
+                }
                 //this._provider.AddForeignKey(name, fktable, fkcols, pktable, primaryCols);
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -140,9 +140,12 @@ public virtual Column[] GetColumns(string table)`
`140`	`140`	`public virtual ForeignKeyConstraint[] GetForeignKeyConstraints(string table)`
`141`	`141`	`{`
`142`	`142`	`var constraints = new List<ForeignKeyConstraint>();`
`143`		`- using (IDbCommand cmd = CreateCommand())`
	`143`	`+ using (var cmd = CreateCommand())`
`144`	`144`	`using (`
`145`		`- IDataReader reader =`
	`145`	`+ var reader =`
	`146`	`+ // TODO:`
	`147`	`+ // In this statement the naming of alias PK is misleading since INFORMATION_SCHEMA.TABLE_CONSTRAINTS (alias PK) is the child`
	`148`	`+ // while INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS (alias C) is the parent`
`146`	`149`	`ExecuteQuery(`
`147`	`150`	cmd, String.Format("SELECT K_Table = FK.TABLE_NAME, FK_Column = CU.COLUMN_NAME, PK_Table = PK.TABLE_NAME, PK_Column = PT.COLUMN_NAME, Constraint_Name = C.CONSTRAINT_NAME FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS C INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS FK ON C.CONSTRAINT_NAME = FK.CONSTRAINT_NAME INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS PK ON C.UNIQUE_CONSTRAINT_NAME = PK.CONSTRAINT_NAME INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE CU ON C.CONSTRAINT_NAME = CU.CONSTRAINT_NAME INNER JOIN ( SELECT i1.TABLE_NAME, i2.COLUMN_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS i1 INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE i2 ON i1.CONSTRAINT_NAME = i2.CONSTRAINT_NAME WHERE i1.CONSTRAINT_TYPE = 'PRIMARY KEY' ) PT ON PT.TABLE_NAME = PK.TABLE_NAME WHERE FK.table_name = '{0}'", table)))
`148`	`151`	`{`
`@@ -151,10 +154,10 @@ public virtual ForeignKeyConstraint[] GetForeignKeyConstraints(string table)`
`151`	`154`	`var constraint = new ForeignKeyConstraint`
`152`	`155`	`{`
`153`	`156`	`Name = reader.GetString(4),`
`154`		`- Table = reader.GetString(0),`
`155`		`- Columns = new[] { reader.GetString(1) },`
`156`		`- PkTable = reader.GetString(2),`
`157`		`- PkColumns = new[] { reader.GetString(3) }`
	`157`	`+ ParentTable = reader.GetString(0),`
	`158`	`+ ParentColumns = [reader.GetString(1)],`
	`159`	`+ ChildTable = reader.GetString(2),`
	`160`	`+ ChildColumns = [reader.GetString(3)]`
`158`	`161`	`};`
`159`	`162`
`160`	`163`	`constraints.Add(constraint);`
`@@ -748,18 +751,18 @@ public virtual void GenerateForeignKey(string primaryTable, string[] primaryColu`
`748`	`751`
`749`	`752`	`public virtual void AddForeignKey(string table, ForeignKeyConstraint fk)`
`750`	`753`	`{`
`751`		`- AddForeignKey(fk.Name, table, fk.Columns, fk.PkTable, fk.PkColumns);`
	`754`	`+ AddForeignKey(fk.Name, table, fk.ParentColumns, fk.ChildTable, fk.ChildColumns);`
`752`	`755`	`}`
`753`	`756`
`754`		`- public virtual void AddForeignKey(string name, string primaryTable, string primaryColumn, string refTable, string refColumn)`
	`757`	`+ public virtual void AddForeignKey(string name, string parentTable, string parentColumn, string childTable, string childColumn)`
`755`	`758`	`{`
`756`	`759`	`try`
`757`	`760`	`{`
`758`		`- AddForeignKey(name, primaryTable, new[] { primaryColumn }, refTable, new[] { refColumn });`
	`761`	`+ AddForeignKey(name, parentTable, [parentColumn], childTable, [childColumn]);`
`759`	`762`	`}`
`760`	`763`	`catch (Exception ex)`
`761`	`764`	`{`
`762`		`- throw new Exception(string.Format("Error occured while adding foreign key: \"{0}\" between table: \"{1}\" and table: \"{2}\" - see inner exception for details", name, primaryTable, refTable), ex);`
	`765`	`+ throw new Exception(string.Format("Error occured while adding foreign key: \"{0}\" between table: \"{1}\" and table: \"{2}\" - see inner exception for details", name, parentTable, childTable), ex);`
`763`	`766`	`}`
`764`	`767`	`}`
`765`	`768`
`@@ -768,32 +771,32 @@ public virtual void AddForeignKey(string name, string primaryTable, string prima`
`768`	`771`	`/// AddForeignKey(string, string, string, string, string)`
`769`	`772`	`/// </see>`
`770`	`773`	`/// </summary>`
`771`		`- public virtual void AddForeignKey(string name, string primaryTable, string[] primaryColumns, string refTable, string[] refColumns)`
	`774`	`+ public virtual void AddForeignKey(string name, string parentTable, string[] parentColumns, string childTable, string[] childColumns)`
`772`	`775`	`{`
`773`		`- AddForeignKey(name, primaryTable, primaryColumns, refTable, refColumns, ForeignKeyConstraintType.NoAction);`
	`776`	`+ AddForeignKey(name, parentTable, parentColumns, childTable, childColumns, ForeignKeyConstraintType.NoAction);`
`774`	`777`	`}`
`775`	`778`
`776`		`- public virtual void AddForeignKey(string name, string primaryTable, string primaryColumn, string refTable, string refColumn, ForeignKeyConstraintType constraint)`
	`779`	`+ public virtual void AddForeignKey(string name, string parentTable, string parentColumn, string childTable, string childColumn, ForeignKeyConstraintType constraint)`
`777`	`780`	`{`
`778`		`- AddForeignKey(name, primaryTable, new[] { primaryColumn }, refTable, new[] { refColumn },`
	`781`	`+ AddForeignKey(name, parentTable, new[] { parentColumn }, childTable, new[] { childColumn },`
`779`	`782`	`constraint);`
`780`	`783`	`}`
`781`	`784`
`782`		`- public virtual void AddForeignKey(string name, string primaryTable, string[] primaryColumns, string refTable,`
`783`		`- string[] refColumns, ForeignKeyConstraintType constraint)`
	`785`	`+ public virtual void AddForeignKey(string name, string parentTable, string[] parentColumns, string childTable,`
	`786`	`+ string[] childColumns, ForeignKeyConstraintType constraint)`
`784`	`787`	`{`
`785`		`- refTable = QuoteTableNameIfRequired(refTable);`
`786`		`- primaryTable = QuoteTableNameIfRequired(primaryTable);`
`787`		`- QuoteColumnNames(primaryColumns);`
`788`		`- QuoteColumnNames(refColumns);`
	`788`	`+ childTable = QuoteTableNameIfRequired(childTable);`
	`789`	`+ parentTable = QuoteTableNameIfRequired(parentTable);`
	`790`	`+ QuoteColumnNames(parentColumns);`
	`791`	`+ QuoteColumnNames(childColumns);`
`789`	`792`
`790`	`793`	`string constraintResolved = constraintMapper.SqlForConstraint(constraint);`
`791`	`794`
`792`	`795`	`ExecuteNonQuery(`
`793`	`796`	`String.Format(`
`794`	`797`	`"ALTER TABLE {0} ADD CONSTRAINT {1} FOREIGN KEY ({2}) REFERENCES {3} ({4}) ON UPDATE {5} ON DELETE {6}",`
`795`		`- primaryTable, name, String.Join(",", primaryColumns),`
`796`		`- refTable, String.Join(",", refColumns), constraintResolved, constraintResolved));`
	`798`	`+ parentTable, name, String.Join(",", parentColumns),`
	`799`	`+ childTable, String.Join(",", childColumns), constraintResolved, constraintResolved));`
`797`	`800`	`}`
`798`	`801`
`799`	`802`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -77,13 +77,17 @@ private string GetListString(string[] list)`
`77`	`77`	`}`
`78`	`78`	`return $"new []{String.Format("{{{0}}}", String.Join(",", list))}";`
`79`	`79`	`}`
	`80`	`+`
`80`	`81`	`private void addForeignKeys(StringWriter writer)`
`81`	`82`	`{`
`82`	`83`	`foreach (var fk in this.foreignKeys)`
`83`	`84`	`{`
`84`		`- string[] fkCols = fk.Columns;`
	`85`	`+ var fkCols = fk.ParentColumns;`
	`86`	`+`
`85`	`87`	`foreach (var col in fkCols)`
`86`		`- writer.WriteLine($"\t\tDatabase.AddForeignKey(\"{fk.Name}\", \"{fk.Table}\", {this.GetListString(fk.Columns)}, \"{fk.PkTable}\", {this.GetListString(fk.PkColumns)});");`
	`88`	`+ {`
	`89`	`+ writer.WriteLine($"\t\tDatabase.AddForeignKey(\"{fk.Name}\", \"{fk.ParentTable}\", {this.GetListString(fk.ParentColumns)}, \"{fk.ChildTable}\", {this.GetListString(fk.ChildColumns)});");`
	`90`	`+ }`
`87`	`91`	`//this._provider.AddForeignKey(name, fktable, fkcols, pktable, primaryCols);`
`88`	`92`	`}`
`89`	`93`	`}`