Merge pull request #69 from dotnetprojects/Sqlite

Sqlite

Author: jogibear9988

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

@@ -19,21 +19,21 @@ public void AddForeignKey()
         Provider.ExecuteNonQuery("INSERT INTO TestTwo (TestId) VALUES (1)");
 
         // Act
-        Provider.AddForeignKey(name: "FK name is not supported by SQLite", childTable: "TestTwo", childColumn: "TestId", parentTable: "Test", parentColumn: "Id", constraint: ForeignKeyConstraintType.Cascade);
+        Provider.AddForeignKey(name: "FKName", childTable: "TestTwo", childColumn: "TestId", parentTable: "Test", parentColumn: "Id", constraint: ForeignKeyConstraintType.Cascade);
 
         // Assert
         var foreignKeyConstraints = ((SQLiteTransformationProvider)Provider).GetForeignKeyConstraints("TestTwo");
         var tableSQLCreateScript = ((SQLiteTransformationProvider)Provider).GetSqlCreateTableScript("TestTwo");
 
-        Assert.That(foreignKeyConstraints.Single().Name, Is.Null);
+        Assert.That(foreignKeyConstraints.Single().Name, Is.EqualTo("FKName"));
         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"));
         // Cascade is not supported
 
         Assert.That(tableSQLCreateScript, Does.Contain("CREATE TABLE \"TestTwo\""));
-        Assert.That(tableSQLCreateScript, Does.Contain(", FOREIGN KEY (TestId) REFERENCES Test(Id))"));
+        Assert.That(tableSQLCreateScript, Does.Contain(", CONSTRAINT FKName FOREIGN KEY (TestId) REFERENCES Test(Id))"));
 
         var result = ((SQLiteTransformationProvider)Provider).CheckForeignKeyIntegrity();
         Assert.That(result, Is.True);
@@ -48,7 +48,7 @@ public void AddForeignKey_RenameParentColumWithForeignKeyAndData_ForeignKeyPoint
         Provider.ExecuteNonQuery("INSERT INTO TestTwo (TestId) VALUES (1)");
 
         // Act
-        Provider.AddForeignKey(name: "FK name is not supported by SQLite", childTable: "TestTwo", childColumn: "TestId", parentTable: "Test", parentColumn: "Id", constraint: ForeignKeyConstraintType.Cascade);
+        Provider.AddForeignKey(name: "FKName", childTable: "TestTwo", childColumn: "TestId", parentTable: "Test", parentColumn: "Id", constraint: ForeignKeyConstraintType.Cascade);
 
         // Rename column in parent
         Provider.RenameColumn("Test", "Id", "IdNew");
@@ -58,7 +58,7 @@ public void AddForeignKey_RenameParentColumWithForeignKeyAndData_ForeignKeyPoint
         var tableSQLCreateScript = ((SQLiteTransformationProvider)Provider).GetSqlCreateTableScript("TestTwo");
 
         Assert.That(tableSQLCreateScript, Does.Contain("CREATE TABLE \"TestTwo\""));
-        Assert.That(tableSQLCreateScript, Does.Contain(", FOREIGN KEY (TestId) REFERENCES Test(IdNew))"));
+        Assert.That(tableSQLCreateScript, Does.Contain(", CONSTRAINT FKName FOREIGN KEY (TestId) REFERENCES Test(IdNew))"));
         Assert.That(foreignKeyConstraints.Single().ParentColumns.Single(), Is.EqualTo("IdNew"));
 
         var result = ((SQLiteTransformationProvider)Provider).CheckForeignKeyIntegrity();

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

@@ -16,7 +16,7 @@ public void CheckForeignKeyIntegrity_IntegrityViolated_ReturnsFalse()
         AddTableWithPrimaryKey();
         Provider.ExecuteNonQuery("INSERT INTO Test (Id, name) VALUES (1, 'my name')");
         Provider.ExecuteNonQuery("INSERT INTO TestTwo (TestId) VALUES (44444)");
