Support for non-autoincrement pk when the pk is non-nullable. Add more tests. More API clean up.

Author: bordoley

SQLitePCL.pretty.Orm/SQLBuilder.cs

@@ -97,15 +97,18 @@ internal static string CreateTableIfNotExists(string tableName, CreateFlags crea
             return query;
         }
 
-        internal static string SqlDecl (string columnName, ColumnMapping columnMapping)
+        internal static string SqlDecl(string columnName, ColumnMapping columnMapping)
         {
             string decl = "\"" + columnName + "\" " + columnMapping.Metadata.DeclaredType + " ";
 
-            // Only specify a column as primary key if it is autoincrement
-            if (columnMapping.Metadata.IsPrimaryKeyPart && columnMapping.Metadata.IsAutoIncrement) 
+            if (columnMapping.Metadata.IsPrimaryKeyPart && columnMapping.Metadata.IsAutoIncrement)
             {
                 decl += "PRIMARY KEY AUTOINCREMENT NOT NULL ";
             }
+            else if (columnMapping.Metadata.IsPrimaryKeyPart)
+            {
+                decl += "PRIMARY KEY NOT NULL ";
+            }
             else if (columnMapping.Metadata.HasNotNullConstraint) 
             {
                 decl += "NOT NULL DEFAULT \"" + columnMapping.DefaultValue.ToString() + "\" ";

SQLitePCL.pretty.Orm/TableMapping.cs

@@ -49,7 +49,7 @@ internal static void Bind<T>(this IStatement This, ITableMapping<T> tableMapping
             }
         }
 
-        public static TableQuery<T> CreateQuery<T>(this ITableMapping<T> This)
+        public static TableQuery<T> Query<T>(this ITableMapping<T> This)
         {
             return new TableQuery<T>(This, "*", null, new List<Ordering>(), null, null);
         }
@@ -218,13 +218,20 @@ private static TableColumnMetadata CreateColumnMetadata(this PropertyInfo This)
             var isAutoInc = false;
             if (isPK)
             {
-                if (columnType != typeof(Nullable<long>))
+                // Only use autoincrement if the primary key is nullable otherwise.
+                if (columnType == typeof(Nullable<long>))
+                {
+                    isAutoInc = true;
+
+                } 
+                else if (columnType == typeof(long))
+                {
+                    isAutoInc = false;
+                }
+                else
                 {
                     throw new ArgumentException("Primary key value must be of type Nullable<long>.");
                 }
-
-                // Only allow autoincrement on nullable long primary keys
-                isAutoInc = true;
             }
 
             // Though technically not required to be not null by SQLite, we enforce that the primary key is always not null

SQLitePCL.pretty.Orm/TableQuery.cs

@@ -106,7 +106,7 @@ public override string ToString()
         /// Converts the query to a count query.
         /// </summary>
         /// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery&lt;T&gt;"/>.</returns>
-        public TableQuery<T> ToCountQuery()
+        public TableQuery<T> Count()
         {
             return new TableQuery<T>(_mapping, "count(*)", _where, _orderBy, _limit, _offset);
         }
@@ -446,8 +446,6 @@ private static string CompileNullBinaryExpression(BinaryExpression expression, s
             else { throw new NotSupportedException("Cannot compile Null-BinaryExpression with type " + expression.NodeType.ToString()); }
         }
 
-
-
         private static string GetSqlName (Expression expr)
         {
             var n = expr.NodeType;
@@ -471,7 +469,7 @@ private static string GetSqlName (Expression expr)
     /// </summary>
     public static class TableQuery
     {
-        public static ITableMappedStatement<T> PrepareQuery<T>(this IDatabaseConnection This, TableQuery<T> query)
+        public static ITableMappedStatement<T> PrepareStatement<T>(this IDatabaseConnection This, TableQuery<T> query)
         {
             return new TableMappedStatement<T>(This.PrepareStatement(query.ToString()), query.Mapping);
         }
@@ -491,19 +489,19 @@ public static IObservable<T> Query<T>(this IAsyncDatabaseConnection This, TableQ
             return This.Query(query.ToString()).Select(query.Mapping.ToObject);
         }
 
-        public static IStatement PrepareCount<T>(this IDatabaseConnection This, TableQuery<T> query)
+        public static IStatement PrepareCountStatement<T>(this IDatabaseConnection This, TableQuery<T> query)
         {
-            return This.PrepareStatement(query.ToCountQuery().ToString());
+            return This.PrepareStatement(query.Count().ToString());
         }
 
-        public static Task<IAsyncStatement> PrepareCountAsync<T>(this IAsyncDatabaseConnection This, TableQuery<T> query)
+        public static Task<IAsyncStatement> PrepareCountStatemenAsync<T>(this IAsyncDatabaseConnection This, TableQuery<T> query)
         {
-            return This.PrepareStatementAsync(query.ToCountQuery().ToString());
+            return This.PrepareStatementAsync(query.Count().ToString());
         }
 
         public static int Count<T>(this IDatabaseConnection This, TableQuery<T> query)
         {
-            return This.Query(query.ToCountQuery().ToString()).SelectScalarInt().First();
+            return This.Query(query.Count().ToString()).SelectScalarInt().First();
         }
 
         public static Task<int> CountAsync<T>(this IAsyncDatabaseConnection This, TableQuery<T> query)
@@ -513,12 +511,12 @@ public static Task<int> CountAsync<T>(this IAsyncDatabaseConnection This, TableQ
 
         public static Task<int> CountAsync<T>(this IAsyncDatabaseConnection This, TableQuery<T> query, CancellationToken ct)
         {
-            return This.Query(query.ToCountQuery().ToString()).SelectScalarInt().FirstAsync().ToTask(ct);
+            return This.Query(query.Count().ToString()).SelectScalarInt().FirstAsync().ToTask(ct);
         }
 
         public static int Count<T>(this IDatabaseConnection This, TableQuery<T> query, params object[] values)
         {
-            return This.Query(query.ToCountQuery().ToString(), values).SelectScalarInt().First();
+            return This.Query(query.Count().ToString(), values).SelectScalarInt().First();
         }
 
         public static Task<int> CountAsync<T>(this IAsyncDatabaseConnection This, TableQuery<T> query, params object[] values)
@@ -528,7 +526,7 @@ public static Task<int> CountAsync<T>(this IAsyncDatabaseConnection This, TableQ
 
         public static Task<int> CountAsync<T>(this IAsyncDatabaseConnection This, TableQuery<T> query, CancellationToken ct, params object[] values)
         {
-            return This.Query(query.ToCountQuery().ToString(), values).SelectScalarInt().FirstAsync().ToTask(ct);
+            return This.Query(query.Count().ToString(), values).SelectScalarInt().FirstAsync().ToTask(ct);
         }
     }    
 }

SQLitePCL.pretty.tests/Orm/BooleanTests.cs

@@ -143,6 +143,27 @@ public void TestCreateWithExplicitTableName()
             Assert.AreEqual(tableWithExplicitName.TableName, "ExplicitTableName");
         }
 
+        public class TestObjectWithNonAutoIncrementPrimaryKey
+        {
+            [PrimaryKey]
+            public long Id { get; set; }
+        }
+
+        [Test]
+        public void TestCreateWithNonAutoIncrementPrimaryKey()
+        {
+            var table = TableMapping.Create<TestObjectWithNonAutoIncrementPrimaryKey>();
+
+            var id = table.Columns["Id"];
+            Assert.AreEqual(id.ClrType, typeof(long));
+            // No way to test the PropertyInfo directly
+            Assert.AreEqual(id.Metadata.CollationSequence, "BINARY");
+            Assert.AreEqual(id.Metadata.DeclaredType, "INTEGER");
+            Assert.IsTrue(id.Metadata.HasNotNullConstraint);
+            Assert.IsFalse(id.Metadata.IsAutoIncrement);
+            Assert.IsTrue(id.Metadata.IsPrimaryKeyPart);
+        }
+
         public class TestObjectWithUnsupportedPropertyType
         {
             [PrimaryKey]