fnc12 · trueqbit · Oct 2, 2025 · Sep 26, 2025 · Sep 26, 2025 · Sep 26, 2025
diff --git a/dev/alias.h b/dev/alias.h
@@ -58,7 +58,7 @@ namespace sqlite_orm {
             is_operator_argument_v<T, std::enable_if_t<polyfill::is_specialization_of<T, alias_column_t>::value>> =
                 true;
 
-        struct basic_table;
+        struct table_identifier;
 
         /*
          * Encapsulates extracting the alias identifier of a non-alias.
@@ -77,7 +77,7 @@ namespace sqlite_orm {
                 return {};
             }
 
-            template<class X = basic_table>
+            template<class X = table_identifier>
             static const std::string& as_qualifier(const X& table) {
                 return table.name;
             }
@@ -114,7 +114,7 @@ namespace sqlite_orm {
 
             // for regular table aliases -> alias identifier
             template<class T = A, satisfies<is_table_alias, T> = true>
-            static std::string as_qualifier(const basic_table&) {
+            static std::string as_qualifier(const table_identifier&) {
                 return alias_extractor::extract();
             }
         };

diff --git a/dev/ast_iterator.h b/dev/ast_iterator.h
@@ -72,8 +72,8 @@ namespace sqlite_orm {
             ast_iterator<T> iterator;
 
             // possibly invoke lambda with node itself
-            if constexpr (polyfill::is_invocable<L, polyfill::bool_constant<true>, const T&>::value) {
-                lambda(polyfill::bool_constant<true>{}, t);
+            if constexpr (polyfill::is_invocable<L, std::true_type, const T&>::value) {
+                lambda(std::true_type{}, t);
             }
 
             iterator(t, lambda);

diff --git a/dev/column_names_getter.h b/dev/column_names_getter.h
@@ -51,7 +51,7 @@ namespace sqlite_orm {
                 if constexpr (is_alias<T>::value) {
                     collectedExpressions.push_back(quote_identifier(alias_extractor<T>::extract()) + ".*");
                 } else if (!context.omit_table_name) {
-                    const basic_table& table = pick_table<mapped_type_proxy_t<T>>(context.db_objects);
+                    const table_identifier& table = pick_table<mapped_type_proxy_t<T>>(context.db_objects);
                     collectedExpressions.push_back(quote_identifier(table.name) + ".*");
                 } else {
                     collectedExpressions.emplace_back("*");

diff --git a/dev/constraints.h b/dev/constraints.h
@@ -631,6 +631,18 @@ SQLITE_ORM_EXPORT namespace sqlite_orm {
     internal::table_content_t<T> content() {
         return {};
     }
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  content='table' table constraint builder function. Used in FTS virtual tables.
+     * 
+     *  https://www.sqlite.org/fts5.html#external_content_tables
+     */
+    template<orm_table_reference auto table>
+    auto content() {
+        return content<internal::auto_decay_table_ref_t<table>>();
+    }
+#endif
 #endif
 
     /**

diff --git a/dev/cte_storage.h b/dev/cte_storage.h
@@ -13,7 +13,7 @@
 #include "table_type_of.h"
 #include "column_result.h"
 #include "select_constraints.h"
-#include "schema/table.h"
+#include "schema/table_base.h"
 #include "alias.h"
 #include "cte_types.h"
 #include "cte_column_names_collector.h"
@@ -64,6 +64,21 @@ namespace sqlite_orm {
                                                                FinalColRefs,
                                                                Result>::type;
 
+        template<class Mapper, class... Cs>
+        struct cte_table : table_identifier, table_definition<Cs...> {
+            using definition_type = table_definition<Cs...>;
+            using cte_mapper_type = Mapper;
+            using cte_moniker_type = typename cte_mapper_type::cte_moniker_type;
+            using object_type = cte_moniker_type;
+            using elements_type = typename definition_type::elements_type;
+        };
+
+        template<class Mapper, class... Cs>
+        cte_table<Mapper, Cs...> make_cte_table(std::string name, Cs... args) {
+            SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(
+                return {std::move(name), std::make_tuple<Cs...>(std::forward<Cs>(args)...)});
+        }
+
         // aliased column expressions, explicit or implicitly numbered
         template<typename F, typename ColRef, satisfies_is_specialization_of<ColRef, alias_holder> = true>
         auto make_cte_column(std::string name, const ColRef& /*finalColRef*/) {
@@ -270,14 +285,14 @@ namespace sqlite_orm {
                                                  std::vector<std::string> columnNames,
                                                  const ColRefs& finalColRefs,
                                                  std::index_sequence<CIs...>) {
-            return make_table<Mapper>(
+            return make_cte_table<Mapper>(
                 std::move(tableName),
                 make_cte_column<std::tuple_element_t<CIs, typename Mapper::fields_type>>(std::move(columnNames.at(CIs)),
                                                                                          get<CIs>(finalColRefs))...);
         }
 
         template<typename DBOs, typename CTE>
-        auto make_cte_table(const DBOs& dbObjects, const CTE& cte) {
+        auto make_cte_db_object(const DBOs& dbObjects, const CTE& cte) {
             using cte_type = CTE;
 
             auto subSelect = get_cte_driving_subselect(cte.subselect);
@@ -315,7 +330,7 @@ namespace sqlite_orm {
         decltype(auto) make_recursive_cte_db_objects(const DBOs& dbObjects,
                                                      const common_table_expressions<CTEs...>& cte,
                                                      std::index_sequence<Ii, In...>) {
-            auto tbl = make_cte_table(dbObjects, get<Ii>(cte));
+            auto tbl = make_cte_db_object(dbObjects, get<Ii>(cte));
 
             if constexpr (sizeof...(In) > 0) {
                 return make_recursive_cte_db_objects(

diff --git a/dev/cte_types.h b/dev/cte_types.h
@@ -27,7 +27,7 @@ namespace sqlite_orm {
 
         /**
          *  This class captures various properties and aspects of a subselect's column expression,
-         *  and is used as a proxy in table_t<>.
+         *  and is used as a proxy in base_table<>.
          */
         template<typename Moniker,
                  typename ExplicitColRefs,

diff --git a/dev/functional/cxx_core_features.h b/dev/functional/cxx_core_features.h
@@ -57,6 +57,10 @@
 #define SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
 #endif
 
+#if __cpp_explicit_this_parameter >= 202110L
+#define SQLITE_ORM_DEDUCING_THIS_SUPPORTED
+#endif
+
 #if __cpp_static_call_operator >= 202207L
 #define SQLITE_ORM_STATIC_CALL_OPERATOR_SUPPORTED
 #endif

diff --git a/dev/implementations/column_definitions.h b/dev/implementations/column_definitions.h
@@ -1,5 +1,5 @@
 /** @file Mainly existing to disentangle implementation details from circular and cross dependencies
- *  (e.g. column_t -> default_value_extractor -> serializer_context -> db_objects_tuple -> table_t -> column_t)
+ *  (e.g. column_t -> default_value_extractor -> serializer_context -> db_objects_tuple -> base_table -> column_t)
  *  this file is also used to provide definitions of interface methods 'hitting the database'.
  */
 #pragma once

diff --git a/dev/implementations/storage_definitions.h b/dev/implementations/storage_definitions.h
@@ -23,7 +23,7 @@
 namespace sqlite_orm {
     namespace internal {
         template<class... DBO>
-        template<class Table, satisfies<is_table, Table>>
+        template<class Table, satisfies<is_base_table, Table>>
         sync_schema_result storage_t<DBO...>::sync_dbo([[maybe_unused]] const Table& table,
                                                        [[maybe_unused]] sqlite3* db,
                                                        [[maybe_unused]] bool preserve) {
@@ -34,13 +34,13 @@ namespace sqlite_orm {
                 std::is_same<object_type_t<Table>, sqlite_master>::value) {
                 return sync_schema_result::already_in_sync;
             } else {
-                return this->sync_regular_table(table, db, preserve);
+                return this->sync_regular_base_table(table, db, preserve);
             }
         }
 
         template<class... DBO>
-        template<class Table, satisfies<is_table, Table>>
-        sync_schema_result storage_t<DBO...>::sync_regular_table(const Table& table, sqlite3* db, bool preserve) {
+        template<class Table, satisfies<is_base_table, Table>>
+        sync_schema_result storage_t<DBO...>::sync_regular_base_table(const Table& table, sqlite3* db, bool preserve) {
             auto res = sync_schema_result::already_in_sync;
             bool attempt_to_preserve = true;
 

diff --git a/dev/implementations/table_definitions.h b/dev/implementations/table_definitions.h
@@ -1,5 +1,5 @@
 /** @file Mainly existing to disentangle implementation details from circular and cross dependencies
- *  (e.g. column_t -> default_value_extractor -> serializer_context -> db_objects_tuple -> table_t -> column_t)
+ *  (e.g. column_t -> default_value_extractor -> serializer_context -> db_objects_tuple -> base_table -> column_t)
  *  this file is also used to provide definitions of interface methods 'hitting the database'.
  */
 #pragma once
@@ -19,10 +19,10 @@
 namespace sqlite_orm {
     namespace internal {
 
-        template<class T, bool WithoutRowId, class... Cs>
-        std::vector<table_xinfo> table_t<T, WithoutRowId, Cs...>::get_table_info() const {
+        template<class T, class WithoutRowId, class... Cs>
+        std::vector<table_xinfo> base_table<T, WithoutRowId, Cs...>::get_table_info() const {
             std::vector<table_xinfo> res;
-            res.reserve(filter_tuple_sequence_t<elements_type, is_column>::size());
+            res.reserve(col_index_sequence_of<elements_type>::size());
             this->for_each_column([&res](auto& column) {
                 using field_type = field_type_t<std::remove_reference_t<decltype(column)>>;
                 std::string dft;

diff --git a/dev/interface_definitions.h b/dev/interface_definitions.h
@@ -1,5 +1,5 @@
 /** @file Mainly existing to disentangle implementation details from circular and cross dependencies
- *  (e.g. column_t -> default_value_extractor -> serializer_context -> db_objects_tuple -> table_t -> column_t)
+ *  (e.g. column_t -> default_value_extractor -> serializer_context -> db_objects_tuple -> base_table -> column_t)
  *  this file is also used to provide definitions of interface methods 'hitting the database'.
  */
 #pragma once