-        Provider.AddForeignKey(name: "FK name is not supported by SQLite", childTable: "TestTwo", childColumn: "TestId", parentTable: "Test", parentColumn: "Id", constraint: ForeignKeyConstraintType.Cascade);
+        Provider.AddForeignKey(name: "FKName", childTable: "TestTwo", childColumn: "TestId", parentTable: "Test", parentColumn: "Id", constraint: ForeignKeyConstraintType.Cascade);
 
         // Act
         var result = ((SQLiteTransformationProvider)Provider).CheckForeignKeyIntegrity();
@@ -32,7 +32,7 @@ public void CheckForeignKeyIntegrity_IntegrityOk_ReturnsTrue()
         AddTableWithPrimaryKey();
         Provider.ExecuteNonQuery("INSERT INTO Test (Id, name) VALUES (1, 'my name')");
         Provider.ExecuteNonQuery("INSERT INTO TestTwo (TestId) VALUES (1)");
-        Provider.AddForeignKey(name: "FK name is not supported by SQLite", childTable: "TestTwo", childColumn: "TestId", parentTable: "Test", parentColumn: "Id", constraint: ForeignKeyConstraintType.Cascade);
+        Provider.AddForeignKey(name: "FKName", childTable: "TestTwo", childColumn: "TestId", parentTable: "Test", parentColumn: "Id", constraint: ForeignKeyConstraintType.Cascade);
 
         // Act
         var result = ((SQLiteTransformationProvider)Provider).CheckForeignKeyIntegrity();

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

@@ -99,7 +99,7 @@ public void GetColumns_AddUniqueWithTwoColumns_NoUniqueOnColumnLevel()
         const string tableName = "GetColumnsTest";
         Provider.AddTable(tableName, new Column("Bla1", System.Data.DbType.Int32), new Column("Bla2", System.Data.DbType.Int32));
 
-        Provider.AddUniqueConstraint("Index name not used in SQLite", tableName, "Bla1", "Bla2");
+        Provider.AddUniqueConstraint("IndexName", tableName, "Bla1", "Bla2");
 
         // Act
         var columns = Provider.GetColumns(tableName);

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

@@ -0,0 +1,56 @@
+using System.Data;
+using System.Linq;
+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);
+
+        // Assert
+        Assert.That(foreignKeyConstraints.Single(x => x.Name == foreignKeyStringA).ChildColumns, Is.EqualTo([childColumnFKToParentAProperty1]));
+        Assert.That(foreignKeyConstraints.Single(x => x.Name == foreignKeyStringA).ParentColumns, Is.EqualTo([parentAProperty1]));
+
+        Assert.That(foreignKeyConstraints.Single(x => x.Name == foreignKeyStringB).ChildColumns, Is.EqualTo([childColumnFKToParentBProperty1, childColumnFKToParentBProperty2]));
+        Assert.That(foreignKeyConstraints.Single(x => x.Name == foreignKeyStringB).ParentColumns, Is.EqualTo([parentBProperty1, parentBProperty2]));
+    }
+}

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

@@ -76,11 +76,11 @@ public void RemoveColumn_HavingASingleForeignKeyPointingToTheTargetColumn_Single
         );
 
         Provider.AddTable(childTestTableName, new Column(propertyChildTableName1, DbType.Int32));
-        Provider.AddForeignKey("Not used in SQLite", childTestTableName, propertyChildTableName1, parentTableName, propertyName1);
+        Provider.AddForeignKey("FKName1", childTestTableName, propertyChildTableName1, parentTableName, propertyName1);
         var script = ((SQLiteTransformationProvider)Provider).GetSqlCreateTableScript(childTestTableName);
 
         Provider.AddTable(childTestTableName2, new Column(propertyChildTableName1, DbType.Int32));
