Prepared foreign key extraction - mixture of sys tables and string extraction

Author: Ja bist du narrisch

src/Migrator.Tests/Providers/SQLite/SQLiteTransformationProvider_GetForeignKeysTests.cs

@@ -0,0 +1,87 @@
+using System.Data;
+using System.Linq;
+using DotNetProjects.Migrator.Framework;
+using DotNetProjects.Migrator.Providers.Impl.SQLite;
+using Migrator.Framework;
+using Migrator.Tests.Providers.SQLite.Base;
+using NUnit.Framework;
+
+namespace Migrator.Tests.Providers.SQLite;
+
+[TestFixture]
+[Category("SQLite")]
+public class SQLiteTransformationProvider_GetForeignKeysTests : SQLiteTransformationProviderTestBase
+{
+    [Test]
+    public void RenameColumn_HavingASingleForeignKeyPointingToTheTargetColumn_SingleColumnForeignKeyIsRemoved()
+    {
+        // Arrange
+        const string parentA = "TableA";
+        const string parentAProperty1 = "ParentBProperty1";
+        const string parentB = "TableB";
+        const string parentBProperty1 = "ParentBProperty1";
+        const string parentBProperty2 = "ParentBProperty2";
+        const string child = "TableChild";
+        const string childColumnFKToParentAProperty1 = "ChildColumnFKToParentAProperty1";
+        const string childColumnFKToParentBProperty1 = "ChildColumnFKToParentBProperty1";
+        const string childColumnFKToParentBProperty2 = "ChildColumnFKToParentBProperty2";
+        const string foreignKeyStringA = "ForeignKeyStringA";
+        const string foreignKeyStringB = "ForeignKeyStringB";
+
+        Provider.AddTable(parentA, new Column(parentAProperty1, DbType.Int32, ColumnProperty.PrimaryKey));
+
+        Provider.AddTable(parentB,
+            new Column(parentBProperty1, DbType.Int32, ColumnProperty.PrimaryKey),
+            new Column(parentBProperty2, DbType.Int32, ColumnProperty.Unique)
+        );
+
+        Provider.AddTable(child,
+            new Column("Id", DbType.Int32, ColumnProperty.PrimaryKey),
+            new Column(childColumnFKToParentAProperty1, DbType.Int32, ColumnProperty.Unique),
+            new Column(childColumnFKToParentBProperty1, DbType.Int32),
+            new Column(childColumnFKToParentBProperty2, DbType.Int32)
+        );
+
+        Provider.AddForeignKey(foreignKeyStringA, child, childColumnFKToParentAProperty1, parentA, parentAProperty1);
+        Provider.AddForeignKey(foreignKeyStringB, child, [childColumnFKToParentBProperty1, childColumnFKToParentBProperty2], parentB, [parentBProperty1, parentBProperty2]);
+
+        // Act
+        var foreignKeyConstraints = Provider.GetForeignKeyConstraints(child);
+
+        // var tableInfoLevel2Before = ((SQLiteTransformationProvider)Provider).GetSQLiteTableInfo(tableNameLevel2);
+        // var tableInfoLevel3Before = ((SQLiteTransformationProvider)Provider).GetSQLiteTableInfo(tableNameLevel3);
+
+        // Provider.ExecuteNonQuery($"INSERT INTO {tableNameLevel1} ({propertyId}) VALUES (1)");
+        // Provider.ExecuteNonQuery($"INSERT INTO {tableNameLevel1} ({propertyId}) VALUES (2)");
+        // Provider.ExecuteNonQuery($"INSERT INTO {tableNameLevel2} ({propertyId}, {propertyLevel1Id}) VALUES (1, 1)");
+        // Provider.ExecuteNonQuery($"INSERT INTO {tableNameLevel3} ({propertyId}, {propertyLevel2Id}) VALUES (1, 1)");
+
+        // // Act
+        // Provider.RenameColumn(tableNameLevel2, propertyId, propertyIdRenamed);
+        // Provider.RenameColumn(tableNameLevel2, propertyLevel1Id, propertyLevel1IdRenamed);
+
+        // // Assert
+        // Provider.ExecuteNonQuery($"INSERT INTO {tableNameLevel2} ({propertyIdRenamed}, {propertyLevel1IdRenamed}) VALUES (2,2)");
+        // using var command = Provider.GetCommand();
+
+        // using var reader = Provider.ExecuteQuery(command, $"SELECT COUNT(*) as Count from {tableNameLevel2}");
+        // reader.Read();
+        // var count = reader.GetInt32(reader.GetOrdinal("Count"));
+        // Assert.That(count, Is.EqualTo(2));
+
+        // var tableInfoLevel2After = ((SQLiteTransformationProvider)Provider).GetSQLiteTableInfo(tableNameLevel2);
+
+        // Assert.That(tableInfoLevel2Before.Columns.Single(x => x.Name == propertyId).ColumnProperty.HasFlag(ColumnProperty.PrimaryKey), Is.True);
+        // Assert.That(tableInfoLevel2Before.Columns.Single(x => x.Name == propertyLevel1Id).ColumnProperty.HasFlag(ColumnProperty.Unique), Is.True);
+        // Assert.That(tableInfoLevel2Before.ForeignKeys.Single().ChildColumns.Single(), Is.EqualTo(propertyLevel1Id));
+
+        // Assert.That(tableInfoLevel2After.Columns.FirstOrDefault(x => x.Name == propertyId), Is.Null);
+        // Assert.That(tableInfoLevel2After.Columns.FirstOrDefault(x => x.Name == propertyLevel1Id), Is.Null);
+        // Assert.That(tableInfoLevel2After.Columns.FirstOrDefault(x => x.Name == propertyIdRenamed), Is.Not.Null);
+        // Assert.That(tableInfoLevel2After.Columns.FirstOrDefault(x => x.Name == propertyLevel1IdRenamed), Is.Not.Null);
+        // Assert.That(tableInfoLevel2After.ForeignKeys.Single().ChildColumns.Single(), Is.EqualTo(propertyLevel1IdRenamed));
+
+        // var valid = ((SQLiteTransformationProvider)Provider).CheckForeignKeyIntegrity();
+        // Assert.That(valid, Is.True);
+    }
+}

