Merge pull request #71 from dotnetprojects/Sqlite

Retrieve Unique constraint names using RegEx in SQLite (from create table script)

Author: JaBistDuNarrisch

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

@@ -0,0 +1,52 @@
+using System.Data;
+using System.Linq;
+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_GetUniquesTests : SQLiteTransformationProviderTestBase
+{
+    [Test]
+    public void GetUniques_Success()
+    {
+        // Arrange
+        const string tableNameA = "TableA";
+        const string property1 = "Property1";
+        const string property2 = "Property2";
+        const string property3 = "Property3";
+        const string property4 = "Property4";
+        const string property5 = "Property5";
+        const string uniqueConstraintName1 = "UniqueConstraint1";
+        const string uniqueConstraintName2 = "UniqueConstraint2";
+
+        Provider.AddTable(tableNameA,
+            new Column(property1, DbType.Int32, ColumnProperty.PrimaryKey),
+            new Column(property2, DbType.Int32, ColumnProperty.Unique),
+            new Column(property3, DbType.Int32),
+            new Column(property4, DbType.Int32),
+            new Column(property5, DbType.Int32)
+        );
+
+        Provider.AddUniqueConstraint(uniqueConstraintName1, tableNameA, property3);
+        Provider.AddUniqueConstraint(uniqueConstraintName2, tableNameA, property4, property5);
+
+        // Act
+        var uniqueConstraints = ((SQLiteTransformationProvider)Provider).GetUniques(tableNameA);
+
+        // Assert
+        var sql = ((SQLiteTransformationProvider)Provider).GetSqlCreateTableScript(tableNameA);
+
+        Assert.That(uniqueConstraints.Count, Is.EqualTo(3));
+        Assert.That(uniqueConstraints.Single(x => x.Name == uniqueConstraintName1).KeyColumns, Is.EqualTo([property3]));
+        Assert.That(uniqueConstraints.Single(x => x.Name == uniqueConstraintName2).KeyColumns, Is.EqualTo([property4, property5]));
+
+        Assert.That(sql, Does.Contain("CONSTRAINT UniqueConstraint1 UNIQUE (Property3)"));
+        Assert.That(sql, Does.Contain("CONSTRAINT UniqueConstraint2 UNIQUE (Property4, Property5)"));
+        Assert.That(sql, Does.Contain("CONSTRAINT sqlite_autoindex_TableA_1 UNIQUE (Property2)"));
+    }
+}

src/Migrator/Framework/ColumnProperty.cs

@@ -26,8 +26,9 @@ public enum ColumnProperty
         Identity = 4,
 
         /// <summary>
-        /// Unique Column
+        /// Unique Column. This is marked being obsolete since you cannot add a name for the constraint which makes it difficult to remove the constraint again.
         /// </summary>
+        [Obsolete("Use method 'AddUniqueConstraint' instead. This is marked being obsolete since you cannot add a name for the constraint which makes it difficult to remove the constraint again.")]
         Unique = 8,
 
         /// <summary>

src/Migrator/Framework/ITransformationProvider.cs

@@ -488,29 +488,33 @@ public interface ITransformationProvider : IDisposable
         void RemoveColumn(string table, string column);
 
         /// <summary>
-        /// Remove an existing foreign key constraint
+        /// Remove an existing foreign key constraint.
         /// </summary>
         /// <param name="table">The table that contains the foreign key.</param>
         /// <param name="name">The name of the foreign key to remove</param>
         void RemoveForeignKey(string table, string name);
 
         /// <summary>
-        /// Remove an existing constraint
+        /// Remove an existing constraint.
         /// </summary>
         /// <param name="table">The table that contains the foreign key.</param>
         /// <param name="name">The name of the constraint to remove</param>
         void RemoveConstraint(string table, string name);
 
+        /// <summary>
+        /// Removes PK, FKs, Unique and CHECK constraints.
+        /// </summary>
+        /// <param name="table"></param>
         void RemoveAllConstraints(string table);
 
         /// <summary>
-        /// Remove an existing primary key
+        /// Remove an existing primary key.
         /// </summary>
         /// <param name="table">The table that contains the primary key.</param>        
         void RemovePrimaryKey(string table);
 
         /// <summary>
-        /// Remove an existing table
+        /// Drops an existing table.
         /// </summary>
         /// <param name="tableName">The name of the table</param>
         void RemoveTable(string tableName);

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

