Merge branch 'dev' into claude

Author: trueqbit

dev/constraints.h

@@ -496,18 +496,56 @@ namespace sqlite_orm::internal {
     template<class T>
     struct is_generated_always : polyfill::bool_constant<is_generated_always_v<T>> {};
 
-    /**
-     *  PRIMARY KEY INSERTABLE traits.
+    // Custom type:
+    // It is the programmer's responsibility to ensure data integrity in the value range of the custom type
+    // and in purview of SQLite using a 64-bit signed integer.
+    template<class F, class SFINAE = void>
+    inline constexpr bool is_rowid_alias_capable_v = std::is_base_of<integer_printer, type_printer<F>>::value;
+
+    // For 64-bit signed integer type: capable
+    template<class F>
+    inline constexpr bool
+        is_rowid_alias_capable_v<F,
+                                 std::enable_if_t<std::is_integral<F>::value &&
+                                                  (sizeof(F) == sizeof(sqlite_int64) &&
+                                                   std::is_signed<F>::value == std::is_signed<sqlite_int64>::value)>> =
+            true;
+
+    // Design decision for integral types other than 64-bit signed integer:
+    // It is the programmer's responsibility to ensure data integrity in the value range of the integral type
+    // and in purview of SQLite using a 64-bit signed integer.
+    template<class F>
+    inline constexpr bool
+        is_rowid_alias_capable_v<F,
+                                 std::enable_if_t<std::is_integral<F>::value &&
+                                                  (sizeof(F) != sizeof(sqlite_int64) ||
+                                                   std::is_signed<F>::value != std::is_signed<sqlite_int64>::value)>> =
+            true;
+
+    // For non-integer types: unsuitable
+    template<class F>
+    inline constexpr bool
+        is_rowid_alias_capable_v<F, std::enable_if_t<!std::is_base_of<integer_printer, type_printer<F>>::value>> =
+            false;
+
+    /** 
+     *  COLUMN PRIMARY KEY INSERTABLE traits.
+     *  
+     *  A column primary key is considered implicitly insertable if:
+     *  - it is an INTEGER PRIMARY KEY (and thus an alias for the "rowid" key),
+     *  - or has a default value.
+     *  
+     *  In terms of C++ types, this means that the field type must be capable of representing a 64-bit signed integer,
+     *  or the column is declared with a DEFAULT constraint.
+     *  
+     *  Implementation note: using a struct template in favor of a template alias so that the stack leading to a deprecation message is shorter.
      */
     template<typename Column>
-    struct is_primary_key_insertable
-        : polyfill::disjunction<mpl::invoke_t<mpl::disjunction<check_if_has_template<primary_key_with_autoincrement>,
-                                                               check_if_has_template<default_t>>,
-                                              constraints_type_t<Column>>,
-                                std::is_base_of<integer_printer, type_printer<field_type_t<Column>>>> {
-
-        static_assert(tuple_has<constraints_type_t<Column>, is_primary_key>::value, "an unexpected type was passed");
-    };
+    struct is_pkcol_implicitly_insertable
+        : mpl::invoke_t<
+              mpl::disjunction<mpl::always<polyfill::bool_constant<is_rowid_alias_capable_v<field_type_t<Column>>>>,
+                               check_if_has_template<default_t>>,
+              constraints_type_t<Column>> {};
 
     template<class T>
     using is_column_constraint = mpl::invoke_t<mpl::disjunction<check_if<std::is_base_of, primary_key_t<>>,
@@ -586,7 +624,7 @@ SQLITE_ORM_EXPORT namespace sqlite_orm {
         return {{}};
     }
 
-#if SQLITE_VERSION_NUMBER >= 3009000
+#if SQLITE_VERSION_NUMBER >= 3009000 || defined(SQLITE_ORM_ENABLE_FTS5)
     /**
      *  UNINDEXED column constraint builder function. Used in FTS virtual tables.
      *  

dev/core_functions.h

@@ -2155,6 +2155,7 @@ SQLITE_ORM_EXPORT namespace sqlite_orm {
         }
     }
 
+#if SQLITE_VERSION_NUMBER >= 3009000 || defined(SQLITE_ORM_ENABLE_FTS5)
     struct fts5;
 
     /** 
@@ -2219,4 +2220,5 @@ SQLITE_ORM_EXPORT namespace sqlite_orm {
         return {std::move(x), std::move(y), std::move(z)};
     }
 #endif
+#endif
 }

dev/cte_column_names_collector.h

@@ -157,8 +157,9 @@ namespace sqlite_orm::internal {
     };
 
     template<typename Ctx, typename E, typename ExplicitColRefs, satisfies_is_specialization_of<E, select_t> = true>
-    std::vector<std::string>
-    collect_cte_column_names(const E& sel, const ExplicitColRefs& explicitColRefs, const Ctx& context) {
+    std::vector<std::string> collect_cte_column_names(const E& sel,
+                                                      [[maybe_unused]] const ExplicitColRefs& explicitColRefs,
+                                                      const Ctx& context) {
         // 1. determine column names from subselect
         std::vector<std::string> columnNames = get_cte_column_names(sel.col, context);
 

dev/schema/column.h

@@ -1,18 +1,19 @@
 #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
 
 #include "../functional/cxx_type_traits_polyfill.h"
 #include "../tuple_helper/tuple_traits.h"
 #include "../tuple_helper/tuple_filter.h"
-#include "../type_traits.h"
 #include "../member_traits/member_traits.h"
+#include "../type_traits.h"
 #include "../type_is_nullable.h"
 #include "../constraints.h"
 
@@ -74,13 +75,21 @@ namespace sqlite_orm::internal {
         constraints_type constraints;
 
         /**
-         *  Checks whether contraints contain specified type.
+         *  Checks whether constraints contain specified type.
          */
         template<template<class...> class Trait>
         constexpr static bool is() {
             return tuple_has<constraints_type, Trait>::value;
         }
 
+        /**
+         *  Checks whether constraints contain specified class template.
+         */
+        template<template<class...> class Primary>
+        constexpr static bool is_template() {
+            return tuple_has_template<constraints_type, Primary>::value;
+        }
+
         /**
          *  Simplified interface for `DEFAULT` constraint
          *  @return string representation of default value if it exists otherwise nullptr
@@ -161,19 +170,65 @@ namespace sqlite_orm::internal {
         field_type_t,
         filter_tuple_sequence_t<Elements, mpl::disjunction_fn<is_column, is_hidden_column>::template fn>>;
 
-#if SQLITE_VERSION_NUMBER >= 3031000
+    // Custom type:
+    // It is the programmer's responsibility to ensure data integrity in the value range of the custom type
+    // and in purview of SQLite using a 64-bit signed integer.
+    template<class F, class SFINAE = void>
+    struct check_pkcol {
+        static constexpr void validate_column_primary_key_with_autoincrement() {}
+    };
+
+    // For integer types: further checks
+    template<class F>
+    struct check_pkcol<F, std::enable_if_t<std::is_integral<F>::value>> {
+        // For 64-bit signed integer type: valid
+        template<class X = F,
+                 std::enable_if_t<sizeof(X) == sizeof(sqlite_int64) &&
+                                      std::is_signed<X>::value == std::is_signed<sqlite_int64>::value,
+                                  bool> = true>
+        static constexpr void validate_column_primary_key_with_autoincrement() {}
+
+        // Design decision for integral types other than 64-bit signed integer:
+        // It is the programmer's responsibility to ensure data integrity in the value range of the integral type
+        // and in purview of SQLite using a 64-bit signed integer.
+        template<class X = F,
+                 std::enable_if_t<sizeof(X) != sizeof(sqlite_int64) ||
+                                      std::is_signed<X>::value != std::is_signed<sqlite_int64>::value,
+                                  bool> = true>
+        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_template<constraints_type, primary_key_with_autoincrement>::value) {
+            check_pkcol<member_field_type_t<G>>::validate_column_primary_key_with_autoincrement();
+        }
+    }
+
     /**
      *  Factory function for a column definition from a member object pointer for hidden virtual table columns.
      */
     template<class M, class... Op, satisfies<std::is_member_object_pointer, M> = true>
     hidden_column<M, empty_setter, Op...> make_hidden_column(std::string name, M memberPointer, Op... constraints) {
-        static_assert(polyfill::conjunction_v<is_column_constraint<Op>...>, "Incorrect constraints pack");
+        static_assert(polyfill::conjunction_v<is_column_constraint<Op>...>, "Incorrect column constraints");
 
         // attention: do not use `std::make_tuple()` for constructing the tuple member `[[no_unique_address]] column_constraints::constraints`,
         // as this will lead to UB with Clang on MinGW!
         return {std::move(name), memberPointer, {}, std::tuple<Op...>{std::move(constraints)...}};
     }
-#endif
 }
 
 SQLITE_ORM_EXPORT namespace sqlite_orm {
@@ -183,7 +238,7 @@ SQLITE_ORM_EXPORT namespace sqlite_orm {
     template<class M, class... Op, internal::satisfies<std::is_member_object_pointer, M> = true>
     internal::column_t<M, internal::empty_setter, Op...>
     make_column(std::string name, M memberPointer, Op... constraints) {
-        static_assert(polyfill::conjunction_v<internal::is_column_constraint<Op>...>, "Incorrect constraints pack");
+        internal::validate_column_definition<M, Op...>();
 
         // attention: do not use `std::make_tuple()` for constructing the tuple member `[[no_unique_address]] column_constraints::constraints`,
         // as this will lead to UB with Clang on MinGW!
@@ -201,7 +256,7 @@ SQLITE_ORM_EXPORT namespace sqlite_orm {
     internal::column_t<G, S, Op...> make_column(std::string name, S setter, G getter, Op... constraints) {
         static_assert(std::is_same<internal::setter_field_type_t<S>, internal::getter_field_type_t<G>>::value,
                       "Getter and setter must get and set same data type");
-        static_assert(polyfill::conjunction_v<internal::is_column_constraint<Op>...>, "Incorrect constraints pack");
+        internal::validate_column_definition<G, Op...>();
 
         // attention: do not use `std::make_tuple()` for constructing the tuple member `[[no_unique_address]] column_constraints::constraints`,
         // as this will lead to UB with Clang on MinGW!
@@ -219,7 +274,7 @@ SQLITE_ORM_EXPORT namespace sqlite_orm {
     internal::column_t<G, S, Op...> make_column(std::string name, G getter, S setter, Op... constraints) {
         static_assert(std::is_same<internal::setter_field_type_t<S>, internal::getter_field_type_t<G>>::value,
                       "Getter and setter must get and set same data type");
-        static_assert(polyfill::conjunction_v<internal::is_column_constraint<Op>...>, "Incorrect constraints pack");
+        internal::validate_column_definition<G, Op...>();
 
         // attention: do not use `std::make_tuple()` for constructing the tuple member `[[no_unique_address]] column_constraints::constraints`,
         // as this will lead to UB with Clang on MinGW!

dev/schema/table.h

@@ -128,7 +128,7 @@ namespace sqlite_orm::internal {
             constexpr size_t nTablePrimaryKeyColumns =
                 nested_tuple_size_for_t<columns_tuple_t, elements_type, pk_index_sequence>::value;
 
-            static_assert(nTablePrimaryKeyColumns > 0, "Tabel primary key definition must contain one column");
+            static_assert(nTablePrimaryKeyColumns > 0, "Table primary key definition must contain one column");
         }
     }
 }

dev/schema/table_base.h

@@ -55,7 +55,7 @@ namespace sqlite_orm::internal {
         }
 
         /*
-         *  Returns the number of columns having the specified constraint trait.
+         *  Returns the number of columns not having the specified constraint trait.
          */
         template<template<class...> class Trait>
         static constexpr int count_of_columns_excluding() {
@@ -179,42 +179,48 @@ namespace sqlite_orm::internal {
     };
 
     template<class... Cs, class G, class S>
-    bool table_primary_key_contains(const insertable_table_definition<Cs...>& definition,
-                                    const column_field<G, S>& column) {
+    bool table_primary_key_contains([[maybe_unused]] const insertable_table_definition<Cs...>& definition,
+                                    [[maybe_unused]] const column_field<G, S>& column) {
         bool res = false;
-        definition.visit_table_primary_key([&column, &res](auto& primaryKey) {
-            using colrefs_tuple = decltype(primaryKey.columns);
-            using same_type_index_sequence =
-                filter_tuple_sequence_t<colrefs_tuple,
-                                        check_if_is_type<member_field_type_t<G>>::template fn,
-                                        member_field_type_t>;
-            iterate_tuple(primaryKey.columns, same_type_index_sequence{}, [&res, &column](auto& memberPointer) {
-                if (compare_fields(memberPointer, column.member_pointer) ||
-                    compare_fields(memberPointer, column.setter)) {
-                    res = true;
-                }
+        // note: though `visit_table_primary_key()` does no work if a column primary key exists, we try to save the compiler some work with this check up front
+        if constexpr (/*bool hasNoColumnPK =*/!insertable_table_definition<Cs...>::template count_of_columns_with<
+                      is_primary_key>()) {
+            definition.visit_table_primary_key([&column, &res](auto& primaryKey) {
+                using colrefs_tuple = decltype(primaryKey.columns);
+                using same_type_index_sequence =
+                    filter_tuple_sequence_t<colrefs_tuple,
+                                            check_if_is_type<member_field_type_t<G>>::template fn,
+                                            member_field_type_t>;
+                iterate_tuple(primaryKey.columns, same_type_index_sequence{}, [&res, &column](auto& memberPointer) {
+                    if (compare_fields(memberPointer, column.member_pointer) ||
+                        compare_fields(memberPointer, column.setter)) {
+                        res = true;
+                    }
+                });
             });
-        });
+        }
         return res;
     }
 
     template<class... Cs, class G, class S>
-    bool is_single_table_primary_key(const insertable_table_definition<Cs...>& definition,
-                                     const column_field<G, S>& column) {
+    bool is_single_table_primary_key([[maybe_unused]] const insertable_table_definition<Cs...>& definition,
+                                     [[maybe_unused]] const column_field<G, S>& column) {
         bool res = false;
-        definition.visit_table_primary_key([&column, &res](auto& primaryKey) {
-            // note: use `decltype(primaryKey)` instead of `decltype(primaryKey.columns)` otherwise msvc 141 chokes on the `if constexpr` below
-            using colrefs_tuple = columns_tuple_t<polyfill::remove_cvref_t<decltype(primaryKey)>>;
-            if constexpr (std::tuple_size<colrefs_tuple>::value != 1) {
-                return;
-            } else {
-                auto& memberPointer = std::get<0>(primaryKey.columns);
-                if (compare_fields(memberPointer, column.member_pointer) ||
-                    compare_fields(memberPointer, column.setter)) {
-                    res = true;
+        // note: though `visit_table_primary_key()` does no work if a column primary key exists, we try to save the compiler some work with this check up front
+        if constexpr (/*bool hasNoColumnPK =*/!insertable_table_definition<Cs...>::template count_of_columns_with<
+                      is_primary_key>()) {
+            definition.visit_table_primary_key([&column, &res](auto& primaryKey) {
+                // note: use `decltype(primaryKey)` instead of `decltype(primaryKey.columns)` otherwise msvc 141 chokes on the `if constexpr` below
+                using colrefs_tuple = columns_tuple_t<polyfill::remove_cvref_t<decltype(primaryKey)>>;
+                if constexpr (std::tuple_size<colrefs_tuple>::value == 1) {
+                    auto& memberPointer = std::get<0>(primaryKey.columns);
+                    if (compare_fields(memberPointer, column.member_pointer) ||
+                        compare_fields(memberPointer, column.setter)) {
+                        res = true;
+                    }
                 }
-            }
-        });
+            });
+        }
         return res;
     }