src/Migrator/Providers/Impl/SQLite/Models/ForeignKeyExtract.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+
+namespace DotNetProjects.Migrator.Providers.Impl.SQLite.Models;
+
+public class ForeignKeyExtract
+{
+    /// <summary>
+    /// Gets or sets the complete foreign key string - CONSTRAINT MyFKName FOREIGN KEY (asdf, asdf) REFERENCES ParentTable(asdf,asdf)
+    /// </summary>
+    public string ForeignKeyString { get; set; }
+
+    /// <summary>
+    /// Gets or sets the foreign key name
+    /// </summary>
+    public string ForeignKeyName { get; set; }
+
+    /// <summary>
+    /// Gets or sets the child column names.
+    /// </summary>
+    public List<string> ChildColumnNames { get; set; }
+
+    /// <summary>
+    /// Gets or sets the parent column names.
+    /// </summary>
+    public List<string> ParentColumnNames { get; set; }
+}

src/Migrator/Providers/Impl/SQLite/SQLiteTransformationProvider.cs

@@ -8,6 +8,7 @@
 using System.Globalization;
 using System.Linq;
 using System.Text;
+using System.Text.RegularExpressions;
 using ForeignKeyConstraint = DotNetProjects.Migrator.Framework.ForeignKeyConstraint;
 using Index = Migrator.Framework.Index;
 
@@ -16,7 +17,7 @@ namespace DotNetProjects.Migrator.Providers.Impl.SQLite
     /// <summary>
     /// Summary description for SQLiteTransformationProvider.
     /// </summary>
