PrimaryKey in ColumnProperty changed

Author: Ja bist du narrisch

src/Migrator.Tests/Providers/Base/TransformationProviderSimpleBase.cs

@@ -48,7 +48,7 @@ public void AddDefaultTable()
     {
         Provider.AddTable("TestTwo",
             new Column("Id", DbType.Int32, ColumnProperty.PrimaryKey),
-            new Column("TestId", DbType.Int32, ColumnProperty.ForeignKey)
+            new Column("TestId", DbType.Int32)
         );
     }
 

src/Migrator.Tests/Providers/SQLite/SQLiteReader/SQLiteReaderTests.cs

@@ -0,0 +1,24 @@
+using DotNetProjects.Migrator.Providers.Impl.SQLite;
+using NUnit.Framework;
+
+namespace Migrator.Tests.Providers.SQLite.SQLiteReader;
+
+[TestFixture]
+[Category("SQLite")]
+public class SQLiteReaderTests
+{
+    private SQLiteCreateTableScriptReader _sqliteCreateTableScriptReader = new SQLiteCreateTableScriptReader();
+
+    [Test]
+    public void GetParenthesisContent()
+    {
+        // Arrange 
+        var testScript = "CREATE TABLE \"TestTwo\" (Id INTEGER NOT NULL PRIMARY KEY, TestId INTEGER NULL, CONSTRAINT FKName FOREIGN KEY (TestId) REFERENCES Test(IdNew))";
+
+        // Act 
+        var parenthesisContent = _sqliteCreateTableScriptReader.GetParenthesisContent(testScript);
+
+        // Assert
+        Assert.That(parenthesisContent, Is.EqualTo("Id INTEGER NOT NULL PRIMARY KEY, TestId INTEGER NULL, CONSTRAINT FKName FOREIGN KEY (TestId) REFERENCES Test(IdNew)"));
+    }
+}

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

@@ -12,7 +12,6 @@ namespace Migrator.Tests.Providers.SQLite;
 [Category("SQLite")]
 public class SQLiteTransformationProvider_AddColumnTests : SQLiteTransformationProviderTestBase
 {
-
     /// <summary>
     /// We use a NULL column as new column here. NOT NULL will fail as expected. The user should handle that on his own.
     /// </summary>

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

@@ -30,7 +30,9 @@ public void AddForeignKey()
         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
+
+        // Cascade is not supported in this migrator see https://github.com/dotnetprojects/Migrator.NET/issues/33
+        // TODO add cascade tests as soon as it is supported.
 
         Assert.That(tableSQLCreateScript, Does.Contain("CREATE TABLE \"TestTwo\""));
         Assert.That(tableSQLCreateScript, Does.Contain(", CONSTRAINT FKName FOREIGN KEY (TestId) REFERENCES Test(Id))"));

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

@@ -113,6 +113,4 @@ public void AddTable_MiscellaneousColumns_Succeeds()
         Assert.That(sqliteInfo.Columns.First().Name, Is.EqualTo(columnName1));
         Assert.That(sqliteInfo.Columns[1].Name, Is.EqualTo(columnName2));
     }
-
-
-}
+}

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

@@ -0,0 +1,30 @@
+using System.Data;
+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_PropertyColumnIdentityTests : SQLiteTransformationProviderTestBase
+{
+    [Test]
+    public void AddPrimaryIdentity_Succeeds()
+    {
+        // Arrange
+        const string testTableName = "MyDefaultTestTable";
+        const string propertyName1 = "Color1";
+        const string propertyName2 = "Color2";
+
+        Provider.AddTable(testTableName,
+            new Column(propertyName1, DbType.Int32, ColumnProperty.PrimaryKey | ColumnProperty.Identity),
+            new Column(propertyName2, DbType.Int32, ColumnProperty.NotNull)
+        );
+
+        var sql = ((SQLiteTransformationProvider)Provider).GetSqlCreateTableScript(testTableName);
+
+        Assert.That(sql, Does.Contain("Color1 INTEGER NOT NULL PRIMARY KEY"));
+    }
+}

src/Migrator/Framework/Column.cs

@@ -164,6 +164,7 @@ public bool IsPrimaryKey
         {
             get { return (ColumnProperty & ColumnProperty.PrimaryKey) == ColumnProperty.PrimaryKey; }
         }
