Deprecated types other than 64-bit signed integer for autoincrement PKs

SQLite documentation clearly states that an auto-incrementable primary key column must be a 64-bit signed integer type.

Author: trueqbit

dev/schema/column.h

@@ -1,10 +1,11 @@
 #pragma once
 
+#include <sqlite3.h>  //  sqlite_int64
 #ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <tuple>  //  std::tuple
 #include <string>  //  std::string
 #include <memory>  //  std::unique_ptr
-#include <type_traits>  //  std::is_same, std::is_member_object_pointer
+#include <type_traits>  //  std::enable_if, std::is_same, std::is_member_object_pointer, std::is_signed
 #include <utility>  //  std::move
 #endif
 
@@ -165,22 +166,40 @@ namespace sqlite_orm {
             field_type_t,
             filter_tuple_sequence_t<Elements, mpl::disjunction_fn<is_column, is_hidden_column>::template fn>>;
 
+        // [Deprecation notice] For arithmetic types other than 64-bit signed integer, AUTOINCREMENT is deprecated on PRIMARY KEY columns and will be removed in v1.11
+        template<class F, class SFINAE = void>
+        struct check_pkcol {
+            [[deprecated(
+                R"(Use a 64-bit signed integer for AUTOINCREMENT on an INTEGER PRIMARY KEY as an alias for the "rowid" key)")]] static constexpr void
+            validate_column_primary_key_with_autoincrement() {}
+        };
+
+        // For 64-bit signed integer type: valid
+        template<class F>
+        struct check_pkcol<F,
+                           std::enable_if_t<sizeof(F) == sizeof(sqlite_int64) &&
+                                            std::is_signed<F>::value == std::is_signed<sqlite_int64>::value>> {
+            static constexpr void validate_column_primary_key_with_autoincrement() {}
+        };
+
+        // For non-integer types: static_assert failure
+        template<class F>
+        struct check_pkcol<F, std::enable_if_t<!std::is_base_of<integer_printer, type_printer<F>>::value>> {
+            static constexpr void validate_column_primary_key_with_autoincrement() {
+                static_assert(
+                    polyfill::always_false_v<F>,
+                    R"(AUTOINCREMENT is only allowed on an INTEGER PRIMARY KEY as an alias for the "rowid" key)");
+            }
+        };
+
         template<class G, class... Op>
         constexpr void validate_column_definition() {
             using constraints_type = std::tuple<Op...>;
 
             static_assert(polyfill::conjunction_v<is_column_constraint<Op>...>, "Incorrect column constraints");
 
-            if constexpr (tuple_has<constraints_type, is_primary_key>::value) {
-                using field_type = member_field_type_t<G>;
-                using is_pkcol_correct = mpl::invoke_t<
-                    mpl::disjunction<mpl::always<std::is_base_of<integer_printer, type_printer<field_type>>>,
-                                     mpl::not_<check_if_has_template<primary_key_with_autoincrement>>>,
-                    constraints_type>;
-
-                static_assert(
-                    is_pkcol_correct::value,
-                    R"(AUTOINCREMENT is only allowed on an INTEGER PRIMARY KEY as an alias for the "rowid" key)");
+            if constexpr (tuple_has_template<constraints_type, primary_key_with_autoincrement>::value) {
+                check_pkcol<member_field_type_t<G>>::validate_column_primary_key_with_autoincrement();
             }
         }
 

examples/chrono_binding.cpp

@@ -138,7 +138,7 @@ using std::cout;
 using std::endl;
 
 struct Person {
-    int id;
+    int64 id;
     std::string name;
     std::chrono::sys_days birthdate;
 };

examples/common_table_expressions.cpp

@@ -526,7 +526,7 @@ void depth_or_breadth_first() {
 
 void select_from_subselect() {
     struct Employee {
-        int m_empno;
+        int64 m_empno;
         std::string m_ename;
         double m_salary;
         std::optional<double> m_commission;

examples/except_intersection.cpp

@@ -9,12 +9,12 @@ using std::cout;
 using std::endl;
 
 struct DeptMaster {
-    int deptId = 0;
+    sqlite_orm::int64 deptId = 0;
     std::string deptName;
 };
 
 struct EmpMaster {
-    int empId = 0;
+    sqlite_orm::int64 empId = 0;
     std::string firstName;
     std::string lastName;
     long salary;

examples/select.cpp

@@ -127,13 +127,13 @@ void all_employees() {
 
 void all_artists() {
     struct Artist {
-        int id;
+        int64 id;
         std::string name;
     };
 
     struct Album {
-        int id;
-        int artist_id;
+        int64 id;
+        int64 artist_id;
     };
 
     auto storage = make_storage("",
@@ -165,13 +165,13 @@ void all_artists() {
 
 void named_adhoc_structs() {
     struct Artist {
-        int id;
+        int64 id;
         std::string name;
     };
 
     struct Album {
-        int id;
-        int artist_id;
+        int64 id;
+        int64 artist_id;
         std::string name;
     };
 

examples/self_join.cpp

@@ -15,7 +15,7 @@ using std::cout;
 using std::endl;
 
 struct Employee {
-    int employeeId;
+    sqlite_orm::int64 employeeId;
     std::string lastName;
     std::string firstName;
     std::string title;

examples/unique.cpp

@@ -9,7 +9,7 @@ using std::cout;
 using std::endl;
 
 struct Entry {
-    int id;
+    sqlite_orm::int64 id;
     std::string uniqueColumn;
     std::unique_ptr<std::string> nullableColumn;
 };

include/sqlite_orm/sqlite_orm.h

@@ -8917,11 +8917,12 @@ SQLITE_ORM_EXPORT namespace sqlite_orm {
 
 // #include "schema/column.h"
 
+#include <sqlite3.h>  //  sqlite_int64
 #ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <tuple>  //  std::tuple
 #include <string>  //  std::string
 #include <memory>  //  std::unique_ptr
-#include <type_traits>  //  std::is_same, std::is_member_object_pointer
+#include <type_traits>  //  std::enable_if, std::is_same, std::is_member_object_pointer, std::is_signed
 #include <utility>  //  std::move
 #endif
 
@@ -9129,22 +9130,40 @@ namespace sqlite_orm {
             field_type_t,
             filter_tuple_sequence_t<Elements, mpl::disjunction_fn<is_column, is_hidden_column>::template fn>>;
 
+        // [Deprecation notice] For arithmetic types other than 64-bit signed integer, AUTOINCREMENT is deprecated on PRIMARY KEY columns and will be removed in v1.11
+        template<class F, class SFINAE = void>
+        struct check_pkcol {
+            [[deprecated(
+                R"(Use a 64-bit signed integer for AUTOINCREMENT on an INTEGER PRIMARY KEY as an alias for the "rowid" key)")]] static constexpr void
+            validate_column_primary_key_with_autoincrement() {}
+        };
+
+        // For 64-bit signed integer type: valid
+        template<class F>
+        struct check_pkcol<F,
+                           std::enable_if_t<sizeof(F) == sizeof(sqlite_int64) &&
+                                            std::is_signed<F>::value == std::is_signed<sqlite_int64>::value>> {
+            static constexpr void validate_column_primary_key_with_autoincrement() {}
+        };
+
+        // For non-integer types: static_assert failure
+        template<class F>
+        struct check_pkcol<F, std::enable_if_t<!std::is_base_of<integer_printer, type_printer<F>>::value>> {
+            static constexpr void validate_column_primary_key_with_autoincrement() {
+                static_assert(
+                    polyfill::always_false_v<F>,
+                    R"(AUTOINCREMENT is only allowed on an INTEGER PRIMARY KEY as an alias for the "rowid" key)");
+            }
+        };
+
         template<class G, class... Op>
         constexpr void validate_column_definition() {
             using constraints_type = std::tuple<Op...>;
 
             static_assert(polyfill::conjunction_v<is_column_constraint<Op>...>, "Incorrect column constraints");
 
-            if constexpr (tuple_has<constraints_type, is_primary_key>::value) {
-                using field_type = member_field_type_t<G>;
-                using is_pkcol_correct = mpl::invoke_t<
-                    mpl::disjunction<mpl::always<std::is_base_of<integer_printer, type_printer<field_type>>>,
-                                     mpl::not_<check_if_has_template<primary_key_with_autoincrement>>>,
-                    constraints_type>;
-
-                static_assert(
-                    is_pkcol_correct::value,
-                    R"(AUTOINCREMENT is only allowed on an INTEGER PRIMARY KEY as an alias for the "rowid" key)");
+            if constexpr (tuple_has_template<constraints_type, primary_key_with_autoincrement>::value) {
+                check_pkcol<member_field_type_t<G>>::validate_column_primary_key_with_autoincrement();
             }
         }
 

tests/constraints/foreign_key.cpp

@@ -133,7 +133,7 @@ TEST_CASE("Foreign key 2") {
 
 TEST_CASE("Foreign key with inheritance") {
     struct Person {
-        int id;
+        int64 id;
         std::string name;
         int age;
     };
@@ -157,9 +157,9 @@ TEST_CASE("Foreign key with inheritance") {
 
     // Define Classroom class referencing Teacher and Student
     struct Classroom {
-        int id;
-        int teacher_id;  // Foreign key referencing Teacher
-        int student_id;  // Foreign key referencing Student
+        int64 id;
+        int64 teacher_id;  // Foreign key referencing Teacher
+        int64 student_id;  // Foreign key referencing Student
         std::string room_name;
     };
 

tests/operators/between.cpp

@@ -5,7 +5,7 @@ using namespace sqlite_orm;
 
 TEST_CASE("Between") {
     struct Object {
-        int id = 0;
+        int64 id = 0;
     };
 
     auto storage =