@@ -53,11 +53,31 @@ public override void AddForeignKey(
             string[] parentColumns,
             ForeignKeyConstraintType constraint)
         {
+            if (string.IsNullOrWhiteSpace(name))
+            {
+                throw new Exception("A FK name is mandatory");
+            }
+
             var sqliteTableInfo = GetSQLiteTableInfo(childTable);
 
+            // Get all unique constraint names if available
+            var uniqueConstraintNames = sqliteTableInfo.Uniques.Select(x => x.Name).ToList();
+
+            // Get all FK constraint names if available
+            var foreignKeyNames = sqliteTableInfo.ForeignKeys.Select(x => x.Name).ToList();
+
+            var names = uniqueConstraintNames.Concat(foreignKeyNames)
+                .Distinct()
+                .Where(x => !string.IsNullOrWhiteSpace(x))
+                .ToList();
+
+            if (names.Any(x => x.Equals(name, StringComparison.OrdinalIgnoreCase)))
+            {
+                throw new Exception($"Constraint name {name} already exists");
+            }
+
             var foreignKey = new ForeignKeyConstraint
             {
-                // SQLite does not support FK names
                 ChildColumns = childColumns,
                 ChildTable = childTable,
                 Name = name,
@@ -149,6 +169,7 @@ public override ForeignKeyConstraint[] GetForeignKeyConstraints(string tableName
                 var foreignKeyExtract = new ForeignKeyExtract()
                 {
                     ChildColumnNames = parenthesisContents[0].Split(',').Select(x => x.Trim()).ToList(),
+                    ForeignKeyString = fkPart,
                     ParentColumnNames = parenthesisContents[1].Split(',').Select(x => x.Trim()).ToList(),
                 };
 
@@ -816,12 +837,40 @@ public override List<string> GetDatabases()
 
         public override bool ConstraintExists(string table, string name)
         {
-            throw new NotSupportedException("SQLite does not offer constraint names e.g. for unique, check constraints. You need to use alternative ways.");
+            var constraintNames = GetConstraints(table);
+
+            var exists = constraintNames.Any(x => x.Equals(name, StringComparison.OrdinalIgnoreCase));
+
+            return exists;
         }
 
         public override string[] GetConstraints(string table)
         {
-            throw new NotSupportedException("SQLite does not offer constraint names e.g. for unique, check constraints  You need to drop them using alternative ways.");
+            var sqliteInfo = GetSQLiteTableInfo(table);
+
+            var foreignKeyNames = sqliteInfo.ForeignKeys
+                .Select(x => x.Name)
+                .ToList();
+
+            var uniqueConstraints = sqliteInfo.Uniques
+                .Select(x => x.Name)
+                .ToList();
+
+            // TODO add PK and CHECK
+
+            var names = foreignKeyNames.Concat(uniqueConstraints)
+                .Where(x => !string.IsNullOrWhiteSpace(x))
+                .ToArray();
+
+            var distinctNames = names.Distinct(StringComparer.OrdinalIgnoreCase)
+                .ToArray();
+
+            if (names.Length != distinctNames.Length)
+            {
+                throw new Exception($"There are duplicate constraint names in table {table}'");
+            }
+
+            return distinctNames;
         }
 
         public override string[] GetTables()
@@ -1059,11 +1108,15 @@ public override void AddTable(string name, string engine, params IDbField[] fiel
             {
                 if (!string.IsNullOrEmpty(u.Name))
                 {
-                    stringBuilder.Append($" CONSTRAINT {u.Name}");
+                    stringBuilder.Append($", CONSTRAINT {u.Name}");
+                }
+                else
+                {
+                    stringBuilder.Append(", ");
                 }
 
                 var uniqueColumnsCommaSeparated = string.Join(", ", u.KeyColumns);
-                stringBuilder.Append($", UNIQUE ({uniqueColumnsCommaSeparated})");
+                stringBuilder.Append($" UNIQUE ({uniqueColumnsCommaSeparated})");
             }
 
             var foreignKeys = fields.Where(x => x is ForeignKeyConstraint).Cast<ForeignKeyConstraint>().ToArray();
@@ -1169,14 +1222,18 @@ public override void RemoveAllIndexes(string tableName)
 
         public List<Unique> GetUniques(string tableName)
         {
+            var regEx = new Regex(@"(?<=,)\s*(CONSTRAINT\s+\w+\s+)?UNIQUE\s*\(\s*[\w\s,]+\s*\)\s*(?=,|\s*\))");
+            var regExConstraintName = new Regex(@"(?<=CONSTRAINT\s+)\w+(?=\s+)");
+            var regExParenthesis = new Regex(@"(?<=\().+(?=\))");
+
             List<Unique> uniques = [];
 
             var pragmaIndexListItems = GetPragmaIndexListItems(tableName);
 
             // Here we filter for origin u and unique while in "GetIndexes()" we exclude them.
-            // If pk is set then it was added by using a primary key. If so this is handled by "GetColumns()".
-            // If c is set it was created by using CREATE INDEX. At this moment in time this migrator does not support UNIQUE indexes but only normal indexes
-            // so u should never be set 30.06.2025).
+            // If "pk" is set then it was added by using a primary key. If so this is handled by "GetColumns()".
+            // If "c" is set it was created by using CREATE INDEX. At this moment in time this migrator does not support UNIQUE indexes but only normal indexes
+            // so "u" should never be set 30.06.2025).
             var uniqueConstraints = pragmaIndexListItems.Where(x => x.Unique && x.Origin == "u")
                 .ToList();
 
@@ -1197,6 +1254,41 @@ public List<Unique> GetUniques(string tableName)
                 uniques.Add(unique);
             }
 
+            var createScript = GetSqlCreateTableScript(tableName);
+
+            var matches = regEx.Matches(createScript).Cast<Match>().Where(x => x.Success).Select(x => x.Value.Trim()).ToList();
+
+            // We can only use the ones containing a  starting with CONSTRAINT 
+            var matchesHavingName = matches.Where(x => x.StartsWith("CONSTRAINT")).ToList();
+
+            foreach (var constraintString in matchesHavingName)
+            {
+                var constraintNameMatch = regExConstraintName.Match(constraintString);
+
+                if (!constraintNameMatch.Success)
+                {
+                    throw new Exception("Cannot extract constraint name - severe issue. Please file an issue");
+                }
+
+                var constraintName = constraintNameMatch.Value;
+
+                var parenthesisMatch = regExParenthesis.Match(constraintString);
+
+                if (!parenthesisMatch.Success)
+                {
+                    throw new Exception("Cannot extract parenthesis content for UNIQUE constraint - severe issue. Please file an issue");
+                }
+
+                var columns = parenthesisMatch.Value.Split(',').Select(x => x.Trim()).ToList();
+
+                var unique = uniques.Where(x => x.KeyColumns.SequenceEqual(columns)).SingleOrDefault();
+
+                if (unique != null)
+                {
+                    unique.Name = constraintName;
+                }
+            }
+
             return uniques;
         }