+
         public bool IsPrimaryKeyNonClustered
         {
             get { return (ColumnProperty & ColumnProperty.PrimaryKeyNonClustered) == ColumnProperty.PrimaryKeyNonClustered; }

src/Migrator/Framework/ColumnProperty.cs

@@ -13,55 +13,59 @@ public enum ColumnProperty
         /// <summary>
         /// Null is allowable
         /// </summary>
-        Null = 1,
+        Null = 1 << 0,
 
         /// <summary>
         /// Null is not allowable
         /// </summary>
-        NotNull = 2,
+        NotNull = 1 << 1,
 
         /// <summary>
         /// Identity column, autoinc
         /// </summary>
-        Identity = 4,
+        Identity = 1 << 2,
 
         /// <summary>
         /// 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,
+        Unique = 1 << 3,
 
         /// <summary>
         /// Indexed Column
         /// </summary>
-        Indexed = 16,
+        Indexed = 1 << 4,
 
         /// <summary>
-        /// Unsigned Column
+        /// Unsigned Column. Not used in SQLite (there is only)
         /// </summary>
-        Unsigned = 32,
+        Unsigned = 1 << 5,
 
-        CaseSensitive = 64,
+        /// <summary>
+        /// CaseSensitive. Currently only used in SQLite, MySQL and SQL Server
+        /// </summary>
+        CaseSensitive = 1 << 6,
 
         /// <summary>
         /// Foreign Key
         /// </summary>
-        ForeignKey = Unsigned | Null,
+        [Obsolete("Use method 'AddForeignKey' instead. The flag does not make sense on column level.")]
+        ForeignKey = 1 << 7,
 
         /// <summary>
         /// Primary Key
         /// </summary>
-        PrimaryKey = 128 | Unsigned | NotNull,
+        PrimaryKey = 1 << 8,
 
         /// <summary>
-        /// Primary key. Make the column a PrimaryKey and unsigned
+        /// Primary key with identity. Will be removed soon.
         /// </summary>
-        PrimaryKeyWithIdentity = PrimaryKey | Identity,
+        PrimaryKeyWithIdentity = 1 << 9 | PrimaryKey | Identity,
 
         /// <summary>
-        /// Primary key. Make the column a PrimaryKey and unsigned
+        /// Primary key. Will be removed soon.
         /// </summary>
-        PrimaryKeyNonClustered = 256 | PrimaryKey
+        PrimaryKeyNonClustered = 1 << 10 | PrimaryKey
     }
 
     public static class ColumnPropertyExtensions

src/Migrator/Framework/SchemaBuilder/SchemaBuilder.cs

@@ -53,8 +53,6 @@ public SchemaBuilder WithSize(int size)
 
         public IForeignKeyOptions AsForeignKey()
         {
-            _currentColumn.ColumnProperty = ColumnProperty.ForeignKey;
-
             return this;
         }
 

src/Migrator/Providers/ColumnPropertiesMapper.cs

@@ -143,7 +143,7 @@ public virtual void MapColumnPropertiesWithoutDefault(Column column)
 
             AddForeignKey(column, vals);
 
-            columnSql = String.Join(" ", vals.ToArray());
+            columnSql = string.Join(" ", vals.ToArray());
         }
 
         protected virtual void AddCaseSensitive(Column column, List<string> vals)
@@ -154,11 +154,14 @@ protected virtual void AddCaseSensitive(Column column, List<string> vals)
         protected virtual void AddDefaultValue(Column column, List<string> vals)
         {
             if (column.DefaultValue != null)
+            {
                 vals.Add(dialect.Default(column.DefaultValue));
+            }
         }
 
         protected virtual void AddForeignKey(Column column, List<string> vals)
         {
+            // TODO Does that really make sense?
             AddValueIfSelected(column, ColumnProperty.ForeignKey, vals);
         }
 
@@ -204,13 +207,17 @@ protected virtual void AddNotNull(Column column, List<string> vals)
         protected virtual void AddUnsigned(Column column, List<string> vals)
         {
             if (dialect.IsUnsignedCompatible(column.Type))
+            {
                 AddValueIfSelected(column, ColumnProperty.Unsigned, vals);
+            }
         }
 
         protected virtual void AddIdentity(Column column, List<string> vals)
         {
             if (!dialect.IdentityNeedsType)
+            {
                 AddValueIfSelected(column, ColumnProperty.Identity, vals);
+            }
         }
 
         protected virtual void AddType(List<string> vals)