-    public class SQLiteTransformationProvider : TransformationProvider
+    public partial class SQLiteTransformationProvider : TransformationProvider
     {
         private const string IntermediateTableSuffix = "Temp";
 
@@ -59,7 +60,7 @@ public override void AddForeignKey(
                 // SQLite does not support FK names
                 ChildColumns = childColumns,
                 ChildTable = childTable,
-                Name = null,
+                Name = name,
                 ParentColumns = parentColumns,
                 ParentTable = parentTable,
             };
@@ -117,6 +118,23 @@ public override ForeignKeyConstraint[] GetForeignKeyConstraints(string tableName
                 foreignKeyConstraints.Add(foreignKeyConstraint);
             }
 
+            var createTableScript = GetSqlCreateTableScript(tableName);
+            var regEx = ForeignKeyRegex();
+            var matchesCollection = regEx.Matches(createTableScript);
+            var matches = matchesCollection.Cast<Match>().ToList().Where(x => x.Success).Select(x => x.Value).ToList();
+
+            if (matches.Count != foreignKeyConstraints.Count)
+            {
+                throw new Exception($"Cannot extract all foreign keys out of the create table script in SQLite. Did you use a name as foreign key constraint for all constraints in table {tableName}?");
+            }
+
+            foreach (var foreignKeyConstraint in foreignKeyConstraints)
+            {
+                var regexParenthesis = ForeignKeyParenthesisRegex();
+                regexParenthesis.Matches()
+            }
+
+
             return foreignKeyConstraints.ToArray();
         }
 
@@ -749,7 +767,7 @@ public override bool ViewExists(string view)
 
         public override List<string> GetDatabases()
         {
-            throw new NotImplementedException();
+            throw new NotSupportedException("SQLite is a file-based database. You cannot list other databases.");
         }
 
         public override bool ConstraintExists(string table, string name)
@@ -995,34 +1013,40 @@ public override void AddTable(string name, string engine, params IDbField[] fiel
 
             foreach (var u in uniques)
             {
-                // var nm = "";
+                if (!string.IsNullOrEmpty(u.Name))
+                {
+                    stringBuilder.Append($" CONSTRAINT {u.Name}");
+                }
 
-                // if (!string.IsNullOrEmpty(u.Name))
-                // {
-                //     nm = string.Format(" CONSTRAINT {0}", u.Name);
-                // }
                 var uniqueColumnsCommaSeparated = string.Join(", ", u.KeyColumns);
                 stringBuilder.Append($", UNIQUE ({uniqueColumnsCommaSeparated})");
             }
 
             var foreignKeys = fields.Where(x => x is ForeignKeyConstraint).Cast<ForeignKeyConstraint>().ToArray();
 
+            List<string> foreignKeyStrings = [];
+
             foreach (var fk in foreignKeys)
             {
-                // Since in SQLite the foreign key name can be given as 
-                // CONSTRAINT <FK name>
-                // 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.ChildColumns.Select(QuoteColumnNameIfRequired));
                 var parentColumnNamesQuotedString = string.Join(", ", fk.ParentColumns.Select(QuoteColumnNameIfRequired));
                 var parentTableNameQuoted = QuoteTableNameIfRequired(fk.ParentTable);
 
-                var foreignKeyString = $", FOREIGN KEY ({sourceColumnNamesQuotedString}) REFERENCES {parentTableNameQuoted}({parentColumnNamesQuotedString})";
+                if (string.IsNullOrWhiteSpace(fk.Name))
+                {
+                    throw new Exception("No foreign key constraint name given");
+                }
+
+                foreignKeyStrings.Add($"CONSTRAINT {fk.Name} FOREIGN KEY ({sourceColumnNamesQuotedString}) REFERENCES {parentTableNameQuoted}({parentColumnNamesQuotedString})");
+            }
 
-                stringBuilder.Append(foreignKeyString);
+            if (foreignKeyStrings.Count != 0)
+            {
+                stringBuilder.Append(", ");
+                stringBuilder.Append(string.Join(", ", foreignKeyStrings));
             }
 
+
             stringBuilder.Append(")");
 
             ExecuteNonQuery(stringBuilder.ToString());
@@ -1230,5 +1254,10 @@ protected override void ConfigureParameterWithValue(IDbDataParameter parameter,
                 base.ConfigureParameterWithValue(parameter, index, value);
             }
         }
+
+        [GeneratedRegex(@"CONSTRAINT\s+\w+\s+FOREIGN\s+KEY\s*\([^)]+\)\s+REFERENCES\s+\w+\s*\([^)]+\)")]
+        private static partial Regex ForeignKeyRegex();
+        [GeneratedRegex(@"\(([^)]+)\)")]
+        private static partial Regex ForeignKeyParenthesisRegex();
     }
 }