-        Provider.AddForeignKey(name: "Not used in SQLite", childTable: childTestTableName2, childColumn: propertyChildTableName1, parentTable: parentTableName, parentColumn: propertyName2);
+        Provider.AddForeignKey(name: "FKName2", childTable: childTestTableName2, childColumn: propertyChildTableName1, parentTable: parentTableName, parentColumn: propertyName2);
 
         var tableInfoBefore = ((SQLiteTransformationProvider)Provider).GetSQLiteTableInfo(parentTableName);
         var tableInfoChildBefore = ((SQLiteTransformationProvider)Provider).GetSQLiteTableInfo(childTestTableName);
@@ -161,7 +161,7 @@ public void RemoveColumn_HavingUniqueConstraintWithTwoColumnsOneOfThemTargetColu
             new Column(propertyName3, DbType.Int32, ColumnProperty.Unique)
         );
 
-        Provider.AddUniqueConstraint("Not used in SQLite", testTableName, [propertyName2, propertyName3]);
+        Provider.AddUniqueConstraint("UniqueConstraintName", testTableName, [propertyName2, propertyName3]);
 
         Provider.AddIndex(indexName, testTableName, [propertyName1, propertyName2]);
         var tableInfoBefore = ((SQLiteTransformationProvider)Provider).GetSQLiteTableInfo(testTableName);

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,66 @@ public override ForeignKeyConstraint[] GetForeignKeyConstraints(string tableName
                 foreignKeyConstraints.Add(foreignKeyConstraint);
             }
 
+            if (foreignKeyConstraints.Count == 0)
+            {
+                return [];
+            }
+
+            var createTableScript = GetSqlCreateTableScript(tableName);
+            var regEx = ForeignKeyRegex();
+            var matchesCollection = regEx.Matches(createTableScript);
+            var fkParts = matchesCollection.Cast<Match>().ToList().Where(x => x.Success).Select(x => x.Value).ToList();
+
+            if (fkParts.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}' in this or older migrations?");
+            }
+
+            List<ForeignKeyExtract> foreignKeyExtracts = [];
+
+            foreach (var fkPart in fkParts)
+            {
+                var regexParenthesis = ForeignKeyParenthesisRegex();
+                var parenthesisContents = regexParenthesis.Matches(fkPart).Cast<Match>().Select(x => x.Groups[1].Value).ToList();
+
+                if (parenthesisContents.Count != 2)
+                {
+                    throw new Exception("Cannot extract parenthesis of foreign key constraint");
+                }
+
+                var foreignKeyExtract = new ForeignKeyExtract()
+                {
+                    ChildColumnNames = parenthesisContents[0].Split(",").Select(x => x.Trim()).ToList(),
+                    ParentColumnNames = parenthesisContents[1].Split(",").Select(x => x.Trim()).ToList(),
+                };
+
+                var foreignKeyConstraintNameRegex = ForeignKeyConstraintNameRegex();
+                var foreignKeyNameMatch = foreignKeyConstraintNameRegex.Match(fkPart);
+
+                if (!foreignKeyNameMatch.Success)
+                {
+                    throw new Exception("Could not extract the foreign key constraint name");
+                }
+
+                foreignKeyExtract.ForeignKeyName = foreignKeyNameMatch.Groups[1].Value;
+
+                foreignKeyExtracts.Add(foreignKeyExtract);
+            }
+
+            foreach (var foreignKeyConstraint in foreignKeyConstraints)
+            {
+                foreach (var foreignKeyExtract in foreignKeyExtracts)
+                {
+                    if (
+                        foreignKeyExtract.ChildColumnNames.SequenceEqual(foreignKeyConstraint.ChildColumns) &&
+                        foreignKeyExtract.ParentColumnNames.SequenceEqual(foreignKeyConstraint.ParentColumns)
+                    )
+                    {
+                        foreignKeyConstraint.Name = foreignKeyExtract.ForeignKeyName;
+                    }
+                }
+            }
+
             return foreignKeyConstraints.ToArray();
         }
 
@@ -749,7 +810,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 +1056,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 +1297,12 @@ 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();
+        [GeneratedRegex(@"CONSTRAINT\s+(\w+)\s+FOREIGN\s+KEY")]
+        private static partial Regex ForeignKeyConstraintNameRegex();
     }
 }