From dde241ee46319535117ebe4daf81395616f7b6d3 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 7 Jan 2022 23:16:54 +0200
Subject: [PATCH 001/161] A first implementation of common table expressions

---
 dev/alias.h                                   |   9 +-
 dev/ast_iterator.h                            |  22 ++
 dev/column_names_getter.h                     |   6 +-
 dev/connection_holder.h                       |   3 +
 dev/cte.h                                     | 256 ++++++++++++++++++
 dev/cxx_polyfill.h                            |  39 +++
 dev/is_base_of_template.h                     |   2 +-
 dev/mapped_type_proxy.h                       |   4 +-
 dev/node_tuple.h                              |  10 +
 dev/select_constraints.h                      |  56 ++++
 dev/statement_serializator.h                  |  57 +++-
 dev/storage.h                                 |  41 ++-
 dev/storage_base.h                            |  25 +-
 dev/storage_impl.h                            |  89 +++++-
 dev/storage_traits.h                          | 114 ++++----
 dev/table.h                                   |  19 +-
 dev/tuple_helper/tuple_helper.h               |   2 +-
 dev/type_traits.h                             |  10 +
 .../sqlite_orm/sqlite_orm.h                   |   1 +
 19 files changed, 666 insertions(+), 99 deletions(-)
 create mode 100644 dev/cte.h
 create mode 100644 dev/type_traits.h

diff --git a/dev/alias.h b/dev/alias.h
index b2073dbab..b0af158f6 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -22,7 +22,7 @@ namespace sqlite_orm {
         struct table_alias : alias_tag {
             using type = T;
 
-            static char get() {
+            constexpr static char get() {
                 return A;
             }
         };
@@ -70,6 +70,8 @@ namespace sqlite_orm {
             using expression_type = E;
 
             expression_type expression;
+            // whether to only serialize the alias
+            bool serializeAlias = false;
         };
 
         template<class T>
@@ -94,6 +96,11 @@ namespace sqlite_orm {
         return {std::move(expression)};
     }
 
+    template<class T, class E>
+    internal::as_t<T, E> refed_as(E expression) {
+        return {std::move(expression), true};
+    }
+
     template<class T>
     internal::alias_holder<T> get() {
         return {};
diff --git a/dev/ast_iterator.h b/dev/ast_iterator.h
index ea2571fa8..da5ee67ef 100644
--- a/dev/ast_iterator.h
+++ b/dev/ast_iterator.h
@@ -190,6 +190,28 @@ namespace sqlite_orm {
             }
         };
 
+        template<class CTE>
+        struct ast_iterator<CTE,
+                            polyfill::enable_if_t<polyfill::is_specialization_of_v<CTE, common_table_expression>>> {
+            using node_type = CTE;
+
+            template<class L>
+            void operator()(const node_type& c, const L& l) const {
+                iterate_ast(c.expression, l);
+            }
+        };
+
+        template<class With>
+        struct ast_iterator<With, polyfill::enable_if_t<polyfill::is_specialization_of_v<With, with_t>>> {
+            using node_type = With;
+
+            template<class L>
+            void operator()(const node_type& c, const L& l) const {
+                iterate_ast(c.cte, l);
+                iterate_ast(c.expression, l);
+            }
+        };
+
         template<class T>
         struct ast_iterator<T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
             using node_type = T;
diff --git a/dev/column_names_getter.h b/dev/column_names_getter.h
index c516d70a9..bcc3853ab 100644
--- a/dev/column_names_getter.h
+++ b/dev/column_names_getter.h
@@ -54,7 +54,7 @@ namespace sqlite_orm {
             template<class C>
             std::vector<std::string> operator()(const expression_type&, const C&) {
                 std::vector<std::string> res;
-                res.push_back("*");
+                res.emplace_back("*");
                 return res;
             }
         };
@@ -66,7 +66,7 @@ namespace sqlite_orm {
             template<class C>
             std::vector<std::string> operator()(const expression_type&, const C&) {
                 std::vector<std::string> res;
-                res.push_back("*");
+                res.emplace_back("*");
                 return res;
             }
         };
@@ -84,7 +84,7 @@ namespace sqlite_orm {
                 iterate_tuple(cols.columns, [&columnNames, &newContext](auto& m) {
                     auto columnName = serialize(m, newContext);
                     if(columnName.length()) {
-                        columnNames.push_back(columnName);
+                        columnNames.push_back(std::move(columnName));
                     } else {
                         throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
                     }
diff --git a/dev/connection_holder.h b/dev/connection_holder.h
index e1857a759..7c49c4a16 100644
--- a/dev/connection_holder.h
+++ b/dev/connection_holder.h
@@ -14,6 +14,9 @@ namespace sqlite_orm {
 
             connection_holder(std::string filename_) : filename(move(filename_)) {}
 
+            connection_holder(connection_holder* connection) :
+                filename{connection->filename}, db{connection->db}, _retain_count{++connection->_retain_count} {}
+
             void retain() {
                 ++this->_retain_count;
                 if(1 == this->_retain_count) {
diff --git a/dev/cte.h b/dev/cte.h
new file mode 100644
index 000000000..6cf973325
--- /dev/null
+++ b/dev/cte.h
@@ -0,0 +1,256 @@
+#pragma once
+
+#include <type_traits>
+#include <tuple>
+#include <string>
+#include <vector>
+#include <system_error>
+
+#include "cxx_polyfill.h"
+#include "column_result.h"
+#include "select_constraints.h"
+#include "alias.h"
+#include "table.h"
+#include "storage.h"
+#include "statement_serializator.h"
+
+namespace sqlite_orm {
+    namespace internal {
+        namespace polyfill {
+            template<template<typename...> typename Base, typename... Fs>
+            Base<Fs...>& as_base_cast(Base<Fs...>& base) {
+                return base;
+            }
+            template<template<typename...> typename Base, typename... Fs>
+            const Base<Fs...>& as_base_cast(const Base<Fs...>& base) {
+                return base;
+            }
+            template<template<typename...> typename Base, typename... Fs>
+            Base<Fs...>&& as_base_cast(Base<Fs...>&& base) {
+                return std::move(base);
+            }
+            template<template<typename...> typename Base, typename... Fs>
+            const Base<Fs...>&& as_base_cast(const Base<Fs...>&& base) {
+                return std::move(base);
+            }
+
+            /** @short Deduce template base specialization from a derived type */
+            template<template<typename...> class Base, class Derived>
+            using as_base_cast_t = decltype(as_base_cast<Base>(std::declval<Derived>()));
+
+            template<template<typename...> class Base, class Derived, typename SFINAE = void>
+            struct is_template_base_of : std::false_type {};
+
+            template<template<typename...> class Base, class Derived>
+            struct is_template_base_of<Base, Derived, polyfill::void_t<as_base_cast_t<Base, Derived>>>
+                : std::true_type {};
+
+            template<template<typename...> class Base, class Derived>
+            using is_template_base_of_t = typename is_template_base_of<Base, Derived>::type;
+
+            template<template<typename...> class Base, class Derived>
+            SQLITE_ORM_INLINE_VAR constexpr bool is_template_base_of_v = is_template_base_of<Base, Derived>::value;
+        }
+    }
+}
+
+namespace sqlite_orm {
+    struct cte_label {
+        static std::string label() {
+            return "cte";
+        }
+    };
+
+    namespace internal {
+        /*
+         *
+         */
+        template<typename... Fs>
+        class column_results : std::tuple<Fs...> {
+          public:
+            using base = std::tuple<Fs...>;
+            using index_sequence = std::make_index_sequence<std::tuple_size<base>::value>;
+            using cte_label_type = cte_label;
+
+            template<size_t I>
+            decltype(auto) cget() const noexcept {
+                return std::get<I>(polyfill::as_base_cast<std::tuple>(*this));
+            }
+            template<size_t I>
+            void set(std::tuple_element_t<I, base> v) noexcept {
+                std::get<I>(polyfill::as_base_cast<std::tuple>(*this)) = std::move(v);
+            }
+        };
+
+        // F = field_type
+        template<typename F>
+        struct create_column_results {
+            using type = column_results<F>;
+        };
+
+        template<typename... Fs>
+        struct create_column_results<std::tuple<Fs...>> {
+            using type = column_results<Fs...>;
+        };
+
+        template<typename... Fs>
+        using create_column_results_t = typename create_column_results<Fs...>::type;
+
+        template<typename O, size_t I>
+        struct create_cte_column {
+            using object_type = O;
+            using field_type = std::tuple_element_t<I, typename O::base>;
+            using getter_type = decltype(&O::template cget<I>);
+            using setter_type = decltype(&O::template set<I>);
+
+            using type = column_t<object_type, field_type, getter_type, setter_type>;
+        };
+
+        template<typename O, size_t I>
+        using create_cte_column_t = typename create_cte_column<O, I>::type;
+
+        template<typename O, typename IdxSeq>
+        struct create_cte_table;
+
+        template<typename... Fs, size_t... Is>
+        struct create_cte_table<column_results<Fs...>, std::index_sequence<Is...>> {
+            using object_type = column_results<Fs...>;
+            using table_type = table_t<object_type, true, create_cte_column_t<object_type, Is>...>;
+
+            using type = table_type;
+        };
+
+        template<typename O, typename IdxSeq>
+        using create_cte_table_t = typename create_cte_table<O, IdxSeq>::type;
+
+        template<class T, class SFINAE = void>
+        struct cte_column_names_collector {
+            using expression_type = T;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& t, const Ctx& context) const {
+                auto newContext = context;
+                newContext.skip_table_name = true;
+                std::string columnName = serialize(t, newContext);
+                if(columnName.empty()) {
+                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                }
+                return {move(columnName)};
+            }
+        };
+
+        template<class T, class Ctx>
+        std::vector<std::string> get_cte_column_names(const T& t, const Ctx& context) {
+            cte_column_names_collector<T> serializator;
+            return serializator(t, context);
+        }
+
+        template<class T, class E>
+        struct cte_column_names_collector<as_t<T, E>, void> {
+            using expression_type = as_t<T, E>;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& /*expression*/, const Ctx& /*context*/) const {
+                return T::get();
+            }
+        };
+
+        template<class T>
+        struct cte_column_names_collector<std::reference_wrapper<T>, void> {
+            using expression_type = std::reference_wrapper<T>;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& expression, const Ctx& context) const {
+                return get_cte_column_names(expression.get(), context);
+            }
+        };
+
+        template<class T>
+        struct cte_column_names_collector<asterisk_t<T>, void> {
+            using expression_type = asterisk_t<T>;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type&, const Ctx& context) const {
+                auto& strgImpl = context.impl.get_impl<T>();
+
+                std::vector<std::string> columnNames;
+                columnNames.reserve(size_t(strgImpl.table.elements_count));
+
+                strgImpl.table.for_each_column([&columnNames](const basic_column& column) {
+                    columnNames.push_back(column.name);
+                });
+                return columnNames;
+            }
+        };
+
+        template<class T>
+        struct cte_column_names_collector<object_t<T>, void>;
+
+        template<class... Args>
+        struct cte_column_names_collector<columns_t<Args...>, void> {
+            using expression_type = columns_t<Args...>;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& cols, const Ctx& context) const {
+                std::vector<std::string> columnNames;
+                columnNames.reserve(size_t(cols.count));
+                auto newContext = context;
+                newContext.skip_table_name = true;
+                iterate_tuple(cols.columns, [&columnNames, &newContext](auto& m) {
+                    std::string columnName;
+                    if constexpr(polyfill::is_specialization_of_v<std::remove_cvref_t<decltype(m)>, as_t>) {
+                        columnName = alias_extractor<typename std::remove_cvref_t<decltype(m)>::alias_type>::get();
+                    } else {
+                        columnName = serialize(m, newContext);
+                    }
+                    if(!columnName.empty()) {
+                        columnNames.push_back(move(columnName));
+                    } else {
+                        throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                    }
+                });
+                return columnNames;
+            }
+        };
+
+        template<typename Strg, typename T, typename... Args>
+        std::vector<std::string> cte_column_names(const Strg& storage, const select_t<T, Args...>& sel) {
+            const serializator_context_builder<Strg> ctxBuilder(storage);
+            return get_cte_column_names(sel.col, ctxBuilder());
+        }
+
+        template<typename O, typename Strg, typename CTE, size_t... Is>
+        create_cte_table_t<O, typename O::index_sequence>
+        make_cte_table(const Strg& storage, std::string name, const CTE& cte, std::index_sequence<Is...>) {
+            std::vector<std::string> columnNames = cte_column_names(storage, cte);
+            assert(columnNames.size() == O::index_sequence::size());
+            // unquote
+            for(std::string& name: columnNames) {
+                if(!name.empty() && name.front() == '"' && name.back() == '"') {
+                    name.erase(name.end() - 1);
+                    name.erase(name.begin());
+                }
+            }
+
+            return create_cte_table_t<O, typename O::index_sequence>{
+                move(name),
+                std::make_tuple<>(
+                    make_column<>(columnNames.at(Is), &(O::template cget<Is>), &(O::template set<Is>))...)}
+                .without_rowid();
+        }
+
+        template<class Strg, class CTE, class E>
+        decltype(auto) make_cte_storage(const Strg& storage, const with_t<CTE, E>& e) {
+            using object_type =
+                create_column_results_t<typename column_result_t<Strg, typename CTE::expression_type>::type>;
+            using table_type = create_cte_table_t<object_type, typename object_type::index_sequence>;
+
+            return storage_cat(storage,
+                               make_cte_table<object_type>(storage,
+                                                           static_cast<std::string>(std::get<0>(e.cte)),
+                                                           std::get<0>(e.cte).expression,
+                                                           typename object_type::index_sequence{}));
+        }
+
+    }
+}
diff --git a/dev/cxx_polyfill.h b/dev/cxx_polyfill.h
index 5f3a804d7..86ab8ce31 100644
--- a/dev/cxx_polyfill.h
+++ b/dev/cxx_polyfill.h
@@ -13,8 +13,12 @@ namespace sqlite_orm {
 
             template<bool v>
             using bool_constant = std::integral_constant<bool, v>;
+
+            template<bool C, typename T>
+            using enable_if_t = typename std::enable_if<C, T>::type;
 #else
             using std::bool_constant;
+            using std::enable_if_t;
             using std::void_t;
 #endif
 
@@ -39,6 +43,41 @@ namespace sqlite_orm {
 
             template<size_t I>
             using index_constant = std::integral_constant<size_t, I>;
+
+#if 1  // library fundamentals TS v2
+            struct nonesuch {
+                ~nonesuch() = delete;
+                nonesuch(const nonesuch&) = delete;
+                void operator=(const nonesuch&) = delete;
+            };
+
+            template<class Default, class AlwaysVoid, template<class...> class Op, class... Args>
+            struct detector {
+                using value_t = std::false_type;
+                using type = Default;
+            };
+
+            template<class Default, template<class...> class Op, class... Args>
+            struct detector<Default, polyfill::void_t<Op<Args...>>, Op, Args...> {
+                using value_t = std::true_type;
+                using type = Op<Args...>;
+            };
+
+            template<template<class...> class Op, class... Args>
+            using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
+
+            template<template<class...> class Op, class... Args>
+            using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
+
+            template<class Default, template<class...> class Op, class... Args>
+            using detected_or = detector<Default, void, Op, Args...>;
+
+            template<class Default, template<class...> class Op, class... Args>
+            using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+            template<template<class...> class Op, class... Args>
+            SQLITE_ORM_INLINE_VAR constexpr bool is_detected_v = is_detected<Op, Args...>::value;
+#endif
         }
     }
 }
diff --git a/dev/is_base_of_template.h b/dev/is_base_of_template.h
index 87a0540c9..0c388fe81 100644
--- a/dev/is_base_of_template.h
+++ b/dev/is_base_of_template.h
@@ -10,7 +10,7 @@ namespace sqlite_orm {
          * This is because of bug in MSVC, for more information, please visit
          * https://stackoverflow.com/questions/34672441/stdis-base-of-for-template-classes/34672753#34672753
          */
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && (_MSC_VER < 1920)
         template<template<typename...> class Base, typename Derived>
         struct is_base_of_template_impl {
             template<typename... Ts>
diff --git a/dev/mapped_type_proxy.h b/dev/mapped_type_proxy.h
index caabd5710..4acbe3f4e 100644
--- a/dev/mapped_type_proxy.h
+++ b/dev/mapped_type_proxy.h
@@ -7,10 +7,10 @@ namespace sqlite_orm {
     namespace internal {
 
         /**
-         *  If T is alias than mapped_type_proxy<T>::type is alias::type
+         *  If T is alias then mapped_type_proxy<T>::type is alias::type
          *  otherwise T is T.
          */
-        template<class T, class sfinae = void>
+        template<class T, class SFINAE = void>
         struct mapped_type_proxy {
             using type = T;
         };
diff --git a/dev/node_tuple.h b/dev/node_tuple.h
index d12322b15..454af2ec4 100644
--- a/dev/node_tuple.h
+++ b/dev/node_tuple.h
@@ -129,6 +129,16 @@ namespace sqlite_orm {
             using type = typename conc_tuple<left_tuple, right_tuple>::type;
         };
 
+        template<class T>
+        struct node_tuple<T, typename std::enable_if<is_base_of_template<T, common_table_expression>::value>::type> {
+            using node_type = T;
+            using cte_type = typename node_type::cte_type;
+            using expression_type = typename node_type::expression_type;
+            using cte_tuple = typename node_tuple<cte_type>::type;
+            using expression_tuple = typename node_tuple<expression_type>::type;
+            using type = typename conc_tuple<cte_tuple, expression_tuple>::type;
+        };
+
         template<class T, class... Args>
         struct node_tuple<select_t<T, Args...>, void> {
             using node_type = select_t<T, Args...>;
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index e5d717fcc..b10421a0c 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -230,6 +230,48 @@ namespace sqlite_orm {
             using super::super;
         };
 
+        struct with_string {
+            explicit operator std::string() const {
+                return "WITH";
+            }
+        };
+
+        /**
+         *  Labeled (aliased) CTE expression.
+         */
+        template<class Label, class E>
+        struct common_table_expression {
+            using label_type = Label;
+            using expression_type = E;
+
+            expression_type expression;
+
+            common_table_expression(expression_type expression) : expression{std::move(expression)} {
+                this->expression.highest_level = false;
+            }
+
+            explicit operator std::string() const {
+                return Label::label();
+            }
+        };
+
+        /**
+         *  Expression with CTEs attached.
+         */
+        template<class CTE, class E>
+        struct with_t : with_string {
+            using cte_type = std::tuple<CTE>;
+            using expression_type = E;
+
+            cte_type cte;
+            expression_type expression;
+
+            with_t(std::tuple<CTE> cte, expression_type expression) :
+                cte{move(cte)}, expression{std::move(expression)} {
+                this->expression.highest_level = true;
+            }
+        };
+
         /**
          *  Generic way to get DISTINCT value from any type.
          */
@@ -418,6 +460,20 @@ namespace sqlite_orm {
         return {std::move(lhs), std::move(rhs)};
     }
 
+    template<class Label, class Select>
+    internal::common_table_expression<Label, Select> cte(Select sel) {
+        return {std::move(sel)};
+    }
+
+    template<class CTE, class E>
+    internal::with_t<CTE, E> with(std::tuple<CTE> ctes, E expression) {
+        return {move(ctes), std::move(expression)};
+    }
+    template<class CTE, class E>
+    internal::with_t<CTE, E> with(CTE cte, E expression) {
+        return {std::tuple<CTE>{move(cte)}, std::move(expression)};
+    }
+
     /**
      *  Public function for UNION ALL operator.
      *  lhs and rhs are subselect objects.
diff --git a/dev/statement_serializator.h b/dev/statement_serializator.h
index 582367f0a..ba3cd7353 100644
--- a/dev/statement_serializator.h
+++ b/dev/statement_serializator.h
@@ -9,6 +9,7 @@
 #include <optional>
 #endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
 
+#include "cxx_polyfill.h"
 #include "core_functions.h"
 #include "constraints.h"
 #include "conditions.h"
@@ -211,7 +212,11 @@ namespace sqlite_orm {
             template<class C>
             std::string operator()(const statement_type& c, const C& context) const {
                 auto tableAliasString = alias_extractor<T>::get();
-                return serialize(c.expression, context) + " AS " + tableAliasString;
+                if(c.serializeAlias) {
+                    return tableAliasString;
+                } else {
+                    return serialize(c.expression, context) + " AS " + tableAliasString;
+                }
             }
         };
 
@@ -471,6 +476,41 @@ namespace sqlite_orm {
             }
         };
 
+        template<class CTE>
+        struct statement_serializator<
+            CTE,
+            polyfill::enable_if_t<polyfill::is_specialization_of_v<CTE, common_table_expression>>> {
+            using statement_type = CTE;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& c, const Ctx& context) const {
+                Ctx cteContext = context;
+                cteContext.use_parentheses = true;
+
+                std::stringstream ss;
+                ss << static_cast<std::string>(c) << " as ";
+                ss << serialize(c.expression, cteContext);
+                return ss.str();
+            }
+        };
+
+        template<class With>
+        struct statement_serializator<With, polyfill::enable_if_t<polyfill::is_specialization_of_v<With, with_t>>> {
+            using statement_type = With;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& c, const Ctx& context) const {
+                Ctx tupleContext = context;
+                tupleContext.use_parentheses = false;
+
+                std::stringstream ss;
+                ss << static_cast<std::string>(c) << " ";
+                ss << serialize(c.cte, tupleContext) << " ";
+                ss << serialize(c.expression, context);
+                return ss.str();
+            }
+        };
+
         template<class T>
         struct statement_serializator<T,
                                       typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
@@ -1785,11 +1825,10 @@ namespace sqlite_orm {
                 ss << "FROM ";
                 size_t index = 0;
                 iterate_tuple<tuple>([&context, &ss, &index](auto* itemPointer) {
-                    using mapped_type = typename std::remove_pointer<decltype(itemPointer)>::type;
+                    using from_type = std::remove_cv_t<std::remove_pointer_t<decltype(itemPointer)>>;
 
-                    auto aliasString = alias_extractor<mapped_type>::get();
-                    ss << "'" << context.impl.find_table_name(typeid(typename mapped_type_proxy<mapped_type>::type))
-                       << "'";
+                    auto aliasString = alias_extractor<from_type>::get();
+                    ss << "'" << context.impl.get_table_name<typename mapped_type_proxy<from_type>::type>() << "'";
                     if(aliasString.length()) {
                         ss << " '" << aliasString << "'";
                     }
@@ -2106,7 +2145,9 @@ namespace sqlite_orm {
             template<class C>
             std::string operator()(const statement_type& statement, const C& context) const {
                 std::stringstream ss;
-                ss << '(';
+                if(context.use_parentheses) {
+                    ss << '(';
+                }
                 auto index = 0;
                 using TupleSize = std::tuple_size<statement_type>;
                 iterate_tuple(statement, [&context, &index, &ss](auto& value) {
@@ -2116,7 +2157,9 @@ namespace sqlite_orm {
                     }
                     ++index;
                 });
-                ss << ')';
+                if(context.use_parentheses) {
+                    ss << ')';
+                }
                 return ss.str();
             }
         };
diff --git a/dev/storage.h b/dev/storage.h
index 33061da87..8ab27def1 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -70,7 +70,9 @@ namespace sqlite_orm {
             storage_t(const std::string& filename, impl_type impl_) :
                 storage_base{filename, foreign_keys_count(impl_)}, impl(std::move(impl_)) {}
 
-            storage_t(const storage_t& other) : storage_base(other), impl(other.impl) {}
+            storage_t(const storage_t&) = default;
+
+            storage_t(const storage_base& base, const Ts&... tables) : storage_base{base, true}, impl{tables...} {}
 
           protected:
             impl_type impl;
@@ -87,6 +89,15 @@ namespace sqlite_orm {
             template<class S>
             friend struct serializator_context_builder;
 
+            template<typename... CTETables>
+            friend storage_t<CTETables..., Ts...> storage_cat(const storage_t<Ts...>& storage,
+                                                              CTETables&&... cteTables) {
+                using storage_type = storage_t<CTETables..., Ts...>;
+                return storage_type(storage,
+                                    std::forward<CTETables>(cteTables)...,
+                                    storage.get_impl<typename Ts::object_type>().table...);
+            }
+
             template<class I>
             void create_table(sqlite3* db, const std::string& tableName, const I& tableImpl) {
                 using table_type = typename std::decay<decltype(tableImpl.table)>::type;
@@ -436,7 +447,7 @@ namespace sqlite_orm {
                      class O,
                      class... Args,
                      class Tuple = std::tuple<Args...>,
-                     typename sfinae = typename std::enable_if<std::tuple_size<Tuple>::value >= 1>::type>
+                     typename SFINAE = typename std::enable_if<std::tuple_size<Tuple>::value >= 1>::type>
             std::string group_concat(F O::*m, Args&&... args) {
                 return this->group_concat_internal(m, {}, std::forward<Args>(args)...);
             }
@@ -904,6 +915,11 @@ namespace sqlite_orm {
                 }
             }
 
+            template<class CTE, class E>
+            friend prepared_statement_t<with_t<CTE, E>> prepare_with_cte(self&& storage, with_t<CTE, E> ast) {
+                return storage.prepare_impl<with_t<CTE, E>>(std::move(ast));
+            }
+
           public:
             /**
              *  This is a cute function used to replace migration up/down functionality.
@@ -969,6 +985,13 @@ namespace sqlite_orm {
                 return this->impl.table_exists(tableName, con.get());
             }
 
+            template<class CTE, class E>
+            typename std::enable_if<is_base_of_template<E, select_t>::value, prepared_statement_t<with_t<CTE, E>>>::type
+            prepare(with_t<CTE, E> ast) {
+                auto cte = make_cte_storage(*this, ast);
+                return prepare_with_cte(std::move(cte), std::move(ast));
+            }
+
             template<class T, class... Args>
             prepared_statement_t<select_t<T, Args...>> prepare(select_t<T, Args...> sel) {
                 sel.highest_level = true;
@@ -1478,8 +1501,8 @@ namespace sqlite_orm {
                 perform_step(db, stmt);
             }
 
-            template<class T, class... Args, class R = typename column_result_t<self, T>::type>
-            std::vector<R> execute(const prepared_statement_t<select_t<T, Args...>>& statement) {
+            template<class R, class S>
+            std::vector<R> _execute_select(const S& statement) {
                 auto con = this->get_connection();
                 auto db = con.get();
                 auto stmt = statement.stmt;
@@ -1518,6 +1541,16 @@ namespace sqlite_orm {
                 return res;
             }
 
+            template<class CTE, class T, class... Args, class R = typename column_result_t<self, T>::type>
+            std::vector<R> execute(const prepared_statement_t<with_t<CTE, select_t<T, Args...>>>& statement) {
+                return _execute_select<R>(statement);
+            }
+
+            template<class T, class... Args, class R = typename column_result_t<self, T>::type>
+            std::vector<R> execute(const prepared_statement_t<select_t<T, Args...>>& statement) {
+                return _execute_select<R>(statement);
+            }
+
             template<class T, class R, class... Args>
             R execute(const prepared_statement_t<get_all_t<T, R, Args...>>& statement) {
                 auto& tImpl = this->get_impl<T>();
diff --git a/dev/storage_base.h b/dev/storage_base.h
index 3c676dbd3..fc140c176 100644
--- a/dev/storage_base.h
+++ b/dev/storage_base.h
@@ -459,8 +459,8 @@ namespace sqlite_orm {
             storage_base(const std::string& filename_, int foreignKeysCount) :
                 pragma(std::bind(&storage_base::get_connection, this)),
                 limit(std::bind(&storage_base::get_connection, this)),
-                inMemory(filename_.empty() || filename_ == ":memory:"),
-                connection(std::make_unique<connection_holder>(filename_)), cachedForeignKeysCount(foreignKeysCount) {
+                inMemory(filename_.empty() || filename_ == ":memory:"), connection(new connection_holder(filename_)),
+                cachedForeignKeysCount(foreignKeysCount) {
                 if(this->inMemory) {
                     this->connection->retain();
                     this->on_open_internal(this->connection->get());
@@ -470,7 +470,7 @@ namespace sqlite_orm {
             storage_base(const storage_base& other) :
                 on_open(other.on_open), pragma(std::bind(&storage_base::get_connection, this)),
                 limit(std::bind(&storage_base::get_connection, this)), inMemory(other.inMemory),
-                connection(std::make_unique<connection_holder>(other.connection->filename)),
+                connection(new connection_holder(other.connection->filename)),
                 cachedForeignKeysCount(other.cachedForeignKeysCount) {
                 if(this->inMemory) {
                     this->connection->retain();
@@ -478,6 +478,12 @@ namespace sqlite_orm {
                 }
             }
 
+            storage_base(const storage_base& other, bool /*shareConnection*/) :
+                on_open{other.on_open}, pragma{std::bind(&storage_base::get_connection, this)},
+                limit{std::bind(&storage_base::get_connection, this)}, inMemory{other.inMemory},
+                connection{other.connection.get(), connection_deleter{false /*no ownership*/}},
+                cachedForeignKeysCount{other.cachedForeignKeysCount} {}
+
             ~storage_base() {
                 if(this->isOpenedForever) {
                     this->connection->release();
@@ -727,9 +733,20 @@ namespace sqlite_orm {
                 return res;
             }
 
+            //  enables turning a unique_ptr into an observing smart pointer
+            struct connection_deleter {
+                const bool ownership = true;
+
+                void operator()(connection_holder* holder) const {
+                    if(this->ownership) {
+                        delete holder;
+                    }
+                }
+            };
+
             const bool inMemory;
             bool isOpenedForever = false;
-            std::unique_ptr<connection_holder> connection;
+            std::unique_ptr<connection_holder, connection_deleter> connection;
             std::map<std::string, collating_function> collatingFunctions;
             const int cachedForeignKeysCount;
             std::function<int(int)> _busy_handler;
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 49ed71566..873a2d7b1 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -198,49 +198,114 @@ namespace sqlite_orm {
                 return this->super::column_name(m);
             }
 
-            template<class T, class F, class HH = typename H::object_type>
-            const std::string* column_name(const column_pointer<T, F>& c,
-                                           typename std::enable_if<std::is_same<T, HH>::value>::type* = nullptr) const {
+            template<class O, class F, class HH = typename H::object_type>
+            const std::string* column_name(const column_pointer<O, F>& c,
+                                           typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) const {
                 return this->column_name_simple(c.field);
             }
 
-            template<class T, class F, class HH = typename H::object_type>
+            template<class O, class F, class HH = typename H::object_type>
             const std::string*
-            column_name(const column_pointer<T, F>& c,
-                        typename std::enable_if<!std::is_same<T, HH>::value>::type* = nullptr) const {
+            column_name(const column_pointer<O, F>& c,
+                        typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) const {
                 return this->super::column_name(c);
             }
 
-            template<class O, class HH = typename H::object_type>
+            template<class O,
+                     class HH = typename H::object_type,
+                     class Label = typename H::cte_label_type,
+                     polyfill::enable_if_t<std::is_void<Label>::value, int> = 0>
             const auto& get_impl(typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) const {
                 return *this;
             }
 
-            template<class O, class HH = typename H::object_type>
+            template<class O,
+                     class HH = typename H::object_type,
+                     class Label = typename H::cte_label_type,
+                     polyfill::enable_if_t<std::is_void<Label>::value, int> = 0>
             const auto& get_impl(typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) const {
                 return this->super::template get_impl<O>();
             }
 
-            template<class O, class HH = typename H::object_type>
+            template<class O,
+                     class HH = typename H::object_type,
+                     class Label = typename H::cte_label_type,
+                     std::enable_if_t<std::is_void<Label>::value, int> = 0>
             auto& get_impl(typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) {
                 return *this;
             }
 
-            template<class O, class HH = typename H::object_type>
+            template<class O,
+                     class HH = typename H::object_type,
+                     class Label = typename H::cte_label_type,
+                     polyfill::enable_if_t<std::is_void<Label>::value, int> = 0>
             auto& get_impl(typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) {
                 return this->super::template get_impl<O>();
             }
 
-            template<class O, class HH = typename H::object_type>
+            template<class Label,
+                     class HL = typename H::cte_label_type,
+                     polyfill::enable_if_t<!std::is_void<HL>::value, int> = 0>
+            const auto& get_impl(polyfill::enable_if_t<std::is_same<Label, HL>::value>* = nullptr) const {
+                return *this;
+            }
+
+            template<class Label,
+                     class HL = typename H::cte_label_type,
+                     polyfill::enable_if_t<!std::is_void<HL>::value, int> = 0>
+            const auto& get_impl(polyfill::enable_if_t<!std::is_same<Label, HL>::value>* = nullptr) const {
+                return this->super::template get_impl<Label>();
+            }
+
+            template<class Label,
+                     class HL = typename H::cte_label_type,
+                     polyfill::enable_if_t<!std::is_void<HL>::value, int> = 0>
+            auto& get_impl(polyfill::enable_if_t<std::is_same<Label, HL>::value>* = nullptr) {
+                return *this;
+            }
+
+            template<class Label,
+                     class HL = typename H::cte_label_type,
+                     polyfill::enable_if_t<!std::is_void<HL>::value, int> = 0>
+            auto& get_impl(polyfill::enable_if_t<!std::is_same<Label, HL>::value>* = nullptr) {
+                return this->super::template get_impl<Label>();
+            }
+
+            template<class O,
+                     class HH = typename H::object_type,
+                     class Label = typename H::cte_label_type,
+                     polyfill::enable_if_t<std::is_void<Label>::value, int> = 0>
             const auto* find_table(typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) const {
                 return &this->table;
             }
 
-            template<class O, class HH = typename H::object_type>
+            template<class O,
+                     class HH = typename H::object_type,
+                     class Label = typename H::cte_label_type,
+                     polyfill::enable_if_t<std::is_void<Label>::value, int> = 0>
             const auto* find_table(typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) const {
                 return this->super::template find_table<O>();
             }
 
+            template<class Label,
+                     class HL = typename H::cte_label_type,
+                     polyfill::enable_if_t<!std::is_void<HL>::value, int> = 0>
+            const auto* find_table(typename std::enable_if<std::is_same<Label, HL>::value>::type* = nullptr) const {
+                return &this->table;
+            }
+
+            template<class Label,
+                     class HL = typename H::cte_label_type,
+                     polyfill::enable_if_t<!std::is_void<HL>::value, int> = 0>
+            const auto* find_table(typename std::enable_if<!std::is_same<Label, HL>::value>::type* = nullptr) const {
+                return this->super::template find_table<Label>();
+            }
+
+            template<class O>
+            const std::string& get_table_name() const {
+                return this->get_impl<O>().table.name;
+            }
+
             std::string find_table_name(std::type_index ti) const {
                 std::type_index thisTypeIndex{typeid(typename H::object_type)};
                 if(thisTypeIndex == ti) {
diff --git a/dev/storage_traits.h b/dev/storage_traits.h
index b9b39df49..4be4a053d 100644
--- a/dev/storage_traits.h
+++ b/dev/storage_traits.h
@@ -8,7 +8,7 @@ namespace sqlite_orm {
         template<class... Ts>
         struct storage_impl;
 
-        template<class T, bool WithoutRowId, class... Cs>
+        template<class O, bool WithoutRowId, class... Cs>
         struct table_t;
 
         template<class A, class B>
@@ -18,71 +18,71 @@ namespace sqlite_orm {
 
             /**
              *  S - storage_impl type
-             *  T - mapped or not mapped data type
+             *  O - mapped or not mapped data type
              */
-            template<class S, class T, class SFINAE = void>
+            template<class S, class O, class SFINAE = void>
             struct type_is_mapped_impl;
 
             /**
              *  S - storage
-             *  T - mapped or not mapped data type
+             *  O - mapped or not mapped data type
              */
-            template<class S, class T>
-            struct type_is_mapped : type_is_mapped_impl<typename S::impl_type, T> {};
+            template<class S, class O>
+            struct type_is_mapped : type_is_mapped_impl<typename S::impl_type, O> {};
 
             /**
              *  Final specialisation
              */
-            template<class T>
-            struct type_is_mapped_impl<storage_impl<>, T, void> : std::false_type {};
+            template<class O>
+            struct type_is_mapped_impl<storage_impl<>, O, void> : std::false_type {};
 
-            template<class S, class T>
+            template<class S, class O>
             struct type_is_mapped_impl<
                 S,
-                T,
-                typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type>
+                O,
+                typename std::enable_if<std::is_same<O, typename S::table_type::object_type>::value>::type>
                 : std::true_type {};
 
-            template<class S, class T>
+            template<class S, class O>
             struct type_is_mapped_impl<
                 S,
-                T,
-                typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
-                : type_is_mapped_impl<typename S::super, T> {};
+                O,
+                typename std::enable_if<!std::is_same<O, typename S::table_type::object_type>::value>::type>
+                : type_is_mapped_impl<typename S::super, O> {};
 
             /**
              *  S - storage_impl type
-             *  T - mapped or not mapped data type
+             *  O - mapped or not mapped data type
              */
-            template<class S, class T, class SFINAE = void>
+            template<class S, class O, class SFINAE = void>
             struct storage_columns_count_impl;
 
             /**
              *  S - storage
-             *  T - mapped or not mapped data type
+             *  O - mapped or not mapped data type
              */
-            template<class S, class T>
-            struct storage_columns_count : storage_columns_count_impl<typename S::impl_type, T> {};
+            template<class S, class O>
+            struct storage_columns_count : storage_columns_count_impl<typename S::impl_type, O> {};
 
             /**
              *  Final specialisation
              */
-            template<class T>
-            struct storage_columns_count_impl<storage_impl<>, T, void> : std::integral_constant<int, 0> {};
+            template<class O>
+            struct storage_columns_count_impl<storage_impl<>, O, void> : std::integral_constant<int, 0> {};
 
-            template<class S, class T>
+            template<class S, class O>
             struct storage_columns_count_impl<
                 S,
-                T,
-                typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type>
+                O,
+                typename std::enable_if<std::is_same<O, typename S::table_type::object_type>::value>::type>
                 : std::integral_constant<int, S::table_type::elements_count> {};
 
-            template<class S, class T>
+            template<class S, class O>
             struct storage_columns_count_impl<
                 S,
-                T,
-                typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
-                : storage_columns_count_impl<typename S::super, T> {};
+                O,
+                typename std::enable_if<!std::is_same<O, typename S::table_type::object_type>::value>::type>
+                : storage_columns_count_impl<typename S::super, O> {};
 
             /**
              *  T - table type.
@@ -93,8 +93,8 @@ namespace sqlite_orm {
             /**
              *  type is std::tuple of field types of mapped colums.
              */
-            template<class T, bool WithoutRowId, class... Args>
-            struct table_types<table_t<T, WithoutRowId, Args...>> {
+            template<class O, bool WithoutRowId, class... Args>
+            struct table_types<table_t<O, WithoutRowId, Args...>> {
                 using args_tuple = std::tuple<Args...>;
                 using columns_tuple = typename tuple_filter<args_tuple, is_column>::type;
 
@@ -103,41 +103,41 @@ namespace sqlite_orm {
 
             /**
              *  S - storage_impl type
-             *  T - mapped or not mapped data type
+             *  O - mapped or not mapped data type
              */
-            template<class S, class T, class SFINAE = void>
+            template<class S, class O, class SFINAE = void>
             struct storage_mapped_columns_impl;
 
             /**
              *  S - storage
-             *  T - mapped or not mapped data type
+             *  O - mapped or not mapped data type
              */
-            template<class S, class T>
-            struct storage_mapped_columns : storage_mapped_columns_impl<typename S::impl_type, T> {};
+            template<class S, class O>
+            struct storage_mapped_columns : storage_mapped_columns_impl<typename S::impl_type, O> {};
 
             /**
              *  Final specialisation
              */
-            template<class T>
-            struct storage_mapped_columns_impl<storage_impl<>, T, void> {
+            template<class O>
+            struct storage_mapped_columns_impl<storage_impl<>, O, void> {
                 using type = std::tuple<>;
             };
 
-            template<class S, class T>
+            template<class S, class O>
             struct storage_mapped_columns_impl<
                 S,
-                T,
-                typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> {
+                O,
+                typename std::enable_if<std::is_same<O, typename S::table_type::object_type>::value>::type> {
                 using table_type = typename S::table_type;
                 using type = typename table_types<table_type>::type;
             };
 
-            template<class S, class T>
+            template<class S, class O>
             struct storage_mapped_columns_impl<
                 S,
-                T,
-                typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
-                : storage_mapped_columns_impl<typename S::super, T> {};
+                O,
+                typename std::enable_if<!std::is_same<O, typename S::table_type::object_type>::value>::type>
+                : storage_mapped_columns_impl<typename S::super, O> {};
 
             /**
              *  C is any column type: column_t or constraint type
@@ -178,11 +178,11 @@ namespace sqlite_orm {
             template<class T, class O>
             struct table_foreign_keys_count;
 
-            template<class T, class... Cs, class O>
-            struct table_foreign_keys_count<table_t<T, false, Cs...>, O> {
-                using table_type = table_t<T, false, Cs...>;
+            template<class O, class... Cs, class P>
+            struct table_foreign_keys_count<table_t<O, false, Cs...>, P> {
+                using table_type = table_t<O, false, Cs...>;
 
-                static constexpr const int value = table_foreign_keys_count_impl<O, Cs...>::value;
+                static constexpr const int value = table_foreign_keys_count_impl<P, Cs...>::value;
             };
 
             /**
@@ -305,18 +305,18 @@ namespace sqlite_orm {
             template<class T, class O>
             struct table_foreign_keys;
 
-            template<class T, bool WithoutRowId, class... Cs, class O>
-            struct table_fk_references<table_t<T, WithoutRowId, Cs...>, O> {
-                using table_type = table_t<T, WithoutRowId, Cs...>;
+            template<class O, bool WithoutRowId, class... Cs, class P>
+            struct table_fk_references<table_t<O, WithoutRowId, Cs...>, P> {
+                using table_type = table_t<O, WithoutRowId, Cs...>;
 
-                using type = typename table_fk_references_impl<O, Cs...>::type;
+                using type = typename table_fk_references_impl<P, Cs...>::type;
             };
 
-            template<class T, bool WithoutRowId, class... Cs, class O>
-            struct table_foreign_keys<table_t<T, WithoutRowId, Cs...>, O> {
-                using table_type = table_t<T, WithoutRowId, Cs...>;
+            template<class O, bool WithoutRowId, class... Cs, class P>
+            struct table_foreign_keys<table_t<O, WithoutRowId, Cs...>, P> {
+                using table_type = table_t<O, WithoutRowId, Cs...>;
 
-                using type = typename table_foreign_keys_impl<O, Cs...>::type;
+                using type = typename table_foreign_keys_impl<P, Cs...>::type;
             };
 
             /**
diff --git a/dev/table.h b/dev/table.h
index 2f129e9e4..db89ecc79 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -6,6 +6,7 @@
 #include <tuple>  //  std::tuple_size, std::tuple_element
 #include <algorithm>  //  std::reverse, std::find_if
 
+#include "cxx_polyfill.h"
 #include "column_result.h"
 #include "static_magic.h"
 #include "typed_comparator.h"
@@ -19,6 +20,9 @@ namespace sqlite_orm {
 
     namespace internal {
 
+        template<typename T>
+        using cte_label_t = typename T::cte_label_type;
+
         struct basic_table {
 
             /**
@@ -30,10 +34,11 @@ namespace sqlite_orm {
         /**
          *  Table class.
          */
-        template<class T, bool WithoutRowId, class... Cs>
+        template<class O, bool WithoutRowId, class... Cs>
         struct table_t : basic_table {
             using super = basic_table;
-            using object_type = T;
+            using object_type = O;
+            using cte_label_type = polyfill::detected_or_t<void, cte_label_t, O>;
             using elements_type = std::tuple<Cs...>;
 
             static constexpr const int elements_count = static_cast<int>(std::tuple_size<elements_type>::value);
@@ -43,7 +48,7 @@ namespace sqlite_orm {
 
             table_t(std::string name_, elements_type elements_) : super{move(name_)}, elements{move(elements_)} {}
 
-            table_t<T, true, Cs...> without_rowid() const {
+            table_t<O, true, Cs...> without_rowid() const {
                 return {this->name, this->elements};
             }
 
@@ -309,13 +314,13 @@ namespace sqlite_orm {
      *  Function used for table creation. Do not use table constructor - use this function
      *  cause table class is templated and its constructing too (just like std::make_unique or std::make_pair).
      */
-    template<class... Cs, class T = typename std::tuple_element<0, std::tuple<Cs...>>::type::object_type>
-    internal::table_t<T, false, Cs...> make_table(const std::string& name, Cs... args) {
+    template<class... Cs, class O = typename std::tuple_element<0, std::tuple<Cs...>>::type::object_type>
+    internal::table_t<O, false, Cs...> make_table(const std::string& name, Cs... args) {
         return {name, std::make_tuple<Cs...>(std::forward<Cs>(args)...)};
     }
 
-    template<class T, class... Cs>
-    internal::table_t<T, false, Cs...> make_table(const std::string& name, Cs... args) {
+    template<class O, class... Cs>
+    internal::table_t<O, false, Cs...> make_table(const std::string& name, Cs... args) {
         return {name, std::make_tuple<Cs...>(std::forward<Cs>(args)...)};
     }
 }
diff --git a/dev/tuple_helper/tuple_helper.h b/dev/tuple_helper/tuple_helper.h
index d3a6c01ac..fb74002f5 100644
--- a/dev/tuple_helper/tuple_helper.h
+++ b/dev/tuple_helper/tuple_helper.h
@@ -152,7 +152,7 @@ namespace sqlite_orm {
         template<size_t N, size_t I, class L, class R>
         void move_tuple_impl(L& lhs, R& rhs) {
             std::get<I>(lhs) = std::move(std::get<I>(rhs));
-            internal::static_if<std::integral_constant<bool, N != I + 1>{}>([](auto& l, auto& r) {
+            static_if<std::integral_constant<bool, N != I + 1>{}>([](auto& l, auto& r) {
                 move_tuple_impl<N, I + 1>(l, r);
             })(lhs, rhs);
         }
diff --git a/dev/type_traits.h b/dev/type_traits.h
new file mode 100644
index 000000000..775983ee5
--- /dev/null
+++ b/dev/type_traits.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <type_traits>
+
+#include "start_macros.h"
+#include "cxx_polyfill.h"
+
+namespace sqlite_orm {
+    namespace internal {}
+}
diff --git a/not_single_header_include/sqlite_orm/sqlite_orm.h b/not_single_header_include/sqlite_orm/sqlite_orm.h
index 8f4b3c33b..ff363b85a 100644
--- a/not_single_header_include/sqlite_orm/sqlite_orm.h
+++ b/not_single_header_include/sqlite_orm/sqlite_orm.h
@@ -48,6 +48,7 @@
 #include "../../dev/table.h"
 #include "../../dev/storage_impl.h"
 #include "../../dev/storage.h"
+#include "../../dev/cte.h"
 #include "../../dev/finish_macros.h"
 #include "../../dev/node_tuple.h"
 #include "../../dev/get_prepared_statement.h"

From f8abfdb9f0a9acf5c1b045dc9bd27dff79b6cc39 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 8 Jan 2022 20:02:08 +0200
Subject: [PATCH 002/161] Prepared for multiple CTEs

---
 dev/cte.h                | 46 ++++++++++++++++++++++++----------------
 dev/select_constraints.h | 29 +++++++++++++------------
 dev/storage.h            | 14 ++++++------
 3 files changed, 50 insertions(+), 39 deletions(-)

diff --git a/dev/cte.h b/dev/cte.h
index 6cf973325..1fba028ee 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -55,22 +55,32 @@ namespace sqlite_orm {
 }
 
 namespace sqlite_orm {
+
+    template<char C, char... Cs>
     struct cte_label {
-        static std::string label() {
-            return "cte";
+        static constexpr char str[] = {C, Cs..., '\0'};
+
+        static const char* label() {
+            return str;
+        }
+
+        explicit operator std::string() const {
+            return cte_label::label();
         }
     };
 
+    using cte_1 = cte_label<'c', 't', 'e', '_', '1'>;
+
     namespace internal {
         /*
          *
          */
-        template<typename... Fs>
+        template<typename Label, typename... Fs>
         class column_results : std::tuple<Fs...> {
           public:
             using base = std::tuple<Fs...>;
             using index_sequence = std::make_index_sequence<std::tuple_size<base>::value>;
-            using cte_label_type = cte_label;
+            using cte_label_type = Label;
 
             template<size_t I>
             decltype(auto) cget() const noexcept {
@@ -83,18 +93,18 @@ namespace sqlite_orm {
         };
 
         // F = field_type
-        template<typename F>
+        template<typename Label, typename F>
         struct create_column_results {
-            using type = column_results<F>;
+            using type = column_results<Label, F>;
         };
 
-        template<typename... Fs>
-        struct create_column_results<std::tuple<Fs...>> {
-            using type = column_results<Fs...>;
+        template<typename Label, typename... Fs>
+        struct create_column_results<Label, std::tuple<Fs...>> {
+            using type = column_results<Label, Fs...>;
         };
 
-        template<typename... Fs>
-        using create_column_results_t = typename create_column_results<Fs...>::type;
+        template<typename Label, typename... Fs>
+        using create_column_results_t = typename create_column_results<Label, Fs...>::type;
 
         template<typename O, size_t I>
         struct create_cte_column {
@@ -112,9 +122,9 @@ namespace sqlite_orm {
         template<typename O, typename IdxSeq>
         struct create_cte_table;
 
-        template<typename... Fs, size_t... Is>
-        struct create_cte_table<column_results<Fs...>, std::index_sequence<Is...>> {
-            using object_type = column_results<Fs...>;
+        template<typename Label, typename... Fs, size_t... Is>
+        struct create_cte_table<column_results<Label, Fs...>, std::index_sequence<Is...>> {
+            using object_type = column_results<Label, Fs...>;
             using table_type = table_t<object_type, true, create_cte_column_t<object_type, Is>...>;
 
             using type = table_type;
@@ -239,10 +249,10 @@ namespace sqlite_orm {
                 .without_rowid();
         }
 
-        template<class Strg, class CTE, class E>
-        decltype(auto) make_cte_storage(const Strg& storage, const with_t<CTE, E>& e) {
-            using object_type =
-                create_column_results_t<typename column_result_t<Strg, typename CTE::expression_type>::type>;
+        template<class Strg, class E, class CTE>
+        decltype(auto) make_cte_storage(const Strg& storage,
+                                        const with_t<E, CTE>& e) {
+            using object_type = create_column_results_t<typename CTE::label_type, typename column_result_t<Strg, typename CTE::expression_type>::type>;
             using table_type = create_cte_table_t<object_type, typename object_type::index_sequence>;
 
             return storage_cat(storage,
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index b10421a0c..874e9852c 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -239,26 +239,22 @@ namespace sqlite_orm {
         /**
          *  Labeled (aliased) CTE expression.
          */
-        template<class Label, class E>
-        struct common_table_expression {
+        template<class Label, class Select>
+        struct common_table_expression : public Label {
             using label_type = Label;
-            using expression_type = E;
+            using expression_type = Select;
 
             expression_type expression;
 
             common_table_expression(expression_type expression) : expression{std::move(expression)} {
                 this->expression.highest_level = false;
             }
-
-            explicit operator std::string() const {
-                return Label::label();
-            }
         };
 
         /**
          *  Expression with CTEs attached.
          */
-        template<class CTE, class E>
+        template<class E, class CTE>
         struct with_t : with_string {
             using cte_type = std::tuple<CTE>;
             using expression_type = E;
@@ -465,13 +461,18 @@ namespace sqlite_orm {
         return {std::move(sel)};
     }
 
-    template<class CTE, class E>
-    internal::with_t<CTE, E> with(std::tuple<CTE> ctes, E expression) {
-        return {move(ctes), std::move(expression)};
+    // tuple of CTEs
+    template<class E, class Label, class CTE>
+    internal::with_t<E, internal::common_table_expression<Label, CTE>>
+    with(std::tuple<internal::common_table_expression<Label, CTE>> cte, E expression) {
+        return {move(cte), std::move(expression)};
     }
-    template<class CTE, class E>
-    internal::with_t<CTE, E> with(CTE cte, E expression) {
-        return {std::tuple<CTE>{move(cte)}, std::move(expression)};
+    
+    // a single CTE
+    template<class E, class Label, class CTE>
+    internal::with_t<E, internal::common_table_expression<Label, CTE>>
+    with(internal::common_table_expression<Label, CTE> cte, E expression) {
+        return {std::make_tuple(move(cte)), std::move(expression)};
     }
 
     /**
diff --git a/dev/storage.h b/dev/storage.h
index 8ab27def1..bbf2daf6f 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -915,9 +915,9 @@ namespace sqlite_orm {
                 }
             }
 
-            template<class CTE, class E>
-            friend prepared_statement_t<with_t<CTE, E>> prepare_with_cte(self&& storage, with_t<CTE, E> ast) {
-                return storage.prepare_impl<with_t<CTE, E>>(std::move(ast));
+            template<class E, class CTE>
+            friend prepared_statement_t<with_t<E, CTE>> prepare_with_cte(self&& storage, with_t<E, CTE> ast) {
+                return storage.prepare_impl<with_t<E, CTE>>(std::move(ast));
             }
 
           public:
@@ -985,9 +985,9 @@ namespace sqlite_orm {
                 return this->impl.table_exists(tableName, con.get());
             }
 
-            template<class CTE, class E>
-            typename std::enable_if<is_base_of_template<E, select_t>::value, prepared_statement_t<with_t<CTE, E>>>::type
-            prepare(with_t<CTE, E> ast) {
+            template<class E, class CTE>
+            typename std::enable_if<is_base_of_template<E, select_t>::value, prepared_statement_t<with_t<E, CTE>>>::type
+            prepare(with_t<E, CTE> ast) {
                 auto cte = make_cte_storage(*this, ast);
                 return prepare_with_cte(std::move(cte), std::move(ast));
             }
@@ -1542,7 +1542,7 @@ namespace sqlite_orm {
             }
 
             template<class CTE, class T, class... Args, class R = typename column_result_t<self, T>::type>
-            std::vector<R> execute(const prepared_statement_t<with_t<CTE, select_t<T, Args...>>>& statement) {
+            std::vector<R> execute(const prepared_statement_t<with_t<select_t<T, Args...>, CTE>>& statement) {
                 return _execute_select<R>(statement);
             }
 

From 454a8219e6d0da4f23024833346235431461e1f7 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 8 Jan 2022 21:53:18 +0200
Subject: [PATCH 003/161] Multiple CTEs

---
 dev/cte.h                | 58 +++++++++++++++++++++++++++-------------
 dev/select_constraints.h | 20 +++++++-------
 dev/storage.h            | 16 +++++------
 3 files changed, 57 insertions(+), 37 deletions(-)

diff --git a/dev/cte.h b/dev/cte.h
index 1fba028ee..680bebbe3 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -70,16 +70,24 @@ namespace sqlite_orm {
     };
 
     using cte_1 = cte_label<'c', 't', 'e', '_', '1'>;
+    using cte_2 = cte_label<'c', 't', 'e', '_', '2'>;
+    using cte_3 = cte_label<'c', 't', 'e', '_', '3'>;
+    using cte_4 = cte_label<'c', 't', 'e', '_', '4'>;
+    using cte_5 = cte_label<'c', 't', 'e', '_', '5'>;
+    using cte_6 = cte_label<'c', 't', 'e', '_', '6'>;
+    using cte_7 = cte_label<'c', 't', 'e', '_', '7'>;
+    using cte_8 = cte_label<'c', 't', 'e', '_', '8'>;
+    using cte_9 = cte_label<'c', 't', 'e', '_', '9'>;
 
     namespace internal {
         /*
-         *
+         *  Tuple data structure for CTEs
          */
         template<typename Label, typename... Fs>
         class column_results : std::tuple<Fs...> {
           public:
             using base = std::tuple<Fs...>;
-            using index_sequence = std::make_index_sequence<std::tuple_size<base>::value>;
+            using index_sequence = std::index_sequence_for<Fs...>;
             using cte_label_type = Label;
 
             template<size_t I>
@@ -92,6 +100,8 @@ namespace sqlite_orm {
             }
         };
 
+
+
         // F = field_type
         template<typename Label, typename F>
         struct create_column_results {
@@ -224,15 +234,15 @@ namespace sqlite_orm {
         };
 
         template<typename Strg, typename T, typename... Args>
-        std::vector<std::string> cte_column_names(const Strg& storage, const select_t<T, Args...>& sel) {
+        std::vector<std::string> collect_cte_column_names(const Strg& storage, const select_t<T, Args...>& sel) {
             const serializator_context_builder<Strg> ctxBuilder(storage);
             return get_cte_column_names(sel.col, ctxBuilder());
         }
 
-        template<typename O, typename Strg, typename CTE, size_t... Is>
+        template<typename O, typename Strg, typename CTE, size_t... CIs>
         create_cte_table_t<O, typename O::index_sequence>
-        make_cte_table(const Strg& storage, std::string name, const CTE& cte, std::index_sequence<Is...>) {
-            std::vector<std::string> columnNames = cte_column_names(storage, cte);
+        make_cte_table_with_column_indices(const Strg& storage, const CTE& cte, std::index_sequence<CIs...>) {
+            std::vector<std::string> columnNames = collect_cte_column_names(storage, cte.expression);
             assert(columnNames.size() == O::index_sequence::size());
             // unquote
             for(std::string& name: columnNames) {
@@ -243,23 +253,33 @@ namespace sqlite_orm {
             }
 
             return create_cte_table_t<O, typename O::index_sequence>{
-                move(name),
+                cte.label(),
                 std::make_tuple<>(
-                    make_column<>(columnNames.at(Is), &(O::template cget<Is>), &(O::template set<Is>))...)}
+                    make_column<>(columnNames.at(CIs), &(O::template cget<CIs>), &(O::template set<CIs>))...)}
                 .without_rowid();
         }
 
-        template<class Strg, class E, class CTE>
-        decltype(auto) make_cte_storage(const Strg& storage,
-                                        const with_t<E, CTE>& e) {
-            using object_type = create_column_results_t<typename CTE::label_type, typename column_result_t<Strg, typename CTE::expression_type>::type>;
-            using table_type = create_cte_table_t<object_type, typename object_type::index_sequence>;
-
-            return storage_cat(storage,
-                               make_cte_table<object_type>(storage,
-                                                           static_cast<std::string>(std::get<0>(e.cte)),
-                                                           std::get<0>(e.cte).expression,
-                                                           typename object_type::index_sequence{}));
+        template<typename O, typename Strg, typename CTE>
+        create_cte_table_t<O, typename O::index_sequence> make_cte_table(const Strg& storage, const CTE& cte) {
+            return make_cte_table_with_column_indices<O>(storage, cte, typename O::index_sequence{});
+        }
+
+        template<class Strg, class E, class... CTEs, size_t... TIs>
+        decltype(auto) make_cte_storage_with_table_indices(const Strg& storage,
+                                                           const with_t<E, CTEs...>& e,
+                                                           std::index_sequence<TIs...>) {
+            return storage_cat(
+                storage,
+                make_cte_table<
+                    create_column_results_t<typename CTEs::label_type,
+                                            typename column_result_t<Strg, typename CTEs::expression_type>::type>>(
+                    storage,
+                    get<TIs>(e.cte))...);
+        }
+
+        template<class Strg, class E, class... CTEs>
+        decltype(auto) make_cte_storage(const Strg& storage, const with_t<E, CTEs...>& e) {
+            return make_cte_storage_with_table_indices(storage, e, std::index_sequence_for<CTEs...>{});
         }
 
     }
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 874e9852c..714aa236e 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -254,15 +254,15 @@ namespace sqlite_orm {
         /**
          *  Expression with CTEs attached.
          */
-        template<class E, class CTE>
+        template<class E, class... CTEs>
         struct with_t : with_string {
-            using cte_type = std::tuple<CTE>;
+            using cte_type = std::tuple<CTEs...>;
             using expression_type = E;
 
             cte_type cte;
             expression_type expression;
 
-            with_t(std::tuple<CTE> cte, expression_type expression) :
+            with_t(std::tuple<CTEs...> cte, expression_type expression) :
                 cte{move(cte)}, expression{std::move(expression)} {
                 this->expression.highest_level = true;
             }
@@ -462,16 +462,16 @@ namespace sqlite_orm {
     }
 
     // tuple of CTEs
-    template<class E, class Label, class CTE>
-    internal::with_t<E, internal::common_table_expression<Label, CTE>>
-    with(std::tuple<internal::common_table_expression<Label, CTE>> cte, E expression) {
+    template<class E, class... Labels, class... Selects>
+    internal::with_t<E, internal::common_table_expression<Labels, Selects>...>
+    with(std::tuple<internal::common_table_expression<Labels, Selects>...> cte, E expression) {
         return {move(cte), std::move(expression)};
     }
-    
+
     // a single CTE
-    template<class E, class Label, class CTE>
-    internal::with_t<E, internal::common_table_expression<Label, CTE>>
-    with(internal::common_table_expression<Label, CTE> cte, E expression) {
+    template<class E, class Label, class Select>
+    internal::with_t<E, internal::common_table_expression<Label, Select>>
+    with(internal::common_table_expression<Label, Select> cte, E expression) {
         return {std::make_tuple(move(cte)), std::move(expression)};
     }
 
diff --git a/dev/storage.h b/dev/storage.h
index bbf2daf6f..e8c681753 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -915,9 +915,9 @@ namespace sqlite_orm {
                 }
             }
 
-            template<class E, class CTE>
-            friend prepared_statement_t<with_t<E, CTE>> prepare_with_cte(self&& storage, with_t<E, CTE> ast) {
-                return storage.prepare_impl<with_t<E, CTE>>(std::move(ast));
+            template<class E, class... CTEs>
+            friend prepared_statement_t<with_t<E, CTEs...>> prepare_with_cte(self&& storage, with_t<E, CTEs...> ast) {
+                return storage.prepare_impl<with_t<E, CTEs...>>(std::move(ast));
             }
 
           public:
@@ -985,9 +985,9 @@ namespace sqlite_orm {
                 return this->impl.table_exists(tableName, con.get());
             }
 
-            template<class E, class CTE>
-            typename std::enable_if<is_base_of_template<E, select_t>::value, prepared_statement_t<with_t<E, CTE>>>::type
-            prepare(with_t<E, CTE> ast) {
+            template<class E, class... CTEs>
+            typename std::enable_if<is_base_of_template<E, select_t>::value, prepared_statement_t<with_t<E, CTEs...>>>::type
+            prepare(with_t<E, CTEs...> ast) {
                 auto cte = make_cte_storage(*this, ast);
                 return prepare_with_cte(std::move(cte), std::move(ast));
             }
@@ -1541,8 +1541,8 @@ namespace sqlite_orm {
                 return res;
             }
 
-            template<class CTE, class T, class... Args, class R = typename column_result_t<self, T>::type>
-            std::vector<R> execute(const prepared_statement_t<with_t<select_t<T, Args...>, CTE>>& statement) {
+            template<class... CTEs, class T, class... Args, class R = typename column_result_t<self, T>::type>
+            std::vector<R> execute(const prepared_statement_t<with_t<select_t<T, Args...>, CTEs...>>& statement) {
                 return _execute_select<R>(statement);
             }
 

From 0a9624c3c9af8b2406c57b33261424f92462e2b5 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 8 Jan 2022 22:07:12 +0200
Subject: [PATCH 004/161] Included util.h in storage.h

---
 dev/storage.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/dev/storage.h b/dev/storage.h
index e8c681753..f785c2dd7 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -49,6 +49,7 @@
 #include "object_from_column_builder.h"
 #include "table.h"
 #include "column.h"
+#include "util.h"
 
 namespace sqlite_orm {
 

From 5c3d3aad0f0087eebe9b549bf47a8a4d5bc562fb Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 9 Jan 2022 00:08:10 +0200
Subject: [PATCH 005/161] ad hoc storage implementation for expression

---
 dev/alias.h                  |  5 ++--
 dev/ast_iterator.h           |  4 ++--
 dev/cte.h                    |  7 ++----
 dev/cxx_polyfill.h           |  4 ----
 dev/statement_serializator.h | 12 +++++-----
 dev/storage.h                | 45 ++++++++++++++++++------------------
 dev/storage_base.h           | 25 ++++----------------
 dev/storage_impl.h           | 30 ++++++++++++------------
 8 files changed, 54 insertions(+), 78 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index b0af158f6..0e790c5a0 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -70,8 +70,9 @@ namespace sqlite_orm {
             using expression_type = E;
 
             expression_type expression;
-            // whether to only serialize the alias
-            bool serializeAlias = false;
+            // Whether to only serialize the alias;
+            // this is used together with refed_as() when selecting an aliased column from a subselect.
+            bool serializeAliasOnly = false;
         };
 
         template<class T>
diff --git a/dev/ast_iterator.h b/dev/ast_iterator.h
index da5ee67ef..969dc4043 100644
--- a/dev/ast_iterator.h
+++ b/dev/ast_iterator.h
@@ -192,7 +192,7 @@ namespace sqlite_orm {
 
         template<class CTE>
         struct ast_iterator<CTE,
-                            polyfill::enable_if_t<polyfill::is_specialization_of_v<CTE, common_table_expression>>> {
+                            std::enable_if_t<polyfill::is_specialization_of_v<CTE, common_table_expression>>> {
             using node_type = CTE;
 
             template<class L>
@@ -202,7 +202,7 @@ namespace sqlite_orm {
         };
 
         template<class With>
-        struct ast_iterator<With, polyfill::enable_if_t<polyfill::is_specialization_of_v<With, with_t>>> {
+        struct ast_iterator<With, std::enable_if_t<polyfill::is_specialization_of_v<With, with_t>>> {
             using node_type = With;
 
             template<class L>
diff --git a/dev/cte.h b/dev/cte.h
index 680bebbe3..91c22793e 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -100,8 +100,6 @@ namespace sqlite_orm {
             }
         };
 
-
-
         // F = field_type
         template<typename Label, typename F>
         struct create_column_results {
@@ -171,7 +169,7 @@ namespace sqlite_orm {
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type& /*expression*/, const Ctx& /*context*/) const {
-                return T::get();
+                return {T::get()};
             }
         };
 
@@ -268,7 +266,7 @@ namespace sqlite_orm {
         decltype(auto) make_cte_storage_with_table_indices(const Strg& storage,
                                                            const with_t<E, CTEs...>& e,
                                                            std::index_sequence<TIs...>) {
-            return storage_cat(
+            return storage_impl_cat(
                 storage,
                 make_cte_table<
                     create_column_results_t<typename CTEs::label_type,
@@ -281,6 +279,5 @@ namespace sqlite_orm {
         decltype(auto) make_cte_storage(const Strg& storage, const with_t<E, CTEs...>& e) {
             return make_cte_storage_with_table_indices(storage, e, std::index_sequence_for<CTEs...>{});
         }
-
     }
 }
diff --git a/dev/cxx_polyfill.h b/dev/cxx_polyfill.h
index 86ab8ce31..89776b814 100644
--- a/dev/cxx_polyfill.h
+++ b/dev/cxx_polyfill.h
@@ -13,12 +13,8 @@ namespace sqlite_orm {
 
             template<bool v>
             using bool_constant = std::integral_constant<bool, v>;
-
-            template<bool C, typename T>
-            using enable_if_t = typename std::enable_if<C, T>::type;
 #else
             using std::bool_constant;
-            using std::enable_if_t;
             using std::void_t;
 #endif
 
diff --git a/dev/statement_serializator.h b/dev/statement_serializator.h
index ba3cd7353..d369bd96c 100644
--- a/dev/statement_serializator.h
+++ b/dev/statement_serializator.h
@@ -211,11 +211,11 @@ namespace sqlite_orm {
 
             template<class C>
             std::string operator()(const statement_type& c, const C& context) const {
-                auto tableAliasString = alias_extractor<T>::get();
-                if(c.serializeAlias) {
-                    return tableAliasString;
+                auto aliasString = alias_extractor<T>::get();
+                if(c.serializeAliasOnly) {
+                    return aliasString;
                 } else {
-                    return serialize(c.expression, context) + " AS " + tableAliasString;
+                    return serialize(c.expression, context) + " AS " + aliasString;
                 }
             }
         };
@@ -479,7 +479,7 @@ namespace sqlite_orm {
         template<class CTE>
         struct statement_serializator<
             CTE,
-            polyfill::enable_if_t<polyfill::is_specialization_of_v<CTE, common_table_expression>>> {
+            std::enable_if_t<polyfill::is_specialization_of_v<CTE, common_table_expression>>> {
             using statement_type = CTE;
 
             template<class Ctx>
@@ -495,7 +495,7 @@ namespace sqlite_orm {
         };
 
         template<class With>
-        struct statement_serializator<With, polyfill::enable_if_t<polyfill::is_specialization_of_v<With, with_t>>> {
+        struct statement_serializator<With, std::enable_if_t<polyfill::is_specialization_of_v<With, with_t>>> {
             using statement_type = With;
 
             template<class Ctx>
diff --git a/dev/storage.h b/dev/storage.h
index f785c2dd7..3b6b3393c 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -73,8 +73,6 @@ namespace sqlite_orm {
 
             storage_t(const storage_t&) = default;
 
-            storage_t(const storage_base& base, const Ts&... tables) : storage_base{base, true}, impl{tables...} {}
-
           protected:
             impl_type impl;
 
@@ -91,12 +89,9 @@ namespace sqlite_orm {
             friend struct serializator_context_builder;
 
             template<typename... CTETables>
-            friend storage_t<CTETables..., Ts...> storage_cat(const storage_t<Ts...>& storage,
-                                                              CTETables&&... cteTables) {
-                using storage_type = storage_t<CTETables..., Ts...>;
-                return storage_type(storage,
-                                    std::forward<CTETables>(cteTables)...,
-                                    storage.get_impl<typename Ts::object_type>().table...);
+            friend storage_impl<CTETables..., Ts...> storage_impl_cat(const storage_t<Ts...>& storage,
+                                                                      CTETables&&... cteTables) {
+                return {std::forward<CTETables>(cteTables)..., storage.impl.get_impl<typename Ts::object_type>().table...};
             }
 
             template<class I>
@@ -561,10 +556,10 @@ namespace sqlite_orm {
             }
 
             template<class T>
-            typename std::enable_if<is_prepared_statement<T>::value, std::string>::type
-            dump(const T& preparedStatement) const {
-                using context_t = serializator_context<impl_type>;
-                context_t context{this->impl};
+            std::enable_if_t<is_prepared_statement<T>::value, std::string> dump(const T& preparedStatement) const {
+                const auto& impl = impl_for_expression(preparedStatement.expression);
+                using context_t = serializator_context<decltype(impl)>;
+                context_t context{impl};
                 return serialize(preparedStatement.expression, context);
             }
 
@@ -898,13 +893,23 @@ namespace sqlite_orm {
                 perform_void_exec(db, ss.str());
             }
 
+            template<class S>
+            const impl_type& impl_for_expression(const S& /*statement*/) const {
+                return this->impl;
+            }
+            template<class... CTEs, class E>
+            decltype(auto) impl_for_expression(const with_t<E, CTEs...>& statement) const {
+                return make_cte_storage(*this, statement);
+            }
+
             template<typename S>
             prepared_statement_t<S> prepare_impl(S statement) {
                 auto con = this->get_connection();
                 sqlite3_stmt* stmt;
                 auto db = con.get();
-                using context_t = serializator_context<impl_type>;
-                context_t context{this->impl};
+                const auto& impl = impl_for_expression(statement);
+                using context_t = serializator_context<decltype(impl)>;
+                context_t context{impl};
                 context.skip_table_name = false;
                 context.replace_bindable_with_question = true;
                 auto query = serialize(statement, context);
@@ -916,11 +921,6 @@ namespace sqlite_orm {
                 }
             }
 
-            template<class E, class... CTEs>
-            friend prepared_statement_t<with_t<E, CTEs...>> prepare_with_cte(self&& storage, with_t<E, CTEs...> ast) {
-                return storage.prepare_impl<with_t<E, CTEs...>>(std::move(ast));
-            }
-
           public:
             /**
              *  This is a cute function used to replace migration up/down functionality.
@@ -987,10 +987,9 @@ namespace sqlite_orm {
             }
 
             template<class E, class... CTEs>
-            typename std::enable_if<is_base_of_template<E, select_t>::value, prepared_statement_t<with_t<E, CTEs...>>>::type
-            prepare(with_t<E, CTEs...> ast) {
-                auto cte = make_cte_storage(*this, ast);
-                return prepare_with_cte(std::move(cte), std::move(ast));
+            std::enable_if_t<is_base_of_template<E, select_t>::value, prepared_statement_t<with_t<E, CTEs...>>>
+            prepare(with_t<E, CTEs...> sel) {
+                return prepare_impl<with_t<E, CTEs...>>(std::move(sel));
             }
 
             template<class T, class... Args>
diff --git a/dev/storage_base.h b/dev/storage_base.h
index fc140c176..3c676dbd3 100644
--- a/dev/storage_base.h
+++ b/dev/storage_base.h
@@ -459,8 +459,8 @@ namespace sqlite_orm {
             storage_base(const std::string& filename_, int foreignKeysCount) :
                 pragma(std::bind(&storage_base::get_connection, this)),
                 limit(std::bind(&storage_base::get_connection, this)),
-                inMemory(filename_.empty() || filename_ == ":memory:"), connection(new connection_holder(filename_)),
-                cachedForeignKeysCount(foreignKeysCount) {
+                inMemory(filename_.empty() || filename_ == ":memory:"),
+                connection(std::make_unique<connection_holder>(filename_)), cachedForeignKeysCount(foreignKeysCount) {
                 if(this->inMemory) {
                     this->connection->retain();
                     this->on_open_internal(this->connection->get());
@@ -470,7 +470,7 @@ namespace sqlite_orm {
             storage_base(const storage_base& other) :
                 on_open(other.on_open), pragma(std::bind(&storage_base::get_connection, this)),
                 limit(std::bind(&storage_base::get_connection, this)), inMemory(other.inMemory),
-                connection(new connection_holder(other.connection->filename)),
+                connection(std::make_unique<connection_holder>(other.connection->filename)),
                 cachedForeignKeysCount(other.cachedForeignKeysCount) {
                 if(this->inMemory) {
                     this->connection->retain();
@@ -478,12 +478,6 @@ namespace sqlite_orm {
                 }
             }
 
-            storage_base(const storage_base& other, bool /*shareConnection*/) :
-                on_open{other.on_open}, pragma{std::bind(&storage_base::get_connection, this)},
-                limit{std::bind(&storage_base::get_connection, this)}, inMemory{other.inMemory},
-                connection{other.connection.get(), connection_deleter{false /*no ownership*/}},
-                cachedForeignKeysCount{other.cachedForeignKeysCount} {}
-
             ~storage_base() {
                 if(this->isOpenedForever) {
                     this->connection->release();
@@ -733,20 +727,9 @@ namespace sqlite_orm {
                 return res;
             }
 
-            //  enables turning a unique_ptr into an observing smart pointer
-            struct connection_deleter {
-                const bool ownership = true;
-
-                void operator()(connection_holder* holder) const {
-                    if(this->ownership) {
-                        delete holder;
-                    }
-                }
-            };
-
             const bool inMemory;
             bool isOpenedForever = false;
-            std::unique_ptr<connection_holder, connection_deleter> connection;
+            std::unique_ptr<connection_holder> connection;
             std::map<std::string, collating_function> collatingFunctions;
             const int cachedForeignKeysCount;
             std::function<int(int)> _busy_handler;
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 873a2d7b1..56e78f9ba 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -214,7 +214,7 @@ namespace sqlite_orm {
             template<class O,
                      class HH = typename H::object_type,
                      class Label = typename H::cte_label_type,
-                     polyfill::enable_if_t<std::is_void<Label>::value, int> = 0>
+                     std::enable_if_t<std::is_void<Label>::value, int> = 0>
             const auto& get_impl(typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) const {
                 return *this;
             }
@@ -222,7 +222,7 @@ namespace sqlite_orm {
             template<class O,
                      class HH = typename H::object_type,
                      class Label = typename H::cte_label_type,
-                     polyfill::enable_if_t<std::is_void<Label>::value, int> = 0>
+                     std::enable_if_t<std::is_void<Label>::value, int> = 0>
             const auto& get_impl(typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) const {
                 return this->super::template get_impl<O>();
             }
@@ -238,43 +238,43 @@ namespace sqlite_orm {
             template<class O,
                      class HH = typename H::object_type,
                      class Label = typename H::cte_label_type,
-                     polyfill::enable_if_t<std::is_void<Label>::value, int> = 0>
+                     std::enable_if_t<std::is_void<Label>::value, int> = 0>
             auto& get_impl(typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) {
                 return this->super::template get_impl<O>();
             }
 
             template<class Label,
                      class HL = typename H::cte_label_type,
-                     polyfill::enable_if_t<!std::is_void<HL>::value, int> = 0>
-            const auto& get_impl(polyfill::enable_if_t<std::is_same<Label, HL>::value>* = nullptr) const {
+                     std::enable_if_t<!std::is_void<HL>::value, int> = 0>
+            const auto& get_impl(std::enable_if_t<std::is_same<Label, HL>::value>* = nullptr) const {
                 return *this;
             }
 
             template<class Label,
                      class HL = typename H::cte_label_type,
-                     polyfill::enable_if_t<!std::is_void<HL>::value, int> = 0>
-            const auto& get_impl(polyfill::enable_if_t<!std::is_same<Label, HL>::value>* = nullptr) const {
+                     std::enable_if_t<!std::is_void<HL>::value, int> = 0>
+            const auto& get_impl(std::enable_if_t<!std::is_same<Label, HL>::value>* = nullptr) const {
                 return this->super::template get_impl<Label>();
             }
 
             template<class Label,
                      class HL = typename H::cte_label_type,
-                     polyfill::enable_if_t<!std::is_void<HL>::value, int> = 0>
-            auto& get_impl(polyfill::enable_if_t<std::is_same<Label, HL>::value>* = nullptr) {
+                     std::enable_if_t<!std::is_void<HL>::value, int> = 0>
+            auto& get_impl(std::enable_if_t<std::is_same<Label, HL>::value>* = nullptr) {
                 return *this;
             }
 
             template<class Label,
                      class HL = typename H::cte_label_type,
-                     polyfill::enable_if_t<!std::is_void<HL>::value, int> = 0>
-            auto& get_impl(polyfill::enable_if_t<!std::is_same<Label, HL>::value>* = nullptr) {
+                     std::enable_if_t<!std::is_void<HL>::value, int> = 0>
+            auto& get_impl(std::enable_if_t<!std::is_same<Label, HL>::value>* = nullptr) {
                 return this->super::template get_impl<Label>();
             }
 
             template<class O,
                      class HH = typename H::object_type,
                      class Label = typename H::cte_label_type,
-                     polyfill::enable_if_t<std::is_void<Label>::value, int> = 0>
+                     std::enable_if_t<std::is_void<Label>::value, int> = 0>
             const auto* find_table(typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) const {
                 return &this->table;
             }
@@ -282,21 +282,21 @@ namespace sqlite_orm {
             template<class O,
                      class HH = typename H::object_type,
                      class Label = typename H::cte_label_type,
-                     polyfill::enable_if_t<std::is_void<Label>::value, int> = 0>
+                     std::enable_if_t<std::is_void<Label>::value, int> = 0>
             const auto* find_table(typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) const {
                 return this->super::template find_table<O>();
             }
 
             template<class Label,
                      class HL = typename H::cte_label_type,
-                     polyfill::enable_if_t<!std::is_void<HL>::value, int> = 0>
+                     std::enable_if_t<!std::is_void<HL>::value, int> = 0>
             const auto* find_table(typename std::enable_if<std::is_same<Label, HL>::value>::type* = nullptr) const {
                 return &this->table;
             }
 
             template<class Label,
                      class HL = typename H::cte_label_type,
-                     polyfill::enable_if_t<!std::is_void<HL>::value, int> = 0>
+                     std::enable_if_t<!std::is_void<HL>::value, int> = 0>
             const auto* find_table(typename std::enable_if<!std::is_same<Label, HL>::value>::type* = nullptr) const {
                 return this->super::template find_table<Label>();
             }

From 0ef34ff0a9148c4e368d39fe5439819843b07767 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 9 Jan 2022 23:35:43 +0200
Subject: [PATCH 006/161] Improve readability

---
 dev/cte.h                    | 70 ++++++++++++++++++------------------
 dev/select_constraints.h     |  2 +-
 dev/statement_serializator.h |  7 ++--
 dev/storage.h                |  3 +-
 dev/storage_impl.h           | 24 +++++++++----
 dev/table.h                  | 20 +++++++++--
 dev/type_traits.h            |  5 ++-
 7 files changed, 81 insertions(+), 50 deletions(-)

diff --git a/dev/cte.h b/dev/cte.h
index 91c22793e..5b364dba3 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -60,7 +60,7 @@ namespace sqlite_orm {
     struct cte_label {
         static constexpr char str[] = {C, Cs..., '\0'};
 
-        static const char* label() {
+        static constexpr const char* label() {
             return str;
         }
 
@@ -114,26 +114,26 @@ namespace sqlite_orm {
         template<typename Label, typename... Fs>
         using create_column_results_t = typename create_column_results<Label, Fs...>::type;
 
-        template<typename O, size_t I>
+        template<typename O, size_t CI>
         struct create_cte_column {
             using object_type = O;
-            using field_type = std::tuple_element_t<I, typename O::base>;
-            using getter_type = decltype(&O::template cget<I>);
-            using setter_type = decltype(&O::template set<I>);
+            using field_type = std::tuple_element_t<CI, typename O::base>;
+            using getter_type = decltype(&O::template cget<CI>);
+            using setter_type = decltype(&O::template set<CI>);
 
             using type = column_t<object_type, field_type, getter_type, setter_type>;
         };
 
-        template<typename O, size_t I>
-        using create_cte_column_t = typename create_cte_column<O, I>::type;
+        template<typename O, size_t CI>
+        using create_cte_column_t = typename create_cte_column<O, CI>::type;
 
         template<typename O, typename IdxSeq>
         struct create_cte_table;
 
-        template<typename Label, typename... Fs, size_t... Is>
-        struct create_cte_table<column_results<Label, Fs...>, std::index_sequence<Is...>> {
+        template<typename Label, typename... Fs, size_t... CIs>
+        struct create_cte_table<column_results<Label, Fs...>, std::index_sequence<CIs...>> {
             using object_type = column_results<Label, Fs...>;
-            using table_type = table_t<object_type, true, create_cte_column_t<object_type, Is>...>;
+            using table_type = table_t<object_type, true, create_cte_column_t<object_type, CIs>...>;
 
             using type = table_type;
         };
@@ -163,19 +163,19 @@ namespace sqlite_orm {
             return serializator(t, context);
         }
 
-        template<class T, class E>
-        struct cte_column_names_collector<as_t<T, E>, void> {
-            using expression_type = as_t<T, E>;
+        template<class As>
+        struct cte_column_names_collector<As, match_specialization_of<As, as_t>> {
+            using expression_type = As;
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type& /*expression*/, const Ctx& /*context*/) const {
-                return {T::get()};
+                return {As::alias_type::get()};
             }
         };
 
-        template<class T>
-        struct cte_column_names_collector<std::reference_wrapper<T>, void> {
-            using expression_type = std::reference_wrapper<T>;
+        template<class RefWrapper>
+        struct cte_column_names_collector<RefWrapper, match_specialization_of<RefWrapper, std::reference_wrapper>> {
+            using expression_type = RefWrapper;
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type& expression, const Ctx& context) const {
@@ -183,30 +183,32 @@ namespace sqlite_orm {
             }
         };
 
-        template<class T>
-        struct cte_column_names_collector<asterisk_t<T>, void> {
-            using expression_type = asterisk_t<T>;
+        template<class Asterisk>
+        struct cte_column_names_collector<Asterisk, match_specialization_of<Asterisk, asterisk_t>> {
+            using expression_type = Asterisk;
+            using T = typename Asterisk::type;
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type&, const Ctx& context) const {
-                auto& strgImpl = context.impl.get_impl<T>();
+                auto& tImpl = context.impl.get_impl<T>();
 
                 std::vector<std::string> columnNames;
-                columnNames.reserve(size_t(strgImpl.table.elements_count));
+                columnNames.reserve(size_t(tImpl.table.elements_count));
 
-                strgImpl.table.for_each_column([&columnNames](const basic_column& column) {
+                tImpl.table.for_each_column([&columnNames](const basic_column& column) {
                     columnNames.push_back(column.name);
                 });
                 return columnNames;
             }
         };
 
-        template<class T>
-        struct cte_column_names_collector<object_t<T>, void>;
+        // No CTE for object expressions.
+        template<class Object>
+        struct cte_column_names_collector<Object, match_specialization_of<Object, object_t>>;
 
-        template<class... Args>
-        struct cte_column_names_collector<columns_t<Args...>, void> {
-            using expression_type = columns_t<Args...>;
+        template<class Columns>
+        struct cte_column_names_collector<Columns, match_specialization_of<Columns, columns_t>> {
+            using expression_type = Columns;
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type& cols, const Ctx& context) const {
@@ -239,7 +241,7 @@ namespace sqlite_orm {
 
         template<typename O, typename Strg, typename CTE, size_t... CIs>
         create_cte_table_t<O, typename O::index_sequence>
-        make_cte_table_with_column_indices(const Strg& storage, const CTE& cte, std::index_sequence<CIs...>) {
+        make_cte_table_using_column_indices(const Strg& storage, const CTE& cte, std::index_sequence<CIs...>) {
             std::vector<std::string> columnNames = collect_cte_column_names(storage, cte.expression);
             assert(columnNames.size() == O::index_sequence::size());
             // unquote
@@ -259,13 +261,13 @@ namespace sqlite_orm {
 
         template<typename O, typename Strg, typename CTE>
         create_cte_table_t<O, typename O::index_sequence> make_cte_table(const Strg& storage, const CTE& cte) {
-            return make_cte_table_with_column_indices<O>(storage, cte, typename O::index_sequence{});
+            return make_cte_table_using_column_indices<O>(storage, cte, typename O::index_sequence{});
         }
 
         template<class Strg, class E, class... CTEs, size_t... TIs>
-        decltype(auto) make_cte_storage_with_table_indices(const Strg& storage,
-                                                           const with_t<E, CTEs...>& e,
-                                                           std::index_sequence<TIs...>) {
+        decltype(auto) make_cte_storage_using_table_indices(const Strg& storage,
+                                                            const with_t<E, CTEs...>& e,
+                                                            std::index_sequence<TIs...>) {
             return storage_impl_cat(
                 storage,
                 make_cte_table<
@@ -277,7 +279,7 @@ namespace sqlite_orm {
 
         template<class Strg, class E, class... CTEs>
         decltype(auto) make_cte_storage(const Strg& storage, const with_t<E, CTEs...>& e) {
-            return make_cte_storage_with_table_indices(storage, e, std::index_sequence_for<CTEs...>{});
+            return make_cte_storage_using_table_indices(storage, e, std::index_sequence_for<CTEs...>{});
         }
     }
 }
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 714aa236e..afc878a5e 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -252,7 +252,7 @@ namespace sqlite_orm {
         };
 
         /**
-         *  Expression with CTEs attached.
+         *  Expression with prepended CTEs.
          */
         template<class E, class... CTEs>
         struct with_t : with_string {
diff --git a/dev/statement_serializator.h b/dev/statement_serializator.h
index d369bd96c..102f1fe02 100644
--- a/dev/statement_serializator.h
+++ b/dev/statement_serializator.h
@@ -10,6 +10,7 @@
 #endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
 
 #include "cxx_polyfill.h"
+#include "type_traits.h"
 #include "core_functions.h"
 #include "constraints.h"
 #include "conditions.h"
@@ -477,9 +478,7 @@ namespace sqlite_orm {
         };
 
         template<class CTE>
-        struct statement_serializator<
-            CTE,
-            std::enable_if_t<polyfill::is_specialization_of_v<CTE, common_table_expression>>> {
+        struct statement_serializator<CTE, match_specialization_of<CTE, common_table_expression>> {
             using statement_type = CTE;
 
             template<class Ctx>
@@ -495,7 +494,7 @@ namespace sqlite_orm {
         };
 
         template<class With>
-        struct statement_serializator<With, std::enable_if_t<polyfill::is_specialization_of_v<With, with_t>>> {
+        struct statement_serializator<With, match_specialization_of<With, with_t>> {
             using statement_type = With;
 
             template<class Ctx>
diff --git a/dev/storage.h b/dev/storage.h
index 3b6b3393c..c134c6e8b 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -91,7 +91,8 @@ namespace sqlite_orm {
             template<typename... CTETables>
             friend storage_impl<CTETables..., Ts...> storage_impl_cat(const storage_t<Ts...>& storage,
                                                                       CTETables&&... cteTables) {
-                return {std::forward<CTETables>(cteTables)..., storage.impl.get_impl<typename Ts::object_type>().table...};
+                return {std::forward<CTETables>(cteTables)...,
+                        storage.impl.get_impl<typename Ts::object_type>().table...};
             }
 
             template<class I>
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 56e78f9ba..3cfb7a70a 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -243,28 +243,36 @@ namespace sqlite_orm {
                 return this->super::template get_impl<O>();
             }
 
-            template<class Label,
+            // Lookup by (CTE) label
+            template<class T,
+                     class Label = detected_cte_label_t<T>,
                      class HL = typename H::cte_label_type,
                      std::enable_if_t<!std::is_void<HL>::value, int> = 0>
             const auto& get_impl(std::enable_if_t<std::is_same<Label, HL>::value>* = nullptr) const {
                 return *this;
             }
 
-            template<class Label,
+            // Lookup by (CTE) label
+            template<class T,
+                     class Label = detected_cte_label_t<T>,
                      class HL = typename H::cte_label_type,
                      std::enable_if_t<!std::is_void<HL>::value, int> = 0>
             const auto& get_impl(std::enable_if_t<!std::is_same<Label, HL>::value>* = nullptr) const {
                 return this->super::template get_impl<Label>();
             }
 
-            template<class Label,
+            // Lookup by (CTE) label
+            template<class T,
+                     class Label = detected_cte_label_t<T>,
                      class HL = typename H::cte_label_type,
                      std::enable_if_t<!std::is_void<HL>::value, int> = 0>
             auto& get_impl(std::enable_if_t<std::is_same<Label, HL>::value>* = nullptr) {
                 return *this;
             }
 
-            template<class Label,
+            // Lookup by (CTE) label
+            template<class T,
+                     class Label = detected_cte_label_t<T>,
                      class HL = typename H::cte_label_type,
                      std::enable_if_t<!std::is_void<HL>::value, int> = 0>
             auto& get_impl(std::enable_if_t<!std::is_same<Label, HL>::value>* = nullptr) {
@@ -287,14 +295,18 @@ namespace sqlite_orm {
                 return this->super::template find_table<O>();
             }
 
-            template<class Label,
+            // Lookup by (CTE) label
+            template<class T,
+                     class Label = detected_cte_label_t<T>,
                      class HL = typename H::cte_label_type,
                      std::enable_if_t<!std::is_void<HL>::value, int> = 0>
             const auto* find_table(typename std::enable_if<std::is_same<Label, HL>::value>::type* = nullptr) const {
                 return &this->table;
             }
 
-            template<class Label,
+            // Lookup by (CTE) label
+            template<class T,
+                     class Label = detected_cte_label_t<T>,
                      class HL = typename H::cte_label_type,
                      std::enable_if_t<!std::is_void<HL>::value, int> = 0>
             const auto* find_table(typename std::enable_if<!std::is_same<Label, HL>::value>::type* = nullptr) const {
diff --git a/dev/table.h b/dev/table.h
index db89ecc79..8898006ac 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -20,8 +20,20 @@ namespace sqlite_orm {
 
     namespace internal {
 
+        /**
+         *  A mapped data type's CTE alias by which a CTE table descriptor can be found.
+         */
+        template<typename O>
+        using cte_label_t = typename O::cte_label_type;
+
+        template<typename O>
+        using cte_label_of_t = polyfill::detected_or_t<void, cte_label_t, O>;
+
+        /**
+         *  A data type's CTE alias, otherwise T itself is used as a CTE alias.
+         */
         template<typename T>
-        using cte_label_t = typename T::cte_label_type;
+        using detected_cte_label_t = polyfill::detected_or_t<T, cte_label_t, T>;
 
         struct basic_table {
 
@@ -32,13 +44,15 @@ namespace sqlite_orm {
         };
 
         /**
-         *  Table class.
+         *  Table descriptor.
+         * 
+         *  Can be either for a table mapped to storage or for a common table expression (CTE).
          */
         template<class O, bool WithoutRowId, class... Cs>
         struct table_t : basic_table {
             using super = basic_table;
             using object_type = O;
-            using cte_label_type = polyfill::detected_or_t<void, cte_label_t, O>;
+            using cte_label_type = cte_label_of_t<O>;
             using elements_type = std::tuple<Cs...>;
 
             static constexpr const int elements_count = static_cast<int>(std::tuple_size<elements_type>::value);
diff --git a/dev/type_traits.h b/dev/type_traits.h
index 775983ee5..accf69987 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -6,5 +6,8 @@
 #include "cxx_polyfill.h"
 
 namespace sqlite_orm {
-    namespace internal {}
+    namespace internal {
+        template<class T, template<typename...> class Primary>
+        using match_specialization_of = std::enable_if_t<polyfill::is_specialization_of_v<T, Primary>>;
+    }
 }

From 31e204f08bc0943eb7c971d6f8c5c8c19a4d4d2b Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Wed, 12 Jan 2022 23:51:11 +0200
Subject: [PATCH 007/161] Curated storage implementation interface

---
 dev/alias.h                  |  19 +++
 dev/column_result.h          |  11 +-
 dev/cte.h                    | 104 ++++++----------
 dev/cte_types.h              |  41 +++++++
 dev/cxx_polyfill.h           |  36 ++++++
 dev/select_constraints.h     |   4 +-
 dev/serializator_context.h   |  20 ---
 dev/statement_serializator.h |  52 ++++----
 dev/storage.h                |  34 +++---
 dev/storage_impl.h           | 231 ++++++++++++-----------------------
 dev/storage_lookup.h         | 168 +++++++++++++++++++++++++
 dev/storage_traits.h         | 111 ++++-------------
 dev/table.h                  |   6 -
 dev/type_traits.h            |  17 ++-
 tests/storage_tests.cpp      |  14 +--
 15 files changed, 484 insertions(+), 384 deletions(-)
 create mode 100644 dev/cte_types.h
 create mode 100644 dev/storage_lookup.h

diff --git a/dev/alias.h b/dev/alias.h
index 0e790c5a0..6d12753eb 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -42,6 +42,16 @@ namespace sqlite_orm {
             alias_column_t(column_type column_) : column(std::move(column_)) {}
         };
 
+        /**
+         *  Column expression with CTE alias attached like 'cte_1.ID'. This is not a column alias
+         */
+        template<class Label>
+        struct cte_alias_column_t {
+            using label_type = Label;
+
+            std::string column;
+        };
+
         template<class T, class SFINAE = void>
         struct alias_extractor;
 
@@ -92,6 +102,15 @@ namespace sqlite_orm {
         return {c};
     }
 
+    /**
+     *  @return column with table alias attached. Place it instead of a column statement in case you need to specify a
+     *  column with table alias prefix like 'a.column'. For more information please look through self_join.cpp example
+     */
+    template<class Label>
+    internal::cte_alias_column_t<Label> cte_column(std::string alias) {
+        return {alias};
+    }
+
     template<class T, class E>
     internal::as_t<T, E> as(E expression) {
         return {std::move(expression)};
diff --git a/dev/column_result.h b/dev/column_result.h
index 71ded29cb..5d6c41023 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -10,6 +10,7 @@
 #include "rowid.h"
 #include "alias.h"
 #include "column.h"
+#include "cte_types.h"
 #include "storage_traits.h"
 #include "function.h"
 
@@ -82,7 +83,7 @@ namespace sqlite_orm {
         };
 
         template<class St, class X, class S>
-        struct column_result_t<St, built_in_function_t<internal::unique_ptr_result_of<X>, S, X>, void> {
+        struct column_result_t<St, built_in_function_t<unique_ptr_result_of<X>, S, X>, void> {
             using type = std::unique_ptr<typename column_result_t<St, X>::type>;
         };
 
@@ -127,7 +128,7 @@ namespace sqlite_orm {
         };
 
         template<class St, class L, class R>
-        struct column_result_t<St, internal::div_t<L, R>, void> {
+        struct column_result_t<St, div_t<L, R>, void> {
             using type = double;
         };
 
@@ -199,6 +200,12 @@ namespace sqlite_orm {
         template<class St, class T, class F>
         struct column_result_t<St, column_pointer<T, F>> : column_result_t<St, F, void> {};
 
+        template<class St, class Label, size_t I>
+        struct column_result_t<St, column_pointer<Label, polyfill::index_constant<I>>>
+            : column_result_t<St,
+                              cte_getter_t<typename storage_pick_impl_t<St, Label>::table_type::object_type, I>,
+                              void> {};
+
         template<class St, class... Args>
         struct column_result_t<St, columns_t<Args...>, void> {
             using type = std::tuple<typename column_result_t<St, typename std::decay<Args>::type>::type...>;
diff --git a/dev/cte.h b/dev/cte.h
index 5b364dba3..926b4bd70 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -11,54 +11,15 @@
 #include "select_constraints.h"
 #include "alias.h"
 #include "table.h"
+#include "cte_types.h"
 #include "storage.h"
 #include "statement_serializator.h"
 
-namespace sqlite_orm {
-    namespace internal {
-        namespace polyfill {
-            template<template<typename...> typename Base, typename... Fs>
-            Base<Fs...>& as_base_cast(Base<Fs...>& base) {
-                return base;
-            }
-            template<template<typename...> typename Base, typename... Fs>
-            const Base<Fs...>& as_base_cast(const Base<Fs...>& base) {
-                return base;
-            }
-            template<template<typename...> typename Base, typename... Fs>
-            Base<Fs...>&& as_base_cast(Base<Fs...>&& base) {
-                return std::move(base);
-            }
-            template<template<typename...> typename Base, typename... Fs>
-            const Base<Fs...>&& as_base_cast(const Base<Fs...>&& base) {
-                return std::move(base);
-            }
-
-            /** @short Deduce template base specialization from a derived type */
-            template<template<typename...> class Base, class Derived>
-            using as_base_cast_t = decltype(as_base_cast<Base>(std::declval<Derived>()));
-
-            template<template<typename...> class Base, class Derived, typename SFINAE = void>
-            struct is_template_base_of : std::false_type {};
-
-            template<template<typename...> class Base, class Derived>
-            struct is_template_base_of<Base, Derived, polyfill::void_t<as_base_cast_t<Base, Derived>>>
-                : std::true_type {};
-
-            template<template<typename...> class Base, class Derived>
-            using is_template_base_of_t = typename is_template_base_of<Base, Derived>::type;
-
-            template<template<typename...> class Base, class Derived>
-            SQLITE_ORM_INLINE_VAR constexpr bool is_template_base_of_v = is_template_base_of<Base, Derived>::value;
-        }
-    }
-}
-
 namespace sqlite_orm {
 
-    template<char C, char... Cs>
+    template<char C, char... Chars>
     struct cte_label {
-        static constexpr char str[] = {C, Cs..., '\0'};
+        static constexpr char str[] = {C, Chars..., '\0'};
 
         static constexpr const char* label() {
             return str;
@@ -79,26 +40,31 @@ namespace sqlite_orm {
     using cte_8 = cte_label<'c', 't', 'e', '_', '8'>;
     using cte_9 = cte_label<'c', 't', 'e', '_', '9'>;
 
+#if __cplusplus >= 201703L  // use of C++17 or higher
     namespace internal {
-        /*
-         *  Tuple data structure for CTEs
-         */
-        template<typename Label, typename... Fs>
-        class column_results : std::tuple<Fs...> {
-          public:
-            using base = std::tuple<Fs...>;
-            using index_sequence = std::index_sequence_for<Fs...>;
-            using cte_label_type = Label;
-
-            template<size_t I>
-            decltype(auto) cget() const noexcept {
-                return std::get<I>(polyfill::as_base_cast<std::tuple>(*this));
+        constexpr size_t _10_pow(size_t n) {
+            if(n == 0) {
+                return 1;
+            } else {
+                return 10 * _10_pow(n - 1);
             }
-            template<size_t I>
-            void set(std::tuple_element_t<I, base> v) noexcept {
-                std::get<I>(polyfill::as_base_cast<std::tuple>(*this)) = std::move(v);
-            }
-        };
+        }
+
+        template<class... Chars, size_t... Is>
+        constexpr size_t n_from_literal(std::index_sequence<Is...>, Chars... chars) {
+            return (((chars - '0') * _10_pow(sizeof...(Is) - 1u - Is /*reversed index sequence*/)) + ...);
+        }
+    }
+
+    // index_constant<> from numeric literal
+    template<char... Chars>
+    [[nodiscard]] constexpr decltype(auto) operator"" _col() {
+        return polyfill::index_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{},
+                                                                 Chars...)>{};
+    }
+#endif
+
+    namespace internal {
 
         // F = field_type
         template<typename Label, typename F>
@@ -117,13 +83,16 @@ namespace sqlite_orm {
         template<typename O, size_t CI>
         struct create_cte_column {
             using object_type = O;
-            using field_type = std::tuple_element_t<CI, typename O::base>;
-            using getter_type = decltype(&O::template cget<CI>);
-            using setter_type = decltype(&O::template set<CI>);
+            using field_type = std::tuple_element_t<CI, typename O::fields_type>;
+            using getter_type = cte_getter_t<O, CI>;
+            using setter_type = cte_setter_t<O, CI>;
 
             using type = column_t<object_type, field_type, getter_type, setter_type>;
         };
 
+        /**
+         *  Metafunction to create a CTE column_t type.
+         */
         template<typename O, size_t CI>
         using create_cte_column_t = typename create_cte_column<O, CI>::type;
 
@@ -138,6 +107,9 @@ namespace sqlite_orm {
             using type = table_type;
         };
 
+        /**
+         *  Metafunction to create a CTE table_t type.
+         */
         template<typename O, typename IdxSeq>
         using create_cte_table_t = typename create_cte_table<O, IdxSeq>::type;
 
@@ -190,7 +162,7 @@ namespace sqlite_orm {
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type&, const Ctx& context) const {
-                auto& tImpl = context.impl.get_impl<T>();
+                auto& tImpl = pick_impl<T>(context.impl);
 
                 std::vector<std::string> columnNames;
                 columnNames.reserve(size_t(tImpl.table.elements_count));
@@ -254,9 +226,7 @@ namespace sqlite_orm {
 
             return create_cte_table_t<O, typename O::index_sequence>{
                 cte.label(),
-                std::make_tuple<>(
-                    make_column<>(columnNames.at(CIs), &(O::template cget<CIs>), &(O::template set<CIs>))...)}
-                .without_rowid();
+                std::make_tuple(make_column<>(columnNames.at(CIs), cte_getter_v<O, CIs>, cte_setter_v<O, CIs>)...)};
         }
 
         template<typename O, typename Strg, typename CTE>
diff --git a/dev/cte_types.h b/dev/cte_types.h
new file mode 100644
index 000000000..d1cef08ee
--- /dev/null
+++ b/dev/cte_types.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <type_traits>
+#include <tuple>
+
+#include "cxx_polyfill.h"
+#include "start_macros.h"
+
+namespace sqlite_orm {
+    namespace internal {
+        /*
+         *  Tuple data structure for CTEs
+         */
+        template<typename Label, typename... Fs>
+        class column_results : std::tuple<Fs...> {
+          public:
+            using fields_type = std::tuple<Fs...>;
+            using index_sequence = std::index_sequence_for<Fs...>;
+            using cte_label_type = Label;
+
+            template<size_t I>
+            decltype(auto) cget() const noexcept {
+                return std::get<I>(polyfill::as_template_base<std::tuple>(*this));
+            }
+            template<size_t I>
+            void set(std::tuple_element_t<I, fields_type> v) noexcept {
+                std::get<I>(polyfill::as_template_base<std::tuple>(*this)) = std::move(v);
+            }
+        };
+
+        template<class O, size_t I>
+        SQLITE_ORM_INLINE_VAR auto cte_getter_v = &(O::template cget<I>);
+        template<class O, size_t I>
+        SQLITE_ORM_INLINE_VAR auto cte_setter_v = &(O::template set<I>);
+
+        template<class O, size_t I>
+        using cte_getter_t = decltype(cte_getter_v<O, I>);
+        template<class O, size_t I>
+        using cte_setter_t = decltype(cte_setter_v<O, I>);
+    }
+}
diff --git a/dev/cxx_polyfill.h b/dev/cxx_polyfill.h
index 89776b814..008ea5385 100644
--- a/dev/cxx_polyfill.h
+++ b/dev/cxx_polyfill.h
@@ -74,6 +74,42 @@ namespace sqlite_orm {
             template<template<class...> class Op, class... Args>
             SQLITE_ORM_INLINE_VAR constexpr bool is_detected_v = is_detected<Op, Args...>::value;
 #endif
+
+            template<template<typename...> typename Base, typename... Fs>
+            Base<Fs...>& as_template_base(Base<Fs...>& base) {
+                return base;
+            }
+            template<template<typename...> typename Base, typename... Fs>
+            const Base<Fs...>& as_template_base(const Base<Fs...>& base) {
+                return base;
+            }
+            template<template<typename...> typename Base, typename... Fs>
+            Base<Fs...>&& as_template_base(Base<Fs...>&& base) {
+                return std::move(base);
+            }
+            template<template<typename...> typename Base, typename... Fs>
+            const Base<Fs...>&& as_template_base(const Base<Fs...>&& base) {
+                return std::move(base);
+            }
+
+            /** @short Deduce template base specialization from a derived type */
+            template<template<typename...> class Base, class Derived>
+            using as_template_base_t = decltype(as_template_base<Base>(std::declval<Derived>()));
+
+            template<template<typename...> class Base, class Derived, typename SFINAE = void>
+            struct is_template_base_of : std::false_type {};
+
+            template<template<typename...> class Base, class Derived>
+            struct is_template_base_of<Base, Derived, polyfill::void_t<as_template_base_t<Base, Derived>>>
+                : std::true_type {};
+
+            template<template<typename...> class Base, class Derived>
+            using is_template_base_of_t = typename is_template_base_of<Base, Derived>::type;
+
+            template<template<typename...> class Base, class Derived>
+            SQLITE_ORM_INLINE_VAR constexpr bool is_template_base_of_v = is_template_base_of<Base, Derived>::value;
         }
     }
+
+    namespace polyfill = internal::polyfill;
 }
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index afc878a5e..4c98e566d 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -468,7 +468,9 @@ namespace sqlite_orm {
         return {move(cte), std::move(expression)};
     }
 
-    // a single CTE
+    /** A single CTE.
+     *  Example : with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
+     */
     template<class E, class Label, class Select>
     internal::with_t<E, internal::common_table_expression<Label, Select>>
     with(internal::common_table_expression<Label, Select> cte, E expression) {
diff --git a/dev/serializator_context.h b/dev/serializator_context.h
index ef67d3fd0..a340ac7cd 100644
--- a/dev/serializator_context.h
+++ b/dev/serializator_context.h
@@ -8,16 +8,6 @@ namespace sqlite_orm {
             bool replace_bindable_with_question = false;
             bool skip_table_name = true;
             bool use_parentheses = true;
-
-            template<class O, class F>
-            const std::string* column_name(F O::*) const {
-                return nullptr;
-            }
-
-            template<class T, class F>
-            const std::string* column_name(const column_pointer<T, F>&) const {
-                return nullptr;
-            }
         };
 
         template<class I>
@@ -27,16 +17,6 @@ namespace sqlite_orm {
             const impl_type& impl;
 
             serializator_context(const impl_type& impl_) : impl(impl_) {}
-
-            template<class O, class F>
-            const std::string* column_name(F O::*memberPointer) const {
-                return this->impl.column_name(memberPointer);
-            }
-
-            template<class T, class F>
-            const std::string* column_name(const column_pointer<T, F>& columnPointer) const {
-                return this->impl.column_name(columnPointer);
-            }
         };
 
         template<class S>
diff --git a/dev/statement_serializator.h b/dev/statement_serializator.h
index 102f1fe02..57f74000d 100644
--- a/dev/statement_serializator.h
+++ b/dev/statement_serializator.h
@@ -63,7 +63,7 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& statement, const C& context) {
                 std::stringstream ss;
                 ss << "excluded.";
-                if(auto columnNamePointer = context.impl.column_name(statement.expression)) {
+                if(auto columnNamePointer = find_column_name(context.impl, statement.expression)) {
                     ss << "\"" << *columnNamePointer << "\"";
                 } else {
                     throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
@@ -290,9 +290,9 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& m, const C& context) const {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
-                    ss << "\"" << context.impl.find_table_name(typeid(O)) << "\".";
+                    ss << "\"" << lookup_table_name<O>(context.impl) << "\".";
                 }
-                if(auto columnnamePointer = context.column_name(m)) {
+                if(auto columnnamePointer = find_column_name(context.impl, m)) {
                     ss << "\"" << *columnnamePointer << "\"";
                 } else {
                     throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
@@ -339,7 +339,7 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& s, const C& context) {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
-                    ss << "'" << context.impl.find_table_name(typeid(O)) << "'.";
+                    ss << "'" << lookup_table_name<O>(context.impl) << "'.";
                 }
                 ss << static_cast<std::string>(s);
                 return ss.str();
@@ -354,7 +354,7 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& s, const C& context) {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
-                    ss << "'" << context.impl.find_table_name(typeid(O)) << "'.";
+                    ss << "'" << lookup_table_name<O>(context.impl) << "'.";
                 }
                 ss << static_cast<std::string>(s);
                 return ss.str();
@@ -369,7 +369,7 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& s, const C& context) {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
-                    ss << "'" << context.impl.find_table_name(typeid(O)) << "'.";
+                    ss << "'" << lookup_table_name<O>(context.impl) << "'.";
                 }
                 ss << static_cast<std::string>(s);
                 return ss.str();
@@ -445,17 +445,17 @@ namespace sqlite_orm {
             }
         };
 
-        template<class T, class F>
-        struct statement_serializator<column_pointer<T, F>, void> {
-            using statement_type = column_pointer<T, F>;
+        template<class O, class F>
+        struct statement_serializator<column_pointer<O, F>, void> {
+            using statement_type = column_pointer<O, F>;
 
             template<class C>
             std::string operator()(const statement_type& c, const C& context) const {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
-                    ss << "'" << context.impl.find_table_name(typeid(T)) << "'.";
+                    ss << "'" << lookup_table_name<O>(context.impl) << "'.";
                 }
-                if(auto columnNamePointer = context.impl.column_name_simple(c.field)) {
+                if(auto columnNamePointer = find_column_name(context.impl, c)) {
                     ss << "\"" << *columnNamePointer << "\"";
                 } else {
                     throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
@@ -793,7 +793,7 @@ namespace sqlite_orm {
                     res += "(";
                     decltype(columnsCount) columnIndex = 0;
                     iterate_tuple(c.columns, [&context, &res, &columnIndex, columnsCount](auto& column) {
-                        if(auto columnNamePointer = context.column_name(column)) {
+                        if(auto columnNamePointer = find_column_name(context.impl, column)) {
                             res += *columnNamePointer;
                             if(columnIndex < columnsCount - 1) {
                                 res += ", ";
@@ -822,7 +822,7 @@ namespace sqlite_orm {
                     res += "(";
                     decltype(columnsCount) columnIndex = 0;
                     iterate_tuple(c.columns, [&context, &res, &columnIndex, columnsCount](auto& column) {
-                        if(auto columnNamePointer = context.column_name(column)) {
+                        if(auto columnNamePointer = find_column_name(context.impl, column)) {
                             res += *columnNamePointer;
                             if(columnIndex < columnsCount - 1) {
                                 res += ", ";
@@ -870,7 +870,7 @@ namespace sqlite_orm {
                 constexpr const size_t columnsCount = std::tuple_size<columns_type_t>::value;
                 columnNames.reserve(columnsCount);
                 iterate_tuple(fk.columns, [&columnNames, &context](auto& v) {
-                    if(auto columnNamePointer = context.impl.column_name(v)) {
+                    if(auto columnNamePointer = find_column_name(context.impl, v)) {
                         columnNames.push_back(*columnNamePointer);
                     } else {
                         columnNames.push_back({});
@@ -891,11 +891,11 @@ namespace sqlite_orm {
                 {
                     using first_reference_t = typename std::tuple_element<0, references_type_t>::type;
                     using first_reference_mapped_type = typename internal::table_type<first_reference_t>::type;
-                    auto refTableName = context.impl.find_table_name(typeid(first_reference_mapped_type));
+                    auto refTableName = lookup_table_name<first_reference_mapped_type>(context.impl);
                     ss << '\'' << refTableName << '\'';
                 }
                 iterate_tuple(fk.references, [&referencesNames, &context](auto& v) {
-                    if(auto columnNamePointer = context.impl.column_name(v)) {
+                    if(auto columnNamePointer = find_column_name(context.impl, v)) {
                         referencesNames.push_back(*columnNamePointer);
                     } else {
                         referencesNames.push_back({});
@@ -1719,7 +1719,7 @@ namespace sqlite_orm {
                     join_iterator<Args...>()([&collector, &context](const auto& c) {
                         using original_join_type = typename std::decay<decltype(c)>::type::join_type::type;
                         using cross_join_type = typename internal::mapped_type_proxy<original_join_type>::type;
-                        auto crossJoinedTableName = context.impl.find_table_name(typeid(cross_join_type));
+                        auto crossJoinedTableName = lookup_table_name<cross_join_type>(context.impl);
                         auto tableAliasString = alias_extractor<original_join_type>::get();
                         std::pair<std::string, std::string> tableNameWithAlias(std::move(crossJoinedTableName),
                                                                                std::move(tableAliasString));
@@ -1795,7 +1795,7 @@ namespace sqlite_orm {
                 using head_t = typename std::tuple_element<0, elements_type>::type::column_type;
                 using indexed_type = typename table_type<head_t>::type;
                 ss << "INDEX IF NOT EXISTS '" << statement.name << "' ON '"
-                   << context.impl.find_table_name(typeid(indexed_type)) << "' (";
+                   << lookup_table_name<indexed_type>(context.impl) << "' (";
                 std::vector<std::string> columnNames;
                 iterate_tuple(statement.elements, [&columnNames, &context](auto& v) {
                     auto columnName = serialize(v, context);
@@ -1827,8 +1827,8 @@ namespace sqlite_orm {
                     using from_type = std::remove_cv_t<std::remove_pointer_t<decltype(itemPointer)>>;
 
                     auto aliasString = alias_extractor<from_type>::get();
-                    ss << "'" << context.impl.get_table_name<typename mapped_type_proxy<from_type>::type>() << "'";
-                    if(aliasString.length()) {
+                    ss << "'" << lookup_table_name<typename mapped_type_proxy<from_type>::type>(context.impl) << "'";
+                    if(!aliasString.empty()) {
                         ss << " '" << aliasString << "'";
                     }
                     if(index < std::tuple_size<tuple>::value - 1) {
@@ -1910,7 +1910,7 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& c, const C& context) const {
                 std::stringstream ss;
                 ss << static_cast<std::string>(c) << " ";
-                ss << " '" << context.impl.find_table_name(typeid(O)) << "'";
+                ss << " '" << lookup_table_name<O>(context.impl) << "'";
                 return ss.str();
             }
         };
@@ -1924,7 +1924,7 @@ namespace sqlite_orm {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " ";
                 auto aliasString = alias_extractor<T>::get();
-                ss << " '" << context.impl.find_table_name(typeid(typename mapped_type_proxy<T>::type)) << "' ";
+                ss << " '" << lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl) << "' ";
                 if(aliasString.length()) {
                     ss << "'" << aliasString << "' ";
                 }
@@ -1956,7 +1956,7 @@ namespace sqlite_orm {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " ";
                 auto aliasString = alias_extractor<T>::get();
-                ss << " '" << context.impl.find_table_name(typeid(typename mapped_type_proxy<T>::type)) << "' ";
+                ss << " '" << lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl) << "' ";
                 if(aliasString.length()) {
                     ss << "'" << aliasString << "' ";
                 }
@@ -1974,7 +1974,7 @@ namespace sqlite_orm {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " ";
                 auto aliasString = alias_extractor<T>::get();
-                ss << " '" << context.impl.find_table_name(typeid(typename mapped_type_proxy<T>::type)) << "' ";
+                ss << " '" << lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl) << "' ";
                 if(aliasString.length()) {
                     ss << "'" << aliasString << "' ";
                 }
@@ -1992,7 +1992,7 @@ namespace sqlite_orm {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " ";
                 auto aliasString = alias_extractor<T>::get();
-                ss << " '" << context.impl.find_table_name(typeid(typename mapped_type_proxy<T>::type)) << "' ";
+                ss << " '" << lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl) << "' ";
                 if(aliasString.length()) {
                     ss << "'" << aliasString << "' ";
                 }
@@ -2009,7 +2009,7 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& c, const C& context) const {
                 std::stringstream ss;
                 ss << static_cast<std::string>(c) << " ";
-                ss << " '" << context.impl.find_table_name(typeid(O)) << "'";
+                ss << " '" << lookup_table_name<O>(context.impl) << "'";
                 return ss.str();
             }
         };
diff --git a/dev/storage.h b/dev/storage.h
index c134c6e8b..0638d2ca3 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -48,6 +48,7 @@
 #include "table_name_collector.h"
 #include "object_from_column_builder.h"
 #include "table.h"
+#include "cte_types.h"
 #include "column.h"
 #include "util.h"
 
@@ -92,7 +93,7 @@ namespace sqlite_orm {
             friend storage_impl<CTETables..., Ts...> storage_impl_cat(const storage_t<Ts...>& storage,
                                                                       CTETables&&... cteTables) {
                 return {std::forward<CTETables>(cteTables)...,
-                        storage.impl.get_impl<typename Ts::object_type>().table...};
+                        pick_impl<typename Ts::object_type>(storage.impl).table...};
             }
 
             template<class I>
@@ -168,7 +169,10 @@ namespace sqlite_orm {
                 using is_without_rowid = std::integral_constant<bool, table_type::is_without_rowid>;
 
                 static_if<is_without_rowid{}>(
-                    [](auto&) {},  // all right. it's a "without_rowid" table
+                    [](auto&) {
+                        static_assert(std::is_void<table_type::cte_label_type>::value,
+                                      "Attempting to execute 'insert' request for a CTE mapping.");
+                    },
                     [](auto& tImpl) {  // unfortunately, this static_assert's can't see any composite keys((
                         std::ignore = tImpl;
                         static_assert(
@@ -185,13 +189,13 @@ namespace sqlite_orm {
             }
 
             template<class O>
-            auto& get_impl() const {
-                return this->impl.template get_impl<O>();
+            storage_pick_impl_t<const self, O>& get_impl() const {
+                return pick_impl<O>(this->impl);
             }
 
             template<class O>
-            auto& get_impl() {
-                return this->impl.template get_impl<O>();
+            storage_pick_impl_t<self, O>& get_impl() {
+                return pick_impl<O>(this->impl);
             }
 
           public:
@@ -789,8 +793,14 @@ namespace sqlite_orm {
             }
 
             template<class F, class O>
-            const std::string* column_name(F O::*memberPointer) const {
-                return this->impl.column_name(memberPointer);
+            [[deprecated("Use the more accurately named function `find_column_name()`")]] const std::string*
+            column_name(F O::*memberPointer) const {
+                return internal::find_column_name(this->impl, memberPointer);
+            }
+
+            template<class F, class O>
+            const std::string* find_column_name(F O::*memberPointer) const {
+                return internal::find_column_name(this->impl, memberPointer);
             }
 
           protected:
@@ -1518,7 +1528,7 @@ namespace sqlite_orm {
                     }
                 });
                 std::vector<R> res;
-                auto tableInfoPointer = this->impl.template find_table<R>();
+                auto tableInfoPointer = lookup_table<R>(this->impl);
                 int stepRes;
                 do {
                     stepRes = sqlite3_step(stmt);
@@ -1750,12 +1760,6 @@ namespace sqlite_orm {
                 return res;
             }
         };  // struct storage_t
-
-        template<class T>
-        struct is_storage : std::false_type {};
-
-        template<class... Ts>
-        struct is_storage<storage_t<Ts...>> : std::true_type {};
     }
 
     template<class... Ts>
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 3cfb7a70a..770c5e3b3 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -139,8 +139,9 @@ namespace sqlite_orm {
 
         template<class H, class... Ts>
         struct storage_impl<H, Ts...> : public storage_impl<Ts...> {
-            using table_type = H;
             using super = storage_impl<Ts...>;
+            using self = storage_impl<H, Ts...>;
+            using table_type = H;
 
             storage_impl(H h, Ts... ts) : super(std::forward<Ts>(ts)...), table(std::move(h)) {}
 
@@ -157,7 +158,7 @@ namespace sqlite_orm {
             /**
              *  Returns foreign keys count in table definition
              */
-            int foreign_keys_count() {
+            int foreign_keys_count() const {
                 auto res = 0;
                 iterate_tuple(this->table.elements, [&res](auto& c) {
                     if(is_foreign_key<typename std::decay<decltype(c)>::type>::value) {
@@ -169,157 +170,24 @@ namespace sqlite_orm {
 
 #endif
 
-            /**
-             *  Is used to get column name by member pointer to a base class.
-             *  Main difference between `column_name` and `column_name_simple` is that
-             *  `column_name` has SFINAE check for type equality but `column_name_simple` has not.
-             */
-            template<class O, class F>
-            const std::string* column_name_simple(F O::*m) const {
-                return this->table.find_column_name(m);
-            }
-
-            /**
-             *  Cute function used to find column name by its type and member pointer. Uses SFINAE to
-             *  skip inequal type O.
-             */
-            template<class O, class F, class HH = typename H::object_type>
-            const std::string* column_name(F O::*m,
-                                           typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) const {
-                return this->table.find_column_name(m);
-            }
-
-            /**
-             *  Opposite version of function defined above. Just calls same function in superclass.
-             */
-            template<class O, class F, class HH = typename H::object_type>
-            const std::string*
-            column_name(F O::*m, typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) const {
-                return this->super::column_name(m);
-            }
-
-            template<class O, class F, class HH = typename H::object_type>
-            const std::string* column_name(const column_pointer<O, F>& c,
-                                           typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) const {
-                return this->column_name_simple(c.field);
-            }
-
-            template<class O, class F, class HH = typename H::object_type>
-            const std::string*
-            column_name(const column_pointer<O, F>& c,
-                        typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) const {
-                return this->super::column_name(c);
-            }
-
-            template<class O,
-                     class HH = typename H::object_type,
-                     class Label = typename H::cte_label_type,
-                     std::enable_if_t<std::is_void<Label>::value, int> = 0>
-            const auto& get_impl(typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) const {
+            template<class Lookup>
+            storage_pick_impl_t<self, Lookup>& get_impl() {
                 return *this;
             }
-
-            template<class O,
-                     class HH = typename H::object_type,
-                     class Label = typename H::cte_label_type,
-                     std::enable_if_t<std::is_void<Label>::value, int> = 0>
-            const auto& get_impl(typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) const {
-                return this->super::template get_impl<O>();
-            }
-
-            template<class O,
-                     class HH = typename H::object_type,
-                     class Label = typename H::cte_label_type,
-                     std::enable_if_t<std::is_void<Label>::value, int> = 0>
-            auto& get_impl(typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) {
+            template<class Lookup>
+            storage_pick_impl_t<const self, Lookup>& get_impl() const {
                 return *this;
             }
 
-            template<class O,
-                     class HH = typename H::object_type,
-                     class Label = typename H::cte_label_type,
-                     std::enable_if_t<std::is_void<Label>::value, int> = 0>
-            auto& get_impl(typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) {
-                return this->super::template get_impl<O>();
-            }
-
-            // Lookup by (CTE) label
-            template<class T,
-                     class Label = detected_cte_label_t<T>,
-                     class HL = typename H::cte_label_type,
-                     std::enable_if_t<!std::is_void<HL>::value, int> = 0>
-            const auto& get_impl(std::enable_if_t<std::is_same<Label, HL>::value>* = nullptr) const {
-                return *this;
-            }
-
-            // Lookup by (CTE) label
-            template<class T,
-                     class Label = detected_cte_label_t<T>,
-                     class HL = typename H::cte_label_type,
-                     std::enable_if_t<!std::is_void<HL>::value, int> = 0>
-            const auto& get_impl(std::enable_if_t<!std::is_same<Label, HL>::value>* = nullptr) const {
-                return this->super::template get_impl<Label>();
-            }
-
-            // Lookup by (CTE) label
-            template<class T,
-                     class Label = detected_cte_label_t<T>,
-                     class HL = typename H::cte_label_type,
-                     std::enable_if_t<!std::is_void<HL>::value, int> = 0>
-            auto& get_impl(std::enable_if_t<std::is_same<Label, HL>::value>* = nullptr) {
-                return *this;
-            }
-
-            // Lookup by (CTE) label
-            template<class T,
-                     class Label = detected_cte_label_t<T>,
-                     class HL = typename H::cte_label_type,
-                     std::enable_if_t<!std::is_void<HL>::value, int> = 0>
-            auto& get_impl(std::enable_if_t<!std::is_same<Label, HL>::value>* = nullptr) {
-                return this->super::template get_impl<Label>();
-            }
-
-            template<class O,
-                     class HH = typename H::object_type,
-                     class Label = typename H::cte_label_type,
-                     std::enable_if_t<std::is_void<Label>::value, int> = 0>
-            const auto* find_table(typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) const {
+            // indirected access to table, for simplified programming
+            const table_type* get_table() const {
                 return &this->table;
             }
 
-            template<class O,
-                     class HH = typename H::object_type,
-                     class Label = typename H::cte_label_type,
-                     std::enable_if_t<std::is_void<Label>::value, int> = 0>
-            const auto* find_table(typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) const {
-                return this->super::template find_table<O>();
-            }
-
-            // Lookup by (CTE) label
-            template<class T,
-                     class Label = detected_cte_label_t<T>,
-                     class HL = typename H::cte_label_type,
-                     std::enable_if_t<!std::is_void<HL>::value, int> = 0>
-            const auto* find_table(typename std::enable_if<std::is_same<Label, HL>::value>::type* = nullptr) const {
-                return &this->table;
-            }
-
-            // Lookup by (CTE) label
-            template<class T,
-                     class Label = detected_cte_label_t<T>,
-                     class HL = typename H::cte_label_type,
-                     std::enable_if_t<!std::is_void<HL>::value, int> = 0>
-            const auto* find_table(typename std::enable_if<!std::is_same<Label, HL>::value>::type* = nullptr) const {
-                return this->super::template find_table<Label>();
-            }
-
-            template<class O>
-            const std::string& get_table_name() const {
-                return this->get_impl<O>().table.name;
-            }
-
             std::string find_table_name(std::type_index ti) const {
-                std::type_index thisTypeIndex{typeid(typename H::object_type)};
+                std::type_index thisTypeIndex{typeid(std::conditional_t<std::is_void<typename H::cte_label_type>::value,
+                                                                        typename H::object_type,
+                                                                        typename H::cte_label_type>)};
                 if(thisTypeIndex == ti) {
                     return this->table.name;
                 } else {
@@ -446,8 +314,6 @@ namespace sqlite_orm {
             }
 
           private:
-            using self = storage_impl<H, Ts...>;
-
             const basic_generated_always::storage_type*
             find_column_generated_storage_type(const std::string& name) const {
                 const basic_generated_always::storage_type* result = nullptr;
@@ -474,6 +340,15 @@ namespace sqlite_orm {
         template<>
         struct storage_impl<> : storage_impl_base {
 
+            template<class Lookup>
+            const storage_impl<>& get_impl() const {
+                static_assert(polyfill::always_false_v<Lookup>, "No such storage implementation");
+            }
+
+            std::nullptr_t get_table() const {
+                return nullptr;
+            }
+
             std::string find_table_name(std::type_index) const {
                 return {};
             }
@@ -481,20 +356,66 @@ namespace sqlite_orm {
             template<class L>
             void for_each(const L&) {}
 
-            int foreign_keys_count() {
+            int foreign_keys_count() const {
                 return 0;
             }
+        };
+    }
+}
 
-            template<class O>
-            const void* find_table() const {
-                return nullptr;
+#include "storage_traits.h"
+
+// interface functions
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
+        const auto* lookup_table(const S& strg) {
+            return find_impl<Lookup>(strg).get_table();
+        }
+
+        template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
+        std::string lookup_table_name(const S& strg) {
+            if(auto* table = lookup_table<Lookup>(strg)) {
+                return table->name;
             }
-        };
 
-        template<class T>
-        struct is_storage_impl : std::false_type {};
+            return {};
+        }
 
-        template<class... Ts>
-        struct is_storage_impl<storage_impl<Ts...>> : std::true_type {};
+        template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
+        const std::string& get_table_name(const S& strg) {
+            return pick_impl<Lookup>(strg).table.name;
+        }
+
+        /**
+         *  Find column name by its type and member pointer.
+         */
+        template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
+        const std::string* find_column_name(const S& strg, F O::*field) {
+            return pick_impl<O>(strg).table.find_column_name(field);
+        }
+
+        /**
+         *  Find column name by its type and member pointer.
+         */
+        template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
+        const std::string* find_column_name(const S& strg, const column_pointer<O, F>& cp) {
+            return pick_impl<O>(strg).table.find_column_name(cp.field);
+        }
+
+        template<class Label, size_t I, class S, satisfies<is_storage_impl, S> = true>
+        constexpr decltype(auto) materialize_column_pointer(const S&,
+                                                            const column_pointer<Label, polyfill::index_constant<I>>&) {
+            using timpl_type = storage_pick_impl_t<S, Label>;
+            return cte_getter_v<typename timpl_type::table_type::object_type, I>;
+        }
+
+        template<class Label, size_t I, class S, satisfies<is_storage_impl, S> = true>
+        const std::string* find_column_name(const S& strg,
+                                            const column_pointer<Label, polyfill::index_constant<I>>& cp) {
+            auto field = materialize_column_pointer(strg, cp);
+            return pick_impl<Label>(strg).table.find_column_name(field);
+        }
     }
 }
diff --git a/dev/storage_lookup.h b/dev/storage_lookup.h
new file mode 100644
index 000000000..64fa5a425
--- /dev/null
+++ b/dev/storage_lookup.h
@@ -0,0 +1,168 @@
+#pragma once
+
+#include <type_traits>
+
+#include "type_traits.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class... Ts>
+        struct storage_t;
+
+        template<class... Ts>
+        struct storage_impl;
+
+        template<class T>
+        struct is_storage : std::false_type {};
+
+        template<class... Ts>
+        struct is_storage<storage_t<Ts...>> : std::true_type {};
+        template<class... Ts>
+        struct is_storage<const storage_t<Ts...>> : std::true_type {};
+
+        template<class T>
+        struct is_storage_impl : std::false_type {};
+
+        template<class... Ts>
+        struct is_storage_impl<storage_impl<Ts...>> : std::true_type {};
+        template<class... Ts>
+        struct is_storage_impl<const storage_impl<Ts...>> : std::true_type {};
+
+        /**
+         *  A mapped data type's CTE alias by which a CTE table descriptor can be found.
+         */
+        template<typename O>
+        using cte_label_t = typename O::cte_label_type;
+
+        /**
+         *  A data type's CTE alias, otherwise T itself is used as a CTE alias.
+         */
+        template<typename T>
+        using detected_cte_label_t = polyfill::detected_or_t<T, cte_label_t, T>;
+    }
+
+    namespace internal {
+
+        template<typename S, typename O>
+        using object_type_matches =
+            typename std::conjunction<std::is_void<typename S::table_type::cte_label_type>,
+                                      std::is_same<O, typename S::table_type::object_type>>::type;
+        template<typename S, typename Label>
+        using label_type_matches = typename std::conjunction<
+            std::negation<std::is_void<typename S::table_type::cte_label_type>>,
+            std::is_same<detected_cte_label_t<Label>, typename S::table_type::cte_label_type>>::type;
+        template<typename S, typename Lookup>
+        using lookup_type_matches =
+            typename std::disjunction<object_type_matches<S, Lookup>, label_type_matches<S, Lookup>>::type;
+
+        /**
+         *  S - storage_impl type
+         *  O - mapped data type or CTE label
+         */
+        template<class S, class O, class SFINAE = void>
+        struct storage_pick_impl_type;
+
+        template<class S, class O>
+        struct storage_pick_impl_type<S, O, match_if<lookup_type_matches, S, O>> {
+            using type = S;
+        };
+
+        template<class S, class O>
+        struct storage_pick_impl_type<S, O, match_if_not<lookup_type_matches, S, O>>
+            : storage_pick_impl_type<typename S::super, O> {};
+
+        /**
+         *  Final specialisation
+         */
+        template<class O>
+        struct storage_pick_impl_type<storage_impl<>, O, void> {};
+
+        /**
+         *  storage_t specialization
+         */
+        template<class... Ts, class O>
+        struct storage_pick_impl_type<storage_t<Ts...>, O, void>
+            : storage_pick_impl_type<typename storage_t<Ts...>::impl_type, O> {};
+
+        /**
+         *  S - storage_t or storage_impl type
+         *  Lookup - mapped data type or CTE label
+         */
+        template<class S, class Lookup>
+        using storage_pick_impl_t =
+            std::conditional_t<std::is_const<S>::value,
+                               std::add_const_t<typename storage_pick_impl_type<std::remove_const_t<S>, Lookup>::type>,
+                               typename storage_pick_impl_type<S, Lookup>::type>;
+
+        /**
+         *  S - storage_impl type
+         *  O - mapped data type or CTE label
+         */
+        template<class S, class O, class SFINAE = void>
+        struct storage_find_impl_type;
+
+        template<class S, class O>
+        struct storage_find_impl_type<S, O, match_if<lookup_type_matches, S, O>> {
+            using type = S;
+        };
+
+        template<class S, class O>
+        struct storage_find_impl_type<S, O, match_if_not<lookup_type_matches, S, O>>
+            : storage_find_impl_type<typename S::super, O> {};
+
+        /**
+         *  Final specialisation
+         */
+        template<class O>
+        struct storage_find_impl_type<storage_impl<>, O, void> {
+            using type = storage_impl<>;
+        };
+
+        /**
+         *  storage_t specialization
+         */
+        template<class... Ts, class O>
+        struct storage_find_impl_type<storage_t<Ts...>, O, void>
+            : storage_find_impl_type<typename storage_t<Ts...>::impl_type, O> {};
+
+        /**
+         *  S - storage_t or storage_impl type
+         *  Lookup - mapped data type or CTE label
+         */
+        template<class S, class Lookup>
+        using storage_find_impl_t =
+            std::conditional_t<std::is_const<S>::value,
+                               std::add_const_t<typename storage_find_impl_type<std::remove_const_t<S>, Lookup>::type>,
+                               typename storage_find_impl_type<S, Lookup>::type>;
+    }
+
+    /**
+      *  S - storage_t type
+      *  Lookup - mapped data type or CTE label
+      */
+    template<class S, class Lookup>
+    using storage_pick_impl_t = internal::storage_pick_impl_t<S, Lookup>;
+
+    /**
+      *  S - storage_t type
+      *  Lookup - mapped data type or CTE label
+      */
+    template<class S, class Lookup>
+    using storage_find_impl_t = internal::storage_find_impl_t<S, Lookup>;
+}
+
+// runtime lookup functions
+namespace sqlite_orm {
+    namespace internal {
+        template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
+        storage_pick_impl_t<S, Lookup>& pick_impl(S& strg) {
+            return strg;
+        }
+
+        template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
+        storage_find_impl_t<S, Lookup>& find_impl(S& strg) {
+            return strg;
+        }
+    }
+}
diff --git a/dev/storage_traits.h b/dev/storage_traits.h
index 4be4a053d..c122d85cc 100644
--- a/dev/storage_traits.h
+++ b/dev/storage_traits.h
@@ -1,13 +1,14 @@
+#pragma once
+
 #include <type_traits>  //  std::is_same, std::enable_if, std::true_type, std::false_type, std::integral_constant
 #include <tuple>  //  std::tuple
 
-namespace sqlite_orm {
+#include "type_traits.h"
+#include "storage_lookup.h"
 
+namespace sqlite_orm {
     namespace internal {
 
-        template<class... Ts>
-        struct storage_impl;
-
         template<class O, bool WithoutRowId, class... Cs>
         struct table_t;
 
@@ -16,73 +17,31 @@ namespace sqlite_orm {
 
         namespace storage_traits {
 
-            /**
-             *  S - storage_impl type
-             *  O - mapped or not mapped data type
-             */
-            template<class S, class O, class SFINAE = void>
-            struct type_is_mapped_impl;
+            template<class S>
+            struct type_is_mapped_impl : std::true_type {};
+
+            template<>
+            struct type_is_mapped_impl<storage_impl<>> : std::false_type {};
 
             /**
              *  S - storage
              *  O - mapped or not mapped data type
              */
             template<class S, class O>
-            struct type_is_mapped : type_is_mapped_impl<typename S::impl_type, O> {};
+            struct type_is_mapped : type_is_mapped_impl<storage_find_impl_t<S, O>> {};
 
-            /**
-             *  Final specialisation
-             */
-            template<class O>
-            struct type_is_mapped_impl<storage_impl<>, O, void> : std::false_type {};
+            template<class S>
+            struct storage_columns_count_impl : std::integral_constant<int, S::table_type::elements_count> {};
 
-            template<class S, class O>
-            struct type_is_mapped_impl<
-                S,
-                O,
-                typename std::enable_if<std::is_same<O, typename S::table_type::object_type>::value>::type>
-                : std::true_type {};
-
-            template<class S, class O>
-            struct type_is_mapped_impl<
-                S,
-                O,
-                typename std::enable_if<!std::is_same<O, typename S::table_type::object_type>::value>::type>
-                : type_is_mapped_impl<typename S::super, O> {};
-
-            /**
-             *  S - storage_impl type
-             *  O - mapped or not mapped data type
-             */
-            template<class S, class O, class SFINAE = void>
-            struct storage_columns_count_impl;
+            template<>
+            struct storage_columns_count_impl<storage_impl<>> : std::integral_constant<int, 0> {};
 
             /**
              *  S - storage
              *  O - mapped or not mapped data type
              */
             template<class S, class O>
-            struct storage_columns_count : storage_columns_count_impl<typename S::impl_type, O> {};
-
-            /**
-             *  Final specialisation
-             */
-            template<class O>
-            struct storage_columns_count_impl<storage_impl<>, O, void> : std::integral_constant<int, 0> {};
-
-            template<class S, class O>
-            struct storage_columns_count_impl<
-                S,
-                O,
-                typename std::enable_if<std::is_same<O, typename S::table_type::object_type>::value>::type>
-                : std::integral_constant<int, S::table_type::elements_count> {};
-
-            template<class S, class O>
-            struct storage_columns_count_impl<
-                S,
-                O,
-                typename std::enable_if<!std::is_same<O, typename S::table_type::object_type>::value>::type>
-                : storage_columns_count_impl<typename S::super, O> {};
+            struct storage_columns_count : storage_columns_count_impl<storage_find_impl_t<S, O>> {};
 
             /**
              *  T - table type.
@@ -105,39 +64,23 @@ namespace sqlite_orm {
              *  S - storage_impl type
              *  O - mapped or not mapped data type
              */
-            template<class S, class O, class SFINAE = void>
-            struct storage_mapped_columns_impl;
+            template<class S>
+            struct storage_mapped_columns_impl {
+                using table_type = typename S::table_type;
+                using type = typename table_types<table_type>::type;
+            };
+
+            template<>
+            struct storage_mapped_columns_impl<storage_impl<>> {
+                using type = std::tuple<>;
+            };
 
             /**
              *  S - storage
              *  O - mapped or not mapped data type
              */
             template<class S, class O>
-            struct storage_mapped_columns : storage_mapped_columns_impl<typename S::impl_type, O> {};
-
-            /**
-             *  Final specialisation
-             */
-            template<class O>
-            struct storage_mapped_columns_impl<storage_impl<>, O, void> {
-                using type = std::tuple<>;
-            };
-
-            template<class S, class O>
-            struct storage_mapped_columns_impl<
-                S,
-                O,
-                typename std::enable_if<std::is_same<O, typename S::table_type::object_type>::value>::type> {
-                using table_type = typename S::table_type;
-                using type = typename table_types<table_type>::type;
-            };
-
-            template<class S, class O>
-            struct storage_mapped_columns_impl<
-                S,
-                O,
-                typename std::enable_if<!std::is_same<O, typename S::table_type::object_type>::value>::type>
-                : storage_mapped_columns_impl<typename S::super, O> {};
+            struct storage_mapped_columns : storage_mapped_columns_impl<storage_find_impl_t<S, O>> {};
 
             /**
              *  C is any column type: column_t or constraint type
diff --git a/dev/table.h b/dev/table.h
index 8898006ac..8ed54d791 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -29,12 +29,6 @@ namespace sqlite_orm {
         template<typename O>
         using cte_label_of_t = polyfill::detected_or_t<void, cte_label_t, O>;
 
-        /**
-         *  A data type's CTE alias, otherwise T itself is used as a CTE alias.
-         */
-        template<typename T>
-        using detected_cte_label_t = polyfill::detected_or_t<T, cte_label_t, T>;
-
         struct basic_table {
 
             /**
diff --git a/dev/type_traits.h b/dev/type_traits.h
index accf69987..c37d81cc5 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -2,12 +2,27 @@
 
 #include <type_traits>
 
-#include "start_macros.h"
 #include "cxx_polyfill.h"
 
 namespace sqlite_orm {
     namespace internal {
         template<class T, template<typename...> class Primary>
         using match_specialization_of = std::enable_if_t<polyfill::is_specialization_of_v<T, Primary>>;
+
+        // enable_if for types
+        template<template<typename...> class Op, class... Args>
+        using match_if = std::enable_if_t<Op<Args...>::value>;
+
+        // enable_if for types
+        template<template<typename...> class Op, class... Args>
+        using match_if_not = std::enable_if_t<std::negation<Op<Args...>>::value>;
+
+        // enable_if for functions
+        template<template<typename...> class Op, class... Args>
+        using satisfies = std::enable_if_t<Op<Args...>::value, bool>;
+
+        // enable_if for functions
+        template<template<typename...> class Op, class... Args>
+        using satisfies_not = std::enable_if_t<std::negation<Op<Args...>>::value, bool>;
     }
 }
diff --git a/tests/storage_tests.cpp b/tests/storage_tests.cpp
index ea4dbdda7..ffce37707 100644
--- a/tests/storage_tests.cpp
+++ b/tests/storage_tests.cpp
@@ -181,7 +181,7 @@ TEST_CASE("has_dependent_rows") {
     REQUIRE(storage.has_dependent_rows(user5));
 }
 
-TEST_CASE("column_name") {
+TEST_CASE("find_column_name") {
     struct User {
         int id = 0;
         std::string name;
@@ -201,10 +201,10 @@ TEST_CASE("column_name") {
                                 make_column("user_id", &Visit::userId),
                                 make_column("date", &Visit::date),
                                 foreign_key(&Visit::userId).references(&User::id)));
-    REQUIRE(*storage.column_name(&User::id) == "id");
-    REQUIRE(*storage.column_name(&User::name) == "name");
-    REQUIRE(*storage.column_name(&Visit::id) == "id");
-    REQUIRE(*storage.column_name(&Visit::userId) == "user_id");
-    REQUIRE(*storage.column_name(&Visit::date) == "date");
-    REQUIRE(storage.column_name(&Visit::notUsed) == nullptr);
+    REQUIRE(*storage.find_column_name(&User::id) == "id");
+    REQUIRE(*storage.find_column_name(&User::name) == "name");
+    REQUIRE(*storage.find_column_name(&Visit::id) == "id");
+    REQUIRE(*storage.find_column_name(&Visit::userId) == "user_id");
+    REQUIRE(*storage.find_column_name(&Visit::date) == "date");
+    REQUIRE(storage.find_column_name(&Visit::notUsed) == nullptr);
 }

From 3546af3d64870ff88f15d459e0e9108827679bf2 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 13 Jan 2022 23:58:04 +0200
Subject: [PATCH 008/161] Explicit column names for CTE

---
 dev/alias.h                      |  19 ---
 dev/column_names_getter.h        |   1 +
 dev/column_result.h              |  22 ++--
 dev/cte.h                        | 197 -------------------------------
 dev/cte_column_names_collector.h | 153 ++++++++++++++++++++++++
 dev/cte_storage.h                | 115 ++++++++++++++++++
 dev/cte_types.h                  |   1 +
 dev/cxx_polyfill.h               |  24 +++-
 dev/iterator.h                   |   2 +-
 dev/select_constraints.h         |  40 +++++--
 dev/serializator_context.h       |   2 +-
 dev/statement_serializator.h     |  15 ++-
 dev/storage.h                    | 134 +++++++++++----------
 dev/storage_impl.h               |  26 ++--
 dev/storage_lookup.h             |  88 +++++++-------
 dev/table.h                      |   6 +-
 dev/type_traits.h                |  27 ++++-
 dev/view.h                       |   6 +-
 18 files changed, 514 insertions(+), 364 deletions(-)
 create mode 100644 dev/cte_column_names_collector.h
 create mode 100644 dev/cte_storage.h

diff --git a/dev/alias.h b/dev/alias.h
index 6d12753eb..0e790c5a0 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -42,16 +42,6 @@ namespace sqlite_orm {
             alias_column_t(column_type column_) : column(std::move(column_)) {}
         };
 
-        /**
-         *  Column expression with CTE alias attached like 'cte_1.ID'. This is not a column alias
-         */
-        template<class Label>
-        struct cte_alias_column_t {
-            using label_type = Label;
-
-            std::string column;
-        };
-
         template<class T, class SFINAE = void>
         struct alias_extractor;
 
@@ -102,15 +92,6 @@ namespace sqlite_orm {
         return {c};
     }
 
-    /**
-     *  @return column with table alias attached. Place it instead of a column statement in case you need to specify a
-     *  column with table alias prefix like 'a.column'. For more information please look through self_join.cpp example
-     */
-    template<class Label>
-    internal::cte_alias_column_t<Label> cte_column(std::string alias) {
-        return {alias};
-    }
-
     template<class T, class E>
     internal::as_t<T, E> as(E expression) {
         return {std::move(expression)};
diff --git a/dev/column_names_getter.h b/dev/column_names_getter.h
index bcc3853ab..ebef5581d 100644
--- a/dev/column_names_getter.h
+++ b/dev/column_names_getter.h
@@ -3,6 +3,7 @@
 #include <string>  //  std::string
 #include <vector>  //  std::vector
 #include <functional>  //  std::reference_wrapper
+#include <system_error>
 
 #include "error_code.h"
 #include "select_constraints.h"
diff --git a/dev/column_result.h b/dev/column_result.h
index 5d6c41023..cf5068260 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -4,6 +4,7 @@
 #include <tuple>  //  std::tuple
 #include <functional>  //  std::reference_wrapper
 
+#include "type_traits.h"
 #include "core_functions.h"
 #include "select_constraints.h"
 #include "operators.h"
@@ -30,6 +31,9 @@ namespace sqlite_orm {
         template<class St, class T, class SFINAE = void>
         struct column_result_t;
 
+        template<class St, class T>
+        using column_result_of_t = typename column_result_t<St, T>::type;
+
 #ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
         template<class St, class T>
         struct column_result_t<St, as_optional_t<T>, void> {
@@ -41,8 +45,8 @@ namespace sqlite_orm {
         template<class St, class O, class F>
         struct column_result_t<St,
                                F O::*,
-                               typename std::enable_if<std::is_member_pointer<F O::*>::value &&
-                                                       !std::is_member_function_pointer<F O::*>::value>::type> {
+                               std::enable_if_t<std::is_member_pointer<F O::*>::value &&
+                                                !std::is_member_function_pointer<F O::*>::value>> {
             using type = F;
         };
 
@@ -60,7 +64,7 @@ namespace sqlite_orm {
          *  Common case for all getter types. Getter types are defined in column.h file
          */
         template<class St, class T>
-        struct column_result_t<St, T, typename std::enable_if<is_getter<T>::value>::type> {
+        struct column_result_t<St, T, match_if<is_getter, T>> {
             using type = typename getter_traits<T>::field_type;
         };
 
@@ -68,7 +72,7 @@ namespace sqlite_orm {
          *  Common case for all setter types. Setter types are defined in column.h file
          */
         template<class St, class T>
-        struct column_result_t<St, T, typename std::enable_if<is_setter<T>::value>::type> {
+        struct column_result_t<St, T, match_if<is_setter, T>> {
             using type = typename setter_traits<T>::field_type;
         };
 
@@ -198,7 +202,7 @@ namespace sqlite_orm {
         };
 
         template<class St, class T, class F>
-        struct column_result_t<St, column_pointer<T, F>> : column_result_t<St, F, void> {};
+        struct column_result_t<St, column_pointer<T, F>> : column_result_t<St, F> {};
 
         template<class St, class Label, size_t I>
         struct column_result_t<St, column_pointer<Label, polyfill::index_constant<I>>>
@@ -212,7 +216,7 @@ namespace sqlite_orm {
         };
 
         template<class St, class T, class... Args>
-        struct column_result_t<St, select_t<T, Args...>> : column_result_t<St, T, void> {};
+        struct column_result_t<St, select_t<T, Args...>> : column_result_t<St, T> {};
 
         template<class St, class T>
         struct column_result_t<St, T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
@@ -234,7 +238,7 @@ namespace sqlite_orm {
          *  Result for the most simple queries like `SELECT 1`
          */
         template<class St, class T>
-        struct column_result_t<St, T, typename std::enable_if<std::is_arithmetic<T>::value>::type> {
+        struct column_result_t<St, T, match_if<std::is_arithmetic, T>> {
             using type = T;
         };
 
@@ -252,7 +256,7 @@ namespace sqlite_orm {
         };
 
         template<class St, class T, class E>
-        struct column_result_t<St, as_t<T, E>, void> : column_result_t<St, typename std::decay<E>::type, void> {};
+        struct column_result_t<St, as_t<T, E>, void> : column_result_t<St, typename std::decay<E>::type> {};
 
         template<class St, class T>
         struct column_result_t<St, asterisk_t<T>, void> {
@@ -290,6 +294,6 @@ namespace sqlite_orm {
         };
 
         template<class St, class T>
-        struct column_result_t<St, std::reference_wrapper<T>, void> : column_result_t<St, T, void> {};
+        struct column_result_t<St, std::reference_wrapper<T>, void> : column_result_t<St, T> {};
     }
 }
diff --git a/dev/cte.h b/dev/cte.h
index 926b4bd70..08f89a125 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -1,19 +1,11 @@
 #pragma once
 
 #include <type_traits>
-#include <tuple>
 #include <string>
-#include <vector>
-#include <system_error>
 
 #include "cxx_polyfill.h"
-#include "column_result.h"
 #include "select_constraints.h"
-#include "alias.h"
-#include "table.h"
 #include "cte_types.h"
-#include "storage.h"
-#include "statement_serializator.h"
 
 namespace sqlite_orm {
 
@@ -63,193 +55,4 @@ namespace sqlite_orm {
                                                                  Chars...)>{};
     }
 #endif
-
-    namespace internal {
-
-        // F = field_type
-        template<typename Label, typename F>
-        struct create_column_results {
-            using type = column_results<Label, F>;
-        };
-
-        template<typename Label, typename... Fs>
-        struct create_column_results<Label, std::tuple<Fs...>> {
-            using type = column_results<Label, Fs...>;
-        };
-
-        template<typename Label, typename... Fs>
-        using create_column_results_t = typename create_column_results<Label, Fs...>::type;
-
-        template<typename O, size_t CI>
-        struct create_cte_column {
-            using object_type = O;
-            using field_type = std::tuple_element_t<CI, typename O::fields_type>;
-            using getter_type = cte_getter_t<O, CI>;
-            using setter_type = cte_setter_t<O, CI>;
-
-            using type = column_t<object_type, field_type, getter_type, setter_type>;
-        };
-
-        /**
-         *  Metafunction to create a CTE column_t type.
-         */
-        template<typename O, size_t CI>
-        using create_cte_column_t = typename create_cte_column<O, CI>::type;
-
-        template<typename O, typename IdxSeq>
-        struct create_cte_table;
-
-        template<typename Label, typename... Fs, size_t... CIs>
-        struct create_cte_table<column_results<Label, Fs...>, std::index_sequence<CIs...>> {
-            using object_type = column_results<Label, Fs...>;
-            using table_type = table_t<object_type, true, create_cte_column_t<object_type, CIs>...>;
-
-            using type = table_type;
-        };
-
-        /**
-         *  Metafunction to create a CTE table_t type.
-         */
-        template<typename O, typename IdxSeq>
-        using create_cte_table_t = typename create_cte_table<O, IdxSeq>::type;
-
-        template<class T, class SFINAE = void>
-        struct cte_column_names_collector {
-            using expression_type = T;
-
-            template<class Ctx>
-            std::vector<std::string> operator()(const expression_type& t, const Ctx& context) const {
-                auto newContext = context;
-                newContext.skip_table_name = true;
-                std::string columnName = serialize(t, newContext);
-                if(columnName.empty()) {
-                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
-                }
-                return {move(columnName)};
-            }
-        };
-
-        template<class T, class Ctx>
-        std::vector<std::string> get_cte_column_names(const T& t, const Ctx& context) {
-            cte_column_names_collector<T> serializator;
-            return serializator(t, context);
-        }
-
-        template<class As>
-        struct cte_column_names_collector<As, match_specialization_of<As, as_t>> {
-            using expression_type = As;
-
-            template<class Ctx>
-            std::vector<std::string> operator()(const expression_type& /*expression*/, const Ctx& /*context*/) const {
-                return {As::alias_type::get()};
-            }
-        };
-
-        template<class RefWrapper>
-        struct cte_column_names_collector<RefWrapper, match_specialization_of<RefWrapper, std::reference_wrapper>> {
-            using expression_type = RefWrapper;
-
-            template<class Ctx>
-            std::vector<std::string> operator()(const expression_type& expression, const Ctx& context) const {
-                return get_cte_column_names(expression.get(), context);
-            }
-        };
-
-        template<class Asterisk>
-        struct cte_column_names_collector<Asterisk, match_specialization_of<Asterisk, asterisk_t>> {
-            using expression_type = Asterisk;
-            using T = typename Asterisk::type;
-
-            template<class Ctx>
-            std::vector<std::string> operator()(const expression_type&, const Ctx& context) const {
-                auto& tImpl = pick_impl<T>(context.impl);
-
-                std::vector<std::string> columnNames;
-                columnNames.reserve(size_t(tImpl.table.elements_count));
-
-                tImpl.table.for_each_column([&columnNames](const basic_column& column) {
-                    columnNames.push_back(column.name);
-                });
-                return columnNames;
-            }
-        };
-
-        // No CTE for object expressions.
-        template<class Object>
-        struct cte_column_names_collector<Object, match_specialization_of<Object, object_t>>;
-
-        template<class Columns>
-        struct cte_column_names_collector<Columns, match_specialization_of<Columns, columns_t>> {
-            using expression_type = Columns;
-
-            template<class Ctx>
-            std::vector<std::string> operator()(const expression_type& cols, const Ctx& context) const {
-                std::vector<std::string> columnNames;
-                columnNames.reserve(size_t(cols.count));
-                auto newContext = context;
-                newContext.skip_table_name = true;
-                iterate_tuple(cols.columns, [&columnNames, &newContext](auto& m) {
-                    std::string columnName;
-                    if constexpr(polyfill::is_specialization_of_v<std::remove_cvref_t<decltype(m)>, as_t>) {
-                        columnName = alias_extractor<typename std::remove_cvref_t<decltype(m)>::alias_type>::get();
-                    } else {
-                        columnName = serialize(m, newContext);
-                    }
-                    if(!columnName.empty()) {
-                        columnNames.push_back(move(columnName));
-                    } else {
-                        throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
-                    }
-                });
-                return columnNames;
-            }
-        };
-
-        template<typename Strg, typename T, typename... Args>
-        std::vector<std::string> collect_cte_column_names(const Strg& storage, const select_t<T, Args...>& sel) {
-            const serializator_context_builder<Strg> ctxBuilder(storage);
-            return get_cte_column_names(sel.col, ctxBuilder());
-        }
-
-        template<typename O, typename Strg, typename CTE, size_t... CIs>
-        create_cte_table_t<O, typename O::index_sequence>
-        make_cte_table_using_column_indices(const Strg& storage, const CTE& cte, std::index_sequence<CIs...>) {
-            std::vector<std::string> columnNames = collect_cte_column_names(storage, cte.expression);
-            assert(columnNames.size() == O::index_sequence::size());
-            // unquote
-            for(std::string& name: columnNames) {
-                if(!name.empty() && name.front() == '"' && name.back() == '"') {
-                    name.erase(name.end() - 1);
-                    name.erase(name.begin());
-                }
-            }
-
-            return create_cte_table_t<O, typename O::index_sequence>{
-                cte.label(),
-                std::make_tuple(make_column<>(columnNames.at(CIs), cte_getter_v<O, CIs>, cte_setter_v<O, CIs>)...)};
-        }
-
-        template<typename O, typename Strg, typename CTE>
-        create_cte_table_t<O, typename O::index_sequence> make_cte_table(const Strg& storage, const CTE& cte) {
-            return make_cte_table_using_column_indices<O>(storage, cte, typename O::index_sequence{});
-        }
-
-        template<class Strg, class E, class... CTEs, size_t... TIs>
-        decltype(auto) make_cte_storage_using_table_indices(const Strg& storage,
-                                                            const with_t<E, CTEs...>& e,
-                                                            std::index_sequence<TIs...>) {
-            return storage_impl_cat(
-                storage,
-                make_cte_table<
-                    create_column_results_t<typename CTEs::label_type,
-                                            typename column_result_t<Strg, typename CTEs::expression_type>::type>>(
-                    storage,
-                    get<TIs>(e.cte))...);
-        }
-
-        template<class Strg, class E, class... CTEs>
-        decltype(auto) make_cte_storage(const Strg& storage, const with_t<E, CTEs...>& e) {
-            return make_cte_storage_using_table_indices(storage, e, std::index_sequence_for<CTEs...>{});
-        }
-    }
 }
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
new file mode 100644
index 000000000..3fc7c1fd9
--- /dev/null
+++ b/dev/cte_column_names_collector.h
@@ -0,0 +1,153 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <functional>  //  std::reference_wrapper
+#include <system_error>
+
+#include "cxx_polyfill.h"
+#include "type_traits.h"
+#include "error_code.h"
+#include "select_constraints.h"
+
+namespace sqlite_orm {
+    namespace internal {
+        // collecting column names utilizes the statement serializer
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context);
+
+        template<class T, class SFINAE = void>
+        struct cte_column_names_collector {
+            using expression_type = T;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& t, const Ctx& context) const {
+                auto newContext = context;
+                newContext.skip_table_name = true;
+                std::string columnName = serialize(t, newContext);
+                if(columnName.empty()) {
+                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                }
+                return {move(columnName)};
+            }
+        };
+
+        template<class T, class Ctx>
+        std::vector<std::string> get_cte_column_names(const T& t, const Ctx& context) {
+            cte_column_names_collector<T> collector;
+            return collector(t, context);
+        }
+
+        template<class As>
+        struct cte_column_names_collector<As, match_specialization_of<As, as_t>> {
+            using expression_type = As;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& /*expression*/, const Ctx& /*context*/) const {
+                return {As::alias_type::get()};
+            }
+        };
+
+        template<class Wrapper>
+        struct cte_column_names_collector<Wrapper, match_specialization_of<Wrapper, std::reference_wrapper>> {
+            using expression_type = Wrapper;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& expression, const Ctx& context) const {
+                return get_cte_column_names(expression.get(), context);
+            }
+        };
+
+        template<class Asterisk>
+        struct cte_column_names_collector<Asterisk, match_specialization_of<Asterisk, asterisk_t>> {
+            using expression_type = Asterisk;
+            using T = typename Asterisk::type;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type&, const Ctx& context) const {
+                auto& tImpl = pick_impl<T>(context.impl);
+
+                std::vector<std::string> columnNames;
+                columnNames.reserve(size_t(tImpl.table.elements_count));
+
+                tImpl.table.for_each_column([&columnNames](const basic_column& column) {
+                    columnNames.push_back(column.name);
+                });
+                return columnNames;
+            }
+        };
+
+        // No CTE for object expressions.
+        template<class Object>
+        struct cte_column_names_collector<Object, match_specialization_of<Object, object_t>> {
+            static_assert(polyfill::always_false_v<Object>, "object_t not supported for subselects.");
+        };
+
+        template<class Columns>
+        struct cte_column_names_collector<Columns, match_specialization_of<Columns, columns_t>> {
+            using expression_type = Columns;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& cols, const Ctx& context) const {
+                std::vector<std::string> columnNames;
+                columnNames.reserve(size_t(cols.count));
+                auto newContext = context;
+                newContext.skip_table_name = true;
+                iterate_tuple(cols.columns, [&columnNames, &newContext](auto& m) {
+                    std::string columnName;
+                    if constexpr(polyfill::is_specialization_of_v<std::remove_cvref_t<decltype(m)>, as_t>) {
+                        columnName = alias_extractor<typename std::remove_cvref_t<decltype(m)>::alias_type>::get();
+                    } else {
+                        columnName = serialize(m, newContext);
+                    }
+                    if(!columnName.empty()) {
+                        columnNames.push_back(move(columnName));
+                    } else {
+                        throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                    }
+                });
+                return columnNames;
+            }
+        };
+
+        template<typename Ctx, typename E, satisfies_is_specialization_of<E, select_t> = true>
+        std::vector<std::string> collect_cte_column_names(const E& sel,
+                                                          const std::vector<std::string>& explicitColumnNames,
+                                                          const Ctx& context) {
+            // 1. determine column names from subselect
+
+            std::vector<std::string> columnNames = get_cte_column_names(sel.col, context);
+
+            // unquote column names
+            for(std::string& name: columnNames) {
+                if(!name.empty() && name.front() == '"' && name.back() == '"') {
+                    name.erase(name.end() - 1);
+                    name.erase(name.begin());
+                }
+            }
+
+            // 2. override column names from cte expression
+            if(!explicitColumnNames.empty()) {
+                if(explicitColumnNames.size() != columnNames.size()) {
+                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                }
+                
+                for(size_t i = 0, n = explicitColumnNames.size(); i < n; ++i) {
+                    if(!explicitColumnNames[i].empty()) {
+                        columnNames[i] = explicitColumnNames[i];
+                    }
+                }
+            }
+            // 3. fill in blanks with numerical column names
+            {
+                for(size_t i = 0, n = columnNames.size(); i < n; ++i) {
+                    if(columnNames[i].empty()) {
+                        columnNames[i] = std::to_string(i);
+                    }
+                }
+            }
+
+            return columnNames;
+        }
+    }
+}
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
new file mode 100644
index 000000000..4d66838f1
--- /dev/null
+++ b/dev/cte_storage.h
@@ -0,0 +1,115 @@
+#pragma once
+
+#include <type_traits>
+#include <tuple>
+#include <string>
+#include <vector>
+
+#include "column_result.h"
+#include "select_constraints.h"
+#include "table.h"
+#include "cte_types.h"
+#include "cte_column_names_collector.h"
+#include "storage_lookup.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+        // F = field_type
+        template<typename Label, typename F>
+        struct create_column_results {
+            using type = column_results<Label, F>;
+        };
+
+        template<typename Label, typename... Fs>
+        struct create_column_results<Label, std::tuple<Fs...>> {
+            using type = column_results<Label, Fs...>;
+        };
+
+        template<typename Label, typename... Fs>
+        using create_column_results_t = typename create_column_results<Label, Fs...>::type;
+
+        template<typename O, size_t CI>
+        struct create_cte_column {
+            using object_type = O;
+            using field_type = std::tuple_element_t<CI, typename O::fields_type>;
+            using getter_type = cte_getter_t<O, CI>;
+            using setter_type = cte_setter_t<O, CI>;
+
+            using type = column_t<object_type, field_type, getter_type, setter_type>;
+        };
+
+        /**
+         *  Metafunction to create a CTE column_t type.
+         */
+        template<typename O, size_t CI>
+        using create_cte_column_t = typename create_cte_column<O, CI>::type;
+
+        template<typename O, typename IdxSeq>
+        struct create_cte_table;
+
+        template<typename Label, typename... Fs, size_t... CIs>
+        struct create_cte_table<column_results<Label, Fs...>, std::index_sequence<CIs...>> {
+            using object_type = column_results<Label, Fs...>;
+            using table_type = table_t<object_type, true, create_cte_column_t<object_type, CIs>...>;
+
+            using type = table_type;
+        };
+
+        /**
+         *  Metafunction to create a CTE table_t type.
+         */
+        template<typename O, typename IdxSeq>
+        using create_cte_table_t = typename create_cte_table<O, IdxSeq>::type;
+
+        template<typename... Ts, typename... CTETables>
+        storage_impl<CTETables..., Ts...> storage_impl_cat(const storage_t<Ts...>& storage, CTETables&&... cteTables) {
+            return {std::forward<CTETables>(cteTables)..., pick_const_impl<object_type_t<Ts>>(storage).table...};
+        }
+
+        template<typename O, typename S, typename CTE, size_t... CIs>
+        create_cte_table_t<O, typename O::index_sequence>
+        make_cte_table_using_column_indices(const S& storage, const CTE& cte, std::index_sequence<CIs...>) {
+            using context_type = serializator_context<typename S::impl_type>;
+            context_type context{obtain_const_impl(storage)};
+            std::vector<std::string> columnNames = collect_cte_column_names(cte.expression, cte.columnNames, context);
+
+            return create_cte_table_t<O, typename O::index_sequence>{
+                cte.label(),
+                std::make_tuple(make_column<>(columnNames.at(CIs), cte_getter_v<O, CIs>, cte_setter_v<O, CIs>)...)};
+        }
+
+        template<typename O, typename S, typename CTE>
+        create_cte_table_t<O, typename O::index_sequence> make_cte_table(const S& storage, const CTE& cte) {
+            return make_cte_table_using_column_indices<O>(storage, cte, typename O::index_sequence{});
+        }
+
+        template<class S, class E, class... CTEs, size_t... TIs>
+        decltype(auto) make_cte_storage_using_table_indices(const S& storage,
+                                                            const with_t<E, CTEs...>& e,
+                                                            std::index_sequence<TIs...>) {
+            return storage_impl_cat(
+                storage,
+                make_cte_table<
+                    create_column_results_t<label_type_t<CTEs>, column_result_of_t<S, expression_type_t<CTEs>>>>(
+                    storage,
+                    get<TIs>(e.cte))...);
+        }
+
+        /**
+         *  Return new storage_impl for CTE expressions.
+         */
+        template<class S, class E, class... CTEs, satisfies<is_storage, S> = true>
+        decltype(auto) storage_for_expression(S& storage, const with_t<E, CTEs...>& e) {
+            return make_cte_storage_using_table_indices(storage, e, std::index_sequence_for<CTEs...>{});
+        }
+
+        /**
+         *  Return const storage_impl of storage.
+         */
+        template<class S, class E, satisfies<is_storage, S> = true>
+        decltype(auto) storage_for_expression(S& storage, const E&) {
+            return obtain_const_impl(storage);
+        }
+    }
+}
diff --git a/dev/cte_types.h b/dev/cte_types.h
index d1cef08ee..b677a70b7 100644
--- a/dev/cte_types.h
+++ b/dev/cte_types.h
@@ -16,6 +16,7 @@ namespace sqlite_orm {
           public:
             using fields_type = std::tuple<Fs...>;
             using index_sequence = std::index_sequence_for<Fs...>;
+            // this type name is used to detect the mapping from label to object
             using cte_label_type = Label;
 
             template<size_t I>
diff --git a/dev/cxx_polyfill.h b/dev/cxx_polyfill.h
index 008ea5385..4dccd4b63 100644
--- a/dev/cxx_polyfill.h
+++ b/dev/cxx_polyfill.h
@@ -8,13 +8,35 @@ namespace sqlite_orm {
     namespace internal {
         namespace polyfill {
 #if __cplusplus < 201703L  // before C++17
-            template<class...>
+            template<typename...>
             using void_t = void;
 
             template<bool v>
             using bool_constant = std::integral_constant<bool, v>;
+
+            template<typename...>
+            struct conjunction : std::true_type {};
+            template<typename B1>
+            struct conjunction<B1> : B1 {};
+            template<typename B1, typename... Bn>
+            struct conjunction<B1, Bn...> : std::conditional_t<B1::value, conjunction<Bn...>, B1> {};
+            template<typename... Bs>
+            constexpr bool conjunction_v = conjunction<Bs...>::value;
+
+            template<typename...>
+            struct disjunction : std::false_type {};
+            template<typename B1>
+            struct disjunction<B1> : B1 {};
+            template<typename B1, typename... Bn>
+            struct disjunction<B1, Bn...> : std::conditional_t<bool(B1::value), B1, disjunction<Bn...>> {};
+            template<typename... Bs>
+            constexpr bool disjunction_v = disjunction<Bs...>::value;
 #else
             using std::bool_constant;
+            using std::conjunction;
+            using std::conjunction_v;
+            using std::disjunction;
+            using std::disjunction_v;
             using std::void_t;
 #endif
 
diff --git a/dev/iterator.h b/dev/iterator.h
index 22d3dc0d5..d4174b758 100644
--- a/dev/iterator.h
+++ b/dev/iterator.h
@@ -43,7 +43,7 @@ namespace sqlite_orm {
 
             void extract_value() {
                 auto& storage = this->view->storage;
-                auto& impl = storage.template get_impl<value_type>();
+                auto& impl = pick_const_impl<value_type>(storage);
                 this->current = std::make_shared<value_type>();
                 object_from_column_builder<value_type> builder{*this->current, this->stmt->get()};
                 impl.table.for_each_column(builder);
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 4c98e566d..c6a5b50b8 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -7,6 +7,7 @@
 #include <optional>  // std::optional
 #endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
 
+#include "cxx_polyfill.h"
 #include "is_base_of_template.h"
 #include "tuple_helper/tuple_helper.h"
 #include "optional_container.h"
@@ -244,26 +245,39 @@ namespace sqlite_orm {
             using label_type = Label;
             using expression_type = Select;
 
+            std::vector<std::string> columnNames;
             expression_type expression;
 
-            common_table_expression(expression_type expression) : expression{std::move(expression)} {
+            common_table_expression(std::vector<std::string> columnNames, expression_type expression) :
+                columnNames{move(columnNames)}, expression{std::move(expression)} {
                 this->expression.highest_level = false;
             }
         };
+        template<class... CTEs>
+        using common_table_expressions = std::tuple<CTEs...>;
+
+        template<typename Label>
+        struct cte_maker {
+            std::vector<std::string> columnNames;
+
+            template<class Select>
+            internal::common_table_expression<Label, Select> operator()(Select sel) && {
+                return {move(this->columnNames), std::move(sel)};
+            }
+        };
 
         /**
          *  Expression with prepended CTEs.
          */
         template<class E, class... CTEs>
         struct with_t : with_string {
-            using cte_type = std::tuple<CTEs...>;
+            using cte_type = common_table_expressions<CTEs...>;
             using expression_type = E;
 
             cte_type cte;
             expression_type expression;
 
-            with_t(std::tuple<CTEs...> cte, expression_type expression) :
-                cte{move(cte)}, expression{std::move(expression)} {
+            with_t(cte_type cte, expression_type expression) : cte{move(cte)}, expression{std::move(expression)} {
                 this->expression.highest_level = true;
             }
         };
@@ -412,9 +426,16 @@ namespace sqlite_orm {
     }
 
     /**
+     *  Explicitly refer to a column, used in contexts
+     *  where the automatic object mapping deduction needs to be overridden,
+     *  or when you need to refer to a column in a CTE.
+     *  
      *  Use it like this:
      *  struct MyType : BaseType { ... };
      *  storage.select(column<MyType>(&BaseType::id));
+     *  // ... or
+     *  struct MyType : BaseType { ... };
+     *  storage.with(cte<cte_1>()(select(&Object::id), select(column<cte_1>(0_col)));
      */
     template<class T, class F>
     internal::column_pointer<T, F> column(F f) {
@@ -456,9 +477,14 @@ namespace sqlite_orm {
         return {std::move(lhs), std::move(rhs)};
     }
 
-    template<class Label, class Select>
-    internal::common_table_expression<Label, Select> cte(Select sel) {
-        return {std::move(sel)};
+    /**
+     *  Example : cte<cte_1>()(select(&Object::id));
+     */
+    template<class Label,
+             class... ColumnNames,
+             std::enable_if_t<polyfill::conjunction_v<std::is_convertible<ColumnNames, std::string>...>, bool> = true>
+    internal::cte_maker<Label> cte(ColumnNames... columnNames) {
+        return {{std::move(columnNames)...}};
     }
 
     // tuple of CTEs
diff --git a/dev/serializator_context.h b/dev/serializator_context.h
index a340ac7cd..e847718f9 100644
--- a/dev/serializator_context.h
+++ b/dev/serializator_context.h
@@ -27,7 +27,7 @@ namespace sqlite_orm {
             serializator_context_builder(const storage_type& storage_) : storage(storage_) {}
 
             serializator_context<impl_type> operator()() const {
-                return {this->storage.impl};
+                return {obtain_const_impl(this->storage)};
             }
 
             const storage_type& storage;
diff --git a/dev/statement_serializator.h b/dev/statement_serializator.h
index 57f74000d..07d2d0313 100644
--- a/dev/statement_serializator.h
+++ b/dev/statement_serializator.h
@@ -19,6 +19,7 @@
 #include "type_printer.h"
 #include "table_name_collector.h"
 #include "column_names_getter.h"
+#include "cte_column_names_collector.h"
 #include "order_by_serializator.h"
 #include "values.h"
 #include "table_type.h"
@@ -487,7 +488,19 @@ namespace sqlite_orm {
                 cteContext.use_parentheses = true;
 
                 std::stringstream ss;
-                ss << static_cast<std::string>(c) << " as ";
+                ss << static_cast<std::string>(c);
+                std::vector<std::string> columnNames = collect_cte_column_names(c.expression, c.columnNames, context);
+                {
+                    ss << '(';
+                    for(size_t i = 0, n = columnNames.size(); i < n; ++i) {
+                        ss << "\"" << columnNames[i] << "\"";
+                        if(i < n - 1) {
+                            ss << ", ";
+                        }
+                    }
+                    ss << ')';
+                }
+                ss << " AS ";
                 ss << serialize(c.expression, cteContext);
                 return ss.str();
             }
diff --git a/dev/storage.h b/dev/storage.h
index 0638d2ca3..0342615c4 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -18,6 +18,7 @@
 #include <optional>  // std::optional
 #endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
 
+#include "type_traits.h"
 #include "alias.h"
 #include "row_extractor_builder.h"
 #include "error_code.h"
@@ -48,8 +49,8 @@
 #include "table_name_collector.h"
 #include "object_from_column_builder.h"
 #include "table.h"
-#include "cte_types.h"
 #include "column.h"
+#include "cte_storage.h"
 #include "util.h"
 
 namespace sqlite_orm {
@@ -77,23 +78,20 @@ namespace sqlite_orm {
           protected:
             impl_type impl;
 
-            template<class T, class S, class... Args>
-            friend struct view_t;
-
-            template<class S>
-            friend struct dynamic_order_by_t;
-
-            template<class V>
-            friend struct iterator_t;
-
-            template<class S>
-            friend struct serializator_context_builder;
-
-            template<typename... CTETables>
-            friend storage_impl<CTETables..., Ts...> storage_impl_cat(const storage_t<Ts...>& storage,
-                                                                      CTETables&&... cteTables) {
-                return {std::forward<CTETables>(cteTables)...,
-                        pick_impl<typename Ts::object_type>(storage.impl).table...};
+            /**
+             *  Obtain a storage_t's const storage_impl.
+             *  
+             *  @note Historically, `serializator_context_builder` was declared friend, along with
+             *  a few other library stock objects, in order limit access to the storage_impl.
+             *  However, one could gain access to a storage_t's storage_impl through
+             *  `serializator_context_builder`, hence leading the whole friend declaration mambo-jumbo
+             *  ad absurdum.
+             *  Providing a free function is way better and cleaner.
+             *
+             *  Hence, friend was replaced by `obtain_const_impl()` and `pick_const_impl()`.
+             */
+            friend const impl_type& obtain_const_impl(const self& storage) noexcept {
+                return storage.impl;
             }
 
             template<class I>
@@ -156,21 +154,22 @@ namespace sqlite_orm {
 
             template<class O>
             void assert_mapped_type() const {
-                using mapped_types_tuples = std::tuple<typename Ts::object_type...>;
+                using mapped_types_tuples = std::tuple<object_type_t<Ts>...>;
                 static_assert(tuple_helper::has_type<O, mapped_types_tuples>::value, "type is not mapped to a storage");
             }
 
             template<class O>
             void assert_insertable_type() const {
                 auto& tImpl = this->get_impl<O>();
-                using table_type = typename std::decay<decltype(tImpl.table)>::type;
-                using elements_type = typename std::decay<decltype(tImpl.table.elements)>::type;
+                using storage_impl_type = std::remove_cvref_t<decltype(tImpl)>;
+                using table_type = typename storage_impl_type::table_type;
+                using elements_type = typename table_type::elements_type;
 
                 using is_without_rowid = std::integral_constant<bool, table_type::is_without_rowid>;
 
                 static_if<is_without_rowid{}>(
                     [](auto&) {
-                        static_assert(std::is_void<table_type::cte_label_type>::value,
+                        static_assert(std::is_void<typename table_type::cte_label_type>::value,
                                       "Attempting to execute 'insert' request for a CTE mapping.");
                     },
                     [](auto& tImpl) {  // unfortunately, this static_assert's can't see any composite keys((
@@ -188,14 +187,13 @@ namespace sqlite_orm {
                     })(tImpl);
             }
 
-            template<class O>
-            storage_pick_impl_t<const self, O>& get_impl() const {
-                return pick_impl<O>(this->impl);
+            template<class Lookup>
+            storage_pick_impl_t<self, Lookup>& get_impl() {
+                return this->impl;
             }
-
-            template<class O>
-            storage_pick_impl_t<self, O>& get_impl() {
-                return pick_impl<O>(this->impl);
+            template<class Lookup>
+            storage_pick_impl_t<const self, Lookup>& get_impl() const {
+                return this->impl;
             }
 
           public:
@@ -448,7 +446,7 @@ namespace sqlite_orm {
                      class O,
                      class... Args,
                      class Tuple = std::tuple<Args...>,
-                     typename SFINAE = typename std::enable_if<std::tuple_size<Tuple>::value >= 1>::type>
+                     std::enable_if_t<std::tuple_size<Tuple>::value >= 1> = true>
             std::string group_concat(F O::*m, Args&&... args) {
                 return this->group_concat_internal(m, {}, std::forward<Args>(args)...);
             }
@@ -551,7 +549,7 @@ namespace sqlite_orm {
              *  For a single column use `auto rows = storage.select(&User::id, where(...));
              *  For multicolumns use `auto rows = storage.select(columns(&User::id, &User::name), where(...));
              */
-            template<class T, class... Args, class R = typename column_result_t<self, T>::type>
+            template<class T, class... Args, class R = column_result_of_t<self, T>>
             std::vector<R> select(T m, Args... args) {
                 static_assert(!is_base_of_template<T, compound_operator>::value ||
                                   std::tuple_size<std::tuple<Args...>>::value == 0,
@@ -560,11 +558,29 @@ namespace sqlite_orm {
                 return this->execute(statement);
             }
 
-            template<class T>
-            std::enable_if_t<is_prepared_statement<T>::value, std::string> dump(const T& preparedStatement) const {
-                const auto& impl = impl_for_expression(preparedStatement.expression);
-                using context_t = serializator_context<decltype(impl)>;
-                context_t context{impl};
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class Label, class Select, class T, class... Args>
+            auto with(common_table_expression<Label, Select> cte, select_t<T, Args...> sel) {
+                auto statement = this->prepare(sqlite_orm::with(move(cte), std::move(sel)));
+                return this->execute(statement);
+            }
+
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class... CTEs, class T, class... Args>
+            auto with(common_table_expressions<CTEs...> cte, select_t<T, Args...> sel) {
+                auto statement = this->prepare(sqlite_orm::with(move(cte), std::move(sel)));
+                return this->execute(statement);
+            }
+
+            template<class T, satisfies<is_prepared_statement, T> = true>
+            std::string dump(const T& preparedStatement) const {
+                const auto& exprImpl = storage_for_expression(*this, preparedStatement.expression);
+                using context_t = serializator_context<std::remove_cvref_t<decltype(exprImpl)>>;
+                context_t context{exprImpl};
                 return serialize(preparedStatement.expression, context);
             }
 
@@ -572,9 +588,8 @@ namespace sqlite_orm {
              *  Returns a string representation of object of a class mapped to the storage.
              *  Type of string has json-like style.
              */
-            template<class O>
-            typename std::enable_if<storage_traits::type_is_mapped<self, O>::value, std::string>::type
-            dump(const O& o) {
+            template<class O, satisfies<storage_traits::type_is_mapped, self, O> = true>
+            std::string dump(const O& o) {
                 auto& tImpl = this->get_impl<O>();
                 std::stringstream ss;
                 ss << "{ ";
@@ -904,23 +919,14 @@ namespace sqlite_orm {
                 perform_void_exec(db, ss.str());
             }
 
-            template<class S>
-            const impl_type& impl_for_expression(const S& /*statement*/) const {
-                return this->impl;
-            }
-            template<class... CTEs, class E>
-            decltype(auto) impl_for_expression(const with_t<E, CTEs...>& statement) const {
-                return make_cte_storage(*this, statement);
-            }
-
             template<typename S>
             prepared_statement_t<S> prepare_impl(S statement) {
                 auto con = this->get_connection();
                 sqlite3_stmt* stmt;
                 auto db = con.get();
-                const auto& impl = impl_for_expression(statement);
-                using context_t = serializator_context<decltype(impl)>;
-                context_t context{impl};
+                const auto& exprImpl = storage_for_expression(*this, statement);
+                using context_t = serializator_context<std::remove_cvref_t<decltype(exprImpl)>>;
+                context_t context{exprImpl};
                 context.skip_table_name = false;
                 context.replace_bindable_with_question = true;
                 auto query = serialize(statement, context);
@@ -997,10 +1003,10 @@ namespace sqlite_orm {
                 return this->impl.table_exists(tableName, con.get());
             }
 
-            template<class E, class... CTEs>
-            std::enable_if_t<is_base_of_template<E, select_t>::value, prepared_statement_t<with_t<E, CTEs...>>>
-            prepare(with_t<E, CTEs...> sel) {
-                return prepare_impl<with_t<E, CTEs...>>(std::move(sel));
+            template<class... CTEs, class T, class... Args>
+            prepared_statement_t<with_t<select_t<T, Args...>, CTEs...>>
+            prepare(with_t<select_t<T, Args...>, CTEs...> sel) {
+                return prepare_impl<with_t<select_t<T, Args...>, CTEs...>>(std::move(sel));
             }
 
             template<class T, class... Args>
@@ -1170,8 +1176,7 @@ namespace sqlite_orm {
                 return sqlite3_last_insert_rowid(db);
             }
 
-            template<class T,
-                     typename std::enable_if<(is_replace_range<T>::value || is_replace<T>::value)>::type* = nullptr>
+            template<class T, std::enable_if_t<is_replace_range<T>::value || is_replace<T>::value, bool> = true>
             void execute(const prepared_statement_t<T>& statement) {
                 using statement_type = typename std::decay<decltype(statement)>::type;
                 using expression_type = typename statement_type::expression_type;
@@ -1227,8 +1232,7 @@ namespace sqlite_orm {
                 perform_step(db, stmt);
             }
 
-            template<class T,
-                     typename std::enable_if<(is_insert_range<T>::value || is_insert<T>::value)>::type* = nullptr>
+            template<class T, std::enable_if_t<is_insert_range<T>::value || is_insert<T>::value, bool> = true>
             int64 execute(const prepared_statement_t<T>& statement) {
                 using statement_type = typename std::decay<decltype(statement)>::type;
                 using expression_type = typename statement_type::expression_type;
@@ -1552,13 +1556,17 @@ namespace sqlite_orm {
                 return res;
             }
 
-            template<class... CTEs, class T, class... Args, class R = typename column_result_t<self, T>::type>
-            std::vector<R> execute(const prepared_statement_t<with_t<select_t<T, Args...>, CTEs...>>& statement) {
+            template<class... CTEs, class T, class... Args>
+            auto execute(const prepared_statement_t<with_t<select_t<T, Args...>, CTEs...>>& statement) {
+                using S =
+                    decltype(storage_for_expression(*this, std::declval<with_t<select_t<T, Args...>, CTEs...>>()));
+                using R = column_result_of_t<S, T>;
                 return _execute_select<R>(statement);
             }
 
-            template<class T, class... Args, class R = typename column_result_t<self, T>::type>
-            std::vector<R> execute(const prepared_statement_t<select_t<T, Args...>>& statement) {
+            template<class T, class... Args>
+            auto execute(const prepared_statement_t<select_t<T, Args...>>& statement) {
+                using R = column_result_of_t<self, T>;
                 return _execute_select<R>(statement);
             }
 
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 770c5e3b3..5d41a6a1e 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -185,9 +185,9 @@ namespace sqlite_orm {
             }
 
             std::string find_table_name(std::type_index ti) const {
-                std::type_index thisTypeIndex{typeid(std::conditional_t<std::is_void<typename H::cte_label_type>::value,
-                                                                        typename H::object_type,
-                                                                        typename H::cte_label_type>)};
+                std::type_index thisTypeIndex{typeid(std::conditional_t<std::is_void<cte_label_type_t<H>>::value,
+                                                                        object_type_t<H>,
+                                                                        cte_label_type_t<H>>)};
                 if(thisTypeIndex == ti) {
                     return this->table.name;
                 } else {
@@ -340,12 +340,13 @@ namespace sqlite_orm {
         template<>
         struct storage_impl<> : storage_impl_base {
 
+            // Provided just to be on the safe side
             template<class Lookup>
             const storage_impl<>& get_impl() const {
                 static_assert(polyfill::always_false_v<Lookup>, "No such storage implementation");
             }
 
-            std::nullptr_t get_table() const {
+            const void* get_table() const {
                 return nullptr;
             }
 
@@ -363,24 +364,27 @@ namespace sqlite_orm {
     }
 }
 
-#include "storage_traits.h"
+#include "storage_lookup.h"
 
 // interface functions
 namespace sqlite_orm {
     namespace internal {
 
         template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
-        const auto* lookup_table(const S& strg) {
+        auto lookup_table(const S& strg) {
             return find_impl<Lookup>(strg).get_table();
         }
 
         template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
         std::string lookup_table_name(const S& strg) {
-            if(auto* table = lookup_table<Lookup>(strg)) {
-                return table->name;
-            }
-
-            return {};
+            auto table = lookup_table<Lookup>(strg);
+            return static_if<std::is_same<decltype(table), const void*>{}>(
+                [](const void*) {
+                    return std::string{};
+                },
+                [](auto table) {
+                    return table->name;
+                })(table);
         }
 
         template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
diff --git a/dev/storage_lookup.h b/dev/storage_lookup.h
index 64fa5a425..b5e42bc85 100644
--- a/dev/storage_lookup.h
+++ b/dev/storage_lookup.h
@@ -2,6 +2,7 @@
 
 #include <type_traits>
 
+#include "cxx_polyfill.h"
 #include "type_traits.h"
 
 namespace sqlite_orm {
@@ -29,32 +30,35 @@ namespace sqlite_orm {
         template<class... Ts>
         struct is_storage_impl<const storage_impl<Ts...>> : std::true_type {};
 
-        /**
-         *  A mapped data type's CTE alias by which a CTE table descriptor can be found.
-         */
-        template<typename O>
-        using cte_label_t = typename O::cte_label_type;
-
         /**
          *  A data type's CTE alias, otherwise T itself is used as a CTE alias.
          */
         template<typename T>
-        using detected_cte_label_t = polyfill::detected_or_t<T, cte_label_t, T>;
-    }
-
-    namespace internal {
+        using detected_cte_label_t = polyfill::detected_or_t<T, cte_label_type_t, T>;
 
+        /**
+         *  std::true_type if given object is mapped, std::false_type otherwise
+         */
         template<typename S, typename O>
         using object_type_matches =
-            typename std::conjunction<std::is_void<typename S::table_type::cte_label_type>,
-                                      std::is_same<O, typename S::table_type::object_type>>::type;
+            typename polyfill::conjunction<std::is_void<typename S::table_type::cte_label_type>,
+                                           std::is_same<O, typename S::table_type::object_type>>::type;
+
+        /**
+         *  std::true_type if object is mapped via given (CTE) label, std::false_type otherwise
+         */
         template<typename S, typename Label>
-        using label_type_matches = typename std::conjunction<
+        using label_type_matches = typename polyfill::conjunction<
             std::negation<std::is_void<typename S::table_type::cte_label_type>>,
             std::is_same<detected_cte_label_t<Label>, typename S::table_type::cte_label_type>>::type;
+
         template<typename S, typename Lookup>
         using lookup_type_matches =
-            typename std::disjunction<object_type_matches<S, Lookup>, label_type_matches<S, Lookup>>::type;
+            typename polyfill::disjunction<object_type_matches<S, Lookup>, label_type_matches<S, Lookup>>::type;
+    }
+
+    // pick/lookup metafunctions
+    namespace internal {
 
         /**
          *  S - storage_impl type
@@ -85,16 +89,6 @@ namespace sqlite_orm {
         struct storage_pick_impl_type<storage_t<Ts...>, O, void>
             : storage_pick_impl_type<typename storage_t<Ts...>::impl_type, O> {};
 
-        /**
-         *  S - storage_t or storage_impl type
-         *  Lookup - mapped data type or CTE label
-         */
-        template<class S, class Lookup>
-        using storage_pick_impl_t =
-            std::conditional_t<std::is_const<S>::value,
-                               std::add_const_t<typename storage_pick_impl_type<std::remove_const_t<S>, Lookup>::type>,
-                               typename storage_pick_impl_type<S, Lookup>::type>;
-
         /**
          *  S - storage_impl type
          *  O - mapped data type or CTE label
@@ -125,6 +119,20 @@ namespace sqlite_orm {
         template<class... Ts, class O>
         struct storage_find_impl_type<storage_t<Ts...>, O, void>
             : storage_find_impl_type<typename storage_t<Ts...>::impl_type, O> {};
+    }
+
+    namespace internal {
+
+        /**
+         *  S - storage_t or storage_impl type
+         *  Lookup - mapped data type or CTE label
+         */
+        template<class S, class Lookup>
+        using storage_pick_impl_t =
+            std::conditional_t<std::is_const<S>::value,
+                               const typename storage_pick_impl_type<std::remove_const_t<S>, Lookup>::type,
+                               // note: need to remove const on this branch, too, due to SFINAE
+                               typename storage_pick_impl_type<std::remove_const_t<S>, Lookup>::type>;
 
         /**
          *  S - storage_t or storage_impl type
@@ -133,36 +141,28 @@ namespace sqlite_orm {
         template<class S, class Lookup>
         using storage_find_impl_t =
             std::conditional_t<std::is_const<S>::value,
-                               std::add_const_t<typename storage_find_impl_type<std::remove_const_t<S>, Lookup>::type>,
-                               typename storage_find_impl_type<S, Lookup>::type>;
+                               const typename storage_find_impl_type<std::remove_const_t<S>, Lookup>::type,
+                               // note: need to remove const on this branch, too, due to SFINAE
+                               typename storage_find_impl_type<std::remove_const_t<S>, Lookup>::type>;
     }
-
-    /**
-      *  S - storage_t type
-      *  Lookup - mapped data type or CTE label
-      */
-    template<class S, class Lookup>
-    using storage_pick_impl_t = internal::storage_pick_impl_t<S, Lookup>;
-
-    /**
-      *  S - storage_t type
-      *  Lookup - mapped data type or CTE label
-      */
-    template<class S, class Lookup>
-    using storage_find_impl_t = internal::storage_find_impl_t<S, Lookup>;
 }
 
 // runtime lookup functions
 namespace sqlite_orm {
     namespace internal {
         template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
-        storage_pick_impl_t<S, Lookup>& pick_impl(S& strg) {
-            return strg;
+        storage_pick_impl_t<S, Lookup>& pick_impl(S& impl) {
+            return impl;
         }
 
         template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
-        storage_find_impl_t<S, Lookup>& find_impl(S& strg) {
-            return strg;
+        storage_find_impl_t<S, Lookup>& find_impl(S& impl) {
+            return impl;
+        }
+
+        template<class Lookup, class S, satisfies<is_storage, S> = true>
+        storage_pick_impl_t<const S, Lookup>& pick_const_impl(S& storage) {
+            return obtain_const_impl(storage);
         }
     }
 }
diff --git a/dev/table.h b/dev/table.h
index 8ed54d791..9971dc871 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -7,6 +7,7 @@
 #include <algorithm>  //  std::reverse, std::find_if
 
 #include "cxx_polyfill.h"
+#include "type_traits.h"
 #include "column_result.h"
 #include "static_magic.h"
 #include "typed_comparator.h"
@@ -24,10 +25,7 @@ namespace sqlite_orm {
          *  A mapped data type's CTE alias by which a CTE table descriptor can be found.
          */
         template<typename O>
-        using cte_label_t = typename O::cte_label_type;
-
-        template<typename O>
-        using cte_label_of_t = polyfill::detected_or_t<void, cte_label_t, O>;
+        using cte_label_of_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
 
         struct basic_table {
 
diff --git a/dev/type_traits.h b/dev/type_traits.h
index c37d81cc5..631296a0b 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -5,10 +5,8 @@
 #include "cxx_polyfill.h"
 
 namespace sqlite_orm {
+    // C++ generic traits used throughout the library
     namespace internal {
-        template<class T, template<typename...> class Primary>
-        using match_specialization_of = std::enable_if_t<polyfill::is_specialization_of_v<T, Primary>>;
-
         // enable_if for types
         template<template<typename...> class Op, class... Args>
         using match_if = std::enable_if_t<Op<Args...>::value>;
@@ -17,6 +15,10 @@ namespace sqlite_orm {
         template<template<typename...> class Op, class... Args>
         using match_if_not = std::enable_if_t<std::negation<Op<Args...>>::value>;
 
+        // enable_if for types
+        template<class T, template<typename...> class Primary>
+        using match_specialization_of = std::enable_if_t<polyfill::is_specialization_of_v<T, Primary>>;
+
         // enable_if for functions
         template<template<typename...> class Op, class... Args>
         using satisfies = std::enable_if_t<Op<Args...>::value, bool>;
@@ -24,5 +26,24 @@ namespace sqlite_orm {
         // enable_if for functions
         template<template<typename...> class Op, class... Args>
         using satisfies_not = std::enable_if_t<std::negation<Op<Args...>>::value, bool>;
+
+        // enable_if for functions
+        template<class T, template<typename...> class Primary>
+        using satisfies_is_specialization_of = std::enable_if_t<polyfill::is_specialization_of_v<T, Primary>, bool>;
+    }
+
+    // type name template aliases for syntactic sugar
+    namespace internal {
+        template<typename T>
+        using object_type_t = typename T::object_type;
+
+        template<typename T>
+        using cte_label_type_t = typename T::cte_label_type;
+
+        template<typename T>
+        using label_type_t = typename T::label_type;
+
+        template<typename T>
+        using expression_type_t = typename T::expression_type;
     }
 }
diff --git a/dev/view.h b/dev/view.h
index 4d17423c4..5be4ce069 100644
--- a/dev/view.h
+++ b/dev/view.h
@@ -41,11 +41,11 @@ namespace sqlite_orm {
             view_t(storage_type& stor, decltype(connection) conn, Args&&... args_) :
                 storage(stor), connection(std::move(conn)), args{std::make_tuple(std::forward<Args>(args_)...)} {}
 
-            size_t size() {
+            size_t size() const {
                 return this->storage.template count<T>();
             }
 
-            bool empty() {
+            bool empty() const {
                 return !this->size();
             }
 
@@ -53,7 +53,7 @@ namespace sqlite_orm {
                 sqlite3_stmt* stmt = nullptr;
                 auto db = this->connection.get();
                 using context_t = serializator_context<typename storage_type::impl_type>;
-                context_t context{this->storage.impl};
+                context_t context{obtain_const_impl(this->storage)};
                 context.skip_table_name = false;
                 context.replace_bindable_with_question = true;
                 auto query = serialize(this->args, context);

From 8fb53cd2b547415f48dd27baaddabcd324c7858f Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 14 Jan 2022 18:04:43 +0200
Subject: [PATCH 009/161] Cleanup code while programming CTEs

---
 dev/alias.h                  |  8 --------
 dev/column_result.h          | 12 ++++--------
 dev/cte.h                    |  7 ++++++-
 dev/cte_storage.h            |  2 +-
 dev/cte_types.h              |  9 ++++++++-
 dev/select_constraints.h     | 22 +++++++++++-----------
 dev/statement_serializator.h | 18 ++++++++----------
 dev/storage.h                |  5 ++---
 dev/storage_impl.h           | 12 ++++++------
 dev/storage_lookup.h         | 11 +++++------
 dev/table.h                  |  6 +++---
 dev/type_traits.h            | 10 ++++++++--
 12 files changed, 62 insertions(+), 60 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 0e790c5a0..9dd05d079 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -70,9 +70,6 @@ namespace sqlite_orm {
             using expression_type = E;
 
             expression_type expression;
-            // Whether to only serialize the alias;
-            // this is used together with refed_as() when selecting an aliased column from a subselect.
-            bool serializeAliasOnly = false;
         };
 
         template<class T>
@@ -97,11 +94,6 @@ namespace sqlite_orm {
         return {std::move(expression)};
     }
 
-    template<class T, class E>
-    internal::as_t<T, E> refed_as(E expression) {
-        return {std::move(expression), true};
-    }
-
     template<class T>
     internal::alias_holder<T> get() {
         return {};
diff --git a/dev/column_result.h b/dev/column_result.h
index cf5068260..53224f85d 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -197,18 +197,14 @@ namespace sqlite_orm {
         };
 
         template<class St, class T, class C>
-        struct column_result_t<St, alias_column_t<T, C>, void> {
-            using type = typename column_result_t<St, C>::type;
-        };
+        struct column_result_t<St, alias_column_t<T, C>, void> : column_result_t<St, C> {};
 
         template<class St, class T, class F>
-        struct column_result_t<St, column_pointer<T, F>> : column_result_t<St, F> {};
+        struct column_result_t<St, column_pointer<T, F>, void> : column_result_t<St, F> {};
 
         template<class St, class Label, size_t I>
-        struct column_result_t<St, column_pointer<Label, polyfill::index_constant<I>>>
-            : column_result_t<St,
-                              cte_getter_t<typename storage_pick_impl_t<St, Label>::table_type::object_type, I>,
-                              void> {};
+        struct column_result_t<St, column_pointer<Label, polyfill::index_constant<I>>, void>
+            : column_result_t<St, cte_getter_t<storage_object_type_t<storage_pick_impl_t<St, Label>>, I>> {};
 
         template<class St, class... Args>
         struct column_result_t<St, columns_t<Args...>, void> {
diff --git a/dev/cte.h b/dev/cte.h
index 08f89a125..2e8dcd244 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -11,6 +11,8 @@ namespace sqlite_orm {
 
     template<char C, char... Chars>
     struct cte_label {
+        using label_tag = cte_label_tag;
+
         static constexpr char str[] = {C, Chars..., '\0'};
 
         static constexpr const char* label() {
@@ -48,7 +50,10 @@ namespace sqlite_orm {
         }
     }
 
-    // index_constant<> from numeric literal
+    /**
+     *  index_constant<> from numeric literal.
+     *  E.g. 0_col, 1_col
+     */
     template<char... Chars>
     [[nodiscard]] constexpr decltype(auto) operator"" _col() {
         return polyfill::index_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{},
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 4d66838f1..2535dc9c9 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -72,7 +72,7 @@ namespace sqlite_orm {
         make_cte_table_using_column_indices(const S& storage, const CTE& cte, std::index_sequence<CIs...>) {
             using context_type = serializator_context<typename S::impl_type>;
             context_type context{obtain_const_impl(storage)};
-            std::vector<std::string> columnNames = collect_cte_column_names(cte.expression, cte.columnNames, context);
+            std::vector<std::string> columnNames = collect_cte_column_names(cte.expression, cte.explicitColumnNames, context);
 
             return create_cte_table_t<O, typename O::index_sequence>{
                 cte.label(),
diff --git a/dev/cte_types.h b/dev/cte_types.h
index b677a70b7..e218e949a 100644
--- a/dev/cte_types.h
+++ b/dev/cte_types.h
@@ -7,7 +7,14 @@
 #include "start_macros.h"
 
 namespace sqlite_orm {
+
+    /**
+     *  Classification of a label as a 'CTE' label.
+     */
+    struct cte_label_tag {};
+
     namespace internal {
+
         /*
          *  Tuple data structure for CTEs
          */
@@ -17,7 +24,7 @@ namespace sqlite_orm {
             using fields_type = std::tuple<Fs...>;
             using index_sequence = std::index_sequence_for<Fs...>;
             // this type name is used to detect the mapping from label to object
-            using cte_label_type = Label;
+            using label_type = Label;
 
             template<size_t I>
             decltype(auto) cget() const noexcept {
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index c6a5b50b8..c0921dd84 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -245,24 +245,24 @@ namespace sqlite_orm {
             using label_type = Label;
             using expression_type = Select;
 
-            std::vector<std::string> columnNames;
+            std::vector<std::string> explicitColumnNames;
             expression_type expression;
 
-            common_table_expression(std::vector<std::string> columnNames, expression_type expression) :
-                columnNames{move(columnNames)}, expression{std::move(expression)} {
-                this->expression.highest_level = false;
+            common_table_expression(std::vector<std::string> explicitColumnNames, expression_type expression) :
+                explicitColumnNames{move(explicitColumnNames)}, expression{std::move(expression)} {
+                this->expression.highest_level = true;
             }
         };
         template<class... CTEs>
         using common_table_expressions = std::tuple<CTEs...>;
 
         template<typename Label>
-        struct cte_maker {
-            std::vector<std::string> columnNames;
+        struct cte_builder {
+            std::vector<std::string> explicitColumnNames;
 
-            template<class Select>
-            internal::common_table_expression<Label, Select> operator()(Select sel) && {
-                return {move(this->columnNames), std::move(sel)};
+            template<class T, class... Args>
+            internal::common_table_expression<Label, select_t<T, Args...>> operator()(select_t<T, Args...> sel) && {
+                return {move(this->explicitColumnNames), std::move(sel)};
             }
         };
 
@@ -483,8 +483,8 @@ namespace sqlite_orm {
     template<class Label,
              class... ColumnNames,
              std::enable_if_t<polyfill::conjunction_v<std::is_convertible<ColumnNames, std::string>...>, bool> = true>
-    internal::cte_maker<Label> cte(ColumnNames... columnNames) {
-        return {{std::move(columnNames)...}};
+    internal::cte_builder<Label> cte(ColumnNames... explicitColumnNames) {
+        return {{std::move(explicitColumnNames)...}};
     }
 
     // tuple of CTEs
diff --git a/dev/statement_serializator.h b/dev/statement_serializator.h
index 07d2d0313..57884d762 100644
--- a/dev/statement_serializator.h
+++ b/dev/statement_serializator.h
@@ -214,11 +214,7 @@ namespace sqlite_orm {
             template<class C>
             std::string operator()(const statement_type& c, const C& context) const {
                 auto aliasString = alias_extractor<T>::get();
-                if(c.serializeAliasOnly) {
-                    return aliasString;
-                } else {
-                    return serialize(c.expression, context) + " AS " + aliasString;
-                }
+                return serialize(c.expression, context) + " AS " + aliasString;
             }
         };
 
@@ -484,12 +480,14 @@ namespace sqlite_orm {
 
             template<class Ctx>
             std::string operator()(const statement_type& c, const Ctx& context) const {
+                // A CTE always starts a new 'highest level' context
                 Ctx cteContext = context;
-                cteContext.use_parentheses = true;
+                cteContext.use_parentheses = false;
 
                 std::stringstream ss;
                 ss << static_cast<std::string>(c);
-                std::vector<std::string> columnNames = collect_cte_column_names(c.expression, c.columnNames, context);
+                std::vector<std::string> columnNames =
+                    collect_cte_column_names(c.expression, c.explicitColumnNames, context);
                 {
                     ss << '(';
                     for(size_t i = 0, n = columnNames.size(); i < n; ++i) {
@@ -501,7 +499,7 @@ namespace sqlite_orm {
                     ss << ')';
                 }
                 ss << " AS ";
-                ss << serialize(c.expression, cteContext);
+                ss << '(' << serialize(c.expression, cteContext) << ')';
                 return ss.str();
             }
         };
@@ -1705,7 +1703,7 @@ namespace sqlite_orm {
             template<class C>
             std::string operator()(const statement_type& sel, const C& context) const {
                 std::stringstream ss;
-                const auto isCompoundOperator = is_base_of_template<T, compound_operator>::value;
+                constexpr bool isCompoundOperator = is_base_of_template<T, compound_operator>::value;
                 if(!isCompoundOperator) {
                     if(!sel.highest_level && context.use_parentheses) {
                         ss << "(";
@@ -1757,7 +1755,7 @@ namespace sqlite_orm {
                 iterate_tuple(sel.conditions, [&context, &ss](auto& v) {
                     ss << ' ' << serialize(v, context);
                 });
-                if(!is_base_of_template<T, compound_operator>::value) {
+                if(!isCompoundOperator) {
                     if(!sel.highest_level && context.use_parentheses) {
                         ss << ")";
                     }
diff --git a/dev/storage.h b/dev/storage.h
index 0342615c4..5f30abd3a 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -161,15 +161,14 @@ namespace sqlite_orm {
             template<class O>
             void assert_insertable_type() const {
                 auto& tImpl = this->get_impl<O>();
-                using storage_impl_type = std::remove_cvref_t<decltype(tImpl)>;
-                using table_type = typename storage_impl_type::table_type;
+                using table_type = table_type_t<std::remove_cvref_t<decltype(tImpl)>>;
                 using elements_type = typename table_type::elements_type;
 
                 using is_without_rowid = std::integral_constant<bool, table_type::is_without_rowid>;
 
                 static_if<is_without_rowid{}>(
                     [](auto&) {
-                        static_assert(std::is_void<typename table_type::cte_label_type>::value,
+                        static_assert(std::is_void<label_type_t<table_type>>::value,
                                       "Attempting to execute 'insert' request for a CTE mapping.");
                     },
                     [](auto& tImpl) {  // unfortunately, this static_assert's can't see any composite keys((
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 5d41a6a1e..36103b5d1 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -185,9 +185,9 @@ namespace sqlite_orm {
             }
 
             std::string find_table_name(std::type_index ti) const {
-                std::type_index thisTypeIndex{typeid(std::conditional_t<std::is_void<cte_label_type_t<H>>::value,
+                std::type_index thisTypeIndex{typeid(std::conditional_t<std::is_void<label_type_t<H>>::value,
                                                                         object_type_t<H>,
-                                                                        cte_label_type_t<H>>)};
+                                                                        label_type_t<H>>)};
                 if(thisTypeIndex == ti) {
                     return this->table.name;
                 } else {
@@ -346,7 +346,7 @@ namespace sqlite_orm {
                 static_assert(polyfill::always_false_v<Lookup>, "No such storage implementation");
             }
 
-            const void* get_table() const {
+            std::nullptr_t get_table() const {
                 return nullptr;
             }
 
@@ -378,8 +378,8 @@ namespace sqlite_orm {
         template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
         std::string lookup_table_name(const S& strg) {
             auto table = lookup_table<Lookup>(strg);
-            return static_if<std::is_same<decltype(table), const void*>{}>(
-                [](const void*) {
+            return static_if<std::is_same<decltype(table), std::nullptr_t>{}>(
+                [](std::nullptr_t) {
                     return std::string{};
                 },
                 [](auto table) {
@@ -412,7 +412,7 @@ namespace sqlite_orm {
         constexpr decltype(auto) materialize_column_pointer(const S&,
                                                             const column_pointer<Label, polyfill::index_constant<I>>&) {
             using timpl_type = storage_pick_impl_t<S, Label>;
-            return cte_getter_v<typename timpl_type::table_type::object_type, I>;
+            return cte_getter_v<storage_object_type_t<timpl_type>, I>;
         }
 
         template<class Label, size_t I, class S, satisfies<is_storage_impl, S> = true>
diff --git a/dev/storage_lookup.h b/dev/storage_lookup.h
index b5e42bc85..07dd4010d 100644
--- a/dev/storage_lookup.h
+++ b/dev/storage_lookup.h
@@ -34,23 +34,22 @@ namespace sqlite_orm {
          *  A data type's CTE alias, otherwise T itself is used as a CTE alias.
          */
         template<typename T>
-        using detected_cte_label_t = polyfill::detected_or_t<T, cte_label_type_t, T>;
+        using detected_cte_label_t = polyfill::detected_or_t<T, label_type_t, T>;
 
         /**
          *  std::true_type if given object is mapped, std::false_type otherwise
          */
         template<typename S, typename O>
-        using object_type_matches =
-            typename polyfill::conjunction<std::is_void<typename S::table_type::cte_label_type>,
-                                           std::is_same<O, typename S::table_type::object_type>>::type;
+        using object_type_matches = typename polyfill::conjunction<std::is_void<storage_label_type_t<S>>,
+                                                                   std::is_same<O, storage_object_type_t<S>>>::type;
 
         /**
          *  std::true_type if object is mapped via given (CTE) label, std::false_type otherwise
          */
         template<typename S, typename Label>
         using label_type_matches = typename polyfill::conjunction<
-            std::negation<std::is_void<typename S::table_type::cte_label_type>>,
-            std::is_same<detected_cte_label_t<Label>, typename S::table_type::cte_label_type>>::type;
+            std::negation<std::is_void<storage_label_type_t<S>>>,
+            std::is_same<detected_cte_label_t<Label>, storage_label_type_t<S>>>::type;
 
         template<typename S, typename Lookup>
         using lookup_type_matches =
diff --git a/dev/table.h b/dev/table.h
index 9971dc871..5b7c9530e 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -22,10 +22,10 @@ namespace sqlite_orm {
     namespace internal {
 
         /**
-         *  A mapped data type's CTE alias by which a CTE table descriptor can be found.
+         *  A data type's label type, void otherwise.
          */
         template<typename O>
-        using cte_label_of_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
+        using label_of_t = polyfill::detected_or_t<void, label_type_t, O>;
 
         struct basic_table {
 
@@ -44,7 +44,7 @@ namespace sqlite_orm {
         struct table_t : basic_table {
             using super = basic_table;
             using object_type = O;
-            using cte_label_type = cte_label_of_t<O>;
+            using label_type = label_of_t<O>;
             using elements_type = std::tuple<Cs...>;
 
             static constexpr const int elements_count = static_cast<int>(std::tuple_size<elements_type>::value);
diff --git a/dev/type_traits.h b/dev/type_traits.h
index 631296a0b..cff6af0cc 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -38,10 +38,16 @@ namespace sqlite_orm {
         using object_type_t = typename T::object_type;
 
         template<typename T>
-        using cte_label_type_t = typename T::cte_label_type;
+        using label_type_t = typename T::label_type;
 
         template<typename T>
-        using label_type_t = typename T::label_type;
+        using table_type_t = typename T::table_type;
+
+        template<typename S>
+        using storage_object_type_t = typename S::table_type::object_type;
+
+        template<typename S>
+        using storage_label_type_t = typename S::table_type::label_type;
 
         template<typename T>
         using expression_type_t = typename T::expression_type;

From 21f976a4da9aa4b7e60fc9eb70a6bc1cc9892fa9 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 14 Jan 2022 18:07:58 +0200
Subject: [PATCH 010/161] Allow compound statements for recursive CTEs

---
 dev/column_result.h              |  4 +--
 dev/cte_column_names_collector.h | 17 ++++++++++
 dev/cte_storage.h                | 55 ++++++++++++++++++++++++++------
 dev/select_constraints.h         |  6 ++++
 dev/storage.h                    | 23 +++++++++++++
 5 files changed, 93 insertions(+), 12 deletions(-)

diff --git a/dev/column_result.h b/dev/column_result.h
index 53224f85d..61f485d36 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -218,8 +218,8 @@ namespace sqlite_orm {
         struct column_result_t<St, T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
             using left_type = typename T::left_type;
             using right_type = typename T::right_type;
-            using left_result = typename column_result_t<St, left_type>::type;
-            using right_result = typename column_result_t<St, right_type>::type;
+            using left_result = column_result_of_t<St, left_type>;
+            using right_result = column_result_of_t<St, right_type>;
             static_assert(std::is_same<left_result, right_result>::value,
                           "Compound subselect queries must return same types");
             using type = left_result;
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index 3fc7c1fd9..497abc212 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -38,6 +38,23 @@ namespace sqlite_orm {
             return collector(t, context);
         }
 
+        // For compound statements we just need to collect the column alias names of the left expression
+        template<class Compound>
+        struct cte_column_names_collector<Compound, std::enable_if_t<is_base_of_template<Compound, compound_operator>::value>> {
+            using expression_type = Compound;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& t, const Ctx& context) const {
+                auto newContext = context;
+                newContext.skip_table_name = true;
+                std::string columnName = serialize(t.left, newContext);
+                if(columnName.empty()) {
+                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                }
+                return {move(columnName)};
+            }
+        };
+
         template<class As>
         struct cte_column_names_collector<As, match_specialization_of<As, as_t>> {
             using expression_type = As;
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 2535dc9c9..f48ad3660 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -67,12 +67,46 @@ namespace sqlite_orm {
             return {std::forward<CTETables>(cteTables)..., pick_const_impl<object_type_t<Ts>>(storage).table...};
         }
 
+        /**
+         *  This function returns the expression contained in a subselect that is relevant for
+         *  creating the definition of a CTE table.
+         *  Because CTEs can recursively refer to themselves in a compound statement, parsing
+         *  the whole compound statement would lead to compiler errors if a column_pointer<>
+         *  can't be resolved. Therefore, at the time of building a CTE table, we are only
+         *  interested in the column results of the left expression.
+         */
+        template<class Select>
+        decltype(auto) get_cte_driving_expression(const Select& subSelect);
+
+        /**
+         *  Return given select expression.
+         */
+        template<class Select>
+        decltype(auto) get_cte_driving_expression(const Select& subSelect) {
+            return subSelect;
+        }
+
+        /**
+         *  Return left expression of compound statement.
+         */
+        template<class Compound,
+                 class... Args,
+                 std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+        decltype(auto) get_cte_driving_expression(const select_t<Compound, Args...>& subSelect) {
+            return subSelect.col.left;
+        }
+
+        template<typename Select>
+        using cte_driving_expression_t =
+            std::remove_cvref_t<decltype(get_cte_driving_expression(std::declval<Select>()))>;
+
         template<typename O, typename S, typename CTE, size_t... CIs>
         create_cte_table_t<O, typename O::index_sequence>
         make_cte_table_using_column_indices(const S& storage, const CTE& cte, std::index_sequence<CIs...>) {
             using context_type = serializator_context<typename S::impl_type>;
             context_type context{obtain_const_impl(storage)};
-            std::vector<std::string> columnNames = collect_cte_column_names(cte.expression, cte.explicitColumnNames, context);
+            std::vector<std::string> columnNames =
+                collect_cte_column_names(get_cte_driving_expression(cte.expression), cte.explicitColumnNames, context);
 
             return create_cte_table_t<O, typename O::index_sequence>{
                 cte.label(),
@@ -91,25 +125,26 @@ namespace sqlite_orm {
             return storage_impl_cat(
                 storage,
                 make_cte_table<
-                    create_column_results_t<label_type_t<CTEs>, column_result_of_t<S, expression_type_t<CTEs>>>>(
+                    create_column_results_t<label_type_t<CTEs>,
+                                            column_result_of_t<S, cte_driving_expression_t<expression_type_t<CTEs>>>>>(
                     storage,
                     get<TIs>(e.cte))...);
         }
 
         /**
-         *  Return new storage_impl for CTE expressions.
+         *  Return const storage_impl of storage_t.
          */
-        template<class S, class E, class... CTEs, satisfies<is_storage, S> = true>
-        decltype(auto) storage_for_expression(S& storage, const with_t<E, CTEs...>& e) {
-            return make_cte_storage_using_table_indices(storage, e, std::index_sequence_for<CTEs...>{});
+        template<class S, class E, satisfies<is_storage, S> = true>
+        decltype(auto) storage_for_expression(S& storage, const E&) {
+            return obtain_const_impl(storage);
         }
 
         /**
-         *  Return const storage_impl of storage.
+         *  Return new storage_impl for CTE expressions.
          */
-        template<class S, class E, satisfies<is_storage, S> = true>
-        decltype(auto) storage_for_expression(S& storage, const E&) {
-            return obtain_const_impl(storage);
+        template<class S, class E, class... CTEs, satisfies<is_storage, S> = true>
+        decltype(auto) storage_for_expression(S& storage, const with_t<E, CTEs...>& e) {
+            return make_cte_storage_using_table_indices(storage, e, std::index_sequence_for<CTEs...>{});
         }
     }
 }
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index c0921dd84..744d152da 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -264,6 +264,12 @@ namespace sqlite_orm {
             internal::common_table_expression<Label, select_t<T, Args...>> operator()(select_t<T, Args...> sel) && {
                 return {move(this->explicitColumnNames), std::move(sel)};
             }
+
+            template<class Compound,
+                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            internal::common_table_expression<Label, select_t<Compound>> operator()(Compound sel) && {
+                return {move(this->explicitColumnNames), {std::move(sel)}};
+            }
         };
 
         /**
diff --git a/dev/storage.h b/dev/storage.h
index 5f30abd3a..aadc09799 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -575,6 +575,29 @@ namespace sqlite_orm {
                 return this->execute(statement);
             }
 
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class Label,
+                     class Select,
+                     class Compound,
+                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            auto with(common_table_expression<Label, Select> cte, Compound sel) {
+                auto statement = this->prepare(sqlite_orm::with(move(cte), sqlite_orm::select(std::move(sel))));
+                return this->execute(statement);
+            }
+
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class... CTEs,
+                     class Compound,
+                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            auto with(common_table_expressions<CTEs...> cte, Compound sel) {
+                auto statement = this->prepare(sqlite_orm::with(move(cte), sqlite_orm::select(std::move(sel))));
+                return this->execute(statement);
+            }
+
             template<class T, satisfies<is_prepared_statement, T> = true>
             std::string dump(const T& preparedStatement) const {
                 const auto& exprImpl = storage_for_expression(*this, preparedStatement.expression);

From df34bb5b1b34a43d562bfddca9e2d47ba15d88e1 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 15 Jan 2022 00:35:45 +0200
Subject: [PATCH 011/161] Complex recursive CTEs

---
 dev/conditions.h                 |  8 +++--
 dev/cte_column_names_collector.h |  6 +---
 dev/cte_storage.h                | 59 ++++++++++++++++++++++----------
 dev/statement_serializator.h     |  6 +++-
 dev/storage.h                    |  1 +
 5 files changed, 53 insertions(+), 27 deletions(-)

diff --git a/dev/conditions.h b/dev/conditions.h
index 169e53dd3..070b39b85 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -753,7 +753,7 @@ namespace sqlite_orm {
          */
         template<class F, class O>
         struct using_t {
-            F O::*column = nullptr;
+            column_pointer<O, F> column;
 
             operator std::string() const {
                 return "USING";
@@ -1000,9 +1000,13 @@ namespace sqlite_orm {
     }
 
     template<class F, class O>
-    internal::using_t<F, O> using_(F O::*p) {
+    internal::using_t<F O::*, O> using_(F O::*p) {
         return {std::move(p)};
     }
+    template<class F, class O>
+    internal::using_t<F, O> using_(internal::column_pointer<O, F> cp) {
+        return {std::move(cp)};
+    }
 
     template<class T>
     internal::on_t<T> on(T t) {
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index 497abc212..b4ce8c463 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -47,11 +47,7 @@ namespace sqlite_orm {
             std::vector<std::string> operator()(const expression_type& t, const Ctx& context) const {
                 auto newContext = context;
                 newContext.skip_table_name = true;
-                std::string columnName = serialize(t.left, newContext);
-                if(columnName.empty()) {
-                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
-                }
-                return {move(columnName)};
+                return get_cte_column_names(t.left.col, context);
             }
         };
 
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index f48ad3660..efc283c51 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -63,8 +63,9 @@ namespace sqlite_orm {
         using create_cte_table_t = typename create_cte_table<O, IdxSeq>::type;
 
         template<typename... Ts, typename... CTETables>
-        storage_impl<CTETables..., Ts...> storage_impl_cat(const storage_t<Ts...>& storage, CTETables&&... cteTables) {
-            return {std::forward<CTETables>(cteTables)..., pick_const_impl<object_type_t<Ts>>(storage).table...};
+        storage_impl<CTETables..., Ts...> storage_impl_cat(const storage_impl<Ts...>& storage,
+                                                           CTETables&&... cteTables) {
+            return {std::forward<CTETables>(cteTables)..., pick_impl<object_type_t<Ts>>(storage).table...};
         }
 
         /**
@@ -102,9 +103,10 @@ namespace sqlite_orm {
 
         template<typename O, typename S, typename CTE, size_t... CIs>
         create_cte_table_t<O, typename O::index_sequence>
-        make_cte_table_using_column_indices(const S& storage, const CTE& cte, std::index_sequence<CIs...>) {
-            using context_type = serializator_context<typename S::impl_type>;
-            context_type context{obtain_const_impl(storage)};
+        make_cte_table_using_column_indices(const S& impl, const CTE& cte, std::index_sequence<CIs...>) {
+            using context_type = serializator_context<S>;
+            context_type context{impl};
+
             std::vector<std::string> columnNames =
                 collect_cte_column_names(get_cte_driving_expression(cte.expression), cte.explicitColumnNames, context);
 
@@ -114,21 +116,38 @@ namespace sqlite_orm {
         }
 
         template<typename O, typename S, typename CTE>
-        create_cte_table_t<O, typename O::index_sequence> make_cte_table(const S& storage, const CTE& cte) {
-            return make_cte_table_using_column_indices<O>(storage, cte, typename O::index_sequence{});
+        create_cte_table_t<O, typename O::index_sequence> make_cte_table(const S& impl, const CTE& cte) {
+            return make_cte_table_using_column_indices<O>(impl, cte, typename O::index_sequence{});
+        }
+
+        template<typename S, typename... CTEs, size_t TI1>
+        decltype(auto) make_recursive_cte_storage_using_table_indices(const S& impl,
+                                                                      const common_table_expressions<CTEs...>& cte,
+                                                                      std::index_sequence<TI1>) {
+            using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
+
+            auto tbl = make_cte_table<
+                create_column_results_t<label_type_t<cte_t>,
+                                        column_result_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>>>(
+                impl,
+                get<TI1>(cte));
+            return storage_impl_cat(impl, std::move(tbl));
         }
 
-        template<class S, class E, class... CTEs, size_t... TIs>
-        decltype(auto) make_cte_storage_using_table_indices(const S& storage,
-                                                            const with_t<E, CTEs...>& e,
-                                                            std::index_sequence<TIs...>) {
-            return storage_impl_cat(
-                storage,
-                make_cte_table<
-                    create_column_results_t<label_type_t<CTEs>,
-                                            column_result_of_t<S, cte_driving_expression_t<expression_type_t<CTEs>>>>>(
-                    storage,
-                    get<TIs>(e.cte))...);
+        template<typename S, typename... CTEs, size_t TI1, size_t... TIn>
+        decltype(auto) make_recursive_cte_storage_using_table_indices(const S& impl,
+                                                                      const common_table_expressions<CTEs...>& cte,
+                                                                      std::index_sequence<TI1, TIn...>) {
+            using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
+
+            auto tbl = make_cte_table<
+                create_column_results_t<label_type_t<cte_t>,
+                                        column_result_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>>>(
+                impl,
+                get<TI1>(cte));
+            return make_recursive_cte_storage_using_table_indices(storage_impl_cat(impl, std::move(tbl)),
+                                                                  cte,
+                                                                  std::index_sequence<TIn...>{});
         }
 
         /**
@@ -144,7 +163,9 @@ namespace sqlite_orm {
          */
         template<class S, class E, class... CTEs, satisfies<is_storage, S> = true>
         decltype(auto) storage_for_expression(S& storage, const with_t<E, CTEs...>& e) {
-            return make_cte_storage_using_table_indices(storage, e, std::index_sequence_for<CTEs...>{});
+            return make_recursive_cte_storage_using_table_indices(obtain_const_impl(storage),
+                                                                  e.cte,
+                                                                  std::index_sequence_for<CTEs...>{});
         }
     }
 }
diff --git a/dev/statement_serializator.h b/dev/statement_serializator.h
index 57884d762..8cb4fe861 100644
--- a/dev/statement_serializator.h
+++ b/dev/statement_serializator.h
@@ -1857,9 +1857,13 @@ namespace sqlite_orm {
 
             template<class C>
             std::string operator()(const statement_type& statement, const C& context) const {
+                auto newContext = context;
+                // be on the safe side
+                newContext.skip_table_name = false;
+
                 std::stringstream ss;
                 ss << statement.serialize() << " ";
-                auto whereString = serialize(statement.expression, context);
+                auto whereString = serialize(statement.expression, newContext);
                 ss << '(' << whereString << ')';
                 return ss.str();
             }
diff --git a/dev/storage.h b/dev/storage.h
index aadc09799..5af62a65e 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -603,6 +603,7 @@ namespace sqlite_orm {
                 const auto& exprImpl = storage_for_expression(*this, preparedStatement.expression);
                 using context_t = serializator_context<std::remove_cvref_t<decltype(exprImpl)>>;
                 context_t context{exprImpl};
+                context.skip_table_name = false;
                 return serialize(preparedStatement.expression, context);
             }
 

From 3b8473f536da797019d92e9d1e6b422299992c67 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 15 Jan 2022 21:00:57 +0200
Subject: [PATCH 012/161] Ability to order by nth column

---
 dev/conditions.h             | 17 ++++++++++++++++-
 dev/cte.h                    | 34 ++++++++++++++++++++++++++++++++++
 dev/cte_storage.h            | 14 +++++++++++---
 dev/select_constraints.h     | 17 ++++++++++++-----
 dev/statement_serializator.h | 15 +++++++++++++++
 dev/type_traits.h            |  5 +++++
 6 files changed, 93 insertions(+), 9 deletions(-)

diff --git a/dev/conditions.h b/dev/conditions.h
index 070b39b85..ae7f80bb4 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -6,6 +6,7 @@
 #include <tuple>  //  std::tuple, std::tuple_size
 #include <sstream>  //  std::stringstream
 
+#include "type_traits.h"
 #include "collate_argument.h"
 #include "constraints.h"
 #include "optional_container.h"
@@ -1197,12 +1198,26 @@ namespace sqlite_orm {
     /**
      * ORDER BY column
      * Example: storage.select(&User::name, order_by(&User::id))
+     * 
+     * Note: choosing a column by a numeric literal isn't supported, i.e. order_by(2),
+     * use order_by(2_nth_col) instead
      */
-    template<class O>
+    template<class O, internal::satisfies_not<std::is_arithmetic, O> = true>
     internal::order_by_t<O> order_by(O o) {
         return {std::move(o)};
     }
 
+    /**
+     * Note: index_constant<> is used for 0-based indexing,
+     * use order_by(2_nth_col) instead
+     */
+    template<size_t I>
+    internal::order_by_t<polyfill::index_constant<I>> order_by(polyfill::index_constant<I> n) {
+        static_assert(polyfill::always_false_v<polyfill::index_constant<I>>,
+                      "Please use 1_nth_col, 2_nth_col, ... instead");
+        return {n};
+    }
+
     /**
      * ORDER BY column1, column2
      * Example: storage.get_all<Singer>(multi_order_by(order_by(&Singer::name).asc(), order_by(&Singer::gender).desc())
diff --git a/dev/cte.h b/dev/cte.h
index 2e8dcd244..d2cd690a5 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -19,6 +19,7 @@ namespace sqlite_orm {
             return str;
         }
 
+        // CTE derives from a label, hence provide a string conversion operator
         explicit operator std::string() const {
             return cte_label::label();
         }
@@ -59,5 +60,38 @@ namespace sqlite_orm {
         return polyfill::index_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{},
                                                                  Chars...)>{};
     }
+
+    /**
+     *  integral_constant<unsigned int> from numeric literal.
+     *  E.g. 1_nth_col, 2_nth_col
+     */
+    template<char... Chars>
+    [[nodiscard]] constexpr decltype(auto) operator"" _nth_col() {
+        static_assert(((Chars != '0') && ...));
+        return internal::nth_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{},
+                                                               Chars...)>{};
+    }
+#else
+    constexpr polyfill::index_constant<0> _0_col{};
+    constexpr polyfill::index_constant<1> _1_col{};
+    constexpr polyfill::index_constant<2> _2_col{};
+    constexpr polyfill::index_constant<3> _3_col{};
+    constexpr polyfill::index_constant<4> _4_col{};
+    constexpr polyfill::index_constant<5> _5_col{};
+    constexpr polyfill::index_constant<6> _6_col{};
+    constexpr polyfill::index_constant<7> _7_col{};
+    constexpr polyfill::index_constant<8> _8_col{};
+    constexpr polyfill::index_constant<9> _9_col{};
+
+    constexpr internal::nth_constant<1> _1_nth_col{};
+    constexpr internal::nth_constant<2> _2_nth_col{};
+    constexpr internal::nth_constant<3> _3_nth_col{};
+    constexpr internal::nth_constant<4> _4_nth_col{};
+    constexpr internal::nth_constant<5> _5_nth_col{};
+    constexpr internal::nth_constant<6> _6_nth_col{};
+    constexpr internal::nth_constant<7> _7_nth_col{};
+    constexpr internal::nth_constant<8> _8_nth_col{};
+    constexpr internal::nth_constant<9> _9_nth_col{};
+    constexpr internal::nth_constant<10> _10_nth_col{};
 #endif
 }
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index efc283c51..03c173df9 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -62,6 +62,10 @@ namespace sqlite_orm {
         template<typename O, typename IdxSeq>
         using create_cte_table_t = typename create_cte_table<O, IdxSeq>::type;
 
+        /**
+         *  Concatenate newly created tables with those from an existing storage, forming a
+         *  new storage object
+         */
         template<typename... Ts, typename... CTETables>
         storage_impl<CTETables..., Ts...> storage_impl_cat(const storage_impl<Ts...>& storage,
                                                            CTETables&&... cteTables) {
@@ -131,6 +135,7 @@ namespace sqlite_orm {
                                         column_result_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>>>(
                 impl,
                 get<TI1>(cte));
+
             return storage_impl_cat(impl, std::move(tbl));
         }
 
@@ -145,9 +150,12 @@ namespace sqlite_orm {
                                         column_result_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>>>(
                 impl,
                 get<TI1>(cte));
-            return make_recursive_cte_storage_using_table_indices(storage_impl_cat(impl, std::move(tbl)),
-                                                                  cte,
-                                                                  std::index_sequence<TIn...>{});
+
+            return make_recursive_cte_storage_using_table_indices(
+                // Because CTEs can depend on their predecessor we recursively pass in a new storage object
+                storage_impl_cat(impl, std::move(tbl)),
+                cte,
+                std::index_sequence<TIn...>{});
         }
 
         /**
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 744d152da..39870ad40 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -261,13 +261,13 @@ namespace sqlite_orm {
             std::vector<std::string> explicitColumnNames;
 
             template<class T, class... Args>
-            internal::common_table_expression<Label, select_t<T, Args...>> operator()(select_t<T, Args...> sel) && {
+            common_table_expression<Label, select_t<T, Args...>> operator()(select_t<T, Args...> sel) && {
                 return {move(this->explicitColumnNames), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            internal::common_table_expression<Label, select_t<Compound>> operator()(Compound sel) && {
+            common_table_expression<Label, select_t<Compound>> operator()(Compound sel) && {
                 return {move(this->explicitColumnNames), {std::move(sel)}};
             }
         };
@@ -440,13 +440,20 @@ namespace sqlite_orm {
      *  struct MyType : BaseType { ... };
      *  storage.select(column<MyType>(&BaseType::id));
      *  // ... or
-     *  struct MyType : BaseType { ... };
+     *  struct Object { ... };
      *  storage.with(cte<cte_1>()(select(&Object::id), select(column<cte_1>(0_col)));
      */
-    template<class T, class F>
-    internal::column_pointer<T, F> column(F f) {
+    template<class O, class F>
+    internal::column_pointer<O, F> column(F f) {
         return {std::move(f)};
     }
+    /**
+     *  Turn 1_nth_col-> 0_col
+     */
+    template<class O, unsigned int I>
+    auto column(internal::nth_constant<I>) {
+        return column<O>(polyfill::index_constant<I - 1>{});
+    }
 
     /**
      *  Public function for subselect query. Is useful in UNION queries.
diff --git a/dev/statement_serializator.h b/dev/statement_serializator.h
index 8cb4fe861..670523af3 100644
--- a/dev/statement_serializator.h
+++ b/dev/statement_serializator.h
@@ -42,6 +42,21 @@ namespace sqlite_orm {
             return serializator(t, context);
         }
 
+        /**
+         *  Constant which gets never replaced in a bindable context.
+         *  Used together with order_by(1_nth_col).
+         */
+        template<unsigned int N>
+        struct statement_serializator<nth_constant<N>, void> {
+            using statement_type = nth_constant<N>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& /*expression*/, const Ctx&) {
+                static_assert(N > 0);
+                return std::to_string(N);
+            }
+        };
+
         template<class T>
         struct statement_serializator<T, typename std::enable_if<is_bindable<T>::value>::type> {
             using statement_type = T;
diff --git a/dev/type_traits.h b/dev/type_traits.h
index cff6af0cc..6684da3e4 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -52,4 +52,9 @@ namespace sqlite_orm {
         template<typename T>
         using expression_type_t = typename T::expression_type;
     }
+
+    namespace internal {
+        template<unsigned int N>
+        using nth_constant = std::integral_constant<unsigned int, N>;
+    }
 }

From 805b2c906019366fc4a8b22c817c56eeddba7641 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 15 Jan 2022 21:01:31 +0200
Subject: [PATCH 013/161] Provided dump function for expressions

---
 dev/storage.h | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/dev/storage.h b/dev/storage.h
index 5af62a65e..9e84910ad 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -599,12 +599,18 @@ namespace sqlite_orm {
             }
 
             template<class T, satisfies<is_prepared_statement, T> = true>
-            std::string dump(const T& preparedStatement) const {
-                const auto& exprImpl = storage_for_expression(*this, preparedStatement.expression);
+            std::string dump(const T& preparedStatement, bool asBindable = true) const {
+                return this->dump(preparedStatement.expression, asBindable);
+            }
+
+            template<class E, satisfies_not<is_prepared_statement, E> = true>
+            std::string dump(const E& expression, bool asBindable = false) const {
+                const auto& exprImpl = storage_for_expression(*this, expression);
                 using context_t = serializator_context<std::remove_cvref_t<decltype(exprImpl)>>;
                 context_t context{exprImpl};
+                context.replace_bindable_with_question = asBindable;
                 context.skip_table_name = false;
-                return serialize(preparedStatement.expression, context);
+                return serialize(expression, context);
             }
 
             /**

From 908dab4d5680e9f2aada233b75a7dfde8fe517d5 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 15 Jan 2022 21:01:47 +0200
Subject: [PATCH 014/161] Added cte.h to amalgamation script

---
 third_party/amalgamate/config.json | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/third_party/amalgamate/config.json b/third_party/amalgamate/config.json
index 0d995cc85..7bcaf7a17 100755
--- a/third_party/amalgamate/config.json
+++ b/third_party/amalgamate/config.json
@@ -5,10 +5,10 @@
 		"dev/start_macros.h",
 		"dev/error_code.h",
 		"dev/tuple_helper/tuple_helper.h",
-        "dev/tuple_helper/find_in_tuple.h",
-        "dev/tuple_helper/tuple_transformer.h",
-        "dev/tuple_helper/count_tuple.h",
-        "dev/tuple_helper/same_or_void.h",
+		"dev/tuple_helper/find_in_tuple.h",
+		"dev/tuple_helper/tuple_transformer.h",
+		"dev/tuple_helper/count_tuple.h",
+		"dev/tuple_helper/same_or_void.h",
 		"dev/xdestroy_handling.h",
 		"dev/type_printer.h",
 		"dev/collate_argument.h",
@@ -39,6 +39,7 @@
 		"dev/table.h",
 		"dev/storage_impl.h",
 		"dev/storage.h",
+		"dev/cte.h",
 		"dev/finish_macros.h",
 		"dev/node_tuple.h",
 		"dev/get_prepared_statement.h",

From e4092bffe9c8402f2ae7ddb55b004ec30ae5cdc0 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 15 Jan 2022 21:18:03 +0200
Subject: [PATCH 015/161] Added a few with-clause examples

---
 dev/select_constraints.h              |   6 +
 examples/common_table_expressions.cpp | 335 ++++++++++++++++++++++++++
 examples/self_join.cpp                |   4 +-
 3 files changed, 343 insertions(+), 2 deletions(-)
 create mode 100644 examples/common_table_expressions.cpp

diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 39870ad40..b4a50ed05 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -492,6 +492,12 @@ namespace sqlite_orm {
 
     /**
      *  Example : cte<cte_1>()(select(&Object::id));
+     *  The list of column names is optional;
+     *  if provided the number of columns must match the number of columns of the subselect.
+     *  The column names will be merged with the subselect:
+     *  1. column names of subselect
+     *  2. explicit columns
+     *  3. fill in empty column names with stringified column index
      */
     template<class Label,
              class... ColumnNames,
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
new file mode 100644
index 000000000..3e5fdb655
--- /dev/null
+++ b/examples/common_table_expressions.cpp
@@ -0,0 +1,335 @@
+/**
+ *  Examples partially from https://sqlite.org/lang_with.html
+ */
+
+#include <tuple>
+#include <iostream>
+#include <sqlite_orm/sqlite_orm.h>
+
+using std::cout;
+using std::endl;
+using std::make_tuple;
+using std::nullopt;
+using std::string;
+using std::system_error;
+using namespace sqlite_orm;
+
+void all_integers_between(int from, int end) {
+    auto storage = make_storage("");
+
+    // variant 1, where-clause
+    {
+        //WITH RECURSIVE
+        //    cnt(x) AS(VALUES(1) UNION ALL SELECT x + 1 FROM cnt WHERE x < 1000000)
+        //    SELECT x FROM cnt;
+        auto ast =
+            with(cte<cte_1>("x")(
+                     union_all(select(from), select(column<cte_1>(0_col) + c(1), where(column<cte_1>(0_col) < end)))),
+                 select(column<cte_1>(0_col)));
+
+        string sql = storage.dump(ast);
+
+        auto stmt = storage.prepare(ast);
+        cout << "Integer range (where-clause) [" << from << ", " << end
+             << "]"
+                "\n";
+        for(int n: storage.execute(stmt)) {
+            cout << n << ", ";
+        }
+        cout << endl;
+    }
+
+    // variant 2, limit-clause
+    {
+        //WITH RECURSIVE
+        //    cnt(x) AS(
+        //        SELECT 1
+        //        UNION ALL
+        //        SELECT x + 1 FROM cnt
+        //        LIMIT 1000000
+        //    )
+        //    SELECT x FROM cnt;
+        auto ast = with(cte<cte_1>("x")(union_all(select(from), select(column<cte_1>(0_col) + c(1), limit(end)))),
+                        select(column<cte_1>(0_col)));
+
+        string sql = storage.dump(ast);
+
+        auto stmt = storage.prepare(ast);
+        cout << "Integer range (limit-clause) [" << from << ", " << end
+             << "]"
+                "\n";
+        for(int n: storage.execute(stmt)) {
+            cout << n << ", ";
+        }
+        cout << endl;
+    }
+}
+
+void works_for_alice() {
+    //CREATE TABLE org(
+    //  name TEXT PRIMARY KEY,
+    //  boss TEXT REFERENCES org,
+    //  height INT,
+    //  -- other content omitted
+    //);
+    struct Org {
+        std::string name;
+        std::optional<std::string> boss;
+        double height;
+    };
+
+    auto storage = make_storage("",
+                                make_table<Org>("org",
+                                                make_column("name", &Org::name, primary_key()),
+                                                make_column("boss", &Org::boss),
+                                                make_column("height", &Org::height),
+                                                foreign_key(&Org::boss).references(&Org::name)));
+    storage.sync_schema();
+
+    storage.replace<Org>({"Alice", nullopt, 160.});
+    storage.replace<Org>({"Bob", nullopt, 177.});
+    storage.replace<Org>({"Foo", "Alice", 165.});
+    storage.replace<Org>({"Bar", "Bob", 159.});
+
+    c(&Org::height) + 1;
+
+    //WITH RECURSIVE
+    //    works_for_alice(n) AS(
+    //        VALUES('Alice')
+    //        UNION
+    //        SELECT name FROM org, works_for_alice
+    //        WHERE org.boss = works_for_alice.n
+        //    )
+        //    SELECT avg(height) FROM org
+        //    WHERE org.name IN works_for_alice;
+        auto ast = with(
+            cte<cte_1>("n")(union_(select("Alice"), select(&Org::name, where(c(&Org::boss) == column<cte_1>(0_col))))),
+            select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<cte_1>(0_col))))));
+
+        //WITH cte_1("n")
+    //    AS(
+    //        SELECT 'Alice'
+    //        UNION
+    //        SELECT "org"."name" FROM 'cte_1', 'org'
+    //        WHERE("org"."boss" = 'cte_1'."n")
+    //    )
+    //    SELECT AVG("org"."height")
+    //    FROM 'org'
+    //    WHERE(
+    //        "name" IN(
+    //            SELECT 'cte_1'."n" FROM 'cte_1'
+    //        )
+    //    )
+    string sql = storage.dump(ast);
+
+        auto stmt = storage.prepare(ast);
+        auto results = storage.execute(stmt);
+        cout << "Average height Alice's team: " << results.at(0) << endl;
+    }
+}
+
+void family_tree() {
+    //CREATE TABLE family(
+    //    name TEXT PRIMARY KEY,
+    //    mom TEXT REFERENCES family,
+    //    dad TEXT REFERENCES family,
+    //    born DATETIME,
+    //    died DATETIME, --NULL if still alive
+    //    -- other content
+    //);
+    struct Family {
+        std::string name;
+        std::optional<std::string> mom;
+        std::optional<std::string> dad;
+        time_t born;
+        std::optional<time_t> died;
+    };
+
+    auto storage = make_storage("",
+                                make_table<Family>("family",
+                                                   make_column("name", &Family::name, primary_key()),
+                                                   make_column("mom", &Family::mom),
+                                                   make_column("dad", &Family::dad),
+                                                   make_column("born", &Family::born),
+                                                   make_column("died", &Family::died),
+                                                   foreign_key(&Family::mom).references(&Family::name),
+                                                   foreign_key(&Family::dad).references(&Family::name)));
+    storage.sync_schema();
+
+    storage.replace<Family>({"Grandma (Mom)", nullopt, nullopt, 0, nullopt});
+    storage.replace<Family>({"Granddad (Mom)", nullopt, nullopt, 1, 1});
+    storage.replace<Family>({"Grandma (Dad)", nullopt, nullopt, 0, 0});
+    storage.replace<Family>({"Granddad (Dad)", nullopt, nullopt, 1, nullopt});
+    storage.replace<Family>({"Mom", "Grandma (Mom)", "Granddad (Mom)", 2, nullopt});
+    storage.replace<Family>({"Dad", "Grandma (Dad)", "Granddad (Dad)", 3, nullopt});
+    storage.replace<Family>({"Alice", "Mom", "Dad", 4, nullopt});
+
+    //WITH RECURSIVE
+    //    parent_of(name, parent) AS
+    //    (SELECT name, mom FROM family UNION SELECT name, dad FROM family),
+    //    ancestor_of_alice(name) AS
+    //    (SELECT parent FROM parent_of WHERE name = 'Alice'
+    //        UNION ALL
+    //        SELECT parent FROM parent_of JOIN ancestor_of_alice USING(name))
+    //    SELECT family.name FROM ancestor_of_alice, family
+    //    WHERE ancestor_of_alice.name = family.name
+    //    AND died IS NULL
+    //    ORDER BY born;
+    auto ast = with(make_tuple(cte<cte_1>("name", "parent")(union_(select(columns(&Family::name, &Family::mom)),
+                                                                   select(columns(&Family::name, &Family::dad)))),
+                               cte<cte_2>("name")(
+                                   union_all(select(column<cte_1>(1_col), where(column<cte_1>(0_col) == "Alice")),
+                                             select(column<cte_1>(1_col), join<cte_2>(using_(column<cte_1>(0_col))))))),
+                    select(&Family::name,
+                           where(is_equal(column<cte_2>(0_col), &Family::name) && is_null(&Family::died)),
+                           order_by(&Family::born)));
+
+    //WITH cte_1("name", "parent")
+    //    AS(
+    //        SELECT "family"."name", "family"."mom"
+    //        FROM 'family'
+    //        UNION
+    //        SELECT "family"."name", "family"."dad"
+    //        FROM 'family'
+    //    ),
+    //    cte_2("name")
+    //    AS(
+    //        SELECT 'cte_1'."parent"
+    //        FROM 'cte_1'
+    //        WHERE('cte_1'."name" = 'Alice')
+    //        UNION ALL
+    //        SELECT 'cte_1'."name"
+    //        FROM 'cte_1'
+    //        JOIN 'cte_2' USING("name")
+    //    )
+    //    SELECT "family"."name"
+    //    FROM 'cte_2',
+    //    'family'
+    //    WHERE(
+    //        (
+    //            ('cte_2'."name" = 'family'."name")
+    //            AND "family"."died" IS NULL
+    //            )
+    //    )
+    //    ORDER BY "family"."born"
+    string sql = storage.dump(ast);
+
+    auto stmt = storage.prepare(ast);
+    auto results = storage.execute(stmt);
+
+    cout << "Living ancestor's of Alice:\n";
+    for(const string& name: results) {
+        cout << name << endl;
+    }
+}
+
+void depth_or_breadth_first() {
+    //CREATE TABLE org(
+    //    name TEXT PRIMARY KEY,
+    //    boss TEXT REFERENCES org
+    //) WITHOUT ROWID;
+    //INSERT INTO org VALUES('Alice', NULL);
+    //INSERT INTO org VALUES('Bob', 'Alice');
+    //INSERT INTO org VALUES('Cindy', 'Alice');
+    //INSERT INTO org VALUES('Dave', 'Bob');
+    //INSERT INTO org VALUES('Emma', 'Bob');
+    //INSERT INTO org VALUES('Fred', 'Cindy');
+    //INSERT INTO org VALUES('Gail', 'Cindy');
+    //CREATE TABLE org(
+    //  name TEXT PRIMARY KEY,
+    //  boss TEXT REFERENCES org,
+    //  height INT,
+    //  -- other content omitted
+    //);
+    struct Org {
+        std::string name;
+        std::optional<std::string> boss;
+        double height;
+    };
+
+    auto storage = make_storage("",
+                                make_table<Org>("org",
+                                                make_column("name", &Org::name, primary_key()),
+                                                make_column("boss", &Org::boss),
+                                                foreign_key(&Org::boss).references(&Org::name)));
+    storage.sync_schema();
+
+    storage.replace<Org>({"Alice", nullopt});
+    storage.replace<Org>({"Bob", "Alice"});
+    storage.replace<Org>({"Cindy", "Alice"});
+    storage.replace<Org>({"Dave", "Bob"});
+    storage.replace<Org>({"Emma", "Bob"});
+    storage.replace<Org>({"Fred", "Cindy"});
+    storage.replace<Org>({"Gail", "Cindy"});
+
+    // breadth-first pattern
+    {
+        //WITH RECURSIVE
+        //    under_alice(name, level) AS(
+        //        VALUES('Alice', 0)
+        //        UNION ALL
+        //        SELECT org.name, under_alice.level + 1
+        //        FROM org JOIN under_alice ON org.boss = under_alice.name
+        //        ORDER BY 2
+        //    )
+        //    SELECT substr('..........', 1, level * 3) || name FROM under_alice;
+        auto ast =
+            with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
+                                                       select(columns(&Org::name, column<cte_1>(1_col) + c(1)),
+                                                              join<cte_1>(on(c(&Org::boss) == column<cte_1>(0_col))),
+                                                              order_by(2_nth_col)))),
+                 select(substr("..........", 1, column<cte_1>(1_col) * c(3)) || c(column<cte_1>(0_col))));
+
+        string sql = storage.dump(ast);
+
+        auto stmt = storage.prepare(ast);
+        auto results = storage.execute(stmt);
+
+        cout << "List of organization members, breadth-first:\n";
+        for(const string& name: results) {
+            cout << name << endl;
+        }
+    }
+
+    // depth-first pattern
+    {
+        //WITH RECURSIVE
+        //    under_alice(name, level) AS(
+        //        VALUES('Alice', 0)
+        //        UNION ALL
+        //        SELECT org.name, under_alice.level + 1
+        //        FROM org JOIN under_alice ON org.boss = under_alice.name
+        //        ORDER BY 2
+        //    )
+        //    SELECT substr('..........', 1, level * 3) || name FROM under_alice;
+        auto ast =
+            with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
+                                                       select(columns(&Org::name, column<cte_1>(1_col) + c(1)),
+                                                              join<cte_1>(on(c(&Org::boss) == column<cte_1>(0_col))),
+                                                              order_by(2_nth_col).desc()))),
+                 select(substr("..........", 1, column<cte_1>(1_col) * c(3)) || c(column<cte_1>(0_col))));
+
+        string sql = storage.dump(ast);
+
+        auto stmt = storage.prepare(ast);
+        auto results = storage.execute(stmt);
+
+        cout << "List of organization members, depth-first:\n";
+        for(const string& name: results) {
+            cout << name << endl;
+        }
+    }
+}
+
+int main() {
+    try {
+        all_integers_between(1, 10);
+        works_for_alice();
+        family_tree();
+        depth_or_breadth_first();
+    } catch(const system_error& e) {
+        cout << "[" << e.code() << "] " << e.what();
+    }
+
+    return 0;
+}
diff --git a/examples/self_join.cpp b/examples/self_join.cpp
index 51fc6d950..2c58e0e17 100644
--- a/examples/self_join.cpp
+++ b/examples/self_join.cpp
@@ -29,8 +29,8 @@ struct Employee {
 
 /**
  *  This is how custom alias is made:
- *  1) it must have `type` alias which is equal to your mapped class
- *  2) is must have static function with `get()` signature and return type with `operator<<`
+ *  1) it must have a `type` alias which is equal to your mapped class
+ *  2) it must have a static function with `get()` signature and return type with `operator<<`
  */
 template<class T>
 struct custom_alias : sqlite_orm::alias_tag {

From 85d92e11b4ae05919ff6e6cc819bceb311bbfa78 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 16 Jan 2022 17:58:18 +0200
Subject: [PATCH 016/161] Ability to select all columns from aliased table

---
 dev/alias.h                           | 10 ++-
 dev/column_names_getter.h             | 15 ++++-
 dev/column_result.h                   |  7 ++-
 dev/table_name_collector.h            | 12 +++-
 examples/common_table_expressions.cpp | 87 ++++++++++++++++++++++++---
 5 files changed, 117 insertions(+), 14 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 9dd05d079..9602254d5 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -45,17 +45,21 @@ namespace sqlite_orm {
         template<class T, class SFINAE = void>
         struct alias_extractor;
 
-        template<class T>
-        struct alias_extractor<T, typename std::enable_if<std::is_base_of<alias_tag, T>::value>::type> {
+        template<class A>
+        struct alias_extractor<A, typename std::enable_if<std::is_base_of<alias_tag, A>::value>::type> {
+            using object_type = typename A::type;
+
             static std::string get() {
                 std::stringstream ss;
-                ss << T::get();
+                ss << A::get();
                 return ss.str();
             }
         };
 
         template<class T>
         struct alias_extractor<T, typename std::enable_if<!std::is_base_of<alias_tag, T>::value>::type> {
+            using object_type = T;
+
             static std::string get() {
                 return {};
             }
diff --git a/dev/column_names_getter.h b/dev/column_names_getter.h
index ebef5581d..610b6a4d1 100644
--- a/dev/column_names_getter.h
+++ b/dev/column_names_getter.h
@@ -7,6 +7,7 @@
 
 #include "error_code.h"
 #include "select_constraints.h"
+#include "alias.h"
 
 namespace sqlite_orm {
 
@@ -49,7 +50,7 @@ namespace sqlite_orm {
         };
 
         template<class T>
-        struct column_names_getter<asterisk_t<T>, void> {
+        struct column_names_getter<asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>> {
             using expression_type = asterisk_t<T>;
 
             template<class C>
@@ -60,6 +61,18 @@ namespace sqlite_orm {
             }
         };
 
+        template<class A>
+        struct column_names_getter<asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>> {
+            using expression_type = asterisk_t<A>;
+
+            template<class C>
+            std::vector<std::string> operator()(const expression_type&, const C&) {
+                std::vector<std::string> res;
+                res.push_back("'" + alias_extractor<A>::get() + "'.*");
+                return res;
+            }
+        };
+
         template<class T>
         struct column_names_getter<object_t<T>, void> {
             using expression_type = object_t<T>;
diff --git a/dev/column_result.h b/dev/column_result.h
index 61f485d36..e266664a5 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -255,10 +255,15 @@ namespace sqlite_orm {
         struct column_result_t<St, as_t<T, E>, void> : column_result_t<St, typename std::decay<E>::type> {};
 
         template<class St, class T>
-        struct column_result_t<St, asterisk_t<T>, void> {
+        struct column_result_t<St, asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>> {
             using type = typename storage_traits::storage_mapped_columns<St, T>::type;
         };
 
+        template<class St, class A>
+        struct column_result_t<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>> {
+            using type = typename storage_traits::storage_mapped_columns<St, typename A::type>::type;
+        };
+
         template<class St, class T>
         struct column_result_t<St, object_t<T>, void> {
             using type = T;
diff --git a/dev/table_name_collector.h b/dev/table_name_collector.h
index 0a0cd72b7..c99dcc96a 100644
--- a/dev/table_name_collector.h
+++ b/dev/table_name_collector.h
@@ -5,6 +5,7 @@
 #include <functional>  //  std::function
 #include <typeindex>  //  std::type_index
 
+#include "static_magic.h"
 #include "select_constraints.h"
 #include "alias.h"
 #include "core_functions.h"
@@ -61,8 +62,15 @@ namespace sqlite_orm {
             template<class T>
             void operator()(const asterisk_t<T> &) const {
                 if(this->find_table_name) {
-                    auto tableName = this->find_table_name(typeid(T));
-                    table_names.insert(std::make_pair(move(tableName), ""));
+                    static_if<std::is_base_of<alias_tag, T>{}>(
+                        [this]() {
+                            auto tableName = this->find_table_name(typeid(typename alias_extractor<T>::object_type));
+                            table_names.insert(std::make_pair(move(tableName), alias_extractor<T>::get()));
+                        },
+                        [this]() {
+                            auto tableName = this->find_table_name(typeid(T));
+                            table_names.insert(std::make_pair(move(tableName), ""));
+                        })();
                 }
             }
 
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 3e5fdb655..543e0233b 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -62,6 +62,74 @@ void all_integers_between(int from, int end) {
             cout << n << ", ";
         }
         cout << endl;
+        cout << endl;
+    }
+}
+
+void supervisor_chain() {
+    //CREATE TABLE org(
+    //    name TEXT PRIMARY KEY,
+    //    boss TEXT REFERENCES org
+    //) WITHOUT ROWID;
+    //INSERT INTO org VALUES('Alice', NULL);
+    //INSERT INTO org VALUES('Bob', 'Alice');
+    //INSERT INTO org VALUES('Cindy', 'Alice');
+    //INSERT INTO org VALUES('Dave', 'Bob');
+    //INSERT INTO org VALUES('Emma', 'Bob');
+    //INSERT INTO org VALUES('Fred', 'Cindy');
+    //INSERT INTO org VALUES('Gail', 'Cindy');
+    //CREATE TABLE org(
+    //  name TEXT PRIMARY KEY,
+    //  boss TEXT REFERENCES org,
+    //  height INT,
+    //  -- other content omitted
+    //);
+    struct Org {
+        std::string name;
+        std::optional<std::string> boss;
+        double height;
+    };
+
+    auto storage = make_storage("",
+                                make_table<Org>("org",
+                                                make_column("name", &Org::name, primary_key()),
+                                                make_column("boss", &Org::boss),
+                                                foreign_key(&Org::boss).references(&Org::name)));
+    storage.sync_schema();
+
+    storage.replace<Org>({"Alice", nullopt});
+    storage.replace<Org>({"Bob", "Alice"});
+    storage.replace<Org>({"Cindy", "Alice"});
+    storage.replace<Org>({"Dave", "Bob"});
+    storage.replace<Org>({"Emma", "Bob"});
+    storage.replace<Org>({"Fred", "Cindy"});
+    storage.replace<Org>({"Gail", "Cindy"});
+
+    // supervisor chain of Fred
+    {
+        //WITH RECURSIVE
+        //    chain AS(
+        //        SELECT * from org WHERE name = 'Fred'
+        //        UNION ALL
+        //        SELECT parent.* FROM org parent, chain
+        //        WHERE parent.name = chain.boss
+        //    )
+        //    SELECT name FROM chain;
+        auto ast = with(
+            cte<cte_1>()(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
+                                   select(asterisk<alias_a<Org>>(),
+                                          where(c(alias_column<alias_a<Org>>(&Org::name)) == column<cte_1>(1_col))))),
+            select(column<cte_1>(0_col)));
+        string sql = storage.dump(ast);
+
+        auto stmt = storage.prepare(ast);
+        auto results = storage.execute(stmt);
+        cout << "Hierarchy chain of Fred:\n";
+        for(const string& name: results) {
+            cout << name << ", ";
+        }
+        cout << endl;
+        cout << endl;
     }
 }
 
@@ -88,14 +156,15 @@ void works_for_alice() {
 
     storage.replace<Org>({"Alice", nullopt, 160.});
     storage.replace<Org>({"Bob", nullopt, 177.});
-    storage.replace<Org>({"Foo", "Alice", 165.});
+    storage.replace<Org>({"Dave", "Alice", 169.});
+    storage.replace<Org>({"Cindy", "Dave", 165.});
     storage.replace<Org>({"Bar", "Bob", 159.});
 
-    c(&Org::height) + 1;
-
-    //WITH RECURSIVE
-    //    works_for_alice(n) AS(
-    //        VALUES('Alice')
+    // average height of Alice's team
+    {
+        //WITH RECURSIVE
+        //    works_for_alice(n) AS(
+        //        VALUES('Alice')
     //        UNION
     //        SELECT name FROM org, works_for_alice
     //        WHERE org.boss = works_for_alice.n
@@ -124,7 +193,8 @@ void works_for_alice() {
 
         auto stmt = storage.prepare(ast);
         auto results = storage.execute(stmt);
-        cout << "Average height Alice's team: " << results.at(0) << endl;
+        cout << "Average height of Alice's team: " << results.at(0) << endl;
+        cout << endl;
     }
 }
 
@@ -221,6 +291,7 @@ void family_tree() {
     for(const string& name: results) {
         cout << name << endl;
     }
+    cout << endl;
 }
 
 void depth_or_breadth_first() {
@@ -318,12 +389,14 @@ void depth_or_breadth_first() {
         for(const string& name: results) {
             cout << name << endl;
         }
+        cout << endl;
     }
 }
 
 int main() {
     try {
         all_integers_between(1, 10);
+        supervisor_chain();
         works_for_alice();
         family_tree();
         depth_or_breadth_first();

From eb7971e6e72e864bdae89b9a6e133525a3424b71 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 16 Jan 2022 19:13:05 +0200
Subject: [PATCH 017/161] Removed 'get table' accessor from storage
 implementation

---
 dev/storage_impl.h | 30 ++++++++++++++----------------
 1 file changed, 14 insertions(+), 16 deletions(-)

diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 36103b5d1..53d745901 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -179,11 +179,6 @@ namespace sqlite_orm {
                 return *this;
             }
 
-            // indirected access to table, for simplified programming
-            const table_type* get_table() const {
-                return &this->table;
-            }
-
             std::string find_table_name(std::type_index ti) const {
                 std::type_index thisTypeIndex{typeid(std::conditional_t<std::is_void<label_type_t<H>>::value,
                                                                         object_type_t<H>,
@@ -346,10 +341,6 @@ namespace sqlite_orm {
                 static_assert(polyfill::always_false_v<Lookup>, "No such storage implementation");
             }
 
-            std::nullptr_t get_table() const {
-                return nullptr;
-            }
-
             std::string find_table_name(std::type_index) const {
                 return {};
             }
@@ -372,19 +363,26 @@ namespace sqlite_orm {
 
         template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
         auto lookup_table(const S& strg) {
-            return find_impl<Lookup>(strg).get_table();
+            const auto& tImpl = find_impl<Lookup>(strg);
+            return static_if<std::is_same<decltype(tImpl), const storage_impl<>&>{}>(
+                [](const storage_impl<>&) {
+                    return nullptr;
+                },
+                [](const auto& tImpl) {
+                    return &tImpl.table;
+                })(tImpl);
         }
 
         template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
         std::string lookup_table_name(const S& strg) {
-            auto table = lookup_table<Lookup>(strg);
-            return static_if<std::is_same<decltype(table), std::nullptr_t>{}>(
-                [](std::nullptr_t) {
+            const auto& tImpl = find_impl<Lookup>(strg);
+            return static_if<std::is_same<decltype(tImpl), const storage_impl<>&>{}>(
+                [](const storage_impl<>&) {
                     return std::string{};
                 },
-                [](auto table) {
-                    return table->name;
-                })(table);
+                [](const auto& tImpl) {
+                    return tImpl.table.name;
+                })(tImpl);
         }
 
         template<class Lookup, class S, satisfies<is_storage_impl, S> = true>

From 518677e024c7ddf9449836a8174b957a5dcba65c Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 16 Jan 2022 19:16:22 +0200
Subject: [PATCH 018/161] Validate number of columns of CTE

---
 dev/ast_iterator.h       |  3 +--
 dev/cte_storage.h        | 20 ++++++++++----------
 dev/select_constraints.h | 25 ++++++++++++++-----------
 dev/storage.h            |  7 ++++---
 4 files changed, 29 insertions(+), 26 deletions(-)

diff --git a/dev/ast_iterator.h b/dev/ast_iterator.h
index 969dc4043..0f97328ef 100644
--- a/dev/ast_iterator.h
+++ b/dev/ast_iterator.h
@@ -191,8 +191,7 @@ namespace sqlite_orm {
         };
 
         template<class CTE>
-        struct ast_iterator<CTE,
-                            std::enable_if_t<polyfill::is_specialization_of_v<CTE, common_table_expression>>> {
+        struct ast_iterator<CTE, match_specialization_of<CTE, common_table_expression>> {
             using node_type = CTE;
 
             template<class L>
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 03c173df9..cfab36b48 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -129,12 +129,12 @@ namespace sqlite_orm {
                                                                       const common_table_expressions<CTEs...>& cte,
                                                                       std::index_sequence<TI1>) {
             using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
-
-            auto tbl = make_cte_table<
+            using O =
                 create_column_results_t<label_type_t<cte_t>,
-                                        column_result_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>>>(
-                impl,
-                get<TI1>(cte));
+                                        column_result_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>>;
+            static_assert(!cte_t::explicit_column_count || cte_t::explicit_column_count == O::index_sequence::size());
+
+            auto tbl = make_cte_table<O>(impl, get<TI1>(cte));
 
             return storage_impl_cat(impl, std::move(tbl));
         }
@@ -144,12 +144,12 @@ namespace sqlite_orm {
                                                                       const common_table_expressions<CTEs...>& cte,
                                                                       std::index_sequence<TI1, TIn...>) {
             using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
-
-            auto tbl = make_cte_table<
+            using O =
                 create_column_results_t<label_type_t<cte_t>,
-                                        column_result_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>>>(
-                impl,
-                get<TI1>(cte));
+                                        column_result_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>>;
+            static_assert(!cte_t::explicit_column_count || cte_t::explicit_column_count == O::index_sequence::size());
+
+            auto tbl = make_cte_table<O>(impl, get<TI1>(cte));
 
             return make_recursive_cte_storage_using_table_indices(
                 // Because CTEs can depend on their predecessor we recursively pass in a new storage object
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index b4a50ed05..6ca3d0a13 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -240,10 +240,11 @@ namespace sqlite_orm {
         /**
          *  Labeled (aliased) CTE expression.
          */
-        template<class Label, class Select>
+        template<class Label, class Select, class nExplicitCols>
         struct common_table_expression : public Label {
             using label_type = Label;
             using expression_type = Select;
+            static constexpr size_t explicit_column_count = nExplicitCols::value;
 
             std::vector<std::string> explicitColumnNames;
             expression_type expression;
@@ -256,18 +257,19 @@ namespace sqlite_orm {
         template<class... CTEs>
         using common_table_expressions = std::tuple<CTEs...>;
 
-        template<typename Label>
+        template<typename Label, class nExplicitCols>
         struct cte_builder {
             std::vector<std::string> explicitColumnNames;
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>> operator()(select_t<T, Args...> sel) && {
+            common_table_expression<Label, select_t<T, Args...>, nExplicitCols>
+            operator()(select_t<T, Args...> sel) && {
                 return {move(this->explicitColumnNames), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>> operator()(Compound sel) && {
+            common_table_expression<Label, select_t<Compound>, nExplicitCols> operator()(Compound sel) && {
                 return {move(this->explicitColumnNames), {std::move(sel)}};
             }
         };
@@ -502,23 +504,24 @@ namespace sqlite_orm {
     template<class Label,
              class... ColumnNames,
              std::enable_if_t<polyfill::conjunction_v<std::is_convertible<ColumnNames, std::string>...>, bool> = true>
-    internal::cte_builder<Label> cte(ColumnNames... explicitColumnNames) {
+    internal::cte_builder<Label, polyfill::index_constant<sizeof...(ColumnNames)>>
+    cte(ColumnNames... explicitColumnNames) {
         return {{std::move(explicitColumnNames)...}};
     }
 
     // tuple of CTEs
-    template<class E, class... Labels, class... Selects>
-    internal::with_t<E, internal::common_table_expression<Labels, Selects>...>
-    with(std::tuple<internal::common_table_expression<Labels, Selects>...> cte, E expression) {
+    template<class E, class... Labels, class... Selects, class... nExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Labels, Selects, nExplicitCols>...>
+    with(std::tuple<internal::common_table_expression<Labels, Selects, nExplicitCols>...> cte, E expression) {
         return {move(cte), std::move(expression)};
     }
 
     /** A single CTE.
      *  Example : with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
      */
-    template<class E, class Label, class Select>
-    internal::with_t<E, internal::common_table_expression<Label, Select>>
-    with(internal::common_table_expression<Label, Select> cte, E expression) {
+    template<class E, class Label, class Select, class nExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Label, Select, nExplicitCols>>
+    with(internal::common_table_expression<Label, Select, nExplicitCols> cte, E expression) {
         return {std::make_tuple(move(cte)), std::move(expression)};
     }
 
diff --git a/dev/storage.h b/dev/storage.h
index 9e84910ad..102a29eb9 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -560,8 +560,8 @@ namespace sqlite_orm {
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class Label, class Select, class T, class... Args>
-            auto with(common_table_expression<Label, Select> cte, select_t<T, Args...> sel) {
+            template<class Label, class Select, class nExplicitCols, class T, class... Args>
+            auto with(common_table_expression<Label, Select, nExplicitCols> cte, select_t<T, Args...> sel) {
                 auto statement = this->prepare(sqlite_orm::with(move(cte), std::move(sel)));
                 return this->execute(statement);
             }
@@ -580,9 +580,10 @@ namespace sqlite_orm {
              */
             template<class Label,
                      class Select,
+                     class nExplicitCols,
                      class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            auto with(common_table_expression<Label, Select> cte, Compound sel) {
+            auto with(common_table_expression<Label, Select, nExplicitCols> cte, Compound sel) {
                 auto statement = this->prepare(sqlite_orm::with(move(cte), sqlite_orm::select(std::move(sel))));
                 return this->execute(statement);
             }

From 09703ecf0ea8d2434dd12edbe7b5c4a50d08ec42 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 16 Jan 2022 21:30:41 +0200
Subject: [PATCH 019/161] Implemented simple multi-argument min/max core
 functions

---
 dev/core_functions.h | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/dev/core_functions.h b/dev/core_functions.h
index b2402c213..0de9473fc 100644
--- a/dev/core_functions.h
+++ b/dev/core_functions.h
@@ -1793,19 +1793,23 @@ namespace sqlite_orm {
     }
 
     /**
-     *  MAX(X) aggregate function.
+     *  MAX(X, ...) aggregate or simple multi-argument function.
+     *  The return type is deduced from the first argument.
      */
-    template<class X>
-    internal::built_in_function_t<internal::unique_ptr_result_of<X>, internal::max_string, X> max(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
+    template<class X, class... Rest>
+    internal::built_in_function_t<internal::unique_ptr_result_of<X>, internal::max_string, X, Rest...>
+    max(X x, Rest... rest) {
+        return {std::tuple<X, Rest...>{std::move(x), std::move(rest)...}};
     }
 
     /**
-     *  MIN(X) aggregate function.
+     *  MIN(X, ...) aggregate or simple multi-argument function.
+     *  The return type is deduced from the first argument.
      */
-    template<class X>
-    internal::built_in_function_t<internal::unique_ptr_result_of<X>, internal::min_string, X> min(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
+    template<class X, class... Rest>
+    internal::built_in_function_t<internal::unique_ptr_result_of<X>, internal::min_string, X, Rest...>
+    min(X x, Rest... rest) {
+        return {std::tuple<X, Rest...>{std::move(x), std::move(rest)...}};
     }
 
     /**

From 5beffa1aaff4009ea72153782cff420fa2565805 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 16 Jan 2022 21:31:52 +0200
Subject: [PATCH 020/161] Most CTE examples are available only with
 std::optional

---
 examples/common_table_expressions.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 543e0233b..f5497ed90 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -9,7 +9,9 @@
 using std::cout;
 using std::endl;
 using std::make_tuple;
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
 using std::nullopt;
+#endif
 using std::string;
 using std::system_error;
 using namespace sqlite_orm;
@@ -67,6 +69,7 @@ void all_integers_between(int from, int end) {
 }
 
 void supervisor_chain() {
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
     //CREATE TABLE org(
     //    name TEXT PRIMARY KEY,
     //    boss TEXT REFERENCES org
@@ -131,9 +134,11 @@ void supervisor_chain() {
         cout << endl;
         cout << endl;
     }
+#endif
 }
 
 void works_for_alice() {
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
     //CREATE TABLE org(
     //  name TEXT PRIMARY KEY,
     //  boss TEXT REFERENCES org,
@@ -196,9 +201,11 @@ void works_for_alice() {
         cout << "Average height of Alice's team: " << results.at(0) << endl;
         cout << endl;
     }
+#endif
 }
 
 void family_tree() {
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
     //CREATE TABLE family(
     //    name TEXT PRIMARY KEY,
     //    mom TEXT REFERENCES family,
@@ -292,9 +299,11 @@ void family_tree() {
         cout << name << endl;
     }
     cout << endl;
+#endif
 }
 
 void depth_or_breadth_first() {
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
     //CREATE TABLE org(
     //    name TEXT PRIMARY KEY,
     //    boss TEXT REFERENCES org
@@ -391,6 +400,7 @@ void depth_or_breadth_first() {
         }
         cout << endl;
     }
+#endif
 }
 
 int main() {

From 024f4270ca3807ec5c26562eec2eae20818cd19f Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 16 Jan 2022 21:33:40 +0200
Subject: [PATCH 021/161] "Apfelmaennchen" (Mandelbrot set) example

---
 examples/common_table_expressions.cpp | 57 +++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)

diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index f5497ed90..5bc655b09 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -403,6 +403,62 @@ void depth_or_breadth_first() {
 #endif
 }
 
+void apfelmaennchen() {
+    auto storage = make_storage("");
+
+    //WITH RECURSIVE
+    //    xaxis(x) AS(VALUES(-2.0) UNION ALL SELECT x + 0.05 FROM xaxis WHERE x < 1.2),
+    //    yaxis(y) AS(VALUES(-1.0) UNION ALL SELECT y + 0.1 FROM yaxis WHERE y < 1.0),
+    //    m(iter, cx, cy, x, y) AS(
+    //        SELECT 0, x, y, 0.0, 0.0 FROM xaxis, yaxis
+    //        UNION ALL
+    //        SELECT iter + 1, cx, cy, x * x - y * y + cx, 2.0 * x * y + cy FROM m
+    //        WHERE(x * x + y * y) < 4.0 AND iter < 28
+    //    ),
+    //    m2(iter, cx, cy) AS(
+    //        SELECT max(iter), cx, cy FROM m GROUP BY cx, cy
+    //    ),
+    //    a(t) AS(
+    //        SELECT group_concat(substr(' .+*#', 1 + min(iter / 7, 4), 1), '')
+    //        FROM m2 GROUP BY cy
+    //    )
+    //    SELECT group_concat(rtrim(t), x'0a') FROM a;
+    auto ast = with(
+        make_tuple(
+            cte<cte_1>("x")(
+                union_all(select(-2.0), select(column<cte_1>(0_col) + c(0.05), where(column<cte_1>(0_col) < 1.2)))),
+            cte<cte_2>("y")(
+                union_all(select(-1.0), select(column<cte_2>(0_col) + c(0.1), where(column<cte_2>(0_col) < 1.0)))),
+            cte<cte_3>("iter", "cx", "cy", "x", "y")(
+                union_all(select(columns(0, column<cte_1>(0_col), column<cte_2>(0_col), 0.0, 0.0)),
+                          select(columns(column<cte_3>(0_col) + c(1),
+                                         column<cte_3>(1_col),
+                                         column<cte_3>(2_col),
+                                         column<cte_3>(3_col) * c(column<cte_3>(3_col)) -
+                                             column<cte_3>(4_col) * c(column<cte_3>(4_col)) + column<cte_3>(1_col),
+                                         c(2.0) * column<cte_3>(3_col) * column<cte_3>(4_col) + column<cte_3>(2_col)),
+                                 where((column<cte_3>(3_col) * c(column<cte_3>(3_col)) +
+                                        column<cte_3>(4_col) * c(column<cte_3>(4_col))) < c(4.0) &&
+                                       column<cte_3>(0_col) < 28)))),
+            cte<cte_4>("iter", "cx", "cy")(
+                select(columns(max<>(column<cte_3>(0_col)), column<cte_3>(1_col), column<cte_3>(2_col)),
+                       group_by(column<cte_3>(1_col), column<cte_3>(2_col)))),
+            cte<cte_5>("t")(select(group_concat(substr(" .+*#", 1 + min<>(column<cte_4>(0_col) / c(7.0), 4.0), 1), ""),
+                                   group_by(column<cte_4>(2_col))))),
+        select(group_concat(rtrim(column<cte_5>(0_col)), "\n")));
+
+    string sql = storage.dump(ast);
+
+    auto stmt = storage.prepare(ast);
+    auto results = storage.execute(stmt);
+
+    cout << "Apfelmaennchen (Mandelbrot set):\n";
+    for(const string& rowString: results) {
+        cout << rowString << endl;
+    }
+    cout << endl;
+}
+
 int main() {
     try {
         all_integers_between(1, 10);
@@ -410,6 +466,7 @@ int main() {
         works_for_alice();
         family_tree();
         depth_or_breadth_first();
+        apfelmaennchen();
     } catch(const system_error& e) {
         cout << "[" << e.code() << "] " << e.what();
     }

From c5aa19fb7b33c30e3342ee61e88d4b17a02bcfc1 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 16 Jan 2022 21:39:23 +0200
Subject: [PATCH 022/161] #include <optional> in CTE examples file

---
 examples/common_table_expressions.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 5bc655b09..f69b053c0 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -3,6 +3,9 @@
  */
 
 #include <tuple>
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+#include <optional>
+#endif
 #include <iostream>
 #include <sqlite_orm/sqlite_orm.h>
 

From d8fd0462a494babe211eacf9cc41cb1cee906552 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 17 Jan 2022 23:24:02 +0200
Subject: [PATCH 023/161] Abstracted table object mapping

---
 dev/column_result.h                   | 60 +++++++++++++++++++-
 dev/cte_storage.h                     | 58 ++++++++++---------
 dev/cte_types.h                       | 24 ++++++--
 dev/select_constraints.h              |  7 ++-
 dev/statement_serializator.h          |  3 +
 dev/storage_impl.h                    | 20 ++++++-
 dev/table.h                           |  9 ++-
 dev/tuple_helper/tuple_helper.h       |  3 +-
 dev/type_traits.h                     | 51 +++++++++++++++++
 examples/common_table_expressions.cpp | 82 ++++++++++++++-------------
 10 files changed, 236 insertions(+), 81 deletions(-)

diff --git a/dev/column_result.h b/dev/column_result.h
index e266664a5..8f4ca37a1 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -20,6 +20,8 @@ namespace sqlite_orm {
     namespace internal {
 
         /**
+         *  Obains the result type of expressions that form the columns of a select statement.
+         *  
          *  This is a proxy class used to define what type must have result type depending on select
          *  arguments (member pointer, aggregate functions, etc). Below you can see specializations
          *  for different types. E.g. specialization for internal::length_t has `type` int cause
@@ -34,6 +36,15 @@ namespace sqlite_orm {
         template<class St, class T>
         using column_result_of_t = typename column_result_t<St, T>::type;
 
+        template<class St, class T, class SFINAE = void>
+        struct column_expression_type;
+
+        /**
+         *  Obains the expressions that form the columns of a subselect statement.
+         */
+        template<class St, class T>
+        using column_expression_of_t = typename column_expression_type<St, T>::type;
+
 #ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
         template<class St, class T>
         struct column_result_t<St, as_optional_t<T>, void> {
@@ -50,6 +61,11 @@ namespace sqlite_orm {
             using type = F;
         };
 
+        template<class St, class O, class F, F O::*m>
+        struct column_result_t<St, ice_t<m>, void> {
+            using type = F;
+        };
+
         template<class St, class L, class A>
         struct column_result_t<St, dynamic_in_t<L, A>, void> {
             using type = bool;
@@ -206,9 +222,14 @@ namespace sqlite_orm {
         struct column_result_t<St, column_pointer<Label, polyfill::index_constant<I>>, void>
             : column_result_t<St, cte_getter_t<storage_object_type_t<storage_pick_impl_t<St, Label>>, I>> {};
 
+        template<class St, class Label, class O, class F, F O::*m>
+        struct column_result_t<St, column_pointer<Label, ice_t<m>>, void> {
+            using type = typename ice_t<m>::value_type;
+        };
+
         template<class St, class... Args>
         struct column_result_t<St, columns_t<Args...>, void> {
-            using type = std::tuple<typename column_result_t<St, typename std::decay<Args>::type>::type...>;
+            using type = fields_t<column_result_of_t<St, std::decay_t<Args>>...>;
         };
 
         template<class St, class T, class... Args>
@@ -261,7 +282,7 @@ namespace sqlite_orm {
 
         template<class St, class A>
         struct column_result_t<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>> {
-            using type = typename storage_traits::storage_mapped_columns<St, typename A::type>::type;
+            using type = typename storage_traits::storage_mapped_columns<St, type_t<A>>::type;
         };
 
         template<class St, class T>
@@ -296,5 +317,40 @@ namespace sqlite_orm {
 
         template<class St, class T>
         struct column_result_t<St, std::reference_wrapper<T>, void> : column_result_t<St, T> {};
+
+        template<class St, class T, class SFINAE>
+        struct column_expression_type {
+            using type = T;
+        };
+
+        template<class St, class T>
+        struct column_expression_type<St, std::reference_wrapper<T>, void> : column_expression_type<St, T> {};
+
+        // No CTE for object expressions.
+        template<class St, class T>
+        struct column_expression_type<St, object_t<T>, void>;
+
+        template<class St, class T>
+        struct column_expression_type<St, asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>> {
+            using type = typename storage_traits::storage_mapped_columns<St, T>::type;
+        };
+
+        template<class St, class A>
+        struct column_expression_type<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>> {
+            using type = typename storage_traits::storage_mapped_columns<St, type_t<A>>::type;
+        };
+
+        template<class St, class O, class F, F O::*m>
+        struct column_expression_type<St, ice_t<m>, void> {
+            using type = ice_t<m>;
+        };
+
+        template<class St, class... Args>
+        struct column_expression_type<St, columns_t<Args...>, void> {
+            using type = std::tuple<column_expression_of_t<St, std::decay_t<Args>>...>;
+        };
+
+        template<class St, class T, class... Args>
+        struct column_expression_type<St, select_t<T, Args...>> : column_expression_type<St, T> {};
     }
 }
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index cfab36b48..b789445c5 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -16,18 +16,18 @@ namespace sqlite_orm {
     namespace internal {
 
         // F = field_type
-        template<typename Label, typename F>
+        template<typename Label, typename Expression, typename F>
         struct create_column_results {
-            using type = column_results<Label, F>;
+            using type = subselect_mapper<Label, Expression, F>;
         };
 
-        template<typename Label, typename... Fs>
-        struct create_column_results<Label, std::tuple<Fs...>> {
-            using type = column_results<Label, Fs...>;
+        template<typename Label, typename Expression, typename... Fs>
+        struct create_column_results<Label, Expression, std::tuple<Fs...>> {
+            using type = subselect_mapper<Label, Expression, Fs...>;
         };
 
-        template<typename Label, typename... Fs>
-        using create_column_results_t = typename create_column_results<Label, Fs...>::type;
+        template<typename Label, typename Expression, typename... Fs>
+        using create_column_results_t = typename create_column_results<Label, Expression, Fs...>::type;
 
         template<typename O, size_t CI>
         struct create_cte_column {
@@ -45,13 +45,13 @@ namespace sqlite_orm {
         template<typename O, size_t CI>
         using create_cte_column_t = typename create_cte_column<O, CI>::type;
 
-        template<typename O, typename IdxSeq>
+        template<typename M, typename IdxSeq>
         struct create_cte_table;
 
-        template<typename Label, typename... Fs, size_t... CIs>
-        struct create_cte_table<column_results<Label, Fs...>, std::index_sequence<CIs...>> {
-            using object_type = column_results<Label, Fs...>;
-            using table_type = table_t<object_type, true, create_cte_column_t<object_type, CIs>...>;
+        template<typename Label, typename Expression, typename... Fs, size_t... CIs>
+        struct create_cte_table<subselect_mapper<Label, Expression, Fs...>, std::index_sequence<CIs...>> {
+            using mapper_type = subselect_mapper<Label, Expression, Fs...>;
+            using table_type = table_t<mapper_type, true, create_cte_column_t<object_type_t<mapper_type>, CIs>...>;
 
             using type = table_type;
         };
@@ -59,8 +59,8 @@ namespace sqlite_orm {
         /**
          *  Metafunction to create a CTE table_t type.
          */
-        template<typename O, typename IdxSeq>
-        using create_cte_table_t = typename create_cte_table<O, IdxSeq>::type;
+        template<typename M, typename IdxSeq>
+        using create_cte_table_t = typename create_cte_table<M, IdxSeq>::type;
 
         /**
          *  Concatenate newly created tables with those from an existing storage, forming a
@@ -105,23 +105,25 @@ namespace sqlite_orm {
         using cte_driving_expression_t =
             std::remove_cvref_t<decltype(get_cte_driving_expression(std::declval<Select>()))>;
 
-        template<typename O, typename S, typename CTE, size_t... CIs>
-        create_cte_table_t<O, typename O::index_sequence>
+        template<typename M, typename S, typename CTE, size_t... CIs>
+        create_cte_table_t<M, typename M::index_sequence>
         make_cte_table_using_column_indices(const S& impl, const CTE& cte, std::index_sequence<CIs...>) {
+            using O = object_type_t<M>;
             using context_type = serializator_context<S>;
             context_type context{impl};
 
             std::vector<std::string> columnNames =
                 collect_cte_column_names(get_cte_driving_expression(cte.expression), cte.explicitColumnNames, context);
 
-            return create_cte_table_t<O, typename O::index_sequence>{
+            return create_cte_table_t<M, typename M::index_sequence>{
                 cte.label(),
-                std::make_tuple(make_column<>(columnNames.at(CIs), cte_getter_v<O, CIs>, cte_setter_v<O, CIs>)...)};
+                std::make_tuple(
+                    make_column<>(move(columnNames.at(CIs)), cte_getter_v<O, CIs>, cte_setter_v<O, CIs>)...)};
         }
 
-        template<typename O, typename S, typename CTE>
-        create_cte_table_t<O, typename O::index_sequence> make_cte_table(const S& impl, const CTE& cte) {
-            return make_cte_table_using_column_indices<O>(impl, cte, typename O::index_sequence{});
+        template<typename M, typename S, typename CTE>
+        create_cte_table_t<M, typename M::index_sequence> make_cte_table(const S& impl, const CTE& cte) {
+            return make_cte_table_using_column_indices<M>(impl, cte, typename M::index_sequence{});
         }
 
         template<typename S, typename... CTEs, size_t TI1>
@@ -129,12 +131,13 @@ namespace sqlite_orm {
                                                                       const common_table_expressions<CTEs...>& cte,
                                                                       std::index_sequence<TI1>) {
             using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
-            using O =
+            using M =
                 create_column_results_t<label_type_t<cte_t>,
+                                        column_expression_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>,
                                         column_result_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>>;
-            static_assert(!cte_t::explicit_column_count || cte_t::explicit_column_count == O::index_sequence::size());
+            static_assert(!cte_t::explicit_column_count || cte_t::explicit_column_count == M::index_sequence::size());
 
-            auto tbl = make_cte_table<O>(impl, get<TI1>(cte));
+            auto tbl = make_cte_table<M>(impl, get<TI1>(cte));
 
             return storage_impl_cat(impl, std::move(tbl));
         }
@@ -144,12 +147,13 @@ namespace sqlite_orm {
                                                                       const common_table_expressions<CTEs...>& cte,
                                                                       std::index_sequence<TI1, TIn...>) {
             using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
-            using O =
+            using M =
                 create_column_results_t<label_type_t<cte_t>,
+                                        column_expression_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>,
                                         column_result_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>>;
-            static_assert(!cte_t::explicit_column_count || cte_t::explicit_column_count == O::index_sequence::size());
+            static_assert(!cte_t::explicit_column_count || cte_t::explicit_column_count == M::index_sequence::size());
 
-            auto tbl = make_cte_table<O>(impl, get<TI1>(cte));
+            auto tbl = make_cte_table<M>(impl, get<TI1>(cte));
 
             return make_recursive_cte_storage_using_table_indices(
                 // Because CTEs can depend on their predecessor we recursively pass in a new storage object
diff --git a/dev/cte_types.h b/dev/cte_types.h
index e218e949a..726a2bb54 100644
--- a/dev/cte_types.h
+++ b/dev/cte_types.h
@@ -5,6 +5,7 @@
 
 #include "cxx_polyfill.h"
 #include "start_macros.h"
+#include "type_traits.h"
 
 namespace sqlite_orm {
 
@@ -15,15 +16,14 @@ namespace sqlite_orm {
 
     namespace internal {
 
-        /*
+        /**
          *  Tuple data structure for CTEs
          */
         template<typename Label, typename... Fs>
-        class column_results : std::tuple<Fs...> {
+        class column_results : fields_t<Fs...> {
           public:
-            using fields_type = std::tuple<Fs...>;
-            using index_sequence = std::index_sequence_for<Fs...>;
-            // this type name is used to detect the mapping from label to object
+            using fields_type = fields_t<Fs...>;
+            // this type name is used to detect the mapping from label to mapper
             using label_type = Label;
 
             template<size_t I>
@@ -36,6 +36,20 @@ namespace sqlite_orm {
             }
         };
 
+        /**
+         *  This class maps an expression of a subselect (basically select_t<>::return_type) to
+         *  a tuple of fields (a column_results<Label, Fields>)
+         */
+        template<typename Label, typename Expression, typename... Fs>
+        class subselect_mapper {
+          public:
+            using index_sequence = std::index_sequence_for<Fs...>;
+            // this type name is used to detect the mapping from label to object
+            using label_type = Label;
+            using object_type = column_results<Label, Fs...>;
+            using expressions_type = tuplify_t<Expression>;
+        };
+
         template<class O, size_t I>
         SQLITE_ORM_INLINE_VAR auto cte_getter_v = &(O::template cget<I>);
         template<class O, size_t I>
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 6ca3d0a13..f16222efb 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -8,6 +8,7 @@
 #endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
 
 #include "cxx_polyfill.h"
+#include "type_traits.h"
 #include "is_base_of_template.h"
 #include "tuple_helper/tuple_helper.h"
 #include "optional_container.h"
@@ -443,14 +444,16 @@ namespace sqlite_orm {
      *  storage.select(column<MyType>(&BaseType::id));
      *  // ... or
      *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id), select(column<cte_1>(0_col)));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(c_v<&Object::id>)));
      */
     template<class O, class F>
     internal::column_pointer<O, F> column(F f) {
         return {std::move(f)};
     }
+
     /**
-     *  Turn 1_nth_col-> 0_col
+     *  Turn 1_nth_col -> 0_col
      */
     template<class O, unsigned int I>
     auto column(internal::nth_constant<I>) {
diff --git a/dev/statement_serializator.h b/dev/statement_serializator.h
index 670523af3..56b639be2 100644
--- a/dev/statement_serializator.h
+++ b/dev/statement_serializator.h
@@ -457,6 +457,9 @@ namespace sqlite_orm {
             }
         };
 
+        template<class O, class F, F O::*m>
+        struct statement_serializator<ice_t<m>, void> : statement_serializator<typename ice_t<m>::value_type> {};
+
         template<class O, class F>
         struct statement_serializator<column_pointer<O, F>, void> {
             using statement_type = column_pointer<O, F>;
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 53d745901..34a20ded4 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -12,6 +12,7 @@
 #include <algorithm>  //  std::find_if
 #include <typeindex>  //  std::type_index
 
+#include "type_traits.h"
 #include "error_code.h"
 #include "statement_finalizer.h"
 #include "row_extractor.h"
@@ -180,9 +181,8 @@ namespace sqlite_orm {
             }
 
             std::string find_table_name(std::type_index ti) const {
-                std::type_index thisTypeIndex{typeid(std::conditional_t<std::is_void<label_type_t<H>>::value,
-                                                                        object_type_t<H>,
-                                                                        label_type_t<H>>)};
+                std::type_index thisTypeIndex{typeid(
+                    std::conditional_t<std::is_void<label_type_t<H>>::value, object_type_t<H>, label_type_t<H>>)};
                 if(thisTypeIndex == ti) {
                     return this->table.name;
                 } else {
@@ -419,5 +419,19 @@ namespace sqlite_orm {
             auto field = materialize_column_pointer(strg, cp);
             return pick_impl<Label>(strg).table.find_column_name(field);
         }
+
+        template<class Label, class O, class F, F O::*m, class S, satisfies<is_storage_impl, S> = true>
+        constexpr decltype(auto) materialize_column_pointer(const S&, const column_pointer<Label, ice_t<m>>&) {
+            using timpl_type = storage_pick_impl_t<S, Label>;
+            using mapper_type = storage_mapper_type_t<timpl_type>;
+            constexpr auto I = tuple_index_of_v<ice_t<m>, typename mapper_type::expressions_type>;
+            return cte_getter_v<object_type_t<mapper_type>, I>;
+        }
+
+        template<class Label, class O, class F, F O::*m, class S, satisfies<is_storage_impl, S> = true>
+        const std::string* find_column_name(const S& strg, const column_pointer<Label, ice_t<m>>& cp) {
+            auto field = materialize_column_pointer(strg, cp);
+            return pick_impl<Label>(strg).table.find_column_name(field);
+        }
     }
 }
diff --git a/dev/table.h b/dev/table.h
index 5b7c9530e..ce9120bce 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -27,6 +27,9 @@ namespace sqlite_orm {
         template<typename O>
         using label_of_t = polyfill::detected_or_t<void, label_type_t, O>;
 
+        template<typename O>
+        using object_type_of_t = polyfill::detected_or_t<O, object_type_t, O>;
+
         struct basic_table {
 
             /**
@@ -39,11 +42,15 @@ namespace sqlite_orm {
          *  Table descriptor.
          * 
          *  Can be either for a table mapped to storage or for a common table expression (CTE).
+         * 
+         *  The template parameter O is either a data structure object (i.e. direct mapping from storage to data)
+         *  or an abstract 'mapper' object with a label attached.
          */
         template<class O, bool WithoutRowId, class... Cs>
         struct table_t : basic_table {
             using super = basic_table;
-            using object_type = O;
+            using mapper_type = O;
+            using object_type = object_type_of_t<O>;
             using label_type = label_of_t<O>;
             using elements_type = std::tuple<Cs...>;
 
diff --git a/dev/tuple_helper/tuple_helper.h b/dev/tuple_helper/tuple_helper.h
index fb74002f5..b2be8b499 100644
--- a/dev/tuple_helper/tuple_helper.h
+++ b/dev/tuple_helper/tuple_helper.h
@@ -1,7 +1,8 @@
 #pragma once
 
-#include <tuple>  //  std::tuple, std::get, std::tuple_element, std::tuple_size
+#include <cstddef>
 #include <type_traits>  //  std::false_type, std::true_type
+#include <tuple>  //  std::tuple, std::get, std::tuple_element, std::tuple_size
 
 #include "../static_magic.h"
 
diff --git a/dev/type_traits.h b/dev/type_traits.h
index 6684da3e4..786d8d69d 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <type_traits>
+#include <tuple>
 
 #include "cxx_polyfill.h"
 
@@ -34,6 +35,9 @@ namespace sqlite_orm {
 
     // type name template aliases for syntactic sugar
     namespace internal {
+        template<typename T>
+        using type_t = typename T::type;
+
         template<typename T>
         using object_type_t = typename T::object_type;
 
@@ -46,6 +50,9 @@ namespace sqlite_orm {
         template<typename S>
         using storage_object_type_t = typename S::table_type::object_type;
 
+        template<typename S>
+        using storage_mapper_type_t = typename S::table_type::mapper_type;
+
         template<typename S>
         using storage_label_type_t = typename S::table_type::label_type;
 
@@ -56,5 +63,49 @@ namespace sqlite_orm {
     namespace internal {
         template<unsigned int N>
         using nth_constant = std::integral_constant<unsigned int, N>;
+
+        template<typename... Fs>
+        using fields_t = std::tuple<Fs...>;
+
+#if __cplusplus >= 201703L  // use of C++17 or higher
+        template<auto c>
+        using ice_t = std::integral_constant<decltype(c), c>;
+
+        // cudos to OznOg https://stackoverflow.com/a/64606884/279251
+        template<class X, class Tuple>
+        struct tuple_index_of;
+
+        template<class X, class... T>
+        struct tuple_index_of<X, std::tuple<T...>> {
+            template<size_t... idx>
+            static constexpr ptrdiff_t find_idx(std::index_sequence<idx...>) {
+                return std::max({static_cast<ptrdiff_t>(std::is_same<X, T>::value ? idx : -1)...});
+            }
+
+            static constexpr ptrdiff_t value = find_idx(std::index_sequence_for<T...>{});
+        };
+        template<class X, class Tuple>
+        inline constexpr ptrdiff_t tuple_index_of_v = tuple_index_of<X, Tuple>::value;
+#endif
+
+        template<typename T>
+        struct tuplify {
+            using type = T;
+        };
+        template<typename... Ts>
+        struct tuplify<std::tuple<Ts...>> {
+            using type = std::tuple<Ts...>;
+        };
+
+        template<typename T>
+        using tuplify_t = typename tuplify<T>::type;
     }
+
+#if __cplusplus >= 201703L  // use of C++17 or higher
+    /**
+     *  Capture a compile-time value as an integral constant.
+     */
+    template<auto c>
+    inline constexpr internal::ice_t<c> c_v{};
+#endif
 }
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index f69b053c0..daec9dec2 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -67,8 +67,8 @@ void all_integers_between(int from, int end) {
             cout << n << ", ";
         }
         cout << endl;
-        cout << endl;
     }
+    cout << endl;
 }
 
 void supervisor_chain() {
@@ -84,16 +84,9 @@ void supervisor_chain() {
     //INSERT INTO org VALUES('Emma', 'Bob');
     //INSERT INTO org VALUES('Fred', 'Cindy');
     //INSERT INTO org VALUES('Gail', 'Cindy');
-    //CREATE TABLE org(
-    //  name TEXT PRIMARY KEY,
-    //  boss TEXT REFERENCES org,
-    //  height INT,
-    //  -- other content omitted
-    //);
     struct Org {
         std::string name;
         std::optional<std::string> boss;
-        double height;
     };
 
     auto storage = make_storage("",
@@ -135,8 +128,8 @@ void supervisor_chain() {
             cout << name << ", ";
         }
         cout << endl;
-        cout << endl;
     }
+        cout << endl;
 #endif
 }
 
@@ -202,8 +195,8 @@ void works_for_alice() {
         auto stmt = storage.prepare(ast);
         auto results = storage.execute(stmt);
         cout << "Average height of Alice's team: " << results.at(0) << endl;
-        cout << endl;
     }
+    cout << endl;
 #endif
 }
 
@@ -255,14 +248,15 @@ void family_tree() {
     //    WHERE ancestor_of_alice.name = family.name
     //    AND died IS NULL
     //    ORDER BY born;
-    auto ast = with(make_tuple(cte<cte_1>("name", "parent")(union_(select(columns(&Family::name, &Family::mom)),
-                                                                   select(columns(&Family::name, &Family::dad)))),
-                               cte<cte_2>("name")(
-                                   union_all(select(column<cte_1>(1_col), where(column<cte_1>(0_col) == "Alice")),
-                                             select(column<cte_1>(1_col), join<cte_2>(using_(column<cte_1>(0_col))))))),
-                    select(&Family::name,
-                           where(is_equal(column<cte_2>(0_col), &Family::name) && is_null(&Family::died)),
-                           order_by(&Family::born)));
+    auto ast =
+        with(make_tuple(cte<cte_1>("name", "parent")(union_(select(columns(c_v<&Family::name>, &Family::mom)),
+                                                            select(columns(&Family::name, &Family::dad)))),
+                        cte<cte_2>("name")(union_all(
+                            select(column<cte_1>(1_col), where(column<cte_1>(c_v<&Family::name>) == "Alice")),
+                            select(column<cte_1>(1_col), join<cte_2>(using_(column<cte_1>(c_v<&Family::name>))))))),
+             select(&Family::name,
+                    where(is_equal(column<cte_2>(0_col), &Family::name) && is_null(&Family::died)),
+                    order_by(&Family::born)));
 
     //WITH cte_1("name", "parent")
     //    AS(
@@ -373,6 +367,7 @@ void depth_or_breadth_first() {
             cout << name << endl;
         }
     }
+    cout << endl;
 
     // depth-first pattern
     {
@@ -401,8 +396,8 @@ void depth_or_breadth_first() {
         for(const string& name: results) {
             cout << name << endl;
         }
-        cout << endl;
     }
+    cout << endl;
 #endif
 }
 
@@ -426,29 +421,36 @@ void apfelmaennchen() {
     //        FROM m2 GROUP BY cy
     //    )
     //    SELECT group_concat(rtrim(t), x'0a') FROM a;
+    using cte_xaxis = cte_label<'x', 'a', 'x', 'i', 's'>;
+    using cte_yaxis = cte_label<'y', 'a', 'x', 'i', 's'>;
+    using cte_m = cte_label<'m'>;
+    using cte_m2 = cte_label<'m', '2'>;
+    using cte_a = cte_label<'a'>;
     auto ast = with(
         make_tuple(
-            cte<cte_1>("x")(
-                union_all(select(-2.0), select(column<cte_1>(0_col) + c(0.05), where(column<cte_1>(0_col) < 1.2)))),
-            cte<cte_2>("y")(
-                union_all(select(-1.0), select(column<cte_2>(0_col) + c(0.1), where(column<cte_2>(0_col) < 1.0)))),
-            cte<cte_3>("iter", "cx", "cy", "x", "y")(
-                union_all(select(columns(0, column<cte_1>(0_col), column<cte_2>(0_col), 0.0, 0.0)),
-                          select(columns(column<cte_3>(0_col) + c(1),
-                                         column<cte_3>(1_col),
-                                         column<cte_3>(2_col),
-                                         column<cte_3>(3_col) * c(column<cte_3>(3_col)) -
-                                             column<cte_3>(4_col) * c(column<cte_3>(4_col)) + column<cte_3>(1_col),
-                                         c(2.0) * column<cte_3>(3_col) * column<cte_3>(4_col) + column<cte_3>(2_col)),
-                                 where((column<cte_3>(3_col) * c(column<cte_3>(3_col)) +
-                                        column<cte_3>(4_col) * c(column<cte_3>(4_col))) < c(4.0) &&
-                                       column<cte_3>(0_col) < 28)))),
-            cte<cte_4>("iter", "cx", "cy")(
-                select(columns(max<>(column<cte_3>(0_col)), column<cte_3>(1_col), column<cte_3>(2_col)),
-                       group_by(column<cte_3>(1_col), column<cte_3>(2_col)))),
-            cte<cte_5>("t")(select(group_concat(substr(" .+*#", 1 + min<>(column<cte_4>(0_col) / c(7.0), 4.0), 1), ""),
-                                   group_by(column<cte_4>(2_col))))),
-        select(group_concat(rtrim(column<cte_5>(0_col)), "\n")));
+            cte<cte_xaxis>("x")(
+                union_all(select(-2.0),
+                          select(column<cte_xaxis>(0_col) + c(0.05), where(column<cte_xaxis>(0_col) < 1.2)))),
+            cte<cte_yaxis>("y")(
+                union_all(select(-1.0),
+                          select(column<cte_yaxis>(0_col) + c(0.1), where(column<cte_yaxis>(0_col) < 1.0)))),
+            cte<cte_m>("iter", "cx", "cy", "x", "y")(
+                union_all(select(columns(0, column<cte_xaxis>(0_col), column<cte_yaxis>(0_col), 0.0, 0.0)),
+                          select(columns(column<cte_m>(0_col) + c(1),
+                                         column<cte_m>(1_col),
+                                         column<cte_m>(2_col),
+                                         column<cte_m>(3_col) * c(column<cte_m>(3_col)) -
+                                             column<cte_m>(4_col) * c(column<cte_m>(4_col)) + column<cte_m>(1_col),
+                                         c(2.0) * column<cte_m>(3_col) * column<cte_m>(4_col) + column<cte_m>(2_col)),
+                                 where((column<cte_m>(3_col) * c(column<cte_m>(3_col)) +
+                                        column<cte_m>(4_col) * c(column<cte_m>(4_col))) < c(4.0) &&
+                                       column<cte_m>(0_col) < 28)))),
+            cte<cte_m2>("iter", "cx", "cy")(select(
+                columns(max<>(column<cte_m>(0_col)), column<cte_m>(1_col), column<cte_m>(2_col)),
+                group_by(column<cte_m>(1_col), column<cte_m>(2_col)))),
+            cte<cte_a>("t")(select(group_concat(substr(" .+*#", 1 + min<>(column<cte_m2>(0_col) / c(7.0), 4.0), 1), ""),
+                                   group_by(column<cte_m2>(2_col))))),
+        select(group_concat(rtrim(column<cte_a>(0_col)), "\n")));
 
     string sql = storage.dump(ast);
 

From c6b461f863208c5a19ac06da745eed7df63f02b2 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 17 Jan 2022 23:43:50 +0200
Subject: [PATCH 024/161] Renamed `label_type` typename alias to
 `cte_label_type`

This change mitigates the problem that `label_type` might be a present outside of sqlite_orm's type system
---
 dev/cte_storage.h        | 35 ++++++++++++++++++-----------------
 dev/cte_types.h          |  6 +++---
 dev/select_constraints.h |  2 +-
 dev/storage.h            |  2 +-
 dev/storage_impl.h       | 11 ++++++-----
 dev/storage_lookup.h     | 12 ++++++------
 dev/table.h              | 13 +++++++------
 dev/type_traits.h        |  9 ++++++---
 8 files changed, 48 insertions(+), 42 deletions(-)

diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index b789445c5..d2cb16cb7 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -31,12 +31,12 @@ namespace sqlite_orm {
 
         template<typename O, size_t CI>
         struct create_cte_column {
-            using object_type = O;
+            using cte_object_type = O;
             using field_type = std::tuple_element_t<CI, typename O::fields_type>;
             using getter_type = cte_getter_t<O, CI>;
             using setter_type = cte_setter_t<O, CI>;
 
-            using type = column_t<object_type, field_type, getter_type, setter_type>;
+            using type = column_t<cte_object_type, field_type, getter_type, setter_type>;
         };
 
         /**
@@ -50,8 +50,9 @@ namespace sqlite_orm {
 
         template<typename Label, typename Expression, typename... Fs, size_t... CIs>
         struct create_cte_table<subselect_mapper<Label, Expression, Fs...>, std::index_sequence<CIs...>> {
-            using mapper_type = subselect_mapper<Label, Expression, Fs...>;
-            using table_type = table_t<mapper_type, true, create_cte_column_t<object_type_t<mapper_type>, CIs>...>;
+            using cte_mapper_type = subselect_mapper<Label, Expression, Fs...>;
+            using table_type =
+                table_t<cte_mapper_type, true, create_cte_column_t<cte_object_type_t<cte_mapper_type>, CIs>...>;
 
             using type = table_type;
         };
@@ -81,13 +82,13 @@ namespace sqlite_orm {
          *  interested in the column results of the left expression.
          */
         template<class Select>
-        decltype(auto) get_cte_driving_expression(const Select& subSelect);
+        decltype(auto) get_cte_driving_subselect(const Select& subSelect);
 
         /**
          *  Return given select expression.
          */
         template<class Select>
-        decltype(auto) get_cte_driving_expression(const Select& subSelect) {
+        decltype(auto) get_cte_driving_subselect(const Select& subSelect) {
             return subSelect;
         }
 
@@ -97,23 +98,23 @@ namespace sqlite_orm {
         template<class Compound,
                  class... Args,
                  std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-        decltype(auto) get_cte_driving_expression(const select_t<Compound, Args...>& subSelect) {
+        decltype(auto) get_cte_driving_subselect(const select_t<Compound, Args...>& subSelect) {
             return subSelect.col.left;
         }
 
         template<typename Select>
-        using cte_driving_expression_t =
-            std::remove_cvref_t<decltype(get_cte_driving_expression(std::declval<Select>()))>;
+        using cte_driving_subselect_t =
+            std::remove_cvref_t<decltype(get_cte_driving_subselect(std::declval<Select>()))>;
 
         template<typename M, typename S, typename CTE, size_t... CIs>
         create_cte_table_t<M, typename M::index_sequence>
         make_cte_table_using_column_indices(const S& impl, const CTE& cte, std::index_sequence<CIs...>) {
-            using O = object_type_t<M>;
+            using O = cte_object_type_t<M>;
             using context_type = serializator_context<S>;
             context_type context{impl};
 
             std::vector<std::string> columnNames =
-                collect_cte_column_names(get_cte_driving_expression(cte.expression), cte.explicitColumnNames, context);
+                collect_cte_column_names(get_cte_driving_subselect(cte.expression), cte.explicitColumnNames, context);
 
             return create_cte_table_t<M, typename M::index_sequence>{
                 cte.label(),
@@ -132,9 +133,9 @@ namespace sqlite_orm {
                                                                       std::index_sequence<TI1>) {
             using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
             using M =
-                create_column_results_t<label_type_t<cte_t>,
-                                        column_expression_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>,
-                                        column_result_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>>;
+                create_column_results_t<cte_label_type_t<cte_t>,
+                                        column_expression_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>,
+                                        column_result_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>>;
             static_assert(!cte_t::explicit_column_count || cte_t::explicit_column_count == M::index_sequence::size());
 
             auto tbl = make_cte_table<M>(impl, get<TI1>(cte));
@@ -148,9 +149,9 @@ namespace sqlite_orm {
                                                                       std::index_sequence<TI1, TIn...>) {
             using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
             using M =
-                create_column_results_t<label_type_t<cte_t>,
-                                        column_expression_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>,
-                                        column_result_of_t<S, cte_driving_expression_t<expression_type_t<cte_t>>>>;
+                create_column_results_t<cte_label_type_t<cte_t>,
+                                        column_expression_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>,
+                                        column_result_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>>;
             static_assert(!cte_t::explicit_column_count || cte_t::explicit_column_count == M::index_sequence::size());
 
             auto tbl = make_cte_table<M>(impl, get<TI1>(cte));
diff --git a/dev/cte_types.h b/dev/cte_types.h
index 726a2bb54..e583263ed 100644
--- a/dev/cte_types.h
+++ b/dev/cte_types.h
@@ -24,7 +24,7 @@ namespace sqlite_orm {
           public:
             using fields_type = fields_t<Fs...>;
             // this type name is used to detect the mapping from label to mapper
-            using label_type = Label;
+            using cte_label_type = Label;
 
             template<size_t I>
             decltype(auto) cget() const noexcept {
@@ -45,8 +45,8 @@ namespace sqlite_orm {
           public:
             using index_sequence = std::index_sequence_for<Fs...>;
             // this type name is used to detect the mapping from label to object
-            using label_type = Label;
-            using object_type = column_results<Label, Fs...>;
+            using cte_label_type = Label;
+            using cte_object_type = column_results<Label, Fs...>;
             using expressions_type = tuplify_t<Expression>;
         };
 
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index f16222efb..70fe55cce 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -243,7 +243,7 @@ namespace sqlite_orm {
          */
         template<class Label, class Select, class nExplicitCols>
         struct common_table_expression : public Label {
-            using label_type = Label;
+            using cte_label_type = Label;
             using expression_type = Select;
             static constexpr size_t explicit_column_count = nExplicitCols::value;
 
diff --git a/dev/storage.h b/dev/storage.h
index 102a29eb9..7a119afa7 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -168,7 +168,7 @@ namespace sqlite_orm {
 
                 static_if<is_without_rowid{}>(
                     [](auto&) {
-                        static_assert(std::is_void<label_type_t<table_type>>::value,
+                        static_assert(std::is_void<cte_label_type_t<table_type>>::value,
                                       "Attempting to execute 'insert' request for a CTE mapping.");
                     },
                     [](auto& tImpl) {  // unfortunately, this static_assert's can't see any composite keys((
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 34a20ded4..ccdca8ec4 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -181,8 +181,9 @@ namespace sqlite_orm {
             }
 
             std::string find_table_name(std::type_index ti) const {
-                std::type_index thisTypeIndex{typeid(
-                    std::conditional_t<std::is_void<label_type_t<H>>::value, object_type_t<H>, label_type_t<H>>)};
+                std::type_index thisTypeIndex{typeid(std::conditional_t<std::is_void<cte_label_type_t<H>>::value,
+                                                                        object_type_t<H>,
+                                                                        cte_label_type_t<H>>)};
                 if(thisTypeIndex == ti) {
                     return this->table.name;
                 } else {
@@ -423,9 +424,9 @@ namespace sqlite_orm {
         template<class Label, class O, class F, F O::*m, class S, satisfies<is_storage_impl, S> = true>
         constexpr decltype(auto) materialize_column_pointer(const S&, const column_pointer<Label, ice_t<m>>&) {
             using timpl_type = storage_pick_impl_t<S, Label>;
-            using mapper_type = storage_mapper_type_t<timpl_type>;
-            constexpr auto I = tuple_index_of_v<ice_t<m>, typename mapper_type::expressions_type>;
-            return cte_getter_v<object_type_t<mapper_type>, I>;
+            using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
+            constexpr auto I = tuple_index_of_v<ice_t<m>, typename cte_mapper_type::expressions_type>;
+            return cte_getter_v<cte_object_type_t<cte_mapper_type>, I>;
         }
 
         template<class Label, class O, class F, F O::*m, class S, satisfies<is_storage_impl, S> = true>
diff --git a/dev/storage_lookup.h b/dev/storage_lookup.h
index 07dd4010d..0faa6fe24 100644
--- a/dev/storage_lookup.h
+++ b/dev/storage_lookup.h
@@ -34,26 +34,26 @@ namespace sqlite_orm {
          *  A data type's CTE alias, otherwise T itself is used as a CTE alias.
          */
         template<typename T>
-        using detected_cte_label_t = polyfill::detected_or_t<T, label_type_t, T>;
+        using detected_cte_label_t = polyfill::detected_or_t<T, cte_label_type_t, T>;
 
         /**
          *  std::true_type if given object is mapped, std::false_type otherwise
          */
         template<typename S, typename O>
-        using object_type_matches = typename polyfill::conjunction<std::is_void<storage_label_type_t<S>>,
+        using object_type_matches = typename polyfill::conjunction<std::is_void<storage_cte_label_type_t<S>>,
                                                                    std::is_same<O, storage_object_type_t<S>>>::type;
 
         /**
          *  std::true_type if object is mapped via given (CTE) label, std::false_type otherwise
          */
         template<typename S, typename Label>
-        using label_type_matches = typename polyfill::conjunction<
-            std::negation<std::is_void<storage_label_type_t<S>>>,
-            std::is_same<detected_cte_label_t<Label>, storage_label_type_t<S>>>::type;
+        using cte_label_type_matches = typename polyfill::conjunction<
+            std::negation<std::is_void<storage_cte_label_type_t<S>>>,
+            std::is_same<detected_cte_label_t<Label>, storage_cte_label_type_t<S>>>::type;
 
         template<typename S, typename Lookup>
         using lookup_type_matches =
-            typename polyfill::disjunction<object_type_matches<S, Lookup>, label_type_matches<S, Lookup>>::type;
+            typename polyfill::disjunction<object_type_matches<S, Lookup>, cte_label_type_matches<S, Lookup>>::type;
     }
 
     // pick/lookup metafunctions
diff --git a/dev/table.h b/dev/table.h
index ce9120bce..58d747787 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -25,10 +25,10 @@ namespace sqlite_orm {
          *  A data type's label type, void otherwise.
          */
         template<typename O>
-        using label_of_t = polyfill::detected_or_t<void, label_type_t, O>;
+        using label_of_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
 
         template<typename O>
-        using object_type_of_t = polyfill::detected_or_t<O, object_type_t, O>;
+        using mapped_object_type_of_t = polyfill::detected_or_t<O, cte_object_type_t, O>;
 
         struct basic_table {
 
@@ -43,15 +43,16 @@ namespace sqlite_orm {
          * 
          *  Can be either for a table mapped to storage or for a common table expression (CTE).
          * 
-         *  The template parameter O is either a data structure object (i.e. direct mapping from storage to data)
+         *  The template parameter O is either a regular data structure object (i.e. direct mapping from storage to data)
          *  or an abstract 'mapper' object with a label attached.
+         *  The driving force behind this 'mapper' abstraction is the presence of a T::cte_label_type.
          */
         template<class O, bool WithoutRowId, class... Cs>
         struct table_t : basic_table {
             using super = basic_table;
-            using mapper_type = O;
-            using object_type = object_type_of_t<O>;
-            using label_type = label_of_t<O>;
+            using cte_mapper_type = O;
+            using cte_label_type = label_of_t<O>;
+            using object_type = mapped_object_type_of_t<O>;
             using elements_type = std::tuple<Cs...>;
 
             static constexpr const int elements_count = static_cast<int>(std::tuple_size<elements_type>::value);
diff --git a/dev/type_traits.h b/dev/type_traits.h
index 786d8d69d..14e8cf8dd 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -42,7 +42,10 @@ namespace sqlite_orm {
         using object_type_t = typename T::object_type;
 
         template<typename T>
-        using label_type_t = typename T::label_type;
+        using cte_label_type_t = typename T::cte_label_type;
+
+        template<typename T>
+        using cte_object_type_t = typename T::cte_object_type;
 
         template<typename T>
         using table_type_t = typename T::table_type;
@@ -51,10 +54,10 @@ namespace sqlite_orm {
         using storage_object_type_t = typename S::table_type::object_type;
 
         template<typename S>
-        using storage_mapper_type_t = typename S::table_type::mapper_type;
+        using storage_cte_mapper_type_t = typename S::table_type::cte_mapper_type;
 
         template<typename S>
-        using storage_label_type_t = typename S::table_type::label_type;
+        using storage_cte_label_type_t = typename S::table_type::cte_label_type;
 
         template<typename T>
         using expression_type_t = typename T::expression_type;

From ff086f612ed167dca5e9dbb29021a7fba5e7a7ee Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 18 Jan 2022 00:30:52 +0200
Subject: [PATCH 025/161] Renamed common_table_expression::expression ->
 subselect

---
 dev/ast_iterator.h           | 2 +-
 dev/cte_storage.h            | 2 +-
 dev/select_constraints.h     | 8 ++++----
 dev/statement_serializator.h | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/dev/ast_iterator.h b/dev/ast_iterator.h
index 0f97328ef..280f5a6cf 100644
--- a/dev/ast_iterator.h
+++ b/dev/ast_iterator.h
@@ -196,7 +196,7 @@ namespace sqlite_orm {
 
             template<class L>
             void operator()(const node_type& c, const L& l) const {
-                iterate_ast(c.expression, l);
+                iterate_ast(c.subselect, l);
             }
         };
 
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index d2cb16cb7..eba706ff3 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -114,7 +114,7 @@ namespace sqlite_orm {
             context_type context{impl};
 
             std::vector<std::string> columnNames =
-                collect_cte_column_names(get_cte_driving_subselect(cte.expression), cte.explicitColumnNames, context);
+                collect_cte_column_names(get_cte_driving_subselect(cte.subselect), cte.explicitColumnNames, context);
 
             return create_cte_table_t<M, typename M::index_sequence>{
                 cte.label(),
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 70fe55cce..171c39f60 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -248,11 +248,11 @@ namespace sqlite_orm {
             static constexpr size_t explicit_column_count = nExplicitCols::value;
 
             std::vector<std::string> explicitColumnNames;
-            expression_type expression;
+            expression_type subselect;
 
-            common_table_expression(std::vector<std::string> explicitColumnNames, expression_type expression) :
-                explicitColumnNames{move(explicitColumnNames)}, expression{std::move(expression)} {
-                this->expression.highest_level = true;
+            common_table_expression(std::vector<std::string> explicitColumnNames, expression_type subselect) :
+                explicitColumnNames{move(explicitColumnNames)}, subselect{std::move(subselect)} {
+                this->subselect.highest_level = true;
             }
         };
         template<class... CTEs>
diff --git a/dev/statement_serializator.h b/dev/statement_serializator.h
index 56b639be2..aa3c48e2e 100644
--- a/dev/statement_serializator.h
+++ b/dev/statement_serializator.h
@@ -505,7 +505,7 @@ namespace sqlite_orm {
                 std::stringstream ss;
                 ss << static_cast<std::string>(c);
                 std::vector<std::string> columnNames =
-                    collect_cte_column_names(c.expression, c.explicitColumnNames, context);
+                    collect_cte_column_names(get_cte_driving_subselect(c.subselect), c.explicitColumnNames, context);
                 {
                     ss << '(';
                     for(size_t i = 0, n = columnNames.size(); i < n; ++i) {
@@ -517,7 +517,7 @@ namespace sqlite_orm {
                     ss << ')';
                 }
                 ss << " AS ";
-                ss << '(' << serialize(c.expression, cteContext) << ')';
+                ss << '(' << serialize(c.subselect, cteContext) << ')';
                 return ss.str();
             }
         };

From 532c430584416fbf29f7153b06355c1aa89577dd Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 18 Jan 2022 14:58:27 +0200
Subject: [PATCH 026/161] Ability to build storage columns by integral member
 pointer constant

This changeset makes `asterisk<Object>` for work CTEs
---
 dev/column.h                          | 49 ++++++++++++++++++++++++++-
 dev/column_result.h                   | 20 ++++++-----
 dev/cte_storage.h                     | 24 ++++++-------
 dev/expression.h                      |  6 ++++
 dev/storage_impl.h                    | 29 +++++++---------
 dev/storage_traits.h                  | 30 +++++++++++++---
 dev/type_traits.h                     | 18 ++++++++++
 examples/common_table_expressions.cpp | 14 ++++----
 8 files changed, 139 insertions(+), 51 deletions(-)

diff --git a/dev/column.h b/dev/column.h
index 19f46ac76..dac91cb93 100644
--- a/dev/column.h
+++ b/dev/column.h
@@ -5,16 +5,25 @@
 #include <memory>  //  std::unique_ptr
 #include <type_traits>  //  std::true_type, std::false_type, std::is_same, std::enable_if, std::is_member_pointer, std::is_member_function_pointer
 
+#include "cxx_polyfill.h"
+#include "type_traits.h"
 #include "type_is_nullable.h"
 #include "tuple_helper/tuple_helper.h"
 #include "default_value_extractor.h"
 #include "constraints.h"
 #include "member_traits/member_traits.h"
+#include "member_traits/field_member_traits.h"
 
 namespace sqlite_orm {
 
     namespace internal {
 
+        /**
+         *  typename T::value_type if is_integral_constant_v<T>
+         */
+        template<typename T>
+        using ice_value_type_t = std::enable_if_t<is_integral_constant_v<T>, value_type_t<T>>;
+
         struct basic_column {
 
             /**
@@ -32,7 +41,14 @@ namespace sqlite_orm {
         template<class O, class T, class G /* = const T& (O::*)() const*/, class S /* = void (O::*)(T)*/, class... Op>
         struct column_t : basic_column {
             using object_type = O;
-            using field_type = T;
+            // the passed in type is either `integral_constant<F O::*member>` or the return type
+            using _ice_or_field_type = T;
+            // `F O::*` from `integral_constant<F O::*member>` or `T`
+            using _member_pointer_or_field_type = polyfill::detected_or_t<T, ice_value_type_t, T>;
+            // `F` from `F O::*` or `T`
+            using field_type = polyfill::detected_or_t<_member_pointer_or_field_type,
+                                                       field_type_t,
+                                                       field_member_traits<_member_pointer_or_field_type>>;
             using constraints_type = std::tuple<Op...>;
             using member_pointer_t = field_type object_type::*;
             using getter_type = G;
@@ -200,6 +216,20 @@ namespace sqlite_orm {
             using type = typename column_t<O, T, Op...>::field_type;
         };
 
+        template<class T, class SFINAE = void>
+        struct column_field_expression {
+            using type = void;
+        };
+
+        template<class O, class T, class... Op>
+        struct column_field_expression<column_t<O, T, Op...>, match_if_not<is_integral_constant, T>> {
+            using type = typename column_t<O, T, Op...>::member_pointer_t;
+        };
+
+        // match `F O::*member`
+        template<class O, class F, F O::*m, class... Op>
+        struct column_field_expression<column_t<O, ice_t<m>, Op...>, void> : ice_t<m> {};
+
         template<class T>
         struct column_constraints_type {
             using type = std::tuple<>;
@@ -228,6 +258,23 @@ namespace sqlite_orm {
         return {name, m, nullptr, nullptr, std::make_tuple(constraints...)};
     }
 
+    /**
+     *  Column builder function. You should use it to create columns instead of constructor
+     */
+    template<class T,
+             T m,
+             class O = typename internal::field_member_traits<T>::object_type,
+             class F = typename internal::field_member_traits<T>::field_type,
+             class... Op>
+    internal::column_t<O, std::integral_constant<T, m>, const F& (O::*)() const, void (O::*)(F), Op...>
+    make_column(const std::string& name, std::integral_constant<T, m>, Op... constraints) {
+        static_assert(internal::template constraints_size<Op...>::value == std::tuple_size<std::tuple<Op...>>::value,
+                      "Incorrect constraints pack");
+        static_assert(internal::is_field_member_pointer<T>::value,
+                      "second argument expected as a member field pointer, not member function pointer");
+        return {name, m, nullptr, nullptr, std::make_tuple(constraints...)};
+    }
+
     /**
      *  Column builder function with setter and getter. You should use it to create columns instead of constructor
      */
diff --git a/dev/column_result.h b/dev/column_result.h
index 8f4ca37a1..2ea7cd6d1 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -4,6 +4,7 @@
 #include <tuple>  //  std::tuple
 #include <functional>  //  std::reference_wrapper
 
+#include "cxx_polyfill.h"
 #include "type_traits.h"
 #include "core_functions.h"
 #include "select_constraints.h"
@@ -224,7 +225,7 @@ namespace sqlite_orm {
 
         template<class St, class Label, class O, class F, F O::*m>
         struct column_result_t<St, column_pointer<Label, ice_t<m>>, void> {
-            using type = typename ice_t<m>::value_type;
+            using type = F;
         };
 
         template<class St, class... Args>
@@ -328,22 +329,23 @@ namespace sqlite_orm {
 
         // No CTE for object expressions.
         template<class St, class T>
-        struct column_expression_type<St, object_t<T>, void>;
+        struct column_expression_type<St, object_t<T>, void> {
+            static_assert(polyfill::always_false_v<T>, "Selecting an object in a subselect is not allowed.");
+        };
 
         template<class St, class T>
-        struct column_expression_type<St, asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>> {
-            using type = typename storage_traits::storage_mapped_columns<St, T>::type;
-        };
+        struct column_expression_type<St, asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>>
+            : storage_traits::storage_mapped_column_expressions<St, T> {};
 
         template<class St, class A>
         struct column_expression_type<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>> {
-            using type = typename storage_traits::storage_mapped_columns<St, type_t<A>>::type;
+            // Currently unimplemented - need to form alias_column_t<> expressions
+            static_assert(polyfill::always_false_v<A>,
+                          "Selecting all columms from an aliased table is currently unimplemented.");
         };
 
         template<class St, class O, class F, F O::*m>
-        struct column_expression_type<St, ice_t<m>, void> {
-            using type = ice_t<m>;
-        };
+        struct column_expression_type<St, ice_t<m>, void> : ice_t<m> {};
 
         template<class St, class... Args>
         struct column_expression_type<St, columns_t<Args...>, void> {
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index eba706ff3..6d460c088 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -17,17 +17,17 @@ namespace sqlite_orm {
 
         // F = field_type
         template<typename Label, typename Expression, typename F>
-        struct create_column_results {
+        struct create_cte_mapper {
             using type = subselect_mapper<Label, Expression, F>;
         };
 
         template<typename Label, typename Expression, typename... Fs>
-        struct create_column_results<Label, Expression, std::tuple<Fs...>> {
+        struct create_cte_mapper<Label, Expression, std::tuple<Fs...>> {
             using type = subselect_mapper<Label, Expression, Fs...>;
         };
 
         template<typename Label, typename Expression, typename... Fs>
-        using create_column_results_t = typename create_column_results<Label, Expression, Fs...>::type;
+        using create_cte_mapper_t = typename create_cte_mapper<Label, Expression, Fs...>::type;
 
         template<typename O, size_t CI>
         struct create_cte_column {
@@ -132,11 +132,10 @@ namespace sqlite_orm {
                                                                       const common_table_expressions<CTEs...>& cte,
                                                                       std::index_sequence<TI1>) {
             using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
-            using M =
-                create_column_results_t<cte_label_type_t<cte_t>,
-                                        column_expression_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>,
-                                        column_result_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>>;
-            static_assert(!cte_t::explicit_column_count || cte_t::explicit_column_count == M::index_sequence::size());
+            using M = create_cte_mapper_t<cte_label_type_t<cte_t>,
+                                          column_expression_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>,
+                                          column_result_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>>;
+            static_assert(cte_t::explicit_column_count == 0 || cte_t::explicit_column_count == M::index_sequence::size());
 
             auto tbl = make_cte_table<M>(impl, get<TI1>(cte));
 
@@ -148,11 +147,10 @@ namespace sqlite_orm {
                                                                       const common_table_expressions<CTEs...>& cte,
                                                                       std::index_sequence<TI1, TIn...>) {
             using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
-            using M =
-                create_column_results_t<cte_label_type_t<cte_t>,
-                                        column_expression_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>,
-                                        column_result_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>>;
-            static_assert(!cte_t::explicit_column_count || cte_t::explicit_column_count == M::index_sequence::size());
+            using M = create_cte_mapper_t<cte_label_type_t<cte_t>,
+                                          column_expression_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>,
+                                          column_result_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>>;
+            static_assert(cte_t::explicit_column_count == 0 || cte_t::explicit_column_count == M::index_sequence::size());
 
             auto tbl = make_cte_table<M>(impl, get<TI1>(cte));
 
diff --git a/dev/expression.h b/dev/expression.h
index f060298e7..17ea95da1 100644
--- a/dev/expression.h
+++ b/dev/expression.h
@@ -1,3 +1,9 @@
+#pragma once
+#include <utility>
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+#include <optional>
+#endif
+
 #include "operators.h"
 
 namespace sqlite_orm {
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index ccdca8ec4..660eb744e 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -399,12 +399,9 @@ namespace sqlite_orm {
             return pick_impl<O>(strg).table.find_column_name(field);
         }
 
-        /**
-         *  Find column name by its type and member pointer.
-         */
-        template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
-        const std::string* find_column_name(const S& strg, const column_pointer<O, F>& cp) {
-            return pick_impl<O>(strg).table.find_column_name(cp.field);
+        template<class Label, class O, class F, class S, satisfies<is_storage_impl, S> = true>
+        constexpr decltype(auto) materialize_column_pointer(const S&, const column_pointer<O, F>& cp) {
+            return cp.field;
         }
 
         template<class Label, size_t I, class S, satisfies<is_storage_impl, S> = true>
@@ -414,25 +411,25 @@ namespace sqlite_orm {
             return cte_getter_v<storage_object_type_t<timpl_type>, I>;
         }
 
-        template<class Label, size_t I, class S, satisfies<is_storage_impl, S> = true>
-        const std::string* find_column_name(const S& strg,
-                                            const column_pointer<Label, polyfill::index_constant<I>>& cp) {
-            auto field = materialize_column_pointer(strg, cp);
-            return pick_impl<Label>(strg).table.find_column_name(field);
-        }
-
         template<class Label, class O, class F, F O::*m, class S, satisfies<is_storage_impl, S> = true>
         constexpr decltype(auto) materialize_column_pointer(const S&, const column_pointer<Label, ice_t<m>>&) {
             using timpl_type = storage_pick_impl_t<S, Label>;
             using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
+            // lookup index in column_results object (aka fields tuple) by member pointer
             constexpr auto I = tuple_index_of_v<ice_t<m>, typename cte_mapper_type::expressions_type>;
             return cte_getter_v<cte_object_type_t<cte_mapper_type>, I>;
         }
 
-        template<class Label, class O, class F, F O::*m, class S, satisfies<is_storage_impl, S> = true>
-        const std::string* find_column_name(const S& strg, const column_pointer<Label, ice_t<m>>& cp) {
+        /**
+         *  Find column name by:
+         *  1. by explicit object type and member pointer.
+         *  2. by label type and index constant.
+         *  3. by label type and member pointer constant.
+         */
+        template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
+        const std::string* find_column_name(const S& strg, const column_pointer<O, F>& cp) {
             auto field = materialize_column_pointer(strg, cp);
-            return pick_impl<Label>(strg).table.find_column_name(field);
+            return pick_impl<O>(strg).table.find_column_name(field);
         }
     }
 }
diff --git a/dev/storage_traits.h b/dev/storage_traits.h
index c122d85cc..d68ed97b7 100644
--- a/dev/storage_traits.h
+++ b/dev/storage_traits.h
@@ -46,18 +46,18 @@ namespace sqlite_orm {
             /**
              *  T - table type.
              */
-            template<class T>
+            template<class T, template<class> class TranfsormOp>
             struct table_types;
 
             /**
              *  type is std::tuple of field types of mapped colums.
              */
-            template<class O, bool WithoutRowId, class... Args>
-            struct table_types<table_t<O, WithoutRowId, Args...>> {
+            template<class O, bool WithoutRowId, class... Args, template<class> class TransformOp>
+            struct table_types<table_t<O, WithoutRowId, Args...>, TransformOp> {
                 using args_tuple = std::tuple<Args...>;
                 using columns_tuple = typename tuple_filter<args_tuple, is_column>::type;
 
-                using type = typename tuple_transformer<columns_tuple, column_field_type>::type;
+                using type = typename tuple_transformer<columns_tuple, TransformOp>::type;
             };
 
             /**
@@ -67,7 +67,7 @@ namespace sqlite_orm {
             template<class S>
             struct storage_mapped_columns_impl {
                 using table_type = typename S::table_type;
-                using type = typename table_types<table_type>::type;
+                using type = typename table_types<table_type, column_field_type>::type;
             };
 
             template<>
@@ -82,6 +82,26 @@ namespace sqlite_orm {
             template<class S, class O>
             struct storage_mapped_columns : storage_mapped_columns_impl<storage_find_impl_t<S, O>> {};
 
+            /**
+             *  S - storage_impl type for specific mapped type
+             *  O - mapped data type
+             */
+            template<class S>
+            struct storage_mapped_column_expressions_impl : table_types<table_type_t<S>, column_field_expression> {};
+
+            template<>
+            struct storage_mapped_column_expressions_impl<storage_impl<>> {
+                using type = std::tuple<>;
+            };
+
+            /**
+             *  S - storage
+             *  O - mapped data type
+             */
+            template<class S, class O>
+            struct storage_mapped_column_expressions
+                : storage_mapped_column_expressions_impl<storage_find_impl_t<S, O>> {};
+
             /**
              *  C is any column type: column_t or constraint type
              *  O - object type references in FOREIGN KEY
diff --git a/dev/type_traits.h b/dev/type_traits.h
index 14e8cf8dd..cab9a06e7 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -33,11 +33,29 @@ namespace sqlite_orm {
         using satisfies_is_specialization_of = std::enable_if_t<polyfill::is_specialization_of_v<T, Primary>, bool>;
     }
 
+    // type traits not quite polyfill, however used throughout the program
+    namespace internal {
+        template<typename T>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_integral_constant_v = false;
+
+        template<typename T, T N>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_integral_constant_v<std::integral_constant<T, N>> = true;
+
+        template<typename T>
+        struct is_integral_constant : polyfill::bool_constant<is_integral_constant_v<T>> {};
+    }
+
     // type name template aliases for syntactic sugar
     namespace internal {
         template<typename T>
         using type_t = typename T::type;
 
+        template<typename T>
+        using value_type_t = typename T::value_type;
+
+        template<typename T>
+        using field_type_t = typename T::field_type;
+
         template<typename T>
         using object_type_t = typename T::object_type;
 
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index daec9dec2..b8d495a2f 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -91,8 +91,8 @@ void supervisor_chain() {
 
     auto storage = make_storage("",
                                 make_table<Org>("org",
-                                                make_column("name", &Org::name, primary_key()),
-                                                make_column("boss", &Org::boss),
+                                                make_column("name", c_v<&Org::name>, primary_key()),
+                                                make_column("boss", c_v<&Org::boss>),
                                                 foreign_key(&Org::boss).references(&Org::name)));
     storage.sync_schema();
 
@@ -114,11 +114,11 @@ void supervisor_chain() {
         //        WHERE parent.name = chain.boss
         //    )
         //    SELECT name FROM chain;
-        auto ast = with(
-            cte<cte_1>()(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
-                                   select(asterisk<alias_a<Org>>(),
-                                          where(c(alias_column<alias_a<Org>>(&Org::name)) == column<cte_1>(1_col))))),
-            select(column<cte_1>(0_col)));
+        auto ast = with(cte<cte_1>()(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
+                                               select(asterisk<alias_a<Org>>(),
+                                                      where(c(alias_column<alias_a<Org>>(&Org::name)) ==
+                                                            column<cte_1>(c_v<&Org::boss>))))),
+                        select(column<cte_1>(c_v<&Org::name>)));
         string sql = storage.dump(ast);
 
         auto stmt = storage.prepare(ast);

From 749ce474c2499b1ca7e7be88e18d19c6df997d5c Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 18 Jan 2022 17:41:53 +0200
Subject: [PATCH 027/161] Implemented getting column expression from aliased
 asterisk expression

---
 dev/column_result.h      | 16 +++++++++++-----
 dev/select_constraints.h |  2 +-
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/dev/column_result.h b/dev/column_result.h
index 2ea7cd6d1..c755635d1 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -15,6 +15,7 @@
 #include "cte_types.h"
 #include "storage_traits.h"
 #include "function.h"
+#include "tuple_helper/tuple_transformer.h"
 
 namespace sqlite_orm {
 
@@ -337,12 +338,17 @@ namespace sqlite_orm {
         struct column_expression_type<St, asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>>
             : storage_traits::storage_mapped_column_expressions<St, T> {};
 
-        template<class St, class A>
-        struct column_expression_type<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>> {
-            // Currently unimplemented - need to form alias_column_t<> expressions
-            static_assert(polyfill::always_false_v<A>,
-                          "Selecting all columms from an aliased table is currently unimplemented.");
+        template<class A>
+        struct add_column_alias {
+            template<typename ColExpr>
+            struct apply {
+                using type = alias_column_t<A, ColExpr>;
+            };
         };
+        template<class St, class A>
+        struct column_expression_type<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>>
+            : tuple_transformer<typename storage_traits::storage_mapped_column_expressions<St, type_t<A>>::type,
+                                add_column_alias<A>::template apply> {};
 
         template<class St, class O, class F, F O::*m>
         struct column_expression_type<St, ice_t<m>, void> : ice_t<m> {};
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 171c39f60..49f7e2be1 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -276,7 +276,7 @@ namespace sqlite_orm {
         };
 
         /**
-         *  Expression with prepended CTEs.
+         *  WITH object type - expression with prepended CTEs.
          */
         template<class E, class... CTEs>
         struct with_t : with_string {

From c772d093e44b7a67815ead8c6154193675f74dd6 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 18 Jan 2022 17:44:13 +0200
Subject: [PATCH 028/161] Static unit tests for column expression types

---
 tests/static_tests/column_expression_type.cpp | 42 +++++++++++++++++++
 tests/static_tests/column_result_t.cpp        | 23 +++++++++-
 2 files changed, 63 insertions(+), 2 deletions(-)
 create mode 100644 tests/static_tests/column_expression_type.cpp

diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
new file mode 100644
index 000000000..b4f318a3a
--- /dev/null
+++ b/tests/static_tests/column_expression_type.cpp
@@ -0,0 +1,42 @@
+#include <type_traits>  //  std::is_same
+#include <sqlite_orm/sqlite_orm.h>
+#include <catch2/catch.hpp>
+
+using namespace sqlite_orm;
+
+template<class St, class E, class V>
+void runTest(V value) {
+    using Type = internal::column_expression_of_t<St, V>;
+    static_assert(std::is_same<Type, E>::value, "");
+}
+
+TEST_CASE("column_expression_of_t") {
+    struct Org {
+        // compile-time mapped (via c_v<>)
+        int64 id = 0;
+        // not compile-time mapped
+        int64 boss = 0;
+    };
+
+    auto storage =
+        make_storage("", make_table("org", make_column("id", c_v<&Org::id>), make_column("boss", &Org::boss)));
+    using storage_type = decltype(storage);
+
+    runTest<storage_type, internal::rowid_t>(rowid());
+    runTest<storage_type, int64 Org::*>(&Org::id);
+    // std::reference_wrapper
+    {
+        int64 x;
+        runTest<storage_type, int64>(std::ref(x));
+    }
+    runTest<storage_type, std::integral_constant<int64 Org::*, &Org::id>>(internal::ice_t<&Org::id>{});
+    runTest<storage_type, internal::ice_t<&Org::id>>(c_v<&Org::id>);
+    runTest<storage_type, std::tuple<internal::ice_t<&Org::id>, int64 Org::*>>(columns(c_v<&Org::id>, &Org::boss));
+    runTest<storage_type, std::tuple<int64 Org::*, internal::ice_t<&Org::boss>>>(columns(&Org::id, c_v<&Org::boss>));
+    runTest<storage_type, std::tuple<internal::ice_t<&Org::id>, int64 Org::*>>(asterisk<Org>());
+    runTest<storage_type,
+            std::tuple<internal::alias_column_t<alias_a<Org>, internal::ice_t<&Org::id>>,
+                       internal::alias_column_t<alias_a<Org>, int64 Org::*>>>(asterisk<alias_a<Org>>());
+    // object_t not allowed
+    //runTest<storage_type, Org>(object<Org>());
+}
diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
index 946eeb61c..40e4d823b 100644
--- a/tests/static_tests/column_result_t.cpp
+++ b/tests/static_tests/column_result_t.cpp
@@ -6,11 +6,11 @@ using namespace sqlite_orm;
 
 template<class St, class E, class V>
 void runTest(V value) {
-    using Type = typename internal::column_result_t<St, V>::type;
+    using Type = internal::column_result_of_t<St, V>;
     static_assert(std::is_same<Type, E>::value, "");
 }
 
-TEST_CASE("column_result_t") {
+TEST_CASE("column_result_of_t 1") {
     struct User {
         int id = 0;
         std::string name;
@@ -102,3 +102,22 @@ TEST_CASE("column_result_t") {
     runTest<Storage, int64>(oid<User>());
     runTest<Storage, int64>(_rowid_<User>());
 }
+
+TEST_CASE("column_result_of_t 2") {
+    struct Org {
+        // compile-time mapped (via c_v<>)
+        int64 id = 0;
+        // not compile-time mapped
+        int64 boss = 0;
+    };
+
+    auto storage =
+        make_storage("", make_table("org", make_column("id", c_v<&Org::id>), make_column("boss", &Org::boss)));
+    using storage_type = decltype(storage);
+
+    runTest<storage_type, int64>(c_v<&Org::id>);
+    runTest<storage_type, std::tuple<int64, int64>>(columns(c_v<&Org::id>, &Org::boss));
+    runTest<storage_type, std::tuple<int64, int64>>(asterisk<Org>());
+    runTest<storage_type, std::tuple<int64, int64>>(asterisk<alias_a<Org>>());
+    runTest<storage_type, Org>(object<Org>());
+}

From 758233028d2f6df72a3e9e2178c88140fadfb79e Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 18 Jan 2022 17:48:47 +0200
Subject: [PATCH 029/161] Added explicit as() call CTE builder

---
 dev/select_constraints.h              | 39 +++++++++++++++++++++++++++
 examples/common_table_expressions.cpp | 13 +++++++++
 2 files changed, 52 insertions(+)

diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 49f7e2be1..71c80c449 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -273,6 +273,45 @@ namespace sqlite_orm {
             common_table_expression<Label, select_t<Compound>, nExplicitCols> operator()(Compound sel) && {
                 return {move(this->explicitColumnNames), {std::move(sel)}};
             }
+
+            template<class T, class... Args>
+            common_table_expression<Label, select_t<T, Args...>, nExplicitCols> as(select_t<T, Args...> sel) && {
+                return {move(this->explicitColumnNames), std::move(sel)};
+            }
+
+            template<class Compound,
+                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            common_table_expression<Label, select_t<Compound>, nExplicitCols> as(Compound sel) && {
+                return {move(this->explicitColumnNames), {std::move(sel)}};
+            }
+
+            template<class T, class... Args>
+            common_table_expression<Label, select_t<T, Args...>, nExplicitCols>
+            materialized(select_t<T, Args...> sel) && {
+                static_assert(polyfill::always_false_v<T>, "`WITH ... AS MATERIALIZED` is unimplemented");
+                return {move(this->explicitColumnNames), std::move(sel)};
+            }
+
+            template<class Compound,
+                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            common_table_expression<Label, select_t<Compound>, nExplicitCols> materialized(Compound sel) && {
+                static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS MATERIALIZED` is unimplemented");
+                return {move(this->explicitColumnNames), {std::move(sel)}};
+            }
+
+            template<class T, class... Args>
+            common_table_expression<Label, select_t<T, Args...>, nExplicitCols>
+            not_materialized(select_t<T, Args...> sel) && {
+                static_assert(polyfill::always_false_v<T>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
+                return {move(this->explicitColumnNames), std::move(sel)};
+            }
+
+            template<class Compound,
+                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            common_table_expression<Label, select_t<Compound>, nExplicitCols> not_materialized(Compound sel) && {
+                static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
+                return {move(this->explicitColumnNames), {std::move(sel)}};
+            }
         };
 
         /**
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index b8d495a2f..babd7fcd2 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -68,6 +68,19 @@ void all_integers_between(int from, int end) {
         }
         cout << endl;
     }
+
+    // variant 3, limit-clause, explicit as() call
+    {
+        cout << "Integer range (limit-clause) [" << from << ", " << end
+             << "]"
+                "\n";
+        for(int n:
+            storage.with(cte<cte_1>("x").as(union_all(select(from), select(column<cte_1>(0_col) + c(1), limit(end)))),
+                         select(column<cte_1>(0_col)))) {
+                cout << n << ", ";
+            }
+        cout << endl;
+    }
     cout << endl;
 }
 

From 1ec93501fad4f276c43c9127532920b355ddb754 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 18 Jan 2022 18:06:03 +0200
Subject: [PATCH 030/161] Provided `polyfill::remove_cvref` for C++17

---
 dev/cte_column_names_collector.h |  8 +++++---
 dev/cte_storage.h                |  2 +-
 dev/cxx_polyfill.h               | 11 +++++++++++
 dev/storage.h                    |  6 +++---
 4 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index b4ce8c463..f69eed03c 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -93,7 +93,7 @@ namespace sqlite_orm {
         // No CTE for object expressions.
         template<class Object>
         struct cte_column_names_collector<Object, match_specialization_of<Object, object_t>> {
-            static_assert(polyfill::always_false_v<Object>, "object_t not supported for subselects.");
+            static_assert(polyfill::always_false_v<Object>, "Selecting an object in a subselect is not allowed.");
         };
 
         template<class Columns>
@@ -107,9 +107,11 @@ namespace sqlite_orm {
                 auto newContext = context;
                 newContext.skip_table_name = true;
                 iterate_tuple(cols.columns, [&columnNames, &newContext](auto& m) {
+                    using value_type = polyfill::remove_cvref_t<decltype(m)>;
+
                     std::string columnName;
-                    if constexpr(polyfill::is_specialization_of_v<std::remove_cvref_t<decltype(m)>, as_t>) {
-                        columnName = alias_extractor<typename std::remove_cvref_t<decltype(m)>::alias_type>::get();
+                    if constexpr(polyfill::is_specialization_of_v<value_type, as_t>) {
+                        columnName = alias_extractor<typename value_type::alias_type>::get();
                     } else {
                         columnName = serialize(m, newContext);
                     }
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 6d460c088..a6db98d1e 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -104,7 +104,7 @@ namespace sqlite_orm {
 
         template<typename Select>
         using cte_driving_subselect_t =
-            std::remove_cvref_t<decltype(get_cte_driving_subselect(std::declval<Select>()))>;
+            polyfill::remove_cvref_t<decltype(get_cte_driving_subselect(std::declval<Select>()))>;
 
         template<typename M, typename S, typename CTE, size_t... CIs>
         create_cte_table_t<M, typename M::index_sequence>
diff --git a/dev/cxx_polyfill.h b/dev/cxx_polyfill.h
index 4dccd4b63..763e7c830 100644
--- a/dev/cxx_polyfill.h
+++ b/dev/cxx_polyfill.h
@@ -40,6 +40,17 @@ namespace sqlite_orm {
             using std::void_t;
 #endif
 
+#if __cplusplus < 202002L
+            template<class T>
+            struct remove_cvref : std::remove_cv<std::remove_reference_t<T>> {};
+
+            template<class T>
+            using remove_cvref_t = typename remove_cvref<T>::type;
+#else
+            using std::remove_cvref;
+            using std::remove_cvref_t;
+#endif
+
 #if __cplusplus < 202312L  // before C++23
             template<typename Type, template<typename...> class Primary>
             SQLITE_ORM_INLINE_VAR constexpr bool is_specialization_of_v = false;
diff --git a/dev/storage.h b/dev/storage.h
index 7a119afa7..35b0f5993 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -161,7 +161,7 @@ namespace sqlite_orm {
             template<class O>
             void assert_insertable_type() const {
                 auto& tImpl = this->get_impl<O>();
-                using table_type = table_type_t<std::remove_cvref_t<decltype(tImpl)>>;
+                using table_type = table_type_t<polyfill::remove_cvref_t<decltype(tImpl)>>;
                 using elements_type = typename table_type::elements_type;
 
                 using is_without_rowid = std::integral_constant<bool, table_type::is_without_rowid>;
@@ -607,7 +607,7 @@ namespace sqlite_orm {
             template<class E, satisfies_not<is_prepared_statement, E> = true>
             std::string dump(const E& expression, bool asBindable = false) const {
                 const auto& exprImpl = storage_for_expression(*this, expression);
-                using context_t = serializator_context<std::remove_cvref_t<decltype(exprImpl)>>;
+                using context_t = serializator_context<polyfill::remove_cvref_t<decltype(exprImpl)>>;
                 context_t context{exprImpl};
                 context.replace_bindable_with_question = asBindable;
                 context.skip_table_name = false;
@@ -955,7 +955,7 @@ namespace sqlite_orm {
                 sqlite3_stmt* stmt;
                 auto db = con.get();
                 const auto& exprImpl = storage_for_expression(*this, statement);
-                using context_t = serializator_context<std::remove_cvref_t<decltype(exprImpl)>>;
+                using context_t = serializator_context<polyfill::remove_cvref_t<decltype(exprImpl)>>;
                 context_t context{exprImpl};
                 context.skip_table_name = false;
                 context.replace_bindable_with_question = true;

From 8f8e99172a81f42f34b48e5f24b8ea7ac80545a0 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 18 Jan 2022 20:23:38 +0200
Subject: [PATCH 031/161] Moved `column_expression_of_t` machinery to its own
 respective header file

---
 dev/column_expression.h | 68 +++++++++++++++++++++++++++++++++++++++++
 dev/column_result.h     | 54 ++------------------------------
 dev/cte_storage.h       |  1 +
 3 files changed, 71 insertions(+), 52 deletions(-)
 create mode 100644 dev/column_expression.h

diff --git a/dev/column_expression.h b/dev/column_expression.h
new file mode 100644
index 000000000..f55cf0679
--- /dev/null
+++ b/dev/column_expression.h
@@ -0,0 +1,68 @@
+#pragma once
+
+#include <type_traits>  //  std::enable_if, std::is_same, std::decay, std::is_arithmetic
+#include <tuple>  //  std::tuple
+#include <functional>  //  std::reference_wrapper
+
+#include "cxx_polyfill.h"
+#include "type_traits.h"
+#include "select_constraints.h"
+#include "alias.h"
+#include "storage_traits.h"
+#include "tuple_helper/tuple_transformer.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        template<class St, class T, class SFINAE = void>
+        struct column_expression_type;
+
+        /**
+         *  Obains the expressions that form the columns of a subselect statement.
+         */
+        template<class St, class T>
+        using column_expression_of_t = typename column_expression_type<St, T>::type;
+
+        template<class St, class T, class SFINAE>
+        struct column_expression_type {
+            using type = T;
+        };
+
+        template<class St, class T>
+        struct column_expression_type<St, std::reference_wrapper<T>, void> : column_expression_type<St, T> {};
+
+        // No CTE for object expressions.
+        template<class St, class T>
+        struct column_expression_type<St, object_t<T>, void> {
+            static_assert(polyfill::always_false_v<T>, "Selecting an object in a subselect is not allowed.");
+        };
+
+        template<class St, class T>
+        struct column_expression_type<St, asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>>
+            : storage_traits::storage_mapped_column_expressions<St, T> {};
+
+        template<class A>
+        struct add_column_alias {
+            template<typename ColExpr>
+            struct apply {
+                using type = alias_column_t<A, ColExpr>;
+            };
+        };
+        template<class St, class A>
+        struct column_expression_type<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>>
+            : tuple_transformer<typename storage_traits::storage_mapped_column_expressions<St, type_t<A>>::type,
+                                add_column_alias<A>::template apply> {};
+
+        template<class St, class O, class F, F O::*m>
+        struct column_expression_type<St, ice_t<m>, void> : ice_t<m> {};
+
+        template<class St, class... Args>
+        struct column_expression_type<St, columns_t<Args...>, void> {
+            using type = std::tuple<column_expression_of_t<St, std::decay_t<Args>>...>;
+        };
+
+        template<class St, class T, class... Args>
+        struct column_expression_type<St, select_t<T, Args...>> : column_expression_type<St, T> {};
+    }
+}
diff --git a/dev/column_result.h b/dev/column_result.h
index c755635d1..618f0c59b 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -11,11 +11,9 @@
 #include "operators.h"
 #include "rowid.h"
 #include "alias.h"
-#include "column.h"
 #include "cte_types.h"
 #include "storage_traits.h"
 #include "function.h"
-#include "tuple_helper/tuple_transformer.h"
 
 namespace sqlite_orm {
 
@@ -31,6 +29,8 @@ namespace sqlite_orm {
          *  c++ SELECT return type for T
          *  T - C++ type
          *  SFINAE - sfinae argument
+         * 
+         *  Note (implementation): could be possibly implemented by utilizing column_expression_of_t
          */
         template<class St, class T, class SFINAE = void>
         struct column_result_t;
@@ -38,15 +38,6 @@ namespace sqlite_orm {
         template<class St, class T>
         using column_result_of_t = typename column_result_t<St, T>::type;
 
-        template<class St, class T, class SFINAE = void>
-        struct column_expression_type;
-
-        /**
-         *  Obains the expressions that form the columns of a subselect statement.
-         */
-        template<class St, class T>
-        using column_expression_of_t = typename column_expression_type<St, T>::type;
-
 #ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
         template<class St, class T>
         struct column_result_t<St, as_optional_t<T>, void> {
@@ -319,46 +310,5 @@ namespace sqlite_orm {
 
         template<class St, class T>
         struct column_result_t<St, std::reference_wrapper<T>, void> : column_result_t<St, T> {};
-
-        template<class St, class T, class SFINAE>
-        struct column_expression_type {
-            using type = T;
-        };
-
-        template<class St, class T>
-        struct column_expression_type<St, std::reference_wrapper<T>, void> : column_expression_type<St, T> {};
-
-        // No CTE for object expressions.
-        template<class St, class T>
-        struct column_expression_type<St, object_t<T>, void> {
-            static_assert(polyfill::always_false_v<T>, "Selecting an object in a subselect is not allowed.");
-        };
-
-        template<class St, class T>
-        struct column_expression_type<St, asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>>
-            : storage_traits::storage_mapped_column_expressions<St, T> {};
-
-        template<class A>
-        struct add_column_alias {
-            template<typename ColExpr>
-            struct apply {
-                using type = alias_column_t<A, ColExpr>;
-            };
-        };
-        template<class St, class A>
-        struct column_expression_type<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>>
-            : tuple_transformer<typename storage_traits::storage_mapped_column_expressions<St, type_t<A>>::type,
-                                add_column_alias<A>::template apply> {};
-
-        template<class St, class O, class F, F O::*m>
-        struct column_expression_type<St, ice_t<m>, void> : ice_t<m> {};
-
-        template<class St, class... Args>
-        struct column_expression_type<St, columns_t<Args...>, void> {
-            using type = std::tuple<column_expression_of_t<St, std::decay_t<Args>>...>;
-        };
-
-        template<class St, class T, class... Args>
-        struct column_expression_type<St, select_t<T, Args...>> : column_expression_type<St, T> {};
     }
 }
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index a6db98d1e..fac5fcf49 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -6,6 +6,7 @@
 #include <vector>
 
 #include "column_result.h"
+#include "column_expression.h"
 #include "select_constraints.h"
 #include "table.h"
 #include "cte_types.h"

From 7d9405928b0f3043a078a7fa14864957a9bd9f8b Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 18 Jan 2022 20:30:26 +0200
Subject: [PATCH 032/161] Corrected column expression for reference wrapper

---
 dev/column_expression.h                       | 3 ++-
 tests/static_tests/column_expression_type.cpp | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/dev/column_expression.h b/dev/column_expression.h
index f55cf0679..3c968a61b 100644
--- a/dev/column_expression.h
+++ b/dev/column_expression.h
@@ -30,7 +30,8 @@ namespace sqlite_orm {
         };
 
         template<class St, class T>
-        struct column_expression_type<St, std::reference_wrapper<T>, void> : column_expression_type<St, T> {};
+        struct column_expression_type<St, std::reference_wrapper<T>, void>
+            : std::add_lvalue_reference<column_expression_of_t<St, T>> {};
 
         // No CTE for object expressions.
         template<class St, class T>
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index b4f318a3a..1dfed57de 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -26,8 +26,8 @@ TEST_CASE("column_expression_of_t") {
     runTest<storage_type, int64 Org::*>(&Org::id);
     // std::reference_wrapper
     {
-        int64 x;
-        runTest<storage_type, int64>(std::ref(x));
+        const int64 x = 42;
+        runTest<storage_type, const int64&>(std::ref(x));
     }
     runTest<storage_type, std::integral_constant<int64 Org::*, &Org::id>>(internal::ice_t<&Org::id>{});
     runTest<storage_type, internal::ice_t<&Org::id>>(c_v<&Org::id>);

From 5e468682173bbd959dc89121a203a064a93eac79 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 18 Jan 2022 20:59:55 +0200
Subject: [PATCH 033/161] Added static unit tests for 'column pointer'

---
 tests/static_tests/column_expression_type.cpp | 14 ++++++++++++--
 tests/static_tests/column_result_t.cpp        | 11 +++++++++--
 2 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index 1dfed57de..d4f380dc4 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -17,11 +17,15 @@ TEST_CASE("column_expression_of_t") {
         // not compile-time mapped
         int64 boss = 0;
     };
+    struct Derived : Org {};
 
-    auto storage =
-        make_storage("", make_table("org", make_column("id", c_v<&Org::id>), make_column("boss", &Org::boss)));
+    auto storage = make_storage(
+        "",
+        make_table("org", make_column("id", c_v<&Org::id>), make_column("boss", &Org::boss)),
+        make_table<Derived>("derived", make_column("id", c_v<&Derived::id>), make_column("boss", &Derived::boss)));
     using storage_type = decltype(storage);
 
+    runTest<storage_type, int>(1);
     runTest<storage_type, internal::rowid_t>(rowid());
     runTest<storage_type, int64 Org::*>(&Org::id);
     // std::reference_wrapper
@@ -39,4 +43,10 @@ TEST_CASE("column_expression_of_t") {
                        internal::alias_column_t<alias_a<Org>, int64 Org::*>>>(asterisk<alias_a<Org>>());
     // object_t not allowed
     //runTest<storage_type, Org>(object<Org>());
+
+    // just like other types, column pointer isn't explicitly handled by column_expression_of_t;
+    // assert expectation nevertheless
+    runTest<storage_type, internal::column_pointer<Derived, int64 Org::*>>(column<Derived>(&Org::id));
+    runTest<storage_type, internal::column_pointer<cte_1, internal::ice_t<&Org::id>>>(column<cte_1>(c_v<&Org::id>));
+    runTest<storage_type, internal::column_pointer<cte_1, polyfill::index_constant<0u>>>(column<cte_1>(0_col));
 }
diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
index 40e4d823b..d81e97cc9 100644
--- a/tests/static_tests/column_result_t.cpp
+++ b/tests/static_tests/column_result_t.cpp
@@ -110,9 +110,12 @@ TEST_CASE("column_result_of_t 2") {
         // not compile-time mapped
         int64 boss = 0;
     };
+    struct Derived : Org {};
 
-    auto storage =
-        make_storage("", make_table("org", make_column("id", c_v<&Org::id>), make_column("boss", &Org::boss)));
+    auto storage = make_storage(
+        "",
+        make_table("org", make_column("id", c_v<&Org::id>), make_column("boss", &Org::boss)),
+        make_table<Derived>("derived", make_column("id", c_v<&Derived::id>), make_column("boss", &Derived::boss)));
     using storage_type = decltype(storage);
 
     runTest<storage_type, int64>(c_v<&Org::id>);
@@ -120,4 +123,8 @@ TEST_CASE("column_result_of_t 2") {
     runTest<storage_type, std::tuple<int64, int64>>(asterisk<Org>());
     runTest<storage_type, std::tuple<int64, int64>>(asterisk<alias_a<Org>>());
     runTest<storage_type, Org>(object<Org>());
+    runTest<storage_type, int64>(column<Derived>(&Org::id));
+    runTest<storage_type, int64>(column<cte_1>(c_v<&Org::id>));
+    // this needs a 'CTE' expression storage
+    //runTest<storage_type, int64>(column<cte_1>(0_col));
 }

From dced338cb9282a11c029d2857eacc7bdbc13f4b2 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Wed, 19 Jan 2022 00:10:42 +0200
Subject: [PATCH 034/161] Updated sqlite_orm.h

---
 include/sqlite_orm/sqlite_orm.h | 38347 ++++++++++++++++--------------
 1 file changed, 19901 insertions(+), 18446 deletions(-)

diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 8034ee00e..643a1cc73 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -1,18446 +1,19901 @@
-#pragma once
-
-#if defined(_MSC_VER)
-#if defined(min)
-__pragma(push_macro("min"))
-#undef min
-#define __RESTORE_MIN__
-#endif
-#if defined(max)
-    __pragma(push_macro("max"))
-#undef max
-#define __RESTORE_MAX__
-#endif
-#endif  // defined(_MSC_VER)
-
-#include <ciso646>  //  due to #166
-
-#if __cplusplus >= 201703L  // use of C++17 or higher
-// Enables use of std::optional in SQLITE_ORM.
-#define SQLITE_ORM_OPTIONAL_SUPPORTED
-#define SQLITE_ORM_STRING_VIEW_SUPPORTED
-#define SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
-#define SQLITE_ORM_INLINE_VAR inline
-#if __cplusplus >= 202002L  // use of C++20 or higher
-#define SQLITE_ORM_CONSTEVAL consteval
-#define SQLITE_ORM_NOUNIQUEADDRESS [[no_unique_address]]
-#else
-#define SQLITE_ORM_CONSTEVAL constexpr
-#define SQLITE_ORM_NOUNIQUEADDRESS
-#endif
-#else
-#define SQLITE_ORM_INLINE_VAR
-#define SQLITE_ORM_CONSTEVAL constexpr
-#define SQLITE_ORM_NOUNIQUEADDRESS
-#endif
-#pragma once
-
-#include <system_error>  // std::error_code, std::system_error
-#include <string>  //  std::string
-#include <sqlite3.h>
-#include <stdexcept>
-#include <sstream>  //  std::ostringstream
-
-        namespace sqlite_orm {
-
-    enum class orm_error_code {
-        not_found = 1,
-        type_is_not_mapped_to_storage,
-        trying_to_dereference_null_iterator,
-        too_many_tables_specified,
-        incorrect_set_fields_specified,
-        column_not_found,
-        table_has_no_primary_key_column,
-        cannot_start_a_transaction_within_a_transaction,
-        no_active_transaction,
-        incorrect_journal_mode_string,
-        invalid_collate_argument_enum,
-        failed_to_init_a_backup,
-        unknown_member_value,
-        incorrect_order,
-        cannot_use_default_value,
-        arguments_count_does_not_match,
-        function_not_found,
-        index_is_out_of_bounds,
-    };
-}
-
-namespace sqlite_orm {
-
-    class orm_error_category : public std::error_category {
-      public:
-        const char* name() const noexcept override final {
-            return "ORM error";
-        }
-
-        std::string message(int c) const override final {
-            switch(static_cast<orm_error_code>(c)) {
-                case orm_error_code::not_found:
-                    return "Not found";
-                case orm_error_code::type_is_not_mapped_to_storage:
-                    return "Type is not mapped to storage";
-                case orm_error_code::trying_to_dereference_null_iterator:
-                    return "Trying to dereference null iterator";
-                case orm_error_code::too_many_tables_specified:
-                    return "Too many tables specified";
-                case orm_error_code::incorrect_set_fields_specified:
-                    return "Incorrect set fields specified";
-                case orm_error_code::column_not_found:
-                    return "Column not found";
-                case orm_error_code::table_has_no_primary_key_column:
-                    return "Table has no primary key column";
-                case orm_error_code::cannot_start_a_transaction_within_a_transaction:
-                    return "Cannot start a transaction within a transaction";
-                case orm_error_code::no_active_transaction:
-                    return "No active transaction";
-                case orm_error_code::invalid_collate_argument_enum:
-                    return "Invalid collate_argument enum";
-                case orm_error_code::failed_to_init_a_backup:
-                    return "Failed to init a backup";
-                case orm_error_code::unknown_member_value:
-                    return "Unknown member value";
-                case orm_error_code::incorrect_order:
-                    return "Incorrect order";
-                case orm_error_code::cannot_use_default_value:
-                    return "The statement 'INSERT INTO * DEFAULT VALUES' can be used with only one row";
-                case orm_error_code::arguments_count_does_not_match:
-                    return "Arguments count does not match";
-                case orm_error_code::function_not_found:
-                    return "Function not found";
-                case orm_error_code::index_is_out_of_bounds:
-                    return "Index is out of bounds";
-                default:
-                    return "unknown error";
-            }
-        }
-    };
-
-    class sqlite_error_category : public std::error_category {
-      public:
-        const char* name() const noexcept override final {
-            return "SQLite error";
-        }
-
-        std::string message(int c) const override final {
-            return sqlite3_errstr(c);
-        }
-    };
-
-    inline const orm_error_category& get_orm_error_category() {
-        static orm_error_category res;
-        return res;
-    }
-
-    inline const sqlite_error_category& get_sqlite_error_category() {
-        static sqlite_error_category res;
-        return res;
-    }
-
-    template<typename... T>
-    std::string get_error_message(sqlite3* db, T&&... args) {
-        std::ostringstream stream;
-        using unpack = int[];
-        static_cast<void>(unpack{0, (static_cast<void>(static_cast<void>(stream << args)), 0)...});
-        stream << sqlite3_errmsg(db);
-        return stream.str();
-    }
-
-    template<typename... T>
-    [[noreturn]] void throw_error(sqlite3* db, T&&... args) {
-        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                get_error_message(db, std::forward<T>(args)...));
-    }
-}
-
-namespace std {
-    template<>
-    struct is_error_code_enum<sqlite_orm::orm_error_code> : std::true_type {};
-
-    inline std::error_code make_error_code(sqlite_orm::orm_error_code errorCode) {
-        return std::error_code(static_cast<int>(errorCode), sqlite_orm::get_orm_error_category());
-    }
-}
-#pragma once
-
-#include <tuple>  //  std::tuple, std::get, std::tuple_element, std::tuple_size
-#include <type_traits>  //  std::false_type, std::true_type
-
-// #include "../static_magic.h"
-
-#include <type_traits>  //  std::false_type, std::true_type, std::integral_constant
-
-namespace sqlite_orm {
-
-    //  got from here
-    //  https://stackoverflow.com/questions/37617677/implementing-a-compile-time-static-if-logic-for-different-string-types-in-a-co
-    namespace internal {
-
-        static inline decltype(auto) empty_callable() {
-            static auto res = [](auto&&...) {};
-            return (res);
-        }
-
-        template<typename T, typename F>
-        decltype(auto) static_if(std::true_type, const T& t, const F&) {
-            return (t);
-        }
-
-        template<typename T, typename F>
-        decltype(auto) static_if(std::false_type, const T&, const F& f) {
-            return (f);
-        }
-
-        template<bool B, typename T, typename F>
-        decltype(auto) static_if(const T& t, const F& f) {
-            return static_if(std::integral_constant<bool, B>{}, t, f);
-        }
-
-        template<bool B, typename T>
-        decltype(auto) static_if(const T& t) {
-            return static_if(std::integral_constant<bool, B>{}, t, empty_callable());
-        }
-
-        template<typename T>
-        using static_not = std::integral_constant<bool, !T::value>;
-    }
-
-}
-
-namespace sqlite_orm {
-
-    //  got from here http://stackoverflow.com/questions/25958259/how-do-i-find-out-if-a-tuple-contains-a-type
-    namespace tuple_helper {
-
-        /**
-         *  HAS_TYPE type trait
-         */
-        template<typename T, typename Tuple>
-        struct has_type;
-
-        template<typename T>
-        struct has_type<T, std::tuple<>> : std::false_type {};
-
-        template<typename T, typename U, typename... Ts>
-        struct has_type<T, std::tuple<U, Ts...>> : has_type<T, std::tuple<Ts...>> {};
-
-        template<typename T, typename... Ts>
-        struct has_type<T, std::tuple<T, Ts...>> : std::true_type {};
-
-        template<typename T, typename Tuple>
-        using tuple_contains_type = typename has_type<T, Tuple>::type;
-
-        /**
-         *  HAS_SOME_TYPE type trait
-         */
-        template<template<class> class TT, typename Tuple>
-        struct has_some_type;
-
-        template<template<class> class TT>
-        struct has_some_type<TT, std::tuple<>> : std::false_type {};
-
-        template<template<class> class TT, typename U, typename... Ts>
-        struct has_some_type<TT, std::tuple<U, Ts...>> : has_some_type<TT, std::tuple<Ts...>> {};
-
-        template<template<class> class TT, typename T, typename... Ts>
-        struct has_some_type<TT, std::tuple<TT<T>, Ts...>> : std::true_type {};
-
-        template<template<class> class TT, typename Tuple>
-        using tuple_contains_some_type = typename has_some_type<TT, Tuple>::type;
-
-        template<size_t N, class... Args>
-        struct iterator_impl {
-
-            template<class L>
-            void operator()(const std::tuple<Args...>& tuple, const L& lambda, bool reverse = true) {
-                if(reverse) {
-                    lambda(std::get<N>(tuple));
-                    iterator_impl<N - 1, Args...>()(tuple, lambda, reverse);
-                } else {
-                    iterator_impl<N - 1, Args...>()(tuple, lambda, reverse);
-                    lambda(std::get<N>(tuple));
-                }
-            }
-
-            template<class L>
-            void operator()(const L& lambda) {
-                iterator_impl<N - 1, Args...>()(lambda);
-                lambda((const typename std::tuple_element<N - 1, std::tuple<Args...>>::type*)nullptr);
-            }
-        };
-
-        template<class... Args>
-        struct iterator_impl<0, Args...> {
-
-            template<class L>
-            void operator()(const std::tuple<Args...>& tuple, const L& lambda, bool /*reverse*/ = true) {
-                lambda(std::get<0>(tuple));
-            }
-
-            template<class L>
-            void operator()(const L& lambda) {
-                lambda((const typename std::tuple_element<0, std::tuple<Args...>>::type*)nullptr);
-            }
-        };
-
-        template<size_t N>
-        struct iterator_impl<N> {
-
-            template<class L>
-            void operator()(const std::tuple<>&, const L&, bool /*reverse*/ = true) {
-                //..
-            }
-
-            template<class L>
-            void operator()(const L&) {
-                //..
-            }
-        };
-
-        template<class... Args>
-        struct iterator_impl2;
-
-        template<>
-        struct iterator_impl2<> {
-
-            template<class L>
-            void operator()(const L&) const {
-                //..
-            }
-        };
-
-        template<class H, class... Tail>
-        struct iterator_impl2<H, Tail...> {
-
-            template<class L>
-            void operator()(const L& lambda) const {
-                lambda((const H*)nullptr);
-                iterator_impl2<Tail...>{}(lambda);
-            }
-        };
-
-        template<class T>
-        struct iterator;
-
-        template<class... Args>
-        struct iterator<std::tuple<Args...>> {
-
-            template<class L>
-            void operator()(const L& lambda) const {
-                iterator_impl2<Args...>{}(lambda);
-            }
-        };
-    }
-
-    namespace internal {
-
-        //  got it form here https://stackoverflow.com/questions/7858817/unpacking-a-tuple-to-call-a-matching-function-pointer
-        template<class Function, class FunctionPointer, class Tuple, size_t... I>
-        auto call_impl(Function& f, FunctionPointer functionPointer, Tuple t, std::index_sequence<I...>) {
-            return (f.*functionPointer)(std::get<I>(move(t))...);
-        }
-
-        template<class Function, class FunctionPointer, class Tuple>
-        auto call(Function& f, FunctionPointer functionPointer, Tuple t) {
-            static constexpr auto size = std::tuple_size<Tuple>::value;
-            return call_impl(f, functionPointer, move(t), std::make_index_sequence<size>{});
-        }
-
-        template<class Function, class Tuple>
-        auto call(Function& f, Tuple t) {
-            return call(f, &Function::operator(), move(t));
-        }
-
-        template<size_t N, size_t I, class L, class R>
-        void move_tuple_impl(L& lhs, R& rhs) {
-            std::get<I>(lhs) = std::move(std::get<I>(rhs));
-            internal::static_if<std::integral_constant<bool, N != I + 1>{}>([](auto& l, auto& r) {
-                move_tuple_impl<N, I + 1>(l, r);
-            })(lhs, rhs);
-        }
-
-        template<size_t N, class L, class R>
-        void move_tuple(L& lhs, R& rhs) {
-            using bool_type = std::integral_constant<bool, N != 0>;
-            static_if<bool_type{}>([](auto& l, auto& r) {
-                move_tuple_impl<N, 0>(l, r);
-            })(lhs, rhs);
-        }
-
-        template<class L, class... Args>
-        void iterate_tuple(const std::tuple<Args...>& tuple, const L& lambda) {
-            using tuple_type = std::tuple<Args...>;
-            tuple_helper::iterator_impl<std::tuple_size<tuple_type>::value - 1, Args...>()(tuple, lambda, false);
-        }
-
-        template<class T, class L>
-        void iterate_tuple(const L& lambda) {
-            tuple_helper::iterator<T>{}(lambda);
-        }
-
-        template<typename... input_t>
-        using tuple_cat_t = decltype(std::tuple_cat(std::declval<input_t>()...));
-
-        template<class... Args>
-        struct conc_tuple {
-            using type = tuple_cat_t<Args...>;
-        };
-    }
-}
-#pragma once
-
-#include <tuple>  //  std::tuple
-#include <type_traits>  //  std::enable_if
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T, template<class> class C, class SFINAE = void>
-        struct find_in_tuple;
-
-        template<template<class> class C>
-        struct find_in_tuple<std::tuple<>, C, void> {
-            using type = void;
-        };
-
-        template<class H, class... Args, template<class> class C>
-        struct find_in_tuple<std::tuple<H, Args...>, C, typename std::enable_if<C<H>::value>::type> {
-            using type = H;
-        };
-
-        template<class H, class... Args, template<class> class C>
-        struct find_in_tuple<std::tuple<H, Args...>, C, typename std::enable_if<!C<H>::value>::type> {
-            using type = typename find_in_tuple<std::tuple<Args...>, C>::type;
-        };
-    }
-}
-#pragma once
-
-#include <tuple>  //  std::tuple
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T, template<class C> class F>
-        struct tuple_transformer;
-
-        template<class... Args, template<class C> class F>
-        struct tuple_transformer<std::tuple<Args...>, F> {
-            using type = std::tuple<typename F<Args>::type...>;
-        };
-    }
-}
-#pragma once
-
-#include <tuple>  //  std::tuple
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T, template<class> class C>
-        struct count_tuple;
-
-        template<template<class> class C>
-        struct count_tuple<std::tuple<>, C> {
-            static constexpr const int value = 0;
-        };
-
-        template<class H, class... Args, template<class> class C>
-        struct count_tuple<std::tuple<H, Args...>, C> {
-            static constexpr const int value = C<H>::value + count_tuple<std::tuple<Args...>, C>::value;
-        };
-    }
-}
-#pragma once
-
-namespace sqlite_orm {
-    namespace internal {
-
-        /**
-         *  Accepts any number of arguments and evaluates `type` alias as T if all arguments are the same or void otherwise
-         */
-        template<class... Args>
-        struct same_or_void {
-            using type = void;
-        };
-
-        template<class A>
-        struct same_or_void<A> {
-            using type = A;
-        };
-
-        template<class A, class B>
-        struct same_or_void<A, B> {
-            using type = void;
-        };
-
-        template<class A>
-        struct same_or_void<A, A> {
-            using type = A;
-        };
-
-        template<class A, class... Args>
-        struct same_or_void<A, A, Args...> {
-            using type = typename same_or_void<A, Args...>::type;
-        };
-
-    }
-}
-#pragma once
-
-#include <type_traits>  // std::integral_constant
-#ifdef __cpp_lib_concepts
-#include <concepts>
-#endif
-
-// #include "start_macros.h"
-
-// #include "cxx_polyfill.h"
-
-#include <type_traits>
-
-// #include "start_macros.h"
-
-namespace sqlite_orm {
-    namespace internal {
-        namespace polyfill {
-#if __cplusplus < 201703L  // before C++17
-            template<class...>
-            using void_t = void;
-
-            template<bool v>
-            using bool_constant = std::integral_constant<bool, v>;
-#else
-            using std::bool_constant;
-            using std::void_t;
-#endif
-
-#if __cplusplus < 202312L  // before C++23
-            template<typename Type, template<typename...> class Primary>
-            SQLITE_ORM_INLINE_VAR constexpr bool is_specialization_of_v = false;
-
-            template<template<typename...> class Primary, class... Types>
-            SQLITE_ORM_INLINE_VAR constexpr bool is_specialization_of_v<Primary<Types...>, Primary> = true;
-
-            template<typename Type, template<typename...> class Primary>
-            struct is_specialization_of : bool_constant<is_specialization_of_v<Type, Primary>> {};
-
-            template<typename... T>
-            using is_specialization_of_t = typename is_specialization_of<T...>::type;
-#else
-            using std::is_specialization_of, std::is_specialization_of_t, std::is_specialization_of_v;
-#endif
-
-            template<typename...>
-            SQLITE_ORM_INLINE_VAR constexpr bool always_false_v = false;
-
-            template<size_t I>
-            using index_constant = std::integral_constant<size_t, I>;
-        }
-    }
-}
-
-namespace sqlite_orm {
-
-    using xdestroy_fn_t = void (*)(void*);
-    using null_xdestroy_t = std::integral_constant<xdestroy_fn_t, nullptr>;
-    SQLITE_ORM_INLINE_VAR constexpr null_xdestroy_t null_xdestroy_f{};
-}
-
-namespace sqlite_orm {
-    namespace internal {
-#ifdef __cpp_concepts
-        /**
-         *  Constraints a deleter to be state-less.
-         */
-        template<typename D>
-        concept stateless_deleter = std::is_empty_v<D> && std::is_default_constructible_v<D>;
-
-        /**
-         *  Constraints a deleter to be an integral function constant.
-         */
-        template<typename D>
-        concept integral_fp_c = requires {
-            typename D::value_type;
-            D::value;
-            requires std::is_function_v<std::remove_pointer_t<typename D::value_type>>;
-        };
-
-        /**
-         *  Constraints a deleter to be or to yield a function pointer.
-         */
-        template<typename D>
-        concept can_yield_fp = requires(D d) {
-            // yielding function pointer by using the plus trick
-            {+d};
-            requires std::is_function_v<std::remove_pointer_t<decltype(+d)>>;
-        };
-#endif
-
-#ifdef __cpp_lib_concepts
-        /**
-         *  Yield a deleter's function pointer.
-         */
-        template<can_yield_fp D>
-        struct yield_fp_of {
-            using type = decltype(+std::declval<D>());
-        };
-#else
-
-        template<typename D>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_stateless_deleter_v =
-            std::is_empty<D>::value&& std::is_default_constructible<D>::value;
-
-        template<typename D, typename SFINAE = void>
-        struct is_integral_fp_c : std::false_type {};
-        template<typename D>
-        struct is_integral_fp_c<
-            D,
-            polyfill::void_t<typename D::value_type,
-                             decltype(D::value),
-                             std::enable_if_t<std::is_function<std::remove_pointer_t<typename D::value_type>>::value>>>
-            : std::true_type {};
-        template<typename D>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_integral_fp_c_v = is_integral_fp_c<D>::value;
-
-        template<typename D, typename SFINAE = void>
-        struct can_yield_fp : std::false_type {};
-        template<typename D>
-        struct can_yield_fp<
-            D,
-            polyfill::void_t<
-                decltype(+std::declval<D>()),
-                std::enable_if_t<std::is_function<std::remove_pointer_t<decltype(+std::declval<D>())>>::value>>>
-            : std::true_type {};
-        template<typename D>
-        SQLITE_ORM_INLINE_VAR constexpr bool can_yield_fp_v = can_yield_fp<D>::value;
-
-        template<typename D, bool = can_yield_fp_v<D>>
-        struct yield_fp_of {
-            using type = polyfill::void_t<>;
-        };
-        template<typename D>
-        struct yield_fp_of<D, true> {
-            using type = decltype(+std::declval<D>());
-        };
-#endif
-        template<typename D>
-        using yielded_fn_t = typename yield_fp_of<D>::type;
-
-#ifdef __cpp_lib_concepts
-        template<typename D>
-        concept is_unusable_for_xdestroy = (!stateless_deleter<D> &&
-                                            (can_yield_fp<D> && !std::same_as<yielded_fn_t<D>, xdestroy_fn_t>));
-
-        template<typename D>
-        concept can_yield_xdestroy = can_yield_fp<D> && std::same_as<yielded_fn_t<D>, xdestroy_fn_t>;
-
-        template<typename D, typename P>
-        concept needs_xdestroy_proxy = (stateless_deleter<D> &&
-                                        (!can_yield_fp<D> || !std::same_as<yielded_fn_t<D>, xdestroy_fn_t>));
-
-        /**
-         *  xDestroy function that constructs and invokes the stateless deleter.
-         *  
-         *  Requires that the deleter can be called with the q-qualified pointer argument;
-         *  it doesn't check so explicitly, but a compiler error will occur.
-         */
-        template<typename D, typename P>
-        requires(!integral_fp_c<D>) void xdestroy_proxy(void* p) noexcept {
-            // C-casting `void* -> P*` like statement_binder<pointer_binding<P, T, D>>
-            auto o = (P*)p;
-            // ignoring return code
-            (void)D{}(o);
-        }
-
-        /**
-         *  xDestroy function that invokes the integral function pointer constant.
-         *  
-         *  Performs a const-cast of the argument pointer in order to allow for C API functions
-         *  that take a non-const parameter, but user code passes a pointer to a const object.
-         */
-        template<integral_fp_c D, typename P>
-        void xdestroy_proxy(void* p) noexcept {
-            // C-casting `void* -> P*` like statement_binder<pointer_binding<P, T, D>>,
-            auto o = (std::remove_cv_t<P>*)(P*)p;
-            // ignoring return code
-            (void)D{}(o);
-        }
-#else
-        template<typename D>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_unusable_for_xdestroy_v =
-            !is_stateless_deleter_v<D> && (can_yield_fp_v<D> && !std::is_same<yielded_fn_t<D>, xdestroy_fn_t>::value);
-
-        template<typename D>
-        SQLITE_ORM_INLINE_VAR constexpr bool can_yield_xdestroy_v =
-            can_yield_fp_v<D>&& std::is_same<yielded_fn_t<D>, xdestroy_fn_t>::value;
-
-        template<typename D, typename P>
-        SQLITE_ORM_INLINE_VAR constexpr bool
-            needs_xdestroy_proxy_v = is_stateless_deleter_v<D> &&
-                                     (!can_yield_fp_v<D> || !std::is_same<yielded_fn_t<D>, xdestroy_fn_t>::value);
-
-        template<typename D, typename P>
-        std::enable_if_t<!is_integral_fp_c_v<D>, void> xdestroy_proxy(void* p) noexcept {
-            // C-casting `void* -> P*` like statement_binder<pointer_binding<P, T, D>>
-            auto o = (P*)p;
-            // ignoring return code
-            (void)D{}(o);
-        }
-
-        template<typename D, typename P>
-        std::enable_if_t<is_integral_fp_c_v<D>, void> xdestroy_proxy(void* p) noexcept {
-            // C-casting `void* -> P*` like statement_binder<pointer_binding<P, T, D>>,
-            auto o = (std::remove_cv_t<P>*)(P*)p;
-            // ignoring return code
-            (void)D{}(o);
-        }
-#endif
-    }
-}
-
-namespace sqlite_orm {
-
-#ifdef __cpp_lib_concepts
-    /**
-     *  Prohibits using a yielded function pointer, which is not of type xdestroy_fn_t.
-     *  
-     *  Explicitly declared for better error messages.
-     */
-    template<typename D, typename P>
-    constexpr xdestroy_fn_t obtain_xdestroy_for(D, P*) noexcept requires(internal::is_unusable_for_xdestroy<D>) {
-        static_assert(std::is_same<D, void>::value,
-                      "A function pointer, which is not of type xdestroy_fn_t, is prohibited.");
-        return nullptr;
-    }
-
-    /**
-     *  Obtains a proxy 'xDestroy' function pointer [of type void(*)(void*)]
-     *  for a deleter in a type-safe way.
-     *  
-     *  The deleter can be one of:
-     *         - integral function constant
-     *         - state-less (empty) deleter
-     *         - non-capturing lambda
-     *  
-     *  Type-safety is garanteed by checking whether the deleter or yielded function pointer
-     *  is invocable with the non-q-qualified pointer value.
-     */
-    template<typename D, typename P>
-    constexpr xdestroy_fn_t obtain_xdestroy_for(D, P*) noexcept requires(internal::needs_xdestroy_proxy<D, P>) {
-        return internal::xdestroy_proxy<D, P>;
-    }
-
-    /**
-     *  Directly obtains a 'xDestroy' function pointer [of type void(*)(void*)]
-     *  from a deleter in a type-safe way.
-     *  
-     *  The deleter can be one of:
-     *         - function pointer of type xdestroy_fn_t
-     *         - structure holding a function pointer
-     *         - integral function constant
-     *         - non-capturing lambda
-     *  ... and yield a function pointer of type xdestroy_fn_t.
-     *  
-     *  Type-safety is garanteed by checking whether the deleter or yielded function pointer
-     *  is invocable with the non-q-qualified pointer value.
-     */
-    template<typename D, typename P>
-    constexpr xdestroy_fn_t obtain_xdestroy_for(D d, P*) noexcept requires(internal::can_yield_xdestroy<D>) {
-        return d;
-    }
-#else
-    template<typename D, typename P>
-    constexpr std::enable_if_t<internal::is_unusable_for_xdestroy_v<D>, xdestroy_fn_t> obtain_xdestroy_for(D, P*) {
-        static_assert(std::is_same<D, void>::value,
-                      "A function pointer, which is not of type xdestroy_fn_t, is prohibited.");
-        return nullptr;
-    }
-
-    template<typename D, typename P>
-    constexpr std::enable_if_t<internal::needs_xdestroy_proxy_v<D, P>, xdestroy_fn_t> obtain_xdestroy_for(D,
-                                                                                                          P*) noexcept {
-        return internal::xdestroy_proxy<D, P>;
-    }
-
-    template<typename D, typename P>
-    constexpr std::enable_if_t<internal::can_yield_xdestroy_v<D>, xdestroy_fn_t> obtain_xdestroy_for(D d, P*) noexcept {
-        return d;
-    }
-#endif
-}
-#pragma once
-
-#include <string>  //  std::string
-#include <memory>  //  std::shared_ptr, std::unique_ptr
-#include <vector>  //  std::vector
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-#include <optional>  // std::optional
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-namespace sqlite_orm {
-
-    /**
-     *  This class accepts c++ type and transfers it to sqlite name (int -> INTEGER, std::string -> TEXT)
-     */
-    template<class T, typename Enable = void>
-    struct type_printer;
-
-    struct integer_printer {
-        inline const std::string& print() {
-            static const std::string res = "INTEGER";
-            return res;
-        }
-    };
-
-    struct text_printer {
-        inline const std::string& print() {
-            static const std::string res = "TEXT";
-            return res;
-        }
-    };
-
-    struct real_printer {
-        inline const std::string& print() {
-            static const std::string res = "REAL";
-            return res;
-        }
-    };
-
-    struct blob_printer {
-        inline const std::string& print() {
-            static const std::string res = "BLOB";
-            return res;
-        }
-    };
-
-    // Note unsigned/signed char and simple char used for storing integer values, not char values.
-    template<>
-    struct type_printer<unsigned char, void> : public integer_printer {};
-
-    template<>
-    struct type_printer<signed char, void> : public integer_printer {};
-
-    template<>
-    struct type_printer<char, void> : public integer_printer {};
-
-    template<>
-    struct type_printer<unsigned short int, void> : public integer_printer {};
-
-    template<>
-    struct type_printer<short, void> : public integer_printer {};
-
-    template<>
-    struct type_printer<unsigned int, void> : public integer_printer {};
-
-    template<>
-    struct type_printer<int, void> : public integer_printer {};
-
-    template<>
-    struct type_printer<unsigned long, void> : public integer_printer {};
-
-    template<>
-    struct type_printer<long, void> : public integer_printer {};
-
-    template<>
-    struct type_printer<unsigned long long, void> : public integer_printer {};
-
-    template<>
-    struct type_printer<long long, void> : public integer_printer {};
-
-    template<>
-    struct type_printer<bool, void> : public integer_printer {};
-
-    template<>
-    struct type_printer<std::string, void> : public text_printer {};
-
-    template<>
-    struct type_printer<std::wstring, void> : public text_printer {};
-
-    template<>
-    struct type_printer<const char*, void> : public text_printer {};
-
-    template<>
-    struct type_printer<float, void> : public real_printer {};
-
-    template<>
-    struct type_printer<double, void> : public real_printer {};
-
-    template<class T>
-    struct type_printer<std::shared_ptr<T>, void> : public type_printer<T> {};
-
-    template<class T>
-    struct type_printer<std::unique_ptr<T>, void> : public type_printer<T> {};
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-    template<class T>
-    struct type_printer<std::optional<T>, void> : public type_printer<T> {};
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-    template<>
-    struct type_printer<std::vector<char>, void> : public blob_printer {};
-}
-#pragma once
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        enum class collate_argument {
-            binary,
-            nocase,
-            rtrim,
-        };
-    }
-
-}
-#pragma once
-
-#include <string>  //  std::string
-#include <tuple>  //  std::tuple, std::make_tuple
-#include <sstream>  //  std::stringstream
-#include <type_traits>  //  std::is_base_of, std::false_type, std::true_type
-#include <ostream>  //  std::ostream
-
-// #include "table_type.h"
-
-#include <type_traits>  //  std::enable_if, std::is_member_pointer, std::is_member_function_pointer
-
-// #include "member_traits/getter_traits.h"
-
-// #include "getters.h"
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class O, class T>
-        using getter_by_value_const = T (O::*)() const;
-
-        template<class O, class T>
-        using getter_by_value = T (O::*)();
-
-        template<class O, class T>
-        using getter_by_ref_const = T& (O::*)() const;
-
-        template<class O, class T>
-        using getter_by_ref = T& (O::*)();
-
-        template<class O, class T>
-        using getter_by_const_ref_const = const T& (O::*)() const;
-
-        template<class O, class T>
-        using getter_by_const_ref = const T& (O::*)();
-#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
-        template<class O, class T>
-        using getter_by_value_const_noexcept = T (O::*)() const noexcept;
-
-        template<class O, class T>
-        using getter_by_value_noexcept = T (O::*)() noexcept;
-
-        template<class O, class T>
-        using getter_by_ref_const_noexcept = T& (O::*)() const noexcept;
-
-        template<class O, class T>
-        using getter_by_ref_noexcept = T& (O::*)() noexcept;
-
-        template<class O, class T>
-        using getter_by_const_ref_const_noexcept = const T& (O::*)() const noexcept;
-
-        template<class O, class T>
-        using getter_by_const_ref_noexcept = const T& (O::*)() noexcept;
-#endif
-    }
-}
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T>
-        struct getter_traits;
-
-        template<class O, class T>
-        struct getter_traits<getter_by_value_const<O, T>> {
-            using object_type = O;
-            using field_type = T;
-
-            static constexpr const bool returns_lvalue = false;
-        };
-
-        template<class O, class T>
-        struct getter_traits<getter_by_value<O, T>> {
-            using object_type = O;
-            using field_type = T;
-
-            static constexpr const bool returns_lvalue = false;
-        };
-
-        template<class O, class T>
-        struct getter_traits<getter_by_ref_const<O, T>> {
-            using object_type = O;
-            using field_type = T;
-
-            static constexpr const bool returns_lvalue = true;
-        };
-
-        template<class O, class T>
-        struct getter_traits<getter_by_ref<O, T>> {
-            using object_type = O;
-            using field_type = T;
-
-            static constexpr const bool returns_lvalue = true;
-        };
-
-        template<class O, class T>
-        struct getter_traits<getter_by_const_ref_const<O, T>> {
-            using object_type = O;
-            using field_type = T;
-
-            static constexpr const bool returns_lvalue = true;
-        };
-
-        template<class O, class T>
-        struct getter_traits<getter_by_const_ref<O, T>> {
-            using object_type = O;
-            using field_type = T;
-
-            static constexpr const bool returns_lvalue = true;
-        };
-#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
-        template<class O, class T>
-        struct getter_traits<getter_by_value_const_noexcept<O, T>> {
-            using object_type = O;
-            using field_type = T;
-
-            static constexpr const bool returns_lvalue = false;
-        };
-
-        template<class O, class T>
-        struct getter_traits<getter_by_value_noexcept<O, T>> {
-            using object_type = O;
-            using field_type = T;
-
-            static constexpr const bool returns_lvalue = false;
-        };
-
-        template<class O, class T>
-        struct getter_traits<getter_by_ref_const_noexcept<O, T>> {
-            using object_type = O;
-            using field_type = T;
-
-            static constexpr const bool returns_lvalue = true;
-        };
-
-        template<class O, class T>
-        struct getter_traits<getter_by_ref_noexcept<O, T>> {
-            using object_type = O;
-            using field_type = T;
-
-            static constexpr const bool returns_lvalue = true;
-        };
-
-        template<class O, class T>
-        struct getter_traits<getter_by_const_ref_const_noexcept<O, T>> {
-            using object_type = O;
-            using field_type = T;
-
-            static constexpr const bool returns_lvalue = true;
-        };
-
-        template<class O, class T>
-        struct getter_traits<getter_by_const_ref_noexcept<O, T>> {
-            using object_type = O;
-            using field_type = T;
-
-            static constexpr const bool returns_lvalue = true;
-        };
-#endif
-    }
-}
-
-// #include "member_traits/setter_traits.h"
-
-// #include "setters.h"
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class O, class T>
-        using setter_by_value = void (O::*)(T);
-
-        template<class O, class T>
-        using setter_by_ref = void (O::*)(T&);
-
-        template<class O, class T>
-        using setter_by_const_ref = void (O::*)(const T&);
-#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
-        template<class O, class T>
-        using setter_by_value_noexcept = void (O::*)(T) noexcept;
-
-        template<class O, class T>
-        using setter_by_ref_noexcept = void (O::*)(T&) noexcept;
-
-        template<class O, class T>
-        using setter_by_const_ref_noexcept = void (O::*)(const T&) noexcept;
-#endif
-    }
-}
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T>
-        struct setter_traits;
-
-        template<class O, class T>
-        struct setter_traits<setter_by_value<O, T>> {
-            using object_type = O;
-            using field_type = T;
-        };
-
-        template<class O, class T>
-        struct setter_traits<setter_by_ref<O, T>> {
-            using object_type = O;
-            using field_type = T;
-        };
-
-        template<class O, class T>
-        struct setter_traits<setter_by_const_ref<O, T>> {
-            using object_type = O;
-            using field_type = T;
-        };
-#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
-        template<class O, class T>
-        struct setter_traits<setter_by_value_noexcept<O, T>> {
-            using object_type = O;
-            using field_type = T;
-        };
-
-        template<class O, class T>
-        struct setter_traits<setter_by_ref_noexcept<O, T>> {
-            using object_type = O;
-            using field_type = T;
-        };
-
-        template<class O, class T>
-        struct setter_traits<setter_by_const_ref_noexcept<O, T>> {
-            using object_type = O;
-            using field_type = T;
-        };
-#endif
-    }
-}
-
-// #include "member_traits/is_getter.h"
-
-#include <type_traits>  //  std::false_type, std::true_type
-
-// #include "getters.h"
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T>
-        struct is_getter : std::false_type {};
-
-        template<class O, class T>
-        struct is_getter<getter_by_value_const<O, T>> : std::true_type {};
-
-        template<class O, class T>
-        struct is_getter<getter_by_value<O, T>> : std::true_type {};
-
-        template<class O, class T>
-        struct is_getter<getter_by_ref_const<O, T>> : std::true_type {};
-
-        template<class O, class T>
-        struct is_getter<getter_by_ref<O, T>> : std::true_type {};
-
-        template<class O, class T>
-        struct is_getter<getter_by_const_ref_const<O, T>> : std::true_type {};
-
-        template<class O, class T>
-        struct is_getter<getter_by_const_ref<O, T>> : std::true_type {};
-#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
-        template<class O, class T>
-        struct is_getter<getter_by_value_const_noexcept<O, T>> : std::true_type {};
-
-        template<class O, class T>
-        struct is_getter<getter_by_value_noexcept<O, T>> : std::true_type {};
-
-        template<class O, class T>
-        struct is_getter<getter_by_ref_const_noexcept<O, T>> : std::true_type {};
-
-        template<class O, class T>
-        struct is_getter<getter_by_ref_noexcept<O, T>> : std::true_type {};
-
-        template<class O, class T>
-        struct is_getter<getter_by_const_ref_const_noexcept<O, T>> : std::true_type {};
-
-        template<class O, class T>
-        struct is_getter<getter_by_const_ref_noexcept<O, T>> : std::true_type {};
-#endif
-    }
-}
-
-// #include "member_traits/is_setter.h"
-
-// #include "setters.h"
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T>
-        struct is_setter : std::false_type {};
-
-        template<class O, class T>
-        struct is_setter<setter_by_value<O, T>> : std::true_type {};
-
-        template<class O, class T>
-        struct is_setter<setter_by_ref<O, T>> : std::true_type {};
-
-        template<class O, class T>
-        struct is_setter<setter_by_const_ref<O, T>> : std::true_type {};
-#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
-        template<class O, class T>
-        struct is_setter<setter_by_value_noexcept<O, T>> : std::true_type {};
-
-        template<class O, class T>
-        struct is_setter<setter_by_ref_noexcept<O, T>> : std::true_type {};
-
-        template<class O, class T>
-        struct is_setter<setter_by_const_ref_noexcept<O, T>> : std::true_type {};
-#endif
-    }
-}
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        template<class T, class F>
-        struct column_pointer;
-
-        /**
-         *  Trait class used to define table mapped type by setter/getter/member
-         *  T - member pointer
-         *  `type` is a type which is mapped.
-         *  E.g.
-         *  -   `table_type<decltype(&User::id)>::type` is `User`
-         *  -   `table_type<decltype(&User::getName)>::type` is `User`
-         *  -   `table_type<decltype(&User::setName)>::type` is `User`
-         */
-        template<class T, class SFINAE = void>
-        struct table_type;
-
-        template<class O, class F>
-        struct table_type<F O::*,
-                          typename std::enable_if<std::is_member_pointer<F O::*>::value &&
-                                                  !std::is_member_function_pointer<F O::*>::value>::type> {
-            using type = O;
-        };
-
-        template<class T>
-        struct table_type<T, typename std::enable_if<is_getter<T>::value>::type> {
-            using type = typename getter_traits<T>::object_type;
-        };
-
-        template<class T>
-        struct table_type<T, typename std::enable_if<is_setter<T>::value>::type> {
-            using type = typename setter_traits<T>::object_type;
-        };
-
-        template<class T, class F>
-        struct table_type<column_pointer<T, F>, void> {
-            using type = T;
-        };
-    }
-}
-
-// #include "tuple_helper/tuple_helper.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         *  AUTOINCREMENT constraint class.
-         */
-        struct autoincrement_t {};
-
-        struct primary_key_base {
-            enum class order_by {
-                unspecified,
-                ascending,
-                descending,
-            };
-
-            order_by asc_option = order_by::unspecified;
-
-            operator std::string() const {
-                std::string res = "PRIMARY KEY";
-                switch(this->asc_option) {
-                    case order_by::ascending:
-                        res += " ASC";
-                        break;
-                    case order_by::descending:
-                        res += " DESC";
-                        break;
-                    default:
-                        break;
-                }
-                return res;
-            }
-        };
-
-        /**
-         *  PRIMARY KEY constraint class.
-         *  Cs is parameter pack which contains columns (member pointers and/or function pointers). Can be empty when
-         *  used withen `make_column` function.
-         */
-        template<class... Cs>
-        struct primary_key_t : primary_key_base {
-            using order_by = primary_key_base::order_by;
-            using columns_tuple = std::tuple<Cs...>;
-
-            columns_tuple columns;
-
-            primary_key_t(decltype(columns) c) : columns(move(c)) {}
-
-            primary_key_t<Cs...> asc() const {
-                auto res = *this;
-                res.asc_option = order_by::ascending;
-                return res;
-            }
-
-            primary_key_t<Cs...> desc() const {
-                auto res = *this;
-                res.asc_option = order_by::descending;
-                return res;
-            }
-        };
-
-        struct unique_base {
-            operator std::string() const {
-                return "UNIQUE";
-            }
-        };
-
-        /**
-         *  UNIQUE constraint class.
-         */
-        template<class... Args>
-        struct unique_t : unique_base {
-            using columns_tuple = std::tuple<Args...>;
-
-            columns_tuple columns;
-
-            unique_t(columns_tuple columns_) : columns(move(columns_)) {}
-        };
-
-        /**
-         *  DEFAULT constraint class.
-         *  T is a value type.
-         */
-        template<class T>
-        struct default_t {
-            using value_type = T;
-
-            value_type value;
-
-            operator std::string() const {
-                return "DEFAULT";
-            }
-        };
-
-#if SQLITE_VERSION_NUMBER >= 3006019
-
-        /**
-         *  FOREIGN KEY constraint class.
-         *  Cs are columns which has foreign key
-         *  Rs are column which C references to
-         *  Available in SQLite 3.6.19 or higher
-         */
-
-        template<class A, class B>
-        struct foreign_key_t;
-
-        enum class foreign_key_action {
-            none,  //  not specified
-            no_action,
-            restrict_,
-            set_null,
-            set_default,
-            cascade,
-        };
-
-        inline std::ostream& operator<<(std::ostream& os, foreign_key_action action) {
-            switch(action) {
-                case decltype(action)::no_action:
-                    os << "NO ACTION";
-                    break;
-                case decltype(action)::restrict_:
-                    os << "RESTRICT";
-                    break;
-                case decltype(action)::set_null:
-                    os << "SET NULL";
-                    break;
-                case decltype(action)::set_default:
-                    os << "SET DEFAULT";
-                    break;
-                case decltype(action)::cascade:
-                    os << "CASCADE";
-                    break;
-                case decltype(action)::none:
-                    break;
-            }
-            return os;
-        }
-
-        struct on_update_delete_base {
-            const bool update;  //  true if update and false if delete
-
-            operator std::string() const {
-                if(this->update) {
-                    return "ON UPDATE";
-                } else {
-                    return "ON DELETE";
-                }
-            }
-        };
-
-        /**
-         *  F - foreign key class
-         */
-        template<class F>
-        struct on_update_delete_t : on_update_delete_base {
-            using foreign_key_type = F;
-
-            const foreign_key_type& fk;
-
-            on_update_delete_t(decltype(fk) fk_, decltype(update) update_, foreign_key_action action_) :
-                on_update_delete_base{update_}, fk(fk_), _action(action_) {}
-
-            foreign_key_action _action = foreign_key_action::none;
-
-            foreign_key_type no_action() const {
-                auto res = this->fk;
-                if(update) {
-                    res.on_update._action = foreign_key_action::no_action;
-                } else {
-                    res.on_delete._action = foreign_key_action::no_action;
-                }
-                return res;
-            }
-
-            foreign_key_type restrict_() const {
-                auto res = this->fk;
-                if(update) {
-                    res.on_update._action = foreign_key_action::restrict_;
-                } else {
-                    res.on_delete._action = foreign_key_action::restrict_;
-                }
-                return res;
-            }
-
-            foreign_key_type set_null() const {
-                auto res = this->fk;
-                if(update) {
-                    res.on_update._action = foreign_key_action::set_null;
-                } else {
-                    res.on_delete._action = foreign_key_action::set_null;
-                }
-                return res;
-            }
-
-            foreign_key_type set_default() const {
-                auto res = this->fk;
-                if(update) {
-                    res.on_update._action = foreign_key_action::set_default;
-                } else {
-                    res.on_delete._action = foreign_key_action::set_default;
-                }
-                return res;
-            }
-
-            foreign_key_type cascade() const {
-                auto res = this->fk;
-                if(update) {
-                    res.on_update._action = foreign_key_action::cascade;
-                } else {
-                    res.on_delete._action = foreign_key_action::cascade;
-                }
-                return res;
-            }
-
-            operator bool() const {
-                return this->_action != decltype(this->_action)::none;
-            }
-        };
-
-        template<class F>
-        bool operator==(const on_update_delete_t<F>& lhs, const on_update_delete_t<F>& rhs) {
-            return lhs._action == rhs._action;
-        }
-
-        template<class... Cs, class... Rs>
-        struct foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>> {
-            using columns_type = std::tuple<Cs...>;
-            using references_type = std::tuple<Rs...>;
-            using self = foreign_key_t<columns_type, references_type>;
-
-            /**
-             * Holds obect type of all referenced columns.
-             */
-            using target_type = typename same_or_void<typename table_type<Rs>::type...>::type;
-
-            /**
-             * Holds obect type of all source columns.
-             */
-            using source_type = typename same_or_void<typename table_type<Cs>::type...>::type;
-
-            columns_type columns;
-            references_type references;
-
-            on_update_delete_t<self> on_update;
-            on_update_delete_t<self> on_delete;
-
-            static_assert(std::tuple_size<columns_type>::value == std::tuple_size<references_type>::value,
-                          "Columns size must be equal to references tuple");
-            static_assert(!std::is_same<target_type, void>::value, "All references must have the same type");
-
-            foreign_key_t(columns_type columns_, references_type references_) :
-                columns(move(columns_)), references(move(references_)),
-                on_update(*this, true, foreign_key_action::none), on_delete(*this, false, foreign_key_action::none) {}
-
-            foreign_key_t(const self& other) :
-                columns(other.columns), references(other.references), on_update(*this, true, other.on_update._action),
-                on_delete(*this, false, other.on_delete._action) {}
-
-            self& operator=(const self& other) {
-                this->columns = other.columns;
-                this->references = other.references;
-                this->on_update = {*this, true, other.on_update._action};
-                this->on_delete = {*this, false, other.on_delete._action};
-                return *this;
-            }
-
-            template<class L>
-            void for_each_column(const L&) {}
-
-            template<class... Opts>
-            constexpr bool has_every() const {
-                return false;
-            }
-        };
-
-        template<class A, class B>
-        bool operator==(const foreign_key_t<A, B>& lhs, const foreign_key_t<A, B>& rhs) {
-            return lhs.columns == rhs.columns && lhs.references == rhs.references && lhs.on_update == rhs.on_update &&
-                   lhs.on_delete == rhs.on_delete;
-        }
-
-        /**
-         *  Cs can be a class member pointer, a getter function member pointer or setter
-         *  func member pointer
-         *  Available in SQLite 3.6.19 or higher
-         */
-        template<class... Cs>
-        struct foreign_key_intermediate_t {
-            using tuple_type = std::tuple<Cs...>;
-
-            tuple_type columns;
-
-            foreign_key_intermediate_t(tuple_type columns_) : columns(std::move(columns_)) {}
-
-            template<class... Rs>
-            foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>> references(Rs... refs) {
-                return {std::move(this->columns), std::make_tuple(std::forward<Rs>(refs)...)};
-            }
-        };
-#endif
-
-        struct collate_constraint_t {
-            internal::collate_argument argument = internal::collate_argument::binary;
-
-            collate_constraint_t(internal::collate_argument argument_) : argument(argument_) {}
-
-            operator std::string() const {
-                std::string res = "COLLATE " + this->string_from_collate_argument(this->argument);
-                return res;
-            }
-
-            static std::string string_from_collate_argument(internal::collate_argument argument) {
-                switch(argument) {
-                    case decltype(argument)::binary:
-                        return "BINARY";
-                    case decltype(argument)::nocase:
-                        return "NOCASE";
-                    case decltype(argument)::rtrim:
-                        return "RTRIM";
-                }
-                throw std::system_error(std::make_error_code(orm_error_code::invalid_collate_argument_enum));
-            }
-        };
-
-        struct check_string {
-            operator std::string() const {
-                return "CHECK";
-            }
-        };
-
-        template<class T>
-        struct check_t : check_string {
-            using expression_type = T;
-
-            expression_type expression;
-
-            check_t(expression_type expression_) : expression(std::move(expression_)) {}
-        };
-        struct basic_generated_always {
-            enum class storage_type {
-                not_specified,
-                virtual_,
-                stored,
-            };
-
-            bool full = true;
-            storage_type storage = storage_type::not_specified;
-        };
-
-        template<class T>
-        struct generated_always_t : basic_generated_always {
-            using expression_type = T;
-
-            expression_type expression;
-
-            generated_always_t(expression_type expression_, bool full, storage_type storage) :
-                basic_generated_always{full, storage}, expression(std::move(expression_)) {}
-
-            generated_always_t<T> virtual_() {
-                return {std::move(this->expression), this->full, storage_type::virtual_};
-            }
-
-            generated_always_t<T> stored() {
-                return {std::move(this->expression), this->full, storage_type::stored};
-            }
-        };
-
-        template<class T>
-        struct is_generated_always : std::false_type {};
-
-        template<class T>
-        struct is_generated_always<generated_always_t<T>> : std::true_type {};
-
-        template<class T>
-        struct is_constraint : std::false_type {};
-
-        template<>
-        struct is_constraint<autoincrement_t> : std::true_type {};
-
-        template<class... Cs>
-        struct is_constraint<primary_key_t<Cs...>> : std::true_type {};
-
-        template<class... Args>
-        struct is_constraint<unique_t<Args...>> : std::true_type {};
-
-        template<class T>
-        struct is_constraint<default_t<T>> : std::true_type {};
-
-        template<class C, class R>
-        struct is_constraint<foreign_key_t<C, R>> : std::true_type {};
-
-        template<>
-        struct is_constraint<collate_constraint_t> : std::true_type {};
-
-        template<class T>
-        struct is_constraint<check_t<T>> : std::true_type {};
-#if SQLITE_VERSION_NUMBER >= 3031000
-        template<class T>
-        struct is_constraint<generated_always_t<T>> : std::true_type {};
-#endif
-        template<class... Args>
-        struct constraints_size;
-
-        template<>
-        struct constraints_size<> {
-            static constexpr const int value = 0;
-        };
-
-        template<class H, class... Args>
-        struct constraints_size<H, Args...> {
-            static constexpr const int value = is_constraint<H>::value + constraints_size<Args...>::value;
-        };
-    }
-#if SQLITE_VERSION_NUMBER >= 3031000
-    template<class T>
-    internal::generated_always_t<T> generated_always_as(T expression) {
-        return {std::move(expression), true, internal::basic_generated_always::storage_type::not_specified};
-    }
-
-    template<class T>
-    internal::generated_always_t<T> as(T expression) {
-        return {std::move(expression), false, internal::basic_generated_always::storage_type::not_specified};
-    }
-#endif
-#if SQLITE_VERSION_NUMBER >= 3006019
-
-    /**
-     *  FOREIGN KEY constraint construction function that takes member pointer as argument
-     *  Available in SQLite 3.6.19 or higher
-     */
-    template<class... Cs>
-    internal::foreign_key_intermediate_t<Cs...> foreign_key(Cs... columns) {
-        return {std::make_tuple(std::forward<Cs>(columns)...)};
-    }
-#endif
-
-    /**
-     *  UNIQUE constraint builder function.
-     */
-    template<class... Args>
-    internal::unique_t<Args...> unique(Args... args) {
-        return {std::make_tuple(std::forward<Args>(args)...)};
-    }
-
-    inline internal::unique_t<> unique() {
-        return {{}};
-    }
-
-    inline internal::autoincrement_t autoincrement() {
-        return {};
-    }
-
-    template<class... Cs>
-    internal::primary_key_t<Cs...> primary_key(Cs... cs) {
-        return {std::make_tuple(std::forward<Cs>(cs)...)};
-    }
-
-    inline internal::primary_key_t<> primary_key() {
-        return {{}};
-    }
-
-    template<class T>
-    internal::default_t<T> default_value(T t) {
-        return {std::move(t)};
-    }
-
-    inline internal::collate_constraint_t collate_nocase() {
-        return {internal::collate_argument::nocase};
-    }
-
-    inline internal::collate_constraint_t collate_binary() {
-        return {internal::collate_argument::binary};
-    }
-
-    inline internal::collate_constraint_t collate_rtrim() {
-        return {internal::collate_argument::rtrim};
-    }
-
-    template<class T>
-    internal::check_t<T> check(T t) {
-        return {std::move(t)};
-    }
-
-    namespace internal {
-
-        /**
-         *  FOREIGN KEY traits. Common case
-         */
-        template<class T>
-        struct is_foreign_key : std::false_type {};
-
-        /**
-         *  FOREIGN KEY traits. Specialized case
-         */
-        template<class C, class R>
-        struct is_foreign_key<internal::foreign_key_t<C, R>> : std::true_type {};
-
-        /**
-         *  PRIMARY KEY traits. Common case
-         */
-        template<class T>
-        struct is_primary_key : public std::false_type {};
-
-        /**
-         *  PRIMARY KEY traits. Specialized case
-         */
-        template<class... Cs>
-        struct is_primary_key<internal::primary_key_t<Cs...>> : public std::true_type {};
-
-        /**
-         * PRIMARY KEY INSERTABLE traits.
-         */
-        template<typename T>
-        struct is_primary_key_insertable {
-            using field_type = typename T::field_type;
-            using constraints_type = typename T::constraints_type;
-
-            static_assert((tuple_helper::tuple_contains_type<primary_key_t<>, constraints_type>::value),
-                          "an unexpected type was passed");
-
-            static constexpr bool value =
-                (tuple_helper::tuple_contains_some_type<default_t, constraints_type>::value ||
-                 tuple_helper::tuple_contains_type<autoincrement_t, constraints_type>::value ||
-                 std::is_base_of<integer_printer, type_printer<field_type>>::value);
-        };
-    }
-
-}
-#pragma once
-
-#include <type_traits>  //  std::false_type, std::true_type
-#include <memory>  //  std::shared_ptr, std::unique_ptr
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-#include <optional>  // std::optional
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-namespace sqlite_orm {
-
-    /**
-     *  This is class that tells `sqlite_orm` that type is nullable. Nullable types
-     *  are mapped to sqlite database as `NULL` and not-nullable are mapped as `NOT NULL`.
-     *  Default nullability status for all types is `NOT NULL`. So if you want to map
-     *  custom type as `NULL` (for example: boost::optional) you have to create a specialiation
-     *  of type_is_nullable for your type and derive from `std::true_type`.
-     */
-    template<class T>
-    struct type_is_nullable : public std::false_type {
-        bool operator()(const T&) const {
-            return true;
-        }
-    };
-
-    /**
-     *  This is a specialization for std::shared_ptr. std::shared_ptr is nullable in sqlite_orm.
-     */
-    template<class T>
-    struct type_is_nullable<std::shared_ptr<T>> : public std::true_type {
-        bool operator()(const std::shared_ptr<T>& t) const {
-            return static_cast<bool>(t);
-        }
-    };
-
-    /**
-     *  This is a specialization for std::unique_ptr. std::unique_ptr is nullable too.
-     */
-    template<class T>
-    struct type_is_nullable<std::unique_ptr<T>> : public std::true_type {
-        bool operator()(const std::unique_ptr<T>& t) const {
-            return static_cast<bool>(t);
-        }
-    };
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-    /**
-     *  This is a specialization for std::optional. std::optional is nullable.
-     */
-    template<class T>
-    struct type_is_nullable<std::optional<T>> : public std::true_type {
-        bool operator()(const std::optional<T>& t) const {
-            return t.has_value();
-        }
-    };
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-}
-#pragma once
-
-#include <memory>  //  std::unique_ptr
-#include <string>  //  std::string
-#include <sstream>  //  std::stringstream
-
-// #include "constraints.h"
-
-// #include "serializator_context.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        struct serializator_context_base {
-            bool replace_bindable_with_question = false;
-            bool skip_table_name = true;
-            bool use_parentheses = true;
-
-            template<class O, class F>
-            const std::string* column_name(F O::*) const {
-                return nullptr;
-            }
-
-            template<class T, class F>
-            const std::string* column_name(const column_pointer<T, F>&) const {
-                return nullptr;
-            }
-        };
-
-        template<class I>
-        struct serializator_context : serializator_context_base {
-            using impl_type = I;
-
-            const impl_type& impl;
-
-            serializator_context(const impl_type& impl_) : impl(impl_) {}
-
-            template<class O, class F>
-            const std::string* column_name(F O::*memberPointer) const {
-                return this->impl.column_name(memberPointer);
-            }
-
-            template<class T, class F>
-            const std::string* column_name(const column_pointer<T, F>& columnPointer) const {
-                return this->impl.column_name(columnPointer);
-            }
-        };
-
-        template<class S>
-        struct serializator_context_builder {
-            using storage_type = S;
-            using impl_type = typename storage_type::impl_type;
-
-            serializator_context_builder(const storage_type& storage_) : storage(storage_) {}
-
-            serializator_context<impl_type> operator()() const {
-                return {this->storage.impl};
-            }
-
-            const storage_type& storage;
-        };
-
-    }
-
-}
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         *  This class is used in tuple interation to know whether tuple constains `default_value_t`
-         *  constraint class and what it's value if it is
-         */
-        struct default_value_extractor {
-
-            template<class A>
-            std::unique_ptr<std::string> operator()(const A&) {
-                return {};
-            }
-
-            template<class T>
-            std::unique_ptr<std::string> operator()(const default_t<T>& t) {
-                serializator_context_base context;
-                return std::make_unique<std::string>(serialize(t.value, context));
-            }
-        };
-
-    }
-
-}
-#pragma once
-
-#include <type_traits>  //  std::false_type, std::true_type
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-#include <optional>  //  std::nullopt
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-// #include "tags.h"
-
-namespace sqlite_orm {
-    namespace internal {
-        struct negatable_t {};
-
-        /**
-         *  Inherit from this class if target class can be chained with other conditions with '&&' and '||' operators
-         */
-        struct condition_t {};
-    }
-}
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         *  Inherit this class to support arithmetic types overloading
-         */
-        struct arithmetic_t {};
-
-        template<class L, class R, class... Ds>
-        struct binary_operator : Ds... {
-            using left_type = L;
-            using right_type = R;
-
-            left_type lhs;
-            right_type rhs;
-
-            binary_operator(left_type lhs_, right_type rhs_) : lhs(std::move(lhs_)), rhs(std::move(rhs_)) {}
-        };
-
-        struct conc_string {
-            operator std::string() const {
-                return "||";
-            }
-        };
-
-        /**
-         *  Result of concatenation || operator
-         */
-        template<class L, class R>
-        using conc_t = binary_operator<L, R, conc_string>;
-
-        struct add_string {
-            operator std::string() const {
-                return "+";
-            }
-        };
-
-        /**
-         *  Result of addition + operator
-         */
-        template<class L, class R>
-        using add_t = binary_operator<L, R, add_string, arithmetic_t, negatable_t>;
-
-        struct sub_string {
-            operator std::string() const {
-                return "-";
-            }
-        };
-
-        /**
-         *  Result of substitute - operator
-         */
-        template<class L, class R>
-        using sub_t = binary_operator<L, R, sub_string, arithmetic_t, negatable_t>;
-
-        struct mul_string {
-            operator std::string() const {
-                return "*";
-            }
-        };
-
-        /**
-         *  Result of multiply * operator
-         */
-        template<class L, class R>
-        using mul_t = binary_operator<L, R, mul_string, arithmetic_t, negatable_t>;
-
-        struct div_string {
-            operator std::string() const {
-                return "/";
-            }
-        };
-
-        /**
-         *  Result of divide / operator
-         */
-        template<class L, class R>
-        using div_t = binary_operator<L, R, div_string, arithmetic_t, negatable_t>;
-
-        struct mod_operator_string {
-            operator std::string() const {
-                return "%";
-            }
-        };
-
-        /**
-         *  Result of mod % operator
-         */
-        template<class L, class R>
-        using mod_t = binary_operator<L, R, mod_operator_string, arithmetic_t, negatable_t>;
-
-        struct bitwise_shift_left_string {
-            operator std::string() const {
-                return "<<";
-            }
-        };
-
-        /**
-         * Result of bitwise shift left << operator
-         */
-        template<class L, class R>
-        using bitwise_shift_left_t = binary_operator<L, R, bitwise_shift_left_string, arithmetic_t, negatable_t>;
-
-        struct bitwise_shift_right_string {
-            operator std::string() const {
-                return ">>";
-            }
-        };
-
-        /**
-         * Result of bitwise shift right >> operator
-         */
-        template<class L, class R>
-        using bitwise_shift_right_t = binary_operator<L, R, bitwise_shift_right_string, arithmetic_t, negatable_t>;
-
-        struct bitwise_and_string {
-            operator std::string() const {
-                return "&";
-            }
-        };
-
-        /**
-         * Result of bitwise and & operator
-         */
-        template<class L, class R>
-        using bitwise_and_t = binary_operator<L, R, bitwise_and_string, arithmetic_t, negatable_t>;
-
-        struct bitwise_or_string {
-            operator std::string() const {
-                return "|";
-            }
-        };
-
-        /**
-         * Result of bitwise or | operator
-         */
-        template<class L, class R>
-        using bitwise_or_t = binary_operator<L, R, bitwise_or_string, arithmetic_t, negatable_t>;
-
-        struct bitwise_not_string {
-            operator std::string() const {
-                return "~";
-            }
-        };
-
-        /**
-         * Result of bitwise not ~ operator
-         */
-        template<class T>
-        struct bitwise_not_t : bitwise_not_string, arithmetic_t, negatable_t {
-            using argument_type = T;
-
-            argument_type argument;
-
-            bitwise_not_t(argument_type argument_) : argument(std::move(argument_)) {}
-        };
-
-        struct assign_string {
-            operator std::string() const {
-                return "=";
-            }
-        };
-
-        /**
-         *  Result of assign = operator
-         */
-        template<class L, class R>
-        using assign_t = binary_operator<L, R, assign_string>;
-
-        /**
-         *  Assign operator traits. Common case
-         */
-        template<class T>
-        struct is_assign_t : public std::false_type {};
-
-        /**
-         *  Assign operator traits. Specialized case
-         */
-        template<class L, class R>
-        struct is_assign_t<assign_t<L, R>> : public std::true_type {};
-
-        template<class L, class... Args>
-        struct in_t;
-
-    }
-
-    /**
-     *  Public interface for || concatenation operator. Example: `select(conc(&User::name, "@gmail.com"));` => SELECT
-     * name || '@gmail.com' FROM users
-     */
-    template<class L, class R>
-    internal::conc_t<L, R> conc(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    /**
-     *  Public interface for + operator. Example: `select(add(&User::age, 100));` => SELECT age + 100 FROM users
-     */
-    template<class L, class R>
-    internal::add_t<L, R> add(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    /**
-     *  Public interface for - operator. Example: `select(sub(&User::age, 1));` => SELECT age - 1 FROM users
-     */
-    template<class L, class R>
-    internal::sub_t<L, R> sub(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    /**
-     *  Public interface for * operator. Example: `select(mul(&User::salary, 2));` => SELECT salary * 2 FROM users
-     */
-    template<class L, class R>
-    internal::mul_t<L, R> mul(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    /**
-     *  Public interface for / operator. Example: `select(div(&User::salary, 3));` => SELECT salary / 3 FROM users
-     *  @note Please notice that ::div function already exists in pure C standard library inside <cstdlib> header.
-     *  If you use `using namespace sqlite_orm` directive you an specify which `div` you call explicitly using  `::div` or `sqlite_orm::div` statements.
-     */
-    template<class L, class R>
-    internal::div_t<L, R> div(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    /**
-     *  Public interface for % operator. Example: `select(mod(&User::age, 5));` => SELECT age % 5 FROM users
-     */
-    template<class L, class R>
-    internal::mod_t<L, R> mod(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::bitwise_shift_left_t<L, R> bitwise_shift_left(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::bitwise_shift_right_t<L, R> bitwise_shift_right(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::bitwise_and_t<L, R> bitwise_and(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::bitwise_or_t<L, R> bitwise_or(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class T>
-    internal::bitwise_not_t<T> bitwise_not(T t) {
-        return {std::move(t)};
-    }
-
-    template<class L, class R>
-    internal::assign_t<L, R> assign(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-}
-#pragma once
-
-#include <tuple>  //  std::tuple
-#include <string>  //  std::string
-#include <memory>  //  std::unique_ptr
-#include <type_traits>  //  std::true_type, std::false_type, std::is_same, std::enable_if, std::is_member_pointer, std::is_member_function_pointer
-
-// #include "type_is_nullable.h"
-
-// #include "tuple_helper/tuple_helper.h"
-
-// #include "default_value_extractor.h"
-
-// #include "constraints.h"
-
-// #include "member_traits/member_traits.h"
-
-#include <type_traits>  //  std::enable_if
-
-// #include "is_field_member_pointer.h"
-
-#include <type_traits>  //  std::false_type, std::true_type, std::is_member_pointer, std::is_member_function_pointer
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T, class SFINAE = void>
-        struct is_field_member_pointer : std::false_type {};
-
-        template<class T>
-        struct is_field_member_pointer<T,
-                                       typename std::enable_if<std::is_member_pointer<T>::value &&
-                                                               !std::is_member_function_pointer<T>::value>::type>
-            : std::true_type {};
-    }
-}
-
-// #include "is_getter.h"
-
-// #include "field_member_traits.h"
-
-#include <type_traits>  //  std::enable_if
-
-// #include "is_field_member_pointer.h"
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T, class SFINAE = void>
-        struct field_member_traits;
-
-        template<class O, class F>
-        struct field_member_traits<F O::*, typename std::enable_if<is_field_member_pointer<F O::*>::value>::type> {
-            using object_type = O;
-            using field_type = F;
-        };
-    }
-}
-
-// #include "is_setter.h"
-
-// #include "getter_traits.h"
-
-// #include "setter_traits.h"
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T, class SFINAE = void>
-        struct member_traits;
-
-        template<class T>
-        struct member_traits<T, typename std::enable_if<is_field_member_pointer<T>::value>::type> {
-            using object_type = typename field_member_traits<T>::object_type;
-            using field_type = typename field_member_traits<T>::field_type;
-        };
-
-        template<class T>
-        struct member_traits<T, typename std::enable_if<is_getter<T>::value>::type> {
-            using object_type = typename getter_traits<T>::object_type;
-            using field_type = typename getter_traits<T>::field_type;
-        };
-
-        template<class T>
-        struct member_traits<T, typename std::enable_if<is_setter<T>::value>::type> {
-            using object_type = typename setter_traits<T>::object_type;
-            using field_type = typename setter_traits<T>::field_type;
-        };
-    }
-}
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        struct basic_column {
-
-            /**
-             *  Column name. Specified during construction in `make_column`.
-             */
-            const std::string name;
-        };
-
-        /**
-         *  This class stores single column info. column_t is a pair of [column_name:member_pointer] mapped to a storage
-         *  O is a mapped class, e.g. User
-         *  T is a mapped class'es field type, e.g. &User::name
-         *  Op... is a constraints pack, e.g. primary_key_t, autoincrement_t etc
-         */
-        template<class O, class T, class G /* = const T& (O::*)() const*/, class S /* = void (O::*)(T)*/, class... Op>
-        struct column_t : basic_column {
-            using object_type = O;
-            using field_type = T;
-            using constraints_type = std::tuple<Op...>;
-            using member_pointer_t = field_type object_type::*;
-            using getter_type = G;
-            using setter_type = S;
-
-            /**
-             *  Member pointer used to read/write member
-             */
-            member_pointer_t member_pointer /* = nullptr*/;
-
-            /**
-             *  Getter member function pointer to get a value. If member_pointer is null than
-             *  `getter` and `setter` must be not null
-             */
-            getter_type getter /* = nullptr*/;
-
-            /**
-             *  Setter member function
-             */
-            setter_type setter /* = nullptr*/;
-
-            /**
-             *  Constraints tuple
-             */
-            constraints_type constraints;
-
-            column_t(std::string name_,
-                     member_pointer_t member_pointer_,
-                     getter_type getter_,
-                     setter_type setter_,
-                     constraints_type constraints_) :
-                basic_column{move(name_)},
-                member_pointer(member_pointer_), getter(getter_), setter(setter_), constraints(move(constraints_)) {}
-
-            /**
-             *  Simplified interface for `NOT NULL` constraint
-             */
-            bool not_null() const {
-                return !type_is_nullable<field_type>::value;
-            }
-
-            template<class Opt>
-            constexpr bool has() const {
-                return tuple_helper::tuple_contains_type<Opt, constraints_type>::value;
-            }
-
-            template<class O1, class O2, class... Opts>
-            constexpr bool has_every() const {
-                if(has<O1>() && has<O2>()) {
-                    return true;
-                } else {
-                    return has_every<Opts...>();
-                }
-            }
-
-            template<class O1>
-            constexpr bool has_every() const {
-                return has<O1>();
-            }
-
-            /**
-             *  Simplified interface for `DEFAULT` constraint
-             *  @return string representation of default value if it exists otherwise nullptr
-             */
-            std::unique_ptr<std::string> default_value() const {
-                std::unique_ptr<std::string> res;
-                iterate_tuple(this->constraints, [&res](auto& v) {
-                    auto dft = internal::default_value_extractor()(v);
-                    if(dft) {
-                        res = std::move(dft);
-                    }
-                });
-                return res;
-            }
-
-            bool is_generated() const {
-#if SQLITE_VERSION_NUMBER >= 3031000
-                auto res = false;
-                iterate_tuple(this->constraints, [&res](auto& constraint) {
-                    using constraint_type = typename std::decay<decltype(constraint)>::type;
-                    if(!res) {
-                        res = is_generated_always<constraint_type>::value;
-                    }
-                });
-                return res;
-#else
-                return false;
-#endif
-            }
-        };
-
-        // we are compelled to wrap all sfinae-implemented traits to prevent "error: type/value mismatch at argument 2 in template parameter list"
-        namespace sfinae {
-            /**
-             *  Column with insertable primary key traits. Common case.
-             */
-            template<class T, class SFINAE = void>
-            struct is_column_with_insertable_primary_key : public std::false_type {};
-
-            /**
-             *  Column with insertable primary key traits. Specialized case case.
-             */
-            template<class O, class T, class... Op>
-            struct is_column_with_insertable_primary_key<
-                column_t<O, T, Op...>,
-                typename std::enable_if<(tuple_helper::tuple_contains_type<
-                                         primary_key_t<>,
-                                         typename column_t<O, T, Op...>::constraints_type>::value)>::type> {
-                using column_type = column_t<O, T, Op...>;
-                static constexpr bool value = is_primary_key_insertable<column_type>::value;
-            };
-
-            /**
-             *  Column with noninsertable primary key traits. Common case.
-             */
-            template<class T, class SFINAE = void>
-            struct is_column_with_noninsertable_primary_key : public std::false_type {};
-
-            /**
-             *  Column with noninsertable primary key traits. Specialized case case.
-             */
-            template<class O, class T, class... Op>
-            struct is_column_with_noninsertable_primary_key<
-                column_t<O, T, Op...>,
-                typename std::enable_if<(tuple_helper::tuple_contains_type<
-                                         primary_key_t<>,
-                                         typename column_t<O, T, Op...>::constraints_type>::value)>::type> {
-                using column_type = column_t<O, T, Op...>;
-                static constexpr bool value = !is_primary_key_insertable<column_type>::value;
-            };
-
-        }
-
-        /**
-         *  Column traits. Common case.
-         */
-        template<class T>
-        struct is_column : public std::false_type {};
-
-        /**
-         *  Column traits. Specialized case case.
-         */
-        template<class O, class T, class... Op>
-        struct is_column<column_t<O, T, Op...>> : public std::true_type {};
-
-        /**
-         *  Column with insertable primary key traits.
-         */
-        template<class T>
-        struct is_column_with_insertable_primary_key : public sfinae::is_column_with_insertable_primary_key<T> {};
-
-        /**
-         *  Column with noninsertable primary key traits.
-         */
-        template<class T>
-        struct is_column_with_noninsertable_primary_key : public sfinae::is_column_with_noninsertable_primary_key<T> {};
-
-        template<class T>
-        struct column_field_type {
-            using type = void;
-        };
-
-        template<class O, class T, class... Op>
-        struct column_field_type<column_t<O, T, Op...>> {
-            using type = typename column_t<O, T, Op...>::field_type;
-        };
-
-        template<class T>
-        struct column_constraints_type {
-            using type = std::tuple<>;
-        };
-
-        template<class O, class T, class... Op>
-        struct column_constraints_type<column_t<O, T, Op...>> {
-            using type = typename column_t<O, T, Op...>::constraints_type;
-        };
-
-    }
-
-    /**
-     *  Column builder function. You should use it to create columns instead of constructor
-     */
-    template<class O,
-             class T,
-             typename = typename std::enable_if<!std::is_member_function_pointer<T O::*>::value>::type,
-             class... Op>
-    internal::column_t<O, T, const T& (O::*)() const, void (O::*)(T), Op...>
-    make_column(const std::string& name, T O::*m, Op... constraints) {
-        static_assert(internal::template constraints_size<Op...>::value == std::tuple_size<std::tuple<Op...>>::value,
-                      "Incorrect constraints pack");
-        static_assert(internal::is_field_member_pointer<T O::*>::value,
-                      "second argument expected as a member field pointer, not member function pointer");
-        return {name, m, nullptr, nullptr, std::make_tuple(constraints...)};
-    }
-
-    /**
-     *  Column builder function with setter and getter. You should use it to create columns instead of constructor
-     */
-    template<class G,
-             class S,
-             typename = typename std::enable_if<internal::is_getter<G>::value>::type,
-             typename = typename std::enable_if<internal::is_setter<S>::value>::type,
-             class... Op>
-    internal::column_t<typename internal::setter_traits<S>::object_type,
-                       typename internal::setter_traits<S>::field_type,
-                       G,
-                       S,
-                       Op...>
-    make_column(const std::string& name, S setter, G getter, Op... constraints) {
-        static_assert(std::is_same<typename internal::setter_traits<S>::field_type,
-                                   typename internal::getter_traits<G>::field_type>::value,
-                      "Getter and setter must get and set same data type");
-        static_assert(internal::template constraints_size<Op...>::value == std::tuple_size<std::tuple<Op...>>::value,
-                      "Incorrect constraints pack");
-        return {name, nullptr, getter, setter, std::make_tuple(constraints...)};
-    }
-
-    /**
-     *  Column builder function with getter and setter (reverse order). You should use it to create columns instead of
-     * constructor
-     */
-    template<class G,
-             class S,
-             typename = typename std::enable_if<internal::is_getter<G>::value>::type,
-             typename = typename std::enable_if<internal::is_setter<S>::value>::type,
-             class... Op>
-    internal::column_t<typename internal::setter_traits<S>::object_type,
-                       typename internal::setter_traits<S>::field_type,
-                       G,
-                       S,
-                       Op...>
-    make_column(const std::string& name, G getter, S setter, Op... constraints) {
-        static_assert(std::is_same<typename internal::setter_traits<S>::field_type,
-                                   typename internal::getter_traits<G>::field_type>::value,
-                      "Getter and setter must get and set same data type");
-        static_assert(internal::template constraints_size<Op...>::value == std::tuple_size<std::tuple<Op...>>::value,
-                      "Incorrect constraints pack");
-        return {name, nullptr, getter, setter, std::make_tuple(constraints...)};
-    }
-
-}
-#pragma once
-
-#include <string>  //  std::string
-#include <sstream>  //  std::stringstream
-#include <vector>  //  std::vector
-#include <cstddef>  //  std::nullptr_t
-#include <memory>  //  std::shared_ptr, std::unique_ptr
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-#include <optional>  // std::optional
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-#ifndef SQLITE_ORM_OMITS_CODECVT
-#include <codecvt>  //  std::codecvt_utf8_utf16
-#endif  //  SQLITE_ORM_OMITS_CODECVT
-
-namespace sqlite_orm {
-
-    /**
-     *  Is used to print members mapped to objects in storage_t::dump member function.
-     *  Other developers can create own specialization to map custom types
-     */
-    template<class T, typename Enable = void>
-    struct field_printer {
-        std::string operator()(const T& t) const {
-            std::stringstream stream;
-            stream << t;
-            return stream.str();
-        }
-    };
-
-    /**
-     *  Upgrade to integer is required when using unsigned char(uint8_t)
-     */
-    template<>
-    struct field_printer<unsigned char, void> {
-        std::string operator()(const unsigned char& t) const {
-            std::stringstream stream;
-            stream << +t;
-            return stream.str();
-        }
-    };
-
-    /**
-     *  Upgrade to integer is required when using signed char(int8_t)
-     */
-    template<>
-    struct field_printer<signed char, void> {
-        std::string operator()(const signed char& t) const {
-            std::stringstream stream;
-            stream << +t;
-            return stream.str();
-        }
-    };
-
-    /**
-     *  char is neigher signer char nor unsigned char so it has its own specialization
-     */
-    template<>
-    struct field_printer<char, void> {
-        std::string operator()(const char& t) const {
-            std::stringstream stream;
-            stream << +t;
-            return stream.str();
-        }
-    };
-
-    template<>
-    struct field_printer<std::string, void> {
-        std::string operator()(const std::string& string) const {
-            return string;
-        }
-    };
-
-    template<>
-    struct field_printer<std::vector<char>, void> {
-        std::string operator()(const std::vector<char>& t) const {
-            std::stringstream ss;
-            ss << std::hex;
-            for(auto c: t) {
-                ss << c;
-            }
-            return ss.str();
-        }
-    };
-#ifndef SQLITE_ORM_OMITS_CODECVT
-    template<>
-    struct field_printer<std::wstring, void> {
-        std::string operator()(const std::wstring& wideString) const {
-            std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
-            return converter.to_bytes(wideString);
-        }
-    };
-#endif  //  SQLITE_ORM_OMITS_CODECVT
-    template<>
-    struct field_printer<std::nullptr_t, void> {
-        std::string operator()(const std::nullptr_t&) const {
-            return "null";
-        }
-    };
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-    template<>
-    struct field_printer<std::nullopt_t, void> {
-        std::string operator()(const std::nullopt_t&) const {
-            return "null";
-        }
-    };
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-    template<class T>
-    struct field_printer<std::shared_ptr<T>, void> {
-        std::string operator()(const std::shared_ptr<T>& t) const {
-            if(t) {
-                return field_printer<T>()(*t);
-            } else {
-                return field_printer<std::nullptr_t>()(nullptr);
-            }
-        }
-    };
-
-    template<class T>
-    struct field_printer<std::unique_ptr<T>, void> {
-        std::string operator()(const std::unique_ptr<T>& t) const {
-            if(t) {
-                return field_printer<T>()(*t);
-            } else {
-                return field_printer<std::nullptr_t>()(nullptr);
-            }
-        }
-    };
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-    template<class T>
-    struct field_printer<std::optional<T>, void> {
-        std::string operator()(const std::optional<T>& t) const {
-            if(t.has_value()) {
-                return field_printer<T>()(*t);
-            } else {
-                return field_printer<std::nullptr_t>()(nullptr);
-            }
-        }
-    };
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-    template<typename P, typename T, typename D>
-    class pointer_binding;
-
-    template<class P, class T, class D>
-    struct field_printer<pointer_binding<P, T, D>, void> {
-        std::string operator()(const pointer_binding<P, T, D>&) const {
-            return field_printer<std::nullptr_t>()(nullptr);
-        }
-    };
-}
-#pragma once
-
-#include <string>  //  std::string
-#include <type_traits>  //  std::enable_if, std::is_same
-#include <vector>  //  std::vector
-#include <tuple>  //  std::tuple, std::tuple_size
-#include <sstream>  //  std::stringstream
-
-// #include "collate_argument.h"
-
-// #include "constraints.h"
-
-// #include "optional_container.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         *  This is a cute class which allows storing something or nothing
-         *  depending on template argument. Useful for optional class members
-         */
-        template<class T>
-        struct optional_container {
-            using type = T;
-
-            type field;
-
-            template<class L>
-            void apply(const L& l) const {
-                l(this->field);
-            }
-        };
-
-        template<>
-        struct optional_container<void> {
-            using type = void;
-
-            template<class L>
-            void apply(const L&) const {
-                //..
-            }
-        };
-    }
-}
-
-// #include "tags.h"
-
-// #include "expression.h"
-// #include "operators.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        template<class L, class R>
-        struct and_condition_t;
-
-        template<class L, class R>
-        struct or_condition_t;
-
-        /**
-         *  Is not an operator but a result of c(...) function. Has operator= overloaded which returns assign_t
-         */
-        template<class T>
-        struct expression_t : condition_t {
-            T value;
-
-            expression_t(T value_) : value(std::move(value_)) {}
-
-            template<class R>
-            assign_t<T, R> operator=(R r) const {
-                return {this->value, std::move(r)};
-            }
-
-            assign_t<T, std::nullptr_t> operator=(std::nullptr_t) const {
-                return {this->value, nullptr};
-            }
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-            assign_t<T, std::nullopt_t> operator=(std::nullopt_t) const {
-                return {this->value, std::nullopt};
-            }
-#endif
-            template<class... Args>
-            in_t<T, Args...> in(Args... args) const {
-                return {this->value, std::make_tuple(std::forward<Args>(args)...), false};
-            }
-
-            template<class... Args>
-            in_t<T, Args...> not_in(Args... args) const {
-                return {this->value, std::make_tuple(std::forward<Args>(args)...), true};
-            }
-
-            template<class R>
-            and_condition_t<T, R> and_(R right) const {
-                return {this->value, std::move(right)};
-            }
-
-            template<class R>
-            or_condition_t<T, R> or_(R right) const {
-                return {this->value, std::move(right)};
-            }
-        };
-
-        template<class T>
-        T get_from_expression(T value) {
-            return std::move(value);
-        }
-
-        template<class T>
-        T get_from_expression(expression_t<T> expression) {
-            return std::move(expression.value);
-        }
-    }
-
-    /**
-     *  Public interface for syntax sugar for columns. Example: `where(c(&User::id) == 5)` or
-     * `storage.update(set(c(&User::name) = "Dua Lipa"));
-     */
-    template<class T>
-    internal::expression_t<T> c(T value) {
-        return {std::move(value)};
-    }
-}
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        struct limit_string {
-            operator std::string() const {
-                return "LIMIT";
-            }
-        };
-
-        /**
-         *  Stores LIMIT/OFFSET info
-         */
-        template<class T, bool has_offset, bool offset_is_implicit, class O>
-        struct limit_t : limit_string {
-            T lim;
-            optional_container<O> off;
-
-            limit_t() = default;
-
-            limit_t(decltype(lim) lim_) : lim(std::move(lim_)) {}
-
-            limit_t(decltype(lim) lim_, decltype(off) off_) : lim(std::move(lim_)), off(std::move(off_)) {}
-        };
-
-        template<class T>
-        struct is_limit : std::false_type {};
-
-        template<class T, bool has_offset, bool offset_is_implicit, class O>
-        struct is_limit<limit_t<T, has_offset, offset_is_implicit, O>> : std::true_type {};
-
-        /**
-         *  Stores OFFSET only info
-         */
-        template<class T>
-        struct offset_t {
-            T off;
-        };
-
-        template<class T>
-        struct is_offset : std::false_type {};
-
-        template<class T>
-        struct is_offset<offset_t<T>> : std::true_type {};
-
-        /**
-         *  Collated something
-         */
-        template<class T>
-        struct collate_t : public condition_t {
-            T expr;
-            collate_argument argument;
-
-            collate_t(T expr_, collate_argument argument_) : expr(std::move(expr_)), argument(argument_) {}
-
-            operator std::string() const {
-                return collate_constraint_t{this->argument};
-            }
-        };
-
-        struct named_collate_base {
-            std::string name;
-
-            operator std::string() const {
-                return "COLLATE " + this->name;
-            }
-        };
-
-        /**
-         *  Collated something with custom collate function
-         */
-        template<class T>
-        struct named_collate : named_collate_base {
-            T expr;
-
-            named_collate(T expr_, std::string name_) : named_collate_base{std::move(name_)}, expr(std::move(expr_)) {}
-        };
-
-        struct negated_condition_string {
-            operator std::string() const {
-                return "NOT";
-            }
-        };
-
-        /**
-         *  Result of not operator
-         */
-        template<class C>
-        struct negated_condition_t : condition_t, negated_condition_string {
-            C c;
-
-            negated_condition_t(C c_) : c(std::move(c_)) {}
-        };
-
-        /**
-         *  Base class for binary conditions
-         *  L is left argument type
-         *  R is right argument type
-         *  S is 'string' class (a class which has cast to `std::string` operator)
-         *  Res is result type
-         */
-        template<class L, class R, class S, class Res>
-        struct binary_condition : condition_t, S {
-            using left_type = L;
-            using right_type = R;
-            using result_type = Res;
-
-            left_type l;
-            right_type r;
-
-            binary_condition() = default;
-
-            binary_condition(left_type l_, right_type r_) : l(std::move(l_)), r(std::move(r_)) {}
-        };
-
-        struct and_condition_string {
-            operator std::string() const {
-                return "AND";
-            }
-        };
-
-        /**
-         *  Result of and operator
-         */
-        template<class L, class R>
-        struct and_condition_t : binary_condition<L, R, and_condition_string, bool> {
-            using super = binary_condition<L, R, and_condition_string, bool>;
-
-            using super::super;
-        };
-
-        template<class L, class R>
-        and_condition_t<L, R> make_and_condition(L left, R right) {
-            return {std::move(left), std::move(right)};
-        }
-
-        struct or_condition_string {
-            operator std::string() const {
-                return "OR";
-            }
-        };
-
-        /**
-         *  Result of or operator
-         */
-        template<class L, class R>
-        struct or_condition_t : binary_condition<L, R, or_condition_string, bool> {
-            using super = binary_condition<L, R, or_condition_string, bool>;
-
-            using super::super;
-        };
-
-        template<class L, class R>
-        or_condition_t<L, R> make_or_condition(L left, R right) {
-            return {std::move(left), std::move(right)};
-        }
-
-        struct is_equal_string {
-            operator std::string() const {
-                return "=";
-            }
-        };
-
-        /**
-         *  = and == operators object
-         */
-        template<class L, class R>
-        struct is_equal_t : binary_condition<L, R, is_equal_string, bool>, negatable_t {
-            using self = is_equal_t<L, R>;
-
-            using binary_condition<L, R, is_equal_string, bool>::binary_condition;
-
-            collate_t<self> collate_binary() const {
-                return {*this, collate_argument::binary};
-            }
-
-            collate_t<self> collate_nocase() const {
-                return {*this, collate_argument::nocase};
-            }
-
-            collate_t<self> collate_rtrim() const {
-                return {*this, collate_argument::rtrim};
-            }
-
-            named_collate<self> collate(std::string name) const {
-                return {*this, std::move(name)};
-            }
-
-            template<class C>
-            named_collate<self> collate() const {
-                std::stringstream ss;
-                ss << C::name();
-                auto name = ss.str();
-                ss.flush();
-                return {*this, std::move(name)};
-            }
-        };
-
-        struct is_not_equal_string {
-            operator std::string() const {
-                return "!=";
-            }
-        };
-
-        /**
-         *  != operator object
-         */
-        template<class L, class R>
-        struct is_not_equal_t : binary_condition<L, R, is_not_equal_string, bool>, negatable_t {
-            using self = is_not_equal_t<L, R>;
-
-            using binary_condition<L, R, is_not_equal_string, bool>::binary_condition;
-
-            collate_t<self> collate_binary() const {
-                return {*this, collate_argument::binary};
-            }
-
-            collate_t<self> collate_nocase() const {
-                return {*this, collate_argument::nocase};
-            }
-
-            collate_t<self> collate_rtrim() const {
-                return {*this, collate_argument::rtrim};
-            }
-        };
-
-        struct greater_than_string {
-            operator std::string() const {
-                return ">";
-            }
-        };
-
-        /**
-         *  > operator object.
-         */
-        template<class L, class R>
-        struct greater_than_t : binary_condition<L, R, greater_than_string, bool>, negatable_t {
-            using self = greater_than_t<L, R>;
-
-            using binary_condition<L, R, greater_than_string, bool>::binary_condition;
-
-            collate_t<self> collate_binary() const {
-                return {*this, collate_argument::binary};
-            }
-
-            collate_t<self> collate_nocase() const {
-                return {*this, collate_argument::nocase};
-            }
-
-            collate_t<self> collate_rtrim() const {
-                return {*this, collate_argument::rtrim};
-            }
-        };
-
-        struct greater_or_equal_string {
-            operator std::string() const {
-                return ">=";
-            }
-        };
-
-        /**
-         *  >= operator object.
-         */
-        template<class L, class R>
-        struct greater_or_equal_t : binary_condition<L, R, greater_or_equal_string, bool>, negatable_t {
-            using self = greater_or_equal_t<L, R>;
-
-            using binary_condition<L, R, greater_or_equal_string, bool>::binary_condition;
-
-            collate_t<self> collate_binary() const {
-                return {*this, collate_argument::binary};
-            }
-
-            collate_t<self> collate_nocase() const {
-                return {*this, collate_argument::nocase};
-            }
-
-            collate_t<self> collate_rtrim() const {
-                return {*this, collate_argument::rtrim};
-            }
-        };
-
-        struct lesser_than_string {
-            operator std::string() const {
-                return "<";
-            }
-        };
-
-        /**
-         *  < operator object.
-         */
-        template<class L, class R>
-        struct lesser_than_t : binary_condition<L, R, lesser_than_string, bool>, negatable_t {
-            using self = lesser_than_t<L, R>;
-
-            using binary_condition<L, R, lesser_than_string, bool>::binary_condition;
-
-            collate_t<self> collate_binary() const {
-                return {*this, collate_argument::binary};
-            }
-
-            collate_t<self> collate_nocase() const {
-                return {*this, collate_argument::nocase};
-            }
-
-            collate_t<self> collate_rtrim() const {
-                return {*this, collate_argument::rtrim};
-            }
-        };
-
-        struct lesser_or_equal_string {
-            operator std::string() const {
-                return "<=";
-            }
-        };
-
-        /**
-         *  <= operator object.
-         */
-        template<class L, class R>
-        struct lesser_or_equal_t : binary_condition<L, R, lesser_or_equal_string, bool>, negatable_t {
-            using self = lesser_or_equal_t<L, R>;
-
-            using binary_condition<L, R, lesser_or_equal_string, bool>::binary_condition;
-
-            collate_t<self> collate_binary() const {
-                return {*this, collate_argument::binary};
-            }
-
-            collate_t<self> collate_nocase() const {
-                return {*this, collate_argument::nocase};
-            }
-
-            collate_t<self> collate_rtrim() const {
-                return {*this, collate_argument::rtrim};
-            }
-        };
-
-        struct in_base {
-            bool negative = false;  //  used in not_in
-
-            operator std::string() const {
-                if(!this->negative) {
-                    return "IN";
-                } else {
-                    return "NOT IN";
-                }
-            }
-        };
-
-        /**
-         *  IN operator object.
-         */
-        template<class L, class A>
-        struct dynamic_in_t : condition_t, in_base, negatable_t {
-            using self = dynamic_in_t<L, A>;
-
-            L left;  //  left expression
-            A argument;  //  in arg
-
-            dynamic_in_t(L left_, A argument_, bool negative_) :
-                in_base{negative_}, left(std::move(left_)), argument(std::move(argument_)) {}
-        };
-
-        template<class L, class... Args>
-        struct in_t : condition_t, in_base, negatable_t {
-            L left;
-            std::tuple<Args...> argument;
-
-            in_t(L left_, decltype(argument) argument_, bool negative_) :
-                in_base{negative_}, left(std::move(left_)), argument(std::move(argument_)) {}
-        };
-
-        struct is_null_string {
-            operator std::string() const {
-                return "IS NULL";
-            }
-        };
-
-        /**
-         *  IS NULL operator object.
-         */
-        template<class T>
-        struct is_null_t : is_null_string, negatable_t {
-            using self = is_null_t<T>;
-
-            T t;
-
-            is_null_t(T t_) : t(std::move(t_)) {}
-        };
-
-        struct is_not_null_string {
-            operator std::string() const {
-                return "IS NOT NULL";
-            }
-        };
-
-        /**
-         *  IS NOT NULL operator object.
-         */
-        template<class T>
-        struct is_not_null_t : is_not_null_string, negatable_t {
-            using self = is_not_null_t<T>;
-
-            T t;
-
-            is_not_null_t(T t_) : t(std::move(t_)) {}
-        };
-
-        struct order_by_base {
-            int asc_desc = 0;  //  1: asc, -1: desc
-            std::string _collate_argument;
-
-            order_by_base() = default;
-
-            order_by_base(decltype(asc_desc) asc_desc_, decltype(_collate_argument) _collate_argument_) :
-                asc_desc(asc_desc_), _collate_argument(move(_collate_argument_)) {}
-        };
-
-        struct order_by_string {
-            operator std::string() const {
-                return "ORDER BY";
-            }
-        };
-
-        /**
-         *  ORDER BY argument holder.
-         */
-        template<class O>
-        struct order_by_t : order_by_base, order_by_string {
-            using expression_type = O;
-            using self = order_by_t<expression_type>;
-
-            expression_type expression;
-
-            order_by_t(expression_type expression_) : order_by_base(), expression(std::move(expression_)) {}
-
-            self asc() {
-                auto res = *this;
-                res.asc_desc = 1;
-                return res;
-            }
-
-            self desc() {
-                auto res = *this;
-                res.asc_desc = -1;
-                return res;
-            }
-
-            self collate_binary() const {
-                auto res = *this;
-                res._collate_argument =
-                    collate_constraint_t::string_from_collate_argument(sqlite_orm::internal::collate_argument::binary);
-                return res;
-            }
-
-            self collate_nocase() const {
-                auto res = *this;
-                res._collate_argument =
-                    collate_constraint_t::string_from_collate_argument(sqlite_orm::internal::collate_argument::nocase);
-                return res;
-            }
-
-            self collate_rtrim() const {
-                auto res = *this;
-                res._collate_argument =
-                    collate_constraint_t::string_from_collate_argument(sqlite_orm::internal::collate_argument::rtrim);
-                return res;
-            }
-
-            self collate(std::string name) const {
-                auto res = *this;
-                res._collate_argument = std::move(name);
-                return res;
-            }
-
-            template<class C>
-            self collate() const {
-                std::stringstream ss;
-                ss << C::name();
-                auto name = ss.str();
-                ss.flush();
-                return this->collate(move(name));
-            }
-        };
-
-        /**
-         *  ORDER BY pack holder.
-         */
-        template<class... Args>
-        struct multi_order_by_t : order_by_string {
-            using args_type = std::tuple<Args...>;
-
-            args_type args;
-
-            multi_order_by_t(args_type&& args_) : args(std::move(args_)) {}
-        };
-
-        struct dynamic_order_by_entry_t : order_by_base {
-            std::string name;
-
-            dynamic_order_by_entry_t(decltype(name) name_, int asc_desc_, std::string collate_argument_) :
-                order_by_base{asc_desc_, move(collate_argument_)}, name(move(name_)) {}
-        };
-
-        /**
-         *  C - serializator context class
-         */
-        template<class C>
-        struct dynamic_order_by_t : order_by_string {
-            using context_t = C;
-            using entry_t = dynamic_order_by_entry_t;
-            using const_iterator = typename std::vector<entry_t>::const_iterator;
-
-            dynamic_order_by_t(const context_t& context_) : context(context_) {}
-
-            template<class O>
-            void push_back(order_by_t<O> order_by) {
-                auto newContext = this->context;
-                newContext.skip_table_name = true;
-                auto columnName = serialize(order_by.expression, newContext);
-                entries.emplace_back(move(columnName), order_by.asc_desc, move(order_by._collate_argument));
-            }
-
-            const_iterator begin() const {
-                return this->entries.begin();
-            }
-
-            const_iterator end() const {
-                return this->entries.end();
-            }
-
-            void clear() {
-                this->entries.clear();
-            }
-
-          protected:
-            std::vector<entry_t> entries;
-            context_t context;
-        };
-
-        template<class T>
-        struct is_order_by : std::false_type {};
-
-        template<class O>
-        struct is_order_by<order_by_t<O>> : std::true_type {};
-
-        template<class... Args>
-        struct is_order_by<multi_order_by_t<Args...>> : std::true_type {};
-
-        template<class C>
-        struct is_order_by<dynamic_order_by_t<C>> : std::true_type {};
-
-        struct between_string {
-            operator std::string() const {
-                return "BETWEEN";
-            }
-        };
-
-        /**
-         *  BETWEEN operator object.
-         */
-        template<class A, class T>
-        struct between_t : condition_t, between_string {
-            using expression_type = A;
-            using lower_type = T;
-            using upper_type = T;
-
-            expression_type expr;
-            lower_type b1;
-            upper_type b2;
-
-            between_t(expression_type expr_, lower_type b1_, upper_type b2_) :
-                expr(std::move(expr_)), b1(std::move(b1_)), b2(std::move(b2_)) {}
-        };
-
-        struct like_string {
-            operator std::string() const {
-                return "LIKE";
-            }
-        };
-
-        /**
-         *  LIKE operator object.
-         */
-        template<class A, class T, class E>
-        struct like_t : condition_t, like_string, negatable_t {
-            using self = like_t<A, T, E>;
-            using arg_t = A;
-            using pattern_t = T;
-            using escape_t = E;
-
-            arg_t arg;
-            pattern_t pattern;
-            optional_container<escape_t> arg3;  //  not escape cause escape exists as a function here
-
-            like_t(arg_t arg_, pattern_t pattern_, optional_container<escape_t> escape_) :
-                arg(std::move(arg_)), pattern(std::move(pattern_)), arg3(std::move(escape_)) {}
-
-            template<class C>
-            like_t<A, T, C> escape(C c) const {
-                optional_container<C> newArg3{std::move(c)};
-                return {std::move(this->arg), std::move(this->pattern), std::move(newArg3)};
-            }
-        };
-
-        struct glob_string {
-            operator std::string() const {
-                return "GLOB";
-            }
-        };
-
-        template<class A, class T>
-        struct glob_t : condition_t, glob_string, internal::negatable_t {
-            using self = glob_t<A, T>;
-            using arg_t = A;
-            using pattern_t = T;
-
-            arg_t arg;
-            pattern_t pattern;
-
-            glob_t(arg_t arg_, pattern_t pattern_) : arg(std::move(arg_)), pattern(std::move(pattern_)) {}
-        };
-
-        struct cross_join_string {
-            operator std::string() const {
-                return "CROSS JOIN";
-            }
-        };
-
-        /**
-         *  CROSS JOIN holder.
-         *  T is joined type which represents any mapped table.
-         */
-        template<class T>
-        struct cross_join_t : cross_join_string {
-            using type = T;
-        };
-
-        struct natural_join_string {
-            operator std::string() const {
-                return "NATURAL JOIN";
-            }
-        };
-
-        /**
-         *  NATURAL JOIN holder.
-         *  T is joined type which represents any mapped table.
-         */
-        template<class T>
-        struct natural_join_t : natural_join_string {
-            using type = T;
-        };
-
-        struct left_join_string {
-            operator std::string() const {
-                return "LEFT JOIN";
-            }
-        };
-
-        /**
-         *  LEFT JOIN holder.
-         *  T is joined type which represents any mapped table.
-         *  O is on(...) argument type.
-         */
-        template<class T, class O>
-        struct left_join_t : left_join_string {
-            using type = T;
-            using on_type = O;
-
-            on_type constraint;
-
-            left_join_t(on_type constraint_) : constraint(std::move(constraint_)) {}
-        };
-
-        struct join_string {
-            operator std::string() const {
-                return "JOIN";
-            }
-        };
-
-        /**
-         *  Simple JOIN holder.
-         *  T is joined type which represents any mapped table.
-         *  O is on(...) argument type.
-         */
-        template<class T, class O>
-        struct join_t : join_string {
-            using type = T;
-            using on_type = O;
-
-            on_type constraint;
-
-            join_t(on_type constraint_) : constraint(std::move(constraint_)) {}
-        };
-
-        struct left_outer_join_string {
-            operator std::string() const {
-                return "LEFT OUTER JOIN";
-            }
-        };
-
-        /**
-         *  LEFT OUTER JOIN holder.
-         *  T is joined type which represents any mapped table.
-         *  O is on(...) argument type.
-         */
-        template<class T, class O>
-        struct left_outer_join_t : left_outer_join_string {
-            using type = T;
-            using on_type = O;
-
-            on_type constraint;
-
-            left_outer_join_t(on_type constraint_) : constraint(std::move(constraint_)) {}
-        };
-
-        struct on_string {
-            operator std::string() const {
-                return "ON";
-            }
-        };
-
-        /**
-         *  on(...) argument holder used for JOIN, LEFT JOIN, LEFT OUTER JOIN and INNER JOIN
-         *  T is on type argument.
-         */
-        template<class T>
-        struct on_t : on_string {
-            using arg_type = T;
-
-            arg_type arg;
-
-            on_t(arg_type arg_) : arg(std::move(arg_)) {}
-        };
-
-        /**
-         *  USING argument holder.
-         */
-        template<class F, class O>
-        struct using_t {
-            F O::*column = nullptr;
-
-            operator std::string() const {
-                return "USING";
-            }
-        };
-
-        struct inner_join_string {
-            operator std::string() const {
-                return "INNER JOIN";
-            }
-        };
-
-        /**
-         *  INNER JOIN holder.
-         *  T is joined type which represents any mapped table.
-         *  O is on(...) argument type.
-         */
-        template<class T, class O>
-        struct inner_join_t : inner_join_string {
-            using type = T;
-            using on_type = O;
-
-            on_type constraint;
-
-            inner_join_t(on_type constraint_) : constraint(std::move(constraint_)) {}
-        };
-
-        struct exists_string {
-            operator std::string() const {
-                return "EXISTS";
-            }
-        };
-
-        template<class T>
-        struct exists_t : condition_t, exists_string, internal::negatable_t {
-            using type = T;
-            using self = exists_t<type>;
-
-            type t;
-
-            exists_t(T t_) : t(std::move(t_)) {}
-        };
-
-        struct cast_string {
-            operator std::string() const {
-                return "CAST";
-            }
-        };
-
-        /**
-         *  CAST holder.
-         *  T is a type to cast to
-         *  E is an expression type
-         *  Example: cast<std::string>(&User::id)
-         */
-        template<class T, class E>
-        struct cast_t : cast_string {
-            using to_type = T;
-            using expression_type = E;
-
-            expression_type expression;
-
-            cast_t(expression_type expression_) : expression(std::move(expression_)) {}
-        };
-
-        template<class... Args>
-        struct from_t {
-            using tuple_type = std::tuple<Args...>;
-        };
-
-        template<class T>
-        struct is_from : std::false_type {};
-
-        template<class... Args>
-        struct is_from<from_t<Args...>> : std::true_type {};
-    }
-
-    /**
-     *  Explicit FROM function. Usage:
-     *  `storage.select(&User::id, from<User>());`
-     */
-    template<class... Args>
-    internal::from_t<Args...> from() {
-        static_assert(std::tuple_size<std::tuple<Args...>>::value > 0, "");
-        return {};
-    }
-
-    template<class T, typename = typename std::enable_if<std::is_base_of<internal::negatable_t, T>::value>::type>
-    internal::negated_condition_t<T> operator!(T arg) {
-        return {std::move(arg)};
-    }
-
-    /**
-     *  Cute operators for columns
-     */
-    template<class T, class R>
-    internal::lesser_than_t<T, R> operator<(internal::expression_t<T> expr, R r) {
-        return {std::move(expr.value), std::move(r)};
-    }
-
-    template<class L, class T>
-    internal::lesser_than_t<L, T> operator<(L l, internal::expression_t<T> expr) {
-        return {std::move(l), std::move(expr.value)};
-    }
-
-    template<class T, class R>
-    internal::lesser_or_equal_t<T, R> operator<=(internal::expression_t<T> expr, R r) {
-        return {std::move(expr.value), std::move(r)};
-    }
-
-    template<class L, class T>
-    internal::lesser_or_equal_t<L, T> operator<=(L l, internal::expression_t<T> expr) {
-        return {std::move(l), std::move(expr.value)};
-    }
-
-    template<class T, class R>
-    internal::greater_than_t<T, R> operator>(internal::expression_t<T> expr, R r) {
-        return {std::move(expr.value), std::move(r)};
-    }
-
-    template<class L, class T>
-    internal::greater_than_t<L, T> operator>(L l, internal::expression_t<T> expr) {
-        return {std::move(l), std::move(expr.value)};
-    }
-
-    template<class T, class R>
-    internal::greater_or_equal_t<T, R> operator>=(internal::expression_t<T> expr, R r) {
-        return {std::move(expr.value), std::move(r)};
-    }
-
-    template<class L, class T>
-    internal::greater_or_equal_t<L, T> operator>=(L l, internal::expression_t<T> expr) {
-        return {std::move(l), std::move(expr.value)};
-    }
-
-    template<class T, class R>
-    internal::is_equal_t<T, R> operator==(internal::expression_t<T> expr, R r) {
-        return {std::move(expr.value), std::move(r)};
-    }
-
-    template<class L, class T>
-    internal::is_equal_t<L, T> operator==(L l, internal::expression_t<T> expr) {
-        return {std::move(l), std::move(expr.value)};
-    }
-
-    template<class T, class R>
-    internal::is_not_equal_t<T, R> operator!=(internal::expression_t<T> expr, R r) {
-        return {std::move(expr.value), std::move(r)};
-    }
-
-    template<class L, class T>
-    internal::is_not_equal_t<L, T> operator!=(L l, internal::expression_t<T> expr) {
-        return {std::move(l), std::move(expr.value)};
-    }
-
-    template<class T, class R>
-    internal::conc_t<T, R> operator||(internal::expression_t<T> expr, R r) {
-        return {std::move(expr.value), std::move(r)};
-    }
-
-    template<class L, class T>
-    internal::conc_t<L, T> operator||(L l, internal::expression_t<T> expr) {
-        return {std::move(l), std::move(expr.value)};
-    }
-
-    template<class L, class R>
-    internal::conc_t<L, R> operator||(internal::expression_t<L> l, internal::expression_t<R> r) {
-        return {std::move(l.value), std::move(r.value)};
-    }
-
-    template<class T, class R>
-    internal::add_t<T, R> operator+(internal::expression_t<T> expr, R r) {
-        return {std::move(expr.value), std::move(r)};
-    }
-
-    template<class L, class T>
-    internal::add_t<L, T> operator+(L l, internal::expression_t<T> expr) {
-        return {std::move(l), std::move(expr.value)};
-    }
-
-    template<class L, class R>
-    internal::add_t<L, R> operator+(internal::expression_t<L> l, internal::expression_t<R> r) {
-        return {std::move(l.value), std::move(r.value)};
-    }
-
-    template<class T, class R>
-    internal::sub_t<T, R> operator-(internal::expression_t<T> expr, R r) {
-        return {std::move(expr.value), std::move(r)};
-    }
-
-    template<class L, class T>
-    internal::sub_t<L, T> operator-(L l, internal::expression_t<T> expr) {
-        return {std::move(l), std::move(expr.value)};
-    }
-
-    template<class L, class R>
-    internal::sub_t<L, R> operator-(internal::expression_t<L> l, internal::expression_t<R> r) {
-        return {std::move(l.value), std::move(r.value)};
-    }
-
-    template<class T, class R>
-    internal::mul_t<T, R> operator*(internal::expression_t<T> expr, R r) {
-        return {std::move(expr.value), std::move(r)};
-    }
-
-    template<class L, class T>
-    internal::mul_t<L, T> operator*(L l, internal::expression_t<T> expr) {
-        return {std::move(l), std::move(expr.value)};
-    }
-
-    template<class L, class R>
-    internal::mul_t<L, R> operator*(internal::expression_t<L> l, internal::expression_t<R> r) {
-        return {std::move(l.value), std::move(r.value)};
-    }
-
-    template<class T, class R>
-    internal::div_t<T, R> operator/(internal::expression_t<T> expr, R r) {
-        return {std::move(expr.value), std::move(r)};
-    }
-
-    template<class L, class T>
-    internal::div_t<L, T> operator/(L l, internal::expression_t<T> expr) {
-        return {std::move(l), std::move(expr.value)};
-    }
-
-    template<class L, class R>
-    internal::div_t<L, R> operator/(internal::expression_t<L> l, internal::expression_t<R> r) {
-        return {std::move(l.value), std::move(r.value)};
-    }
-
-    template<class T, class R>
-    internal::mod_t<T, R> operator%(internal::expression_t<T> expr, R r) {
-        return {std::move(expr.value), std::move(r)};
-    }
-
-    template<class L, class T>
-    internal::mod_t<L, T> operator%(L l, internal::expression_t<T> expr) {
-        return {std::move(l), std::move(expr.value)};
-    }
-
-    template<class L, class R>
-    internal::mod_t<L, R> operator%(internal::expression_t<L> l, internal::expression_t<R> r) {
-        return {std::move(l.value), std::move(r.value)};
-    }
-
-    template<class F, class O>
-    internal::using_t<F, O> using_(F O::*p) {
-        return {std::move(p)};
-    }
-
-    template<class T>
-    internal::on_t<T> on(T t) {
-        return {std::move(t)};
-    }
-
-    template<class T>
-    internal::cross_join_t<T> cross_join() {
-        return {};
-    }
-
-    template<class T>
-    internal::natural_join_t<T> natural_join() {
-        return {};
-    }
-
-    template<class T, class O>
-    internal::left_join_t<T, O> left_join(O o) {
-        return {std::move(o)};
-    }
-
-    template<class T, class O>
-    internal::join_t<T, O> join(O o) {
-        return {std::move(o)};
-    }
-
-    template<class T, class O>
-    internal::left_outer_join_t<T, O> left_outer_join(O o) {
-        return {std::move(o)};
-    }
-
-    template<class T, class O>
-    internal::inner_join_t<T, O> inner_join(O o) {
-        return {std::move(o)};
-    }
-
-    template<class T>
-    internal::offset_t<T> offset(T off) {
-        return {std::move(off)};
-    }
-
-    template<class T>
-    internal::limit_t<T, false, false, void> limit(T lim) {
-        return {std::move(lim)};
-    }
-
-    template<class T, class O>
-    typename std::enable_if<!internal::is_offset<T>::value, internal::limit_t<T, true, true, O>>::type limit(O off,
-                                                                                                             T lim) {
-        return {std::move(lim), {std::move(off)}};
-    }
-
-    template<class T, class O>
-    internal::limit_t<T, true, false, O> limit(T lim, internal::offset_t<O> offt) {
-        return {std::move(lim), {std::move(offt.off)}};
-    }
-
-    template<class L,
-             class R,
-             typename = typename std::enable_if<std::is_base_of<internal::condition_t, L>::value ||
-                                                std::is_base_of<internal::condition_t, R>::value>::type>
-    auto operator&&(L l, R r) {
-        using internal::get_from_expression;
-        return internal::make_and_condition(std::move(get_from_expression(l)), std::move(get_from_expression(r)));
-    }
-
-    template<class L, class R>
-    auto and_(L l, R r) {
-        using internal::get_from_expression;
-        return internal::make_and_condition(std::move(get_from_expression(l)), std::move(get_from_expression(r)));
-    }
-
-    template<class L,
-             class R,
-             typename = typename std::enable_if<std::is_base_of<internal::condition_t, L>::value ||
-                                                std::is_base_of<internal::condition_t, R>::value>::type>
-    auto operator||(L l, R r) {
-        using internal::get_from_expression;
-        return internal::make_or_condition(std::move(get_from_expression(l)), std::move(get_from_expression(r)));
-    }
-
-    template<class L, class R>
-    auto or_(L l, R r) {
-        using internal::get_from_expression;
-        return internal::make_or_condition(std::move(get_from_expression(l)), std::move(get_from_expression(r)));
-    }
-
-    template<class T>
-    internal::is_not_null_t<T> is_not_null(T t) {
-        return {std::move(t)};
-    }
-
-    template<class T>
-    internal::is_null_t<T> is_null(T t) {
-        return {std::move(t)};
-    }
-
-    template<class L, class E>
-    internal::dynamic_in_t<L, std::vector<E>> in(L l, std::vector<E> values) {
-        return {std::move(l), std::move(values), false};
-    }
-
-    template<class L, class E>
-    internal::dynamic_in_t<L, std::vector<E>> in(L l, std::initializer_list<E> values) {
-        return {std::move(l), std::move(values), false};
-    }
-
-    template<class L, class A>
-    internal::dynamic_in_t<L, A> in(L l, A arg) {
-        return {std::move(l), std::move(arg), false};
-    }
-
-    template<class L, class E>
-    internal::dynamic_in_t<L, std::vector<E>> not_in(L l, std::vector<E> values) {
-        return {std::move(l), std::move(values), true};
-    }
-
-    template<class L, class E>
-    internal::dynamic_in_t<L, std::vector<E>> not_in(L l, std::initializer_list<E> values) {
-        return {std::move(l), std::move(values), true};
-    }
-
-    template<class L, class A>
-    internal::dynamic_in_t<L, A> not_in(L l, A arg) {
-        return {std::move(l), std::move(arg), true};
-    }
-
-    template<class L, class R>
-    internal::is_equal_t<L, R> is_equal(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::is_equal_t<L, R> eq(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::is_not_equal_t<L, R> is_not_equal(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::is_not_equal_t<L, R> ne(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::greater_than_t<L, R> greater_than(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::greater_than_t<L, R> gt(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::greater_or_equal_t<L, R> greater_or_equal(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::greater_or_equal_t<L, R> ge(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::lesser_than_t<L, R> lesser_than(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::lesser_than_t<L, R> lt(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::lesser_or_equal_t<L, R> lesser_or_equal(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L, class R>
-    internal::lesser_or_equal_t<L, R> le(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    /**
-     * ORDER BY column
-     * Example: storage.select(&User::name, order_by(&User::id))
-     */
-    template<class O>
-    internal::order_by_t<O> order_by(O o) {
-        return {std::move(o)};
-    }
-
-    /**
-     * ORDER BY column1, column2
-     * Example: storage.get_all<Singer>(multi_order_by(order_by(&Singer::name).asc(), order_by(&Singer::gender).desc())
-     */
-    template<class... Args>
-    internal::multi_order_by_t<Args...> multi_order_by(Args&&... args) {
-        return {std::make_tuple(std::forward<Args>(args)...)};
-    }
-
-    /**
-     * ORDER BY column1, column2
-     * Difference from `multi_order_by` is that `dynamic_order_by` can be changed at runtime using `push_back` member
-     * function Example:
-     *  auto orderBy = dynamic_order_by(storage);
-     *  if(someCondition) {
-     *      orderBy.push_back(&User::id);
-     *  } else {
-     *      orderBy.push_back(&User::name);
-     *      orderBy.push_back(&User::birthDate);
-     *  }
-     */
-    template<class S>
-    internal::dynamic_order_by_t<internal::serializator_context<typename S::impl_type>>
-    dynamic_order_by(const S& storage) {
-        internal::serializator_context_builder<S> builder(storage);
-        return builder();
-    }
-
-    /**
-     *  X BETWEEN Y AND Z
-     *  Example: storage.select(between(&User::id, 10, 20))
-     */
-    template<class A, class T>
-    internal::between_t<A, T> between(A expr, T b1, T b2) {
-        return {std::move(expr), std::move(b1), std::move(b2)};
-    }
-
-    /**
-     *  X LIKE Y
-     *  Example: storage.select(like(&User::name, "T%"))
-     */
-    template<class A, class T>
-    internal::like_t<A, T, void> like(A a, T t) {
-        return {std::move(a), std::move(t), {}};
-    }
-
-    /**
-     *  X GLOB Y
-     *  Example: storage.select(glob(&User::name, "*S"))
-     */
-    template<class A, class T>
-    internal::glob_t<A, T> glob(A a, T t) {
-        return {std::move(a), std::move(t)};
-    }
-
-    /**
-     *  X LIKE Y ESCAPE Z
-     *  Example: storage.select(like(&User::name, "T%", "%"))
-     */
-    template<class A, class T, class E>
-    internal::like_t<A, T, E> like(A a, T t, E e) {
-        return {std::move(a), std::move(t), {std::move(e)}};
-    }
-
-    /**
-     *  EXISTS(condition).
-     *  Example: storage.select(columns(&Agent::code, &Agent::name, &Agent::workingArea, &Agent::comission),
-         where(exists(select(asterisk<Customer>(),
-         where(is_equal(&Customer::grade, 3) and
-         is_equal(&Agent::code, &Customer::agentCode))))),
-         order_by(&Agent::comission));
-     */
-    template<class T>
-    internal::exists_t<T> exists(T t) {
-        return {std::move(t)};
-    }
-
-    /**
-     *  CAST(X AS type).
-     *  Example: cast<std::string>(&User::id)
-     */
-    template<class T, class E>
-    internal::cast_t<T, E> cast(E e) {
-        return {std::move(e)};
-    }
-}
-#pragma once
-
-#include <type_traits>  //  std::enable_if, std::is_base_of, std::is_member_pointer
-#include <sstream>  //  std::stringstream
-#include <string>  //  std::string
-
-namespace sqlite_orm {
-
-    /**
-     *  This is base class for every class which is used as a custom table alias.
-     *  For more information please look through self_join.cpp example
-     */
-    struct alias_tag {};
-
-    namespace internal {
-
-        /**
-         *  This is a common built-in class used for custom single character table aliases.
-         *  Also you can use language aliases `alias_a`, `alias_b` etc. instead
-         */
-        template<class T, char A>
-        struct table_alias : alias_tag {
-            using type = T;
-
-            static char get() {
-                return A;
-            }
-        };
-
-        /**
-         *  Column expression with table alias attached like 'C.ID'. This is not a column alias
-         */
-        template<class T, class C>
-        struct alias_column_t {
-            using alias_type = T;
-            using column_type = C;
-
-            column_type column;
-
-            alias_column_t(){};
-
-            alias_column_t(column_type column_) : column(std::move(column_)) {}
-        };
-
-        template<class T, class SFINAE = void>
-        struct alias_extractor;
-
-        template<class T>
-        struct alias_extractor<T, typename std::enable_if<std::is_base_of<alias_tag, T>::value>::type> {
-            static std::string get() {
-                std::stringstream ss;
-                ss << T::get();
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct alias_extractor<T, typename std::enable_if<!std::is_base_of<alias_tag, T>::value>::type> {
-            static std::string get() {
-                return {};
-            }
-        };
-
-        /**
-         * Used to store alias for expression
-         */
-        template<class T, class E>
-        struct as_t {
-            using alias_type = T;
-            using expression_type = E;
-
-            expression_type expression;
-        };
-
-        template<class T>
-        struct alias_holder {
-            using type = T;
-        };
-    }
-
-    /**
-     *  @return column with table alias attached. Place it instead of a column statement in case you need to specify a
-     *  column with table alias prefix like 'a.column'. For more information please look through self_join.cpp example
-     */
-    template<class T, class C>
-    internal::alias_column_t<T, C> alias_column(C c) {
-        static_assert(std::is_member_pointer<C>::value,
-                      "alias_column argument must be a member pointer mapped to a storage");
-        return {c};
-    }
-
-    template<class T, class E>
-    internal::as_t<T, E> as(E expression) {
-        return {std::move(expression)};
-    }
-
-    template<class T>
-    internal::alias_holder<T> get() {
-        return {};
-    }
-
-    template<class T>
-    using alias_a = internal::table_alias<T, 'a'>;
-    template<class T>
-    using alias_b = internal::table_alias<T, 'b'>;
-    template<class T>
-    using alias_c = internal::table_alias<T, 'c'>;
-    template<class T>
-    using alias_d = internal::table_alias<T, 'd'>;
-    template<class T>
-    using alias_e = internal::table_alias<T, 'e'>;
-    template<class T>
-    using alias_f = internal::table_alias<T, 'f'>;
-    template<class T>
-    using alias_g = internal::table_alias<T, 'g'>;
-    template<class T>
-    using alias_h = internal::table_alias<T, 'h'>;
-    template<class T>
-    using alias_i = internal::table_alias<T, 'i'>;
-    template<class T>
-    using alias_j = internal::table_alias<T, 'j'>;
-    template<class T>
-    using alias_k = internal::table_alias<T, 'k'>;
-    template<class T>
-    using alias_l = internal::table_alias<T, 'l'>;
-    template<class T>
-    using alias_m = internal::table_alias<T, 'm'>;
-    template<class T>
-    using alias_n = internal::table_alias<T, 'n'>;
-    template<class T>
-    using alias_o = internal::table_alias<T, 'o'>;
-    template<class T>
-    using alias_p = internal::table_alias<T, 'p'>;
-    template<class T>
-    using alias_q = internal::table_alias<T, 'q'>;
-    template<class T>
-    using alias_r = internal::table_alias<T, 'r'>;
-    template<class T>
-    using alias_s = internal::table_alias<T, 's'>;
-    template<class T>
-    using alias_t = internal::table_alias<T, 't'>;
-    template<class T>
-    using alias_u = internal::table_alias<T, 'u'>;
-    template<class T>
-    using alias_v = internal::table_alias<T, 'v'>;
-    template<class T>
-    using alias_w = internal::table_alias<T, 'w'>;
-    template<class T>
-    using alias_x = internal::table_alias<T, 'x'>;
-    template<class T>
-    using alias_y = internal::table_alias<T, 'y'>;
-    template<class T>
-    using alias_z = internal::table_alias<T, 'z'>;
-}
-#pragma once
-
-// #include "conditions.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        template<class... Args>
-        struct join_iterator;
-
-        template<>
-        struct join_iterator<> {
-
-            template<class L>
-            void operator()(const L&) const {
-                //..
-            }
-        };
-
-        template<class H, class... Tail>
-        struct join_iterator<H, Tail...> : public join_iterator<Tail...> {
-            using super = join_iterator<Tail...>;
-
-            template<class L>
-            void operator()(const L& l) const {
-                this->super::operator()(l);
-            }
-        };
-
-        template<class T, class... Tail>
-        struct join_iterator<cross_join_t<T>, Tail...> : public join_iterator<Tail...> {
-            using super = join_iterator<Tail...>;
-            using join_type = cross_join_t<T>;
-
-            template<class L>
-            void operator()(const L& l) const {
-                l(*this);
-                this->super::operator()(l);
-            }
-        };
-
-        template<class T, class... Tail>
-        struct join_iterator<natural_join_t<T>, Tail...> : public join_iterator<Tail...> {
-            using super = join_iterator<Tail...>;
-            using join_type = natural_join_t<T>;
-
-            template<class L>
-            void operator()(const L& l) const {
-                l(*this);
-                this->super::operator()(l);
-            }
-        };
-
-        template<class T, class O, class... Tail>
-        struct join_iterator<left_join_t<T, O>, Tail...> : public join_iterator<Tail...> {
-            using super = join_iterator<Tail...>;
-            using join_type = left_join_t<T, O>;
-
-            template<class L>
-            void operator()(const L& l) const {
-                l(*this);
-                this->super::operator()(l);
-            }
-        };
-
-        template<class T, class O, class... Tail>
-        struct join_iterator<join_t<T, O>, Tail...> : public join_iterator<Tail...> {
-            using super = join_iterator<Tail...>;
-            using join_type = join_t<T, O>;
-
-            template<class L>
-            void operator()(const L& l) const {
-                l(*this);
-                this->super::operator()(l);
-            }
-        };
-
-        template<class T, class O, class... Tail>
-        struct join_iterator<left_outer_join_t<T, O>, Tail...> : public join_iterator<Tail...> {
-            using super = join_iterator<Tail...>;
-            using join_type = left_outer_join_t<T, O>;
-
-            template<class L>
-            void operator()(const L& l) const {
-                l(*this);
-                this->super::operator()(l);
-            }
-        };
-
-        template<class T, class O, class... Tail>
-        struct join_iterator<inner_join_t<T, O>, Tail...> : public join_iterator<Tail...> {
-            using super = join_iterator<Tail...>;
-            using join_type = inner_join_t<T, O>;
-
-            template<class L>
-            void operator()(const L& l) const {
-                l(*this);
-                this->super::operator()(l);
-            }
-        };
-    }
-}
-#pragma once
-
-#include <string>  //  std::string
-#include <tuple>  //  std::make_tuple, std::tuple_size
-#include <type_traits>  //  std::forward, std::is_base_of, std::enable_if
-#include <memory>  //  std::unique_ptr
-#include <vector>  //  std::vector
-
-// #include "conditions.h"
-
-// #include "operators.h"
-
-// #include "is_base_of_template.h"
-
-#include <type_traits>  //  std::true_type, std::false_type, std::declval
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /*
-         * This is because of bug in MSVC, for more information, please visit
-         * https://stackoverflow.com/questions/34672441/stdis-base-of-for-template-classes/34672753#34672753
-         */
-#if defined(_MSC_VER)
-        template<template<typename...> class Base, typename Derived>
-        struct is_base_of_template_impl {
-            template<typename... Ts>
-            static constexpr std::true_type test(const Base<Ts...>*);
-
-            static constexpr std::false_type test(...);
-
-            using type = decltype(test(std::declval<Derived*>()));
-        };
-
-        template<typename Derived, template<typename...> class Base>
-        using is_base_of_template = typename is_base_of_template_impl<Base, Derived>::type;
-
-#else
-        template<template<typename...> class C, typename... Ts>
-        std::true_type is_base_of_template_impl(const C<Ts...>*);
-
-        template<template<typename...> class C>
-        std::false_type is_base_of_template_impl(...);
-
-        template<typename T, template<typename...> class C>
-        using is_base_of_template = decltype(is_base_of_template_impl<C>(std::declval<T*>()));
-#endif
-    }
-}
-
-// #include "serialize_result_type.h"
-
-#ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
-#include <string_view>  //  string_view
-#else
-#include <string>  //  std::string
-#endif
-
-namespace sqlite_orm {
-    namespace internal {
-#ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
-        using serialize_result_type = std::string_view;
-#else
-        using serialize_result_type = std::string;
-#endif
-    }
-}
-
-namespace sqlite_orm {
-
-    using int64 = sqlite_int64;
-    using uint64 = sqlite_uint64;
-
-    namespace internal {
-
-        template<class T>
-        struct is_into;
-
-        template<class T>
-        struct unique_ptr_result_of {};
-
-        /**
-         *  Base class for operator overloading
-         *  R - return type
-         *  S - class with operator std::string
-         *  Args - function arguments types
-         */
-        template<class R, class S, class... Args>
-        struct built_in_function_t : S, arithmetic_t {
-            using return_type = R;
-            using string_type = S;
-            using args_type = std::tuple<Args...>;
-
-            static constexpr const size_t args_size = std::tuple_size<args_type>::value;
-
-            args_type args;
-
-            built_in_function_t(args_type&& args_) : args(std::move(args_)) {}
-        };
-
-        struct typeof_string {
-            serialize_result_type serialize() const {
-                return "TYPEOF";
-            }
-        };
-
-        struct unicode_string {
-            serialize_result_type serialize() const {
-                return "UNICODE";
-            }
-        };
-
-        struct length_string {
-            serialize_result_type serialize() const {
-                return "LENGTH";
-            }
-        };
-
-        struct abs_string {
-            serialize_result_type serialize() const {
-                return "ABS";
-            }
-        };
-
-        struct lower_string {
-            serialize_result_type serialize() const {
-                return "LOWER";
-            }
-        };
-
-        struct upper_string {
-            serialize_result_type serialize() const {
-                return "UPPER";
-            }
-        };
-
-        struct last_insert_rowid_string {
-            serialize_result_type serialize() const {
-                return "LAST_INSERT_ROWID";
-            }
-        };
-
-        struct total_changes_string {
-            serialize_result_type serialize() const {
-                return "TOTAL_CHANGES";
-            }
-        };
-
-        struct changes_string {
-            serialize_result_type serialize() const {
-                return "CHANGES";
-            }
-        };
-
-        struct trim_string {
-            serialize_result_type serialize() const {
-                return "TRIM";
-            }
-        };
-
-        struct ltrim_string {
-            serialize_result_type serialize() const {
-                return "LTRIM";
-            }
-        };
-
-        struct rtrim_string {
-            serialize_result_type serialize() const {
-                return "RTRIM";
-            }
-        };
-
-        struct hex_string {
-            serialize_result_type serialize() const {
-                return "HEX";
-            }
-        };
-
-        struct quote_string {
-            serialize_result_type serialize() const {
-                return "QUOTE";
-            }
-        };
-
-        struct randomblob_string {
-            serialize_result_type serialize() const {
-                return "RANDOMBLOB";
-            }
-        };
-
-        struct instr_string {
-            serialize_result_type serialize() const {
-                return "INSTR";
-            }
-        };
-
-        struct replace_string {
-            serialize_result_type serialize() const {
-                return "REPLACE";
-            }
-        };
-
-        struct round_string {
-            serialize_result_type serialize() const {
-                return "ROUND";
-            }
-        };
-
-#if SQLITE_VERSION_NUMBER >= 3007016
-
-        struct char_string {
-            serialize_result_type serialize() const {
-                return "CHAR";
-            }
-        };
-
-        struct random_string {
-            serialize_result_type serialize() const {
-                return "RANDOM";
-            }
-        };
-
-#endif
-
-        struct coalesce_string {
-            serialize_result_type serialize() const {
-                return "COALESCE";
-            }
-        };
-
-        struct ifnull_string {
-            serialize_result_type serialize() const {
-                return "IFNULL";
-            }
-        };
-
-        struct date_string {
-            serialize_result_type serialize() const {
-                return "DATE";
-            }
-        };
-
-        struct time_string {
-            serialize_result_type serialize() const {
-                return "TIME";
-            }
-        };
-
-        struct datetime_string {
-            serialize_result_type serialize() const {
-                return "DATETIME";
-            }
-        };
-
-        struct julianday_string {
-            serialize_result_type serialize() const {
-                return "JULIANDAY";
-            }
-        };
-
-        struct strftime_string {
-            serialize_result_type serialize() const {
-                return "STRFTIME";
-            }
-        };
-
-        struct zeroblob_string {
-            serialize_result_type serialize() const {
-                return "ZEROBLOB";
-            }
-        };
-
-        struct substr_string {
-            serialize_result_type serialize() const {
-                return "SUBSTR";
-            }
-        };
-#ifdef SQLITE_SOUNDEX
-        struct soundex_string {
-            serialize_result_type serialize() const {
-                return "SOUNDEX";
-            }
-        };
-#endif
-        struct total_string {
-            serialize_result_type serialize() const {
-                return "TOTAL";
-            }
-        };
-
-        struct sum_string {
-            serialize_result_type serialize() const {
-                return "SUM";
-            }
-        };
-
-        struct count_string {
-            serialize_result_type serialize() const {
-                return "COUNT";
-            }
-        };
-
-        /**
-         *  T is use to specify type explicitly for queries like
-         *  SELECT COUNT(*) FROM table_name;
-         *  T can be omitted with void.
-         */
-        template<class T>
-        struct count_asterisk_t : count_string {
-            using type = T;
-        };
-
-        /**
-         *  The same thing as count<T>() but without T arg.
-         *  Is used in cases like this:
-         *    SELECT cust_code, cust_name, cust_city, grade
-         *    FROM customer
-         *    WHERE grade=2 AND EXISTS
-         *        (SELECT COUNT(*)
-         *        FROM customer
-         *        WHERE grade=2
-         *        GROUP BY grade
-         *        HAVING COUNT(*)>2);
-         *  `c++`
-         *  auto rows =
-         *      storage.select(columns(&Customer::code, &Customer::name, &Customer::city, &Customer::grade),
-         *          where(is_equal(&Customer::grade, 2)
-         *              and exists(select(count<Customer>(),
-         *                  where(is_equal(&Customer::grade, 2)),
-         *          group_by(&Customer::grade),
-         *          having(greater_than(count(), 2))))));
-         */
-        struct count_asterisk_without_type : count_string {};
-
-        struct avg_string {
-            serialize_result_type serialize() const {
-                return "AVG";
-            }
-        };
-
-        struct max_string {
-            serialize_result_type serialize() const {
-                return "MAX";
-            }
-        };
-
-        struct min_string {
-            serialize_result_type serialize() const {
-                return "MIN";
-            }
-        };
-
-        struct group_concat_string {
-            serialize_result_type serialize() const {
-                return "GROUP_CONCAT";
-            }
-        };
-#ifdef SQLITE_ENABLE_MATH_FUNCTIONS
-        struct acos_string {
-            serialize_result_type serialize() const {
-                return "ACOS";
-            }
-        };
-
-        struct acosh_string {
-            serialize_result_type serialize() const {
-                return "ACOSH";
-            }
-        };
-
-        struct asin_string {
-            serialize_result_type serialize() const {
-                return "ASIN";
-            }
-        };
-
-        struct asinh_string {
-            serialize_result_type serialize() const {
-                return "ASINH";
-            }
-        };
-
-        struct atan_string {
-            serialize_result_type serialize() const {
-                return "ATAN";
-            }
-        };
-
-        struct atan2_string {
-            serialize_result_type serialize() const {
-                return "ATAN2";
-            }
-        };
-
-        struct atanh_string {
-            serialize_result_type serialize() const {
-                return "ATANH";
-            }
-        };
-
-        struct ceil_string {
-            serialize_result_type serialize() const {
-                return "CEIL";
-            }
-        };
-
-        struct ceiling_string {
-            serialize_result_type serialize() const {
-                return "CEILING";
-            }
-        };
-
-        struct cos_string {
-            serialize_result_type serialize() const {
-                return "COS";
-            }
-        };
-
-        struct cosh_string {
-            serialize_result_type serialize() const {
-                return "COSH";
-            }
-        };
-
-        struct degrees_string {
-            serialize_result_type serialize() const {
-                return "DEGREES";
-            }
-        };
-
-        struct exp_string {
-            serialize_result_type serialize() const {
-                return "EXP";
-            }
-        };
-
-        struct floor_string {
-            serialize_result_type serialize() const {
-                return "FLOOR";
-            }
-        };
-
-        struct ln_string {
-            serialize_result_type serialize() const {
-                return "LN";
-            }
-        };
-
-        struct log_string {
-            serialize_result_type serialize() const {
-                return "LOG";
-            }
-        };
-
-        struct log10_string {
-            serialize_result_type serialize() const {
-                return "LOG10";
-            }
-        };
-
-        struct log2_string {
-            serialize_result_type serialize() const {
-                return "LOG2";
-            }
-        };
-
-        struct mod_string {
-            serialize_result_type serialize() const {
-                return "MOD";
-            }
-        };
-
-        struct pi_string {
-            serialize_result_type serialize() const {
-                return "PI";
-            }
-        };
-
-        struct pow_string {
-            serialize_result_type serialize() const {
-                return "POW";
-            }
-        };
-
-        struct power_string {
-            serialize_result_type serialize() const {
-                return "POWER";
-            }
-        };
-
-        struct radians_string {
-            serialize_result_type serialize() const {
-                return "RADIANS";
-            }
-        };
-
-        struct sin_string {
-            serialize_result_type serialize() const {
-                return "SIN";
-            }
-        };
-
-        struct sinh_string {
-            serialize_result_type serialize() const {
-                return "SINH";
-            }
-        };
-
-        struct sqrt_string {
-            serialize_result_type serialize() const {
-                return "SQRT";
-            }
-        };
-
-        struct tan_string {
-            serialize_result_type serialize() const {
-                return "TAN";
-            }
-        };
-
-        struct tanh_string {
-            serialize_result_type serialize() const {
-                return "TANH";
-            }
-        };
-
-        struct trunc_string {
-            serialize_result_type serialize() const {
-                return "TRUNC";
-            }
-        };
-
-#endif  //  SQLITE_ENABLE_MATH_FUNCTIONS
-#ifdef SQLITE_ENABLE_JSON1
-        struct json_string {
-            serialize_result_type serialize() const {
-                return "JSON";
-            }
-        };
-
-        struct json_array_string {
-            serialize_result_type serialize() const {
-                return "JSON_ARRAY";
-            }
-        };
-
-        struct json_array_length_string {
-            serialize_result_type serialize() const {
-                return "JSON_ARRAY_LENGTH";
-            }
-        };
-
-        struct json_extract_string {
-            serialize_result_type serialize() const {
-                return "JSON_EXTRACT";
-            }
-        };
-
-        struct json_insert_string {
-            serialize_result_type serialize() const {
-                return "JSON_INSERT";
-            }
-        };
-
-        struct json_replace_string {
-            serialize_result_type serialize() const {
-                return "JSON_REPLACE";
-            }
-        };
-
-        struct json_set_string {
-            serialize_result_type serialize() const {
-                return "JSON_SET";
-            }
-        };
-
-        struct json_object_string {
-            serialize_result_type serialize() const {
-                return "JSON_OBJECT";
-            }
-        };
-
-        struct json_patch_string {
-            serialize_result_type serialize() const {
-                return "JSON_PATCH";
-            }
-        };
-
-        struct json_remove_string {
-            serialize_result_type serialize() const {
-                return "JSON_REMOVE";
-            }
-        };
-
-        struct json_type_string {
-            serialize_result_type serialize() const {
-                return "JSON_TYPE";
-            }
-        };
-
-        struct json_valid_string {
-            serialize_result_type serialize() const {
-                return "JSON_VALID";
-            }
-        };
-
-        struct json_quote_string {
-            serialize_result_type serialize() const {
-                return "JSON_QUOTE";
-            }
-        };
-
-        struct json_group_array_string {
-            serialize_result_type serialize() const {
-                return "JSON_GROUP_ARRAY";
-            }
-        };
-
-        struct json_group_object_string {
-            serialize_result_type serialize() const {
-                return "JSON_GROUP_OBJECT";
-            }
-        };
-#endif  //  SQLITE_ENABLE_JSON1
-    }
-
-    /**
-     *  Cute operators for core functions
-     */
-    template<class F,
-             class R,
-             typename =
-                 typename std::enable_if<internal::is_base_of_template<F, internal::built_in_function_t>::value>::type>
-    internal::lesser_than_t<F, R> operator<(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F,
-             class R,
-             typename =
-                 typename std::enable_if<internal::is_base_of_template<F, internal::built_in_function_t>::value>::type>
-    internal::lesser_or_equal_t<F, R> operator<=(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F,
-             class R,
-             typename =
-                 typename std::enable_if<internal::is_base_of_template<F, internal::built_in_function_t>::value>::type>
-    internal::greater_than_t<F, R> operator>(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F,
-             class R,
-             typename =
-                 typename std::enable_if<internal::is_base_of_template<F, internal::built_in_function_t>::value>::type>
-    internal::greater_or_equal_t<F, R> operator>=(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F,
-             class R,
-             typename =
-                 typename std::enable_if<internal::is_base_of_template<F, internal::built_in_function_t>::value>::type>
-    internal::is_equal_t<F, R> operator==(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F,
-             class R,
-             typename =
-                 typename std::enable_if<internal::is_base_of_template<F, internal::built_in_function_t>::value>::type>
-    internal::is_not_equal_t<F, R> operator!=(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-#ifdef SQLITE_ENABLE_MATH_FUNCTIONS
-
-    /**
-     *  ACOS(X) function https://www.sqlite.org/lang_mathfunc.html#acos
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::acos(&Triangle::cornerA));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::acos_string, X> acos(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  ACOS(X) function https://www.sqlite.org/lang_mathfunc.html#acos
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::acos<std::optional<double>>(&Triangle::cornerA));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::acos_string, X> acos(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  ACOSH(X) function https://www.sqlite.org/lang_mathfunc.html#acosh
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::acosh(&Triangle::cornerA));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::acosh_string, X> acosh(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  ACOSH(X) function https://www.sqlite.org/lang_mathfunc.html#acosh
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::acosh<std::optional<double>>(&Triangle::cornerA));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::acosh_string, X> acosh(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  ASIN(X) function https://www.sqlite.org/lang_mathfunc.html#asin
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::asin(&Triangle::cornerA));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::asin_string, X> asin(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  ASIN(X) function https://www.sqlite.org/lang_mathfunc.html#asin
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::asin<std::optional<double>>(&Triangle::cornerA));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::asin_string, X> asin(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  ASINH(X) function https://www.sqlite.org/lang_mathfunc.html#asinh
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::asinh(&Triangle::cornerA));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::asinh_string, X> asinh(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  ASINH(X) function https://www.sqlite.org/lang_mathfunc.html#asinh
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::asinh<std::optional<double>>(&Triangle::cornerA));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::asinh_string, X> asinh(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  ATAN(X) function https://www.sqlite.org/lang_mathfunc.html#atan
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::atan(1));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::atan_string, X> atan(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  ATAN(X) function https://www.sqlite.org/lang_mathfunc.html#atan
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::atan<std::optional<double>>(1));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::atan_string, X> atan(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  ATAN2(X, Y) function https://www.sqlite.org/lang_mathfunc.html#atan2
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::atan2(1, 3));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X, class Y>
-    internal::built_in_function_t<double, internal::atan2_string, X, Y> atan2(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    /**
-     *  ATAN2(X, Y) function https://www.sqlite.org/lang_mathfunc.html#atan2
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::atan2<std::optional<double>>(1, 3));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X, class Y>
-    internal::built_in_function_t<R, internal::atan2_string, X, Y> atan2(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    /**
-     *  ATANH(X) function https://www.sqlite.org/lang_mathfunc.html#atanh
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::atanh(1));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::atanh_string, X> atanh(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  ATANH(X) function https://www.sqlite.org/lang_mathfunc.html#atanh
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::atanh<std::optional<double>>(1));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::atanh_string, X> atanh(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  CEIL(X) function https://www.sqlite.org/lang_mathfunc.html#ceil
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::ceil(&User::rating));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::ceil_string, X> ceil(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  CEIL(X) function https://www.sqlite.org/lang_mathfunc.html#ceil
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::ceil<std::optional<double>>(&User::rating));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::ceil_string, X> ceil(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  CEILING(X) function https://www.sqlite.org/lang_mathfunc.html#ceil
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::ceiling(&User::rating));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::ceiling_string, X> ceiling(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  CEILING(X) function https://www.sqlite.org/lang_mathfunc.html#ceil
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::ceiling<std::optional<double>>(&User::rating));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::ceiling_string, X> ceiling(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  COS(X) function https://www.sqlite.org/lang_mathfunc.html#cos
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::cos(&Triangle::cornerB));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::cos_string, X> cos(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  COS(X) function https://www.sqlite.org/lang_mathfunc.html#cos
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::cos<std::optional<double>>(&User::rating));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::cos_string, X> cos(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  COSH(X) function https://www.sqlite.org/lang_mathfunc.html#cosh
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::cosh(&Triangle::cornerB));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::cosh_string, X> cosh(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  COSH(X)  function https://www.sqlite.org/lang_mathfunc.html#cosh
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::cosh<std::optional<double>>(&User::rating));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::cosh_string, X> cosh(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  DEGREES(X) function https://www.sqlite.org/lang_mathfunc.html#degrees
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::degrees(&Triangle::cornerB));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::degrees_string, X> degrees(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  DEGREES(X) function https://www.sqlite.org/lang_mathfunc.html#degrees
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::degrees<std::optional<double>>(&User::rating));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::degrees_string, X> degrees(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  EXP(X) function https://www.sqlite.org/lang_mathfunc.html#exp
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::exp(&Triangle::cornerB));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::exp_string, X> exp(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  EXP(X) function https://www.sqlite.org/lang_mathfunc.html#exp
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::exp<std::optional<double>>(&User::rating));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::exp_string, X> exp(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  FLOOR(X) function https://www.sqlite.org/lang_mathfunc.html#floor
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::floor(&User::rating));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::floor_string, X> floor(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  FLOOR(X) function https://www.sqlite.org/lang_mathfunc.html#floor
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::floor<std::optional<double>>(&User::rating));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::floor_string, X> floor(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  LN(X) function https://www.sqlite.org/lang_mathfunc.html#ln
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::ln(200));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::ln_string, X> ln(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  LN(X) function https://www.sqlite.org/lang_mathfunc.html#ln
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::ln<std::optional<double>>(200));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::ln_string, X> ln(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  LOG(X) function https://www.sqlite.org/lang_mathfunc.html#log
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::log(100));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::log_string, X> log(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  LOG(X) function https://www.sqlite.org/lang_mathfunc.html#log
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::log<std::optional<double>>(100));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::log_string, X> log(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  LOG10(X) function https://www.sqlite.org/lang_mathfunc.html#log
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::log10(100));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::log10_string, X> log10(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  LOG10(X) function https://www.sqlite.org/lang_mathfunc.html#log
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::log10<std::optional<double>>(100));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::log10_string, X> log10(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  LOG(B, X) function https://www.sqlite.org/lang_mathfunc.html#log
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::log(10, 100));   //  decltype(rows) is std::vector<double>
-     */
-    template<class B, class X>
-    internal::built_in_function_t<double, internal::log_string, B, X> log(B b, X x) {
-        return {std::tuple<B, X>{std::forward<B>(b), std::forward<X>(x)}};
-    }
-
-    /**
-     *  LOG(B, X) function https://www.sqlite.org/lang_mathfunc.html#log
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::log<std::optional<double>>(10, 100));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class B, class X>
-    internal::built_in_function_t<R, internal::log_string, B, X> log(B b, X x) {
-        return {std::tuple<B, X>{std::forward<B>(b), std::forward<X>(x)}};
-    }
-
-    /**
-     *  LOG2(X) function https://www.sqlite.org/lang_mathfunc.html#log2
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::log2(64));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::log2_string, X> log2(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  LOG2(X) function https://www.sqlite.org/lang_mathfunc.html#log2
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::log2<std::optional<double>>(64));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::log2_string, X> log2(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  MOD(X, Y) function https://www.sqlite.org/lang_mathfunc.html#mod
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::mod_f(6, 5));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X, class Y>
-    internal::built_in_function_t<double, internal::mod_string, X, Y> mod_f(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    /**
-     *  MOD(X, Y) function https://www.sqlite.org/lang_mathfunc.html#mod
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::mod_f<std::optional<double>>(6, 5));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X, class Y>
-    internal::built_in_function_t<R, internal::mod_string, X, Y> mod_f(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    /**
-     *  PI() function https://www.sqlite.org/lang_mathfunc.html#pi
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::pi());   //  decltype(rows) is std::vector<double>
-     */
-    inline internal::built_in_function_t<double, internal::pi_string> pi() {
-        return {{}};
-    }
-
-    /**
-     *  PI() function https://www.sqlite.org/lang_mathfunc.html#pi
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, etc.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::pi<float>());   //  decltype(rows) is std::vector<float>
-     */
-    template<class R>
-    internal::built_in_function_t<R, internal::pi_string> pi() {
-        return {{}};
-    }
-
-    /**
-     *  POW(X, Y) function https://www.sqlite.org/lang_mathfunc.html#pow
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::pow(2, 5));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X, class Y>
-    internal::built_in_function_t<double, internal::pow_string, X, Y> pow(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    /**
-     *  POW(X, Y) function https://www.sqlite.org/lang_mathfunc.html#pow
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::pow<std::optional<double>>(2, 5));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X, class Y>
-    internal::built_in_function_t<R, internal::pow_string, X, Y> pow(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    /**
-     *  POWER(X, Y) function https://www.sqlite.org/lang_mathfunc.html#pow
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::power(2, 5));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X, class Y>
-    internal::built_in_function_t<double, internal::power_string, X, Y> power(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    /**
-     *  POWER(X, Y) function https://www.sqlite.org/lang_mathfunc.html#pow
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::power<std::optional<double>>(2, 5));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X, class Y>
-    internal::built_in_function_t<R, internal::power_string, X, Y> power(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    /**
-     *  RADIANS(X) function https://www.sqlite.org/lang_mathfunc.html#radians
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::radians(&Triangle::cornerAInDegrees));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::radians_string, X> radians(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  RADIANS(X) function https://www.sqlite.org/lang_mathfunc.html#radians
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::radians<std::optional<double>>(&Triangle::cornerAInDegrees));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::radians_string, X> radians(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  SIN(X) function https://www.sqlite.org/lang_mathfunc.html#sin
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::sin(&Triangle::cornerA));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::sin_string, X> sin(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  SIN(X) function https://www.sqlite.org/lang_mathfunc.html#sin
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::sin<std::optional<double>>(&Triangle::cornerA));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::sin_string, X> sin(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  SINH(X) function https://www.sqlite.org/lang_mathfunc.html#sinh
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::sinh(&Triangle::cornerA));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::sinh_string, X> sinh(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  SINH(X) function https://www.sqlite.org/lang_mathfunc.html#sinh
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::sinh<std::optional<double>>(&Triangle::cornerA));   //  decltype(rows) is std::vector<std::optional<double>>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::sinh_string, X> sinh(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  SQRT(X) function https://www.sqlite.org/lang_mathfunc.html#sqrt
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::sqrt(25));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::sqrt_string, X> sqrt(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  SQRT(X) function https://www.sqlite.org/lang_mathfunc.html#sqrt
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::sqrt<int>(25));   //  decltype(rows) is std::vector<int>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::sqrt_string, X> sqrt(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  TAN(X) function https://www.sqlite.org/lang_mathfunc.html#tan
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::tan(&Triangle::cornerC));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::tan_string, X> tan(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  TAN(X) function https://www.sqlite.org/lang_mathfunc.html#tan
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::tan<float>(&Triangle::cornerC));   //  decltype(rows) is std::vector<float>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::tan_string, X> tan(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  TANH(X) function https://www.sqlite.org/lang_mathfunc.html#tanh
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::tanh(&Triangle::cornerC));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::tanh_string, X> tanh(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  TANH(X) function https://www.sqlite.org/lang_mathfunc.html#tanh
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::tanh<float>(&Triangle::cornerC));   //  decltype(rows) is std::vector<float>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::tanh_string, X> tanh(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  TRUNC(X) function https://www.sqlite.org/lang_mathfunc.html#trunc
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::trunc(5.5));   //  decltype(rows) is std::vector<double>
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::trunc_string, X> trunc(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  TRUNC(X) function https://www.sqlite.org/lang_mathfunc.html#trunc
-     *
-     *  Difference with the previous function is that previous override has `double` as return type but this
-     *  override accepts return type from you as a template argument. You can use any bindable type:
-     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
-     *
-     *  Example:
-     *
-     *  auto rows = storage.select(sqlite_orm::trunc<float>(5.5));   //  decltype(rows) is std::vector<float>
-     */
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::trunc_string, X> trunc(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-#endif  //  SQLITE_ENABLE_MATH_FUNCTIONS
-    /**
-     *  TYPEOF(x) function https://sqlite.org/lang_corefunc.html#typeof
-     */
-    template<class T>
-    internal::built_in_function_t<std::string, internal::typeof_string, T> typeof_(T t) {
-        return {std::tuple<T>{std::forward<T>(t)}};
-    }
-
-    /**
-     *  UNICODE(x) function https://sqlite.org/lang_corefunc.html#unicode
-     */
-    template<class T>
-    internal::built_in_function_t<int, internal::unicode_string, T> unicode(T t) {
-        return {std::tuple<T>{std::forward<T>(t)}};
-    }
-
-    /**
-     *  LENGTH(x) function https://sqlite.org/lang_corefunc.html#length
-     */
-    template<class T>
-    internal::built_in_function_t<int, internal::length_string, T> length(T t) {
-        return {std::tuple<T>{std::forward<T>(t)}};
-    }
-
-    /**
-     *  ABS(x) function https://sqlite.org/lang_corefunc.html#abs
-     */
-    template<class T>
-    internal::built_in_function_t<std::unique_ptr<double>, internal::abs_string, T> abs(T t) {
-        return {std::tuple<T>{std::forward<T>(t)}};
-    }
-
-    /**
-     *  LOWER(x) function https://sqlite.org/lang_corefunc.html#lower
-     */
-    template<class T>
-    internal::built_in_function_t<std::string, internal::lower_string, T> lower(T t) {
-        return {std::tuple<T>{std::forward<T>(t)}};
-    }
-
-    /**
-     *  UPPER(x) function https://sqlite.org/lang_corefunc.html#upper
-     */
-    template<class T>
-    internal::built_in_function_t<std::string, internal::upper_string, T> upper(T t) {
-        return {std::tuple<T>{std::forward<T>(t)}};
-    }
-
-    /**
-     *  LAST_INSERT_ROWID(x) function https://www.sqlite.org/lang_corefunc.html#last_insert_rowid
-     */
-    inline internal::built_in_function_t<int64, internal::last_insert_rowid_string> last_insert_rowid() {
-        return {{}};
-    }
-
-    /**
-     *  TOTAL_CHANGES() function https://sqlite.org/lang_corefunc.html#total_changes
-     */
-    inline internal::built_in_function_t<int, internal::total_changes_string> total_changes() {
-        return {{}};
-    }
-
-    /**
-     *  CHANGES() function https://sqlite.org/lang_corefunc.html#changes
-     */
-    inline internal::built_in_function_t<int, internal::changes_string> changes() {
-        return {{}};
-    }
-
-    /**
-     *  TRIM(X) function https://sqlite.org/lang_corefunc.html#trim
-     */
-    template<class T>
-    internal::built_in_function_t<std::string, internal::trim_string, T> trim(T t) {
-        return {std::tuple<T>{std::forward<T>(t)}};
-    }
-
-    /**
-     *  TRIM(X,Y) function https://sqlite.org/lang_corefunc.html#trim
-     */
-    template<class X, class Y>
-    internal::built_in_function_t<std::string, internal::trim_string, X, Y> trim(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    /**
-     *  LTRIM(X) function https://sqlite.org/lang_corefunc.html#ltrim
-     */
-    template<class X>
-    internal::built_in_function_t<std::string, internal::ltrim_string, X> ltrim(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  LTRIM(X,Y) function https://sqlite.org/lang_corefunc.html#ltrim
-     */
-    template<class X, class Y>
-    internal::built_in_function_t<std::string, internal::ltrim_string, X, Y> ltrim(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    /**
-     *  RTRIM(X) function https://sqlite.org/lang_corefunc.html#rtrim
-     */
-    template<class X>
-    internal::built_in_function_t<std::string, internal::rtrim_string, X> rtrim(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  RTRIM(X,Y) function https://sqlite.org/lang_corefunc.html#rtrim
-     */
-    template<class X, class Y>
-    internal::built_in_function_t<std::string, internal::rtrim_string, X, Y> rtrim(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    /**
-     *  HEX(X) function https://sqlite.org/lang_corefunc.html#hex
-     */
-    template<class X>
-    internal::built_in_function_t<std::string, internal::hex_string, X> hex(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  QUOTE(X) function https://sqlite.org/lang_corefunc.html#quote
-     */
-    template<class X>
-    internal::built_in_function_t<std::string, internal::quote_string, X> quote(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  RANDOMBLOB(X) function https://sqlite.org/lang_corefunc.html#randomblob
-     */
-    template<class X>
-    internal::built_in_function_t<std::vector<char>, internal::randomblob_string, X> randomblob(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  INSTR(X) function https://sqlite.org/lang_corefunc.html#instr
-     */
-    template<class X, class Y>
-    internal::built_in_function_t<int, internal::instr_string, X, Y> instr(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    /**
-     *  REPLACE(X) function https://sqlite.org/lang_corefunc.html#replace
-     */
-    template<class X, class Y, class Z>
-    typename std::enable_if<internal::count_tuple<std::tuple<X, Y, Z>, internal::is_into>::value == 0,
-                            internal::built_in_function_t<std::string, internal::replace_string, X, Y, Z>>::type
-    replace(X x, Y y, Z z) {
-        return {std::tuple<X, Y, Z>{std::forward<X>(x), std::forward<Y>(y), std::forward<Z>(z)}};
-    }
-
-    /**
-     *  ROUND(X) function https://sqlite.org/lang_corefunc.html#round
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::round_string, X> round(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  ROUND(X, Y) function https://sqlite.org/lang_corefunc.html#round
-     */
-    template<class X, class Y>
-    internal::built_in_function_t<double, internal::round_string, X, Y> round(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-#if SQLITE_VERSION_NUMBER >= 3007016
-
-    /**
-     *  CHAR(X1,X2,...,XN) function https://sqlite.org/lang_corefunc.html#char
-     */
-    template<class... Args>
-    internal::built_in_function_t<std::string, internal::char_string, Args...> char_(Args... args) {
-        return {std::make_tuple(std::forward<Args>(args)...)};
-    }
-
-    /**
-     *  RANDOM() function https://www.sqlite.org/lang_corefunc.html#random
-     */
-    inline internal::built_in_function_t<int, internal::random_string> random() {
-        return {{}};
-    }
-
-#endif
-
-    /**
-     *  COALESCE(X,Y,...) function https://www.sqlite.org/lang_corefunc.html#coalesce
-     */
-    template<class R, class... Args>
-    internal::built_in_function_t<R, internal::coalesce_string, Args...> coalesce(Args... args) {
-        return {std::make_tuple(std::forward<Args>(args)...)};
-    }
-
-    /**
-     *  IFNULL(X,Y) function https://www.sqlite.org/lang_corefunc.html#ifnull
-     */
-    template<class R, class X, class Y>
-    internal::built_in_function_t<R, internal::ifnull_string, X, Y> ifnull(X x, Y y) {
-        return {std::make_tuple(std::move(x), std::move(y))};
-    }
-
-    /**
-     *  DATE(timestring, modifier, modifier, ...) function https://www.sqlite.org/lang_datefunc.html
-     */
-    template<class... Args>
-    internal::built_in_function_t<std::string, internal::date_string, Args...> date(Args... args) {
-        return {std::tuple<Args...>{std::forward<Args>(args)...}};
-    }
-
-    /**
-     *  TIME(timestring, modifier, modifier, ...) function https://www.sqlite.org/lang_datefunc.html
-     */
-    template<class... Args>
-    internal::built_in_function_t<std::string, internal::time_string, Args...> time(Args... args) {
-        return {std::tuple<Args...>{std::forward<Args>(args)...}};
-    }
-
-    /**
-     *  DATETIME(timestring, modifier, modifier, ...) function https://www.sqlite.org/lang_datefunc.html
-     */
-    template<class... Args>
-    internal::built_in_function_t<std::string, internal::datetime_string, Args...> datetime(Args... args) {
-        return {std::tuple<Args...>{std::forward<Args>(args)...}};
-    }
-
-    /**
-     *  JULIANDAY(timestring, modifier, modifier, ...) function https://www.sqlite.org/lang_datefunc.html
-     */
-    template<class... Args>
-    internal::built_in_function_t<double, internal::julianday_string, Args...> julianday(Args... args) {
-        return {std::tuple<Args...>{std::forward<Args>(args)...}};
-    }
-
-    /**
-     *  STRFTIME(timestring, modifier, modifier, ...) function https://www.sqlite.org/lang_datefunc.html
-     */
-    template<class... Args>
-    internal::built_in_function_t<std::string, internal::strftime_string, Args...> strftime(Args... args) {
-        return {std::tuple<Args...>{std::forward<Args>(args)...}};
-    }
-
-    /**
-     *  ZEROBLOB(N) function https://www.sqlite.org/lang_corefunc.html#zeroblob
-     */
-    template<class N>
-    internal::built_in_function_t<std::vector<char>, internal::zeroblob_string, N> zeroblob(N n) {
-        return {std::tuple<N>{std::forward<N>(n)}};
-    }
-
-    /**
-     *  SUBSTR(X,Y) function https://www.sqlite.org/lang_corefunc.html#substr
-     */
-    template<class X, class Y>
-    internal::built_in_function_t<std::string, internal::substr_string, X, Y> substr(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    /**
-     *  SUBSTR(X,Y,Z) function https://www.sqlite.org/lang_corefunc.html#substr
-     */
-    template<class X, class Y, class Z>
-    internal::built_in_function_t<std::string, internal::substr_string, X, Y, Z> substr(X x, Y y, Z z) {
-        return {std::tuple<X, Y, Z>{std::forward<X>(x), std::forward<Y>(y), std::forward<Z>(z)}};
-    }
-
-#ifdef SQLITE_SOUNDEX
-    /**
-     *  SOUNDEX(X) function https://www.sqlite.org/lang_corefunc.html#soundex
-     */
-    template<class X>
-    internal::core_function_t<std::string, internal::soundex_string, X> soundex(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-#endif
-
-    /**
-     *  TOTAL(X) aggregate function.
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::total_string, X> total(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  SUM(X) aggregate function.
-     */
-    template<class X>
-    internal::built_in_function_t<std::unique_ptr<double>, internal::sum_string, X> sum(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  COUNT(X) aggregate function.
-     */
-    template<class X>
-    internal::built_in_function_t<int, internal::count_string, X> count(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  COUNT(*) without FROM function.
-     */
-    inline internal::count_asterisk_without_type count() {
-        return {};
-    }
-
-    /**
-     *  COUNT(*) with FROM function. Specified type T will be serializeed as
-     *  a from argument.
-     */
-    template<class T>
-    internal::count_asterisk_t<T> count() {
-        return {};
-    }
-
-    /**
-     *  AVG(X) aggregate function.
-     */
-    template<class X>
-    internal::built_in_function_t<double, internal::avg_string, X> avg(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  MAX(X) aggregate function.
-     */
-    template<class X>
-    internal::built_in_function_t<internal::unique_ptr_result_of<X>, internal::max_string, X> max(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  MIN(X) aggregate function.
-     */
-    template<class X>
-    internal::built_in_function_t<internal::unique_ptr_result_of<X>, internal::min_string, X> min(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  GROUP_CONCAT(X) aggregate function.
-     */
-    template<class X>
-    internal::built_in_function_t<std::string, internal::group_concat_string, X> group_concat(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    /**
-     *  GROUP_CONCAT(X, Y) aggregate function.
-     */
-    template<class X, class Y>
-    internal::built_in_function_t<std::string, internal::group_concat_string, X, Y> group_concat(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-#ifdef SQLITE_ENABLE_JSON1
-    template<class X>
-    internal::built_in_function_t<std::string, internal::json_string, X> json(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    template<class... Args>
-    internal::built_in_function_t<std::string, internal::json_array_string, Args...> json_array(Args... args) {
-        return {std::tuple<Args...>{std::forward<Args>(args)...}};
-    }
-
-    template<class X>
-    internal::built_in_function_t<int, internal::json_array_length_string, X> json_array_length(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::json_array_length_string, X> json_array_length(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    template<class X, class Y>
-    internal::built_in_function_t<int, internal::json_array_length_string, X, Y> json_array_length(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    template<class R, class X, class Y>
-    internal::built_in_function_t<R, internal::json_array_length_string, X, Y> json_array_length(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    template<class R, class X, class... Args>
-    internal::built_in_function_t<R, internal::json_extract_string, X, Args...> json_extract(X x, Args... args) {
-        return {std::tuple<X, Args...>{std::forward<X>(x), std::forward<Args>(args)...}};
-    }
-
-    template<class X, class... Args>
-    internal::built_in_function_t<std::string, internal::json_insert_string, X, Args...> json_insert(X x,
-                                                                                                     Args... args) {
-        static_assert(std::tuple_size<std::tuple<Args...>>::value % 2 == 0,
-                      "number of arguments in json_insert must be odd");
-        return {std::tuple<X, Args...>{std::forward<X>(x), std::forward<Args>(args)...}};
-    }
-
-    template<class X, class... Args>
-    internal::built_in_function_t<std::string, internal::json_replace_string, X, Args...> json_replace(X x,
-                                                                                                       Args... args) {
-        static_assert(std::tuple_size<std::tuple<Args...>>::value % 2 == 0,
-                      "number of arguments in json_replace must be odd");
-        return {std::tuple<X, Args...>{std::forward<X>(x), std::forward<Args>(args)...}};
-    }
-
-    template<class X, class... Args>
-    internal::built_in_function_t<std::string, internal::json_set_string, X, Args...> json_set(X x, Args... args) {
-        static_assert(std::tuple_size<std::tuple<Args...>>::value % 2 == 0,
-                      "number of arguments in json_set must be odd");
-        return {std::tuple<X, Args...>{std::forward<X>(x), std::forward<Args>(args)...}};
-    }
-
-    template<class... Args>
-    internal::built_in_function_t<std::string, internal::json_object_string, Args...> json_object(Args... args) {
-        static_assert(std::tuple_size<std::tuple<Args...>>::value % 2 == 0,
-                      "number of arguments in json_object must be even");
-        return {std::tuple<Args...>{std::forward<Args>(args)...}};
-    }
-
-    template<class X, class Y>
-    internal::built_in_function_t<std::string, internal::json_patch_string, X, Y> json_patch(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    template<class X, class... Args>
-    internal::built_in_function_t<std::string, internal::json_remove_string, X, Args...> json_remove(X x,
-                                                                                                     Args... args) {
-        return {std::tuple<X, Args...>{std::forward<X>(x), std::forward<Args>(args)...}};
-    }
-
-    template<class R, class X, class... Args>
-    internal::built_in_function_t<R, internal::json_remove_string, X, Args...> json_remove(X x, Args... args) {
-        return {std::tuple<X, Args...>{std::forward<X>(x), std::forward<Args>(args)...}};
-    }
-
-    template<class X>
-    internal::built_in_function_t<std::string, internal::json_type_string, X> json_type(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::json_type_string, X> json_type(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    template<class X, class Y>
-    internal::built_in_function_t<std::string, internal::json_type_string, X, Y> json_type(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    template<class R, class X, class Y>
-    internal::built_in_function_t<R, internal::json_type_string, X, Y> json_type(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-    template<class X>
-    internal::built_in_function_t<bool, internal::json_valid_string, X> json_valid(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    template<class R, class X>
-    internal::built_in_function_t<R, internal::json_quote_string, X> json_quote(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    template<class X>
-    internal::built_in_function_t<std::string, internal::json_group_array_string, X> json_group_array(X x) {
-        return {std::tuple<X>{std::forward<X>(x)}};
-    }
-
-    template<class X, class Y>
-    internal::built_in_function_t<std::string, internal::json_group_object_string, X, Y> json_group_object(X x, Y y) {
-        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
-    }
-
-#endif  //  SQLITE_ENABLE_JSON1
-    template<class L,
-             class R,
-             typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value +
-                                                     std::is_base_of<internal::arithmetic_t, R>::value >
-                                                 0)>::type>
-    internal::add_t<L, R> operator+(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L,
-             class R,
-             typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value +
-                                                     std::is_base_of<internal::arithmetic_t, R>::value >
-                                                 0)>::type>
-    internal::sub_t<L, R> operator-(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L,
-             class R,
-             typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value +
-                                                     std::is_base_of<internal::arithmetic_t, R>::value >
-                                                 0)>::type>
-    internal::mul_t<L, R> operator*(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L,
-             class R,
-             typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value +
-                                                     std::is_base_of<internal::arithmetic_t, R>::value >
-                                                 0)>::type>
-    internal::div_t<L, R> operator/(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-
-    template<class L,
-             class R,
-             typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value +
-                                                     std::is_base_of<internal::arithmetic_t, R>::value >
-                                                 0)>::type>
-    internal::mod_t<L, R> operator%(L l, R r) {
-        return {std::move(l), std::move(r)};
-    }
-}
-#pragma once
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         *  Cute class used to compare setters/getters and member pointers with each other.
-         */
-        template<class L, class R>
-        struct typed_comparator {
-            bool operator()(const L&, const R&) const {
-                return false;
-            }
-        };
-
-        template<class O>
-        struct typed_comparator<O, O> {
-            bool operator()(const O& lhs, const O& rhs) const {
-                return lhs == rhs;
-            }
-        };
-
-        template<class L, class R>
-        bool compare_any(const L& lhs, const R& rhs) {
-            return typed_comparator<L, R>()(lhs, rhs);
-        }
-    }
-}
-#pragma once
-
-#include <string>  //  std::string
-#include <utility>  //  std::declval
-#include <tuple>  //  std::tuple, std::get, std::tuple_size
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-#include <optional>  // std::optional
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-// #include "is_base_of_template.h"
-
-// #include "tuple_helper/tuple_helper.h"
-
-// #include "optional_container.h"
-
-// #include "ast/where.h"
-
-// #include "../serialize_result_type.h"
-
-namespace sqlite_orm {
-    namespace internal {
-
-        struct where_string {
-            serialize_result_type serialize() const {
-                return "WHERE";
-            }
-        };
-
-        /**
-         *  WHERE argument holder.
-         *  C is expression type. Can be any expression like: is_equal_t, is_null_t, exists_t etc
-         *  Don't construct it manually. Call `where(...)` function instead.
-         */
-        template<class C>
-        struct where_t : where_string {
-            using expression_type = C;
-
-            expression_type expression;
-
-            where_t(expression_type expression_) : expression(std::move(expression_)) {}
-        };
-
-        template<class T>
-        struct is_where : std::false_type {};
-
-        template<class T>
-        struct is_where<where_t<T>> : std::true_type {};
-    }
-
-    /**
-     *  WHERE clause. Use it to add WHERE conditions wherever you like.
-     *  C is expression type. Can be any expression like: is_equal_t, is_null_t, exists_t etc
-     *  @example
-     *  //  SELECT name
-     *  //  FROM letters
-     *  //  WHERE id > 3
-     *  auto rows = storage.select(&Letter::name, where(greater_than(&Letter::id, 3)));
-     */
-    template<class C>
-    internal::where_t<C> where(C expression) {
-        return {std::move(expression)};
-    }
-}
-
-// #include "ast/group_by.h"
-
-#include <tuple>  //  std::tuple, std::make_tuple
-#include <type_traits>  //  std::true_type, std::false_type, std::forward
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T, class... Args>
-        struct group_by_with_having {
-            using args_type = std::tuple<Args...>;
-            using expression_type = T;
-
-            args_type args;
-            expression_type expression;
-        };
-
-        /**
-         *  GROUP BY pack holder.
-         */
-        template<class... Args>
-        struct group_by_t {
-            using args_type = std::tuple<Args...>;
-
-            args_type args;
-
-            template<class T>
-            group_by_with_having<T, Args...> having(T expression) {
-                return {move(this->args), std::move(expression)};
-            }
-        };
-
-        template<class T>
-        struct is_group_by : std::false_type {};
-
-        template<class... Args>
-        struct is_group_by<group_by_t<Args...>> : std::true_type {};
-
-        template<class T, class... Args>
-        struct is_group_by<group_by_with_having<T, Args...>> : std::true_type {};
-
-        /**
-         *  HAVING holder.
-         *  T is having argument type.
-         */
-        template<class T>
-        struct having_t {
-            using expression_type = T;
-
-            expression_type expression;
-        };
-
-        template<class T>
-        struct is_having : std::false_type {};
-
-        template<class T>
-        struct is_having<having_t<T>> : std::true_type {};
-    }
-
-    /**
-     *  GROUP BY column.
-     *  Example: storage.get_all<Employee>(group_by(&Employee::name))
-     */
-    template<class... Args>
-    internal::group_by_t<Args...> group_by(Args&&... args) {
-        return {std::make_tuple(std::forward<Args>(args)...)};
-    }
-
-    /**
-     *  [Deprecation notice]: this function is deprecated and will be removed in v1.9. Please use `group_by(...).having(...)` instead.
-     *
-     *  HAVING(expression).
-     *  Example: storage.get_all<Employee>(group_by(&Employee::name), having(greater_than(count(&Employee::name), 2)));
-     */
-    template<class T>
-    internal::having_t<T> having(T expression) {
-        return {std::move(expression)};
-    }
-}
-
-namespace sqlite_orm {
-
-    namespace internal {
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class T>
-        struct as_optional_t {
-            using value_type = T;
-
-            value_type value;
-        };
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-
-        struct distinct_string {
-            operator std::string() const {
-                return "DISTINCT";
-            }
-        };
-
-        /**
-         *  DISCTINCT generic container.
-         */
-        template<class T>
-        struct distinct_t : distinct_string {
-            using value_type = T;
-
-            value_type value;
-
-            distinct_t(value_type value_) : value(std::move(value_)) {}
-        };
-
-        struct all_string {
-            operator std::string() const {
-                return "ALL";
-            }
-        };
-
-        /**
-         *  ALL generic container.
-         */
-        template<class T>
-        struct all_t : all_string {
-            T value;
-
-            all_t(T value_) : value(std::move(value_)) {}
-        };
-
-        template<class... Args>
-        struct columns_t {
-            using columns_type = std::tuple<Args...>;
-
-            columns_type columns;
-            bool distinct = false;
-
-            static constexpr const int count = std::tuple_size<columns_type>::value;
-        };
-
-        template<class T>
-        struct is_columns : std::false_type {};
-
-        template<class... Args>
-        struct is_columns<columns_t<Args...>> : std::true_type {};
-
-        struct set_string {
-            operator std::string() const {
-                return "SET";
-            }
-        };
-
-        template<class... Args>
-        struct set_t : set_string {
-            using assigns_type = std::tuple<Args...>;
-
-            assigns_type assigns;
-
-            set_t(assigns_type assigns_) : assigns(move(assigns_)) {}
-        };
-
-        /**
-         *  This class is used to store explicit mapped type T and its column descriptor (member pointer/getter/setter).
-         *  Is useful when mapped type is derived from other type and base class has members mapped to a storage.
-         */
-        template<class T, class F>
-        struct column_pointer {
-            using self = column_pointer<T, F>;
-            using type = T;
-            using field_type = F;
-
-            field_type field;
-
-            template<class R>
-            internal::is_equal_t<self, R> operator==(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::is_not_equal_t<self, R> operator!=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::lesser_than_t<self, R> operator<(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::lesser_or_equal_t<self, R> operator<=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::greater_than_t<self, R> operator>(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::greater_or_equal_t<self, R> operator>=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-        };
-
-        /**
-         *  Subselect object type.
-         */
-        template<class T, class... Args>
-        struct select_t {
-            using return_type = T;
-            using conditions_type = std::tuple<Args...>;
-
-            return_type col;
-            conditions_type conditions;
-            bool highest_level = false;
-        };
-
-        template<class T>
-        struct is_select : std::false_type {};
-
-        template<class T, class... Args>
-        struct is_select<select_t<T, Args...>> : std::true_type {};
-
-        /**
-         *  Base for UNION, UNION ALL, EXCEPT and INTERSECT
-         */
-        template<class L, class R>
-        struct compound_operator {
-            using left_type = L;
-            using right_type = R;
-
-            left_type left;
-            right_type right;
-
-            compound_operator(left_type l, right_type r) : left(std::move(l)), right(std::move(r)) {
-                this->left.highest_level = true;
-                this->right.highest_level = true;
-            }
-        };
-
-        struct union_base {
-            bool all = false;
-
-            operator std::string() const {
-                if(!this->all) {
-                    return "UNION";
-                } else {
-                    return "UNION ALL";
-                }
-            }
-        };
-
-        /**
-         *  UNION object type.
-         */
-        template<class L, class R>
-        struct union_t : public compound_operator<L, R>, union_base {
-            using left_type = typename compound_operator<L, R>::left_type;
-            using right_type = typename compound_operator<L, R>::right_type;
-
-            union_t(left_type l, right_type r, decltype(all) all_) :
-                compound_operator<L, R>(std::move(l), std::move(r)), union_base{all_} {}
-
-            union_t(left_type l, right_type r) : union_t(std::move(l), std::move(r), false) {}
-        };
-
-        struct except_string {
-            operator std::string() const {
-                return "EXCEPT";
-            }
-        };
-
-        /**
-         *  EXCEPT object type.
-         */
-        template<class L, class R>
-        struct except_t : compound_operator<L, R>, except_string {
-            using super = compound_operator<L, R>;
-            using left_type = typename super::left_type;
-            using right_type = typename super::right_type;
-
-            using super::super;
-        };
-
-        struct intersect_string {
-            operator std::string() const {
-                return "INTERSECT";
-            }
-        };
-        /**
-         *  INTERSECT object type.
-         */
-        template<class L, class R>
-        struct intersect_t : compound_operator<L, R>, intersect_string {
-            using super = compound_operator<L, R>;
-            using left_type = typename super::left_type;
-            using right_type = typename super::right_type;
-
-            using super::super;
-        };
-
-        /**
-         *  Generic way to get DISTINCT value from any type.
-         */
-        template<class T>
-        bool get_distinct(const T&) {
-            return false;
-        }
-
-        template<class... Args>
-        bool get_distinct(const columns_t<Args...>& cols) {
-            return cols.distinct;
-        }
-
-        template<class T>
-        struct asterisk_t {
-            using type = T;
-        };
-
-        template<class T>
-        struct object_t {
-            using type = T;
-        };
-
-        template<class T>
-        struct then_t {
-            using expression_type = T;
-
-            expression_type expression;
-        };
-
-        template<class R, class T, class E, class... Args>
-        struct simple_case_t {
-            using return_type = R;
-            using case_expression_type = T;
-            using args_type = std::tuple<Args...>;
-            using else_expression_type = E;
-
-            optional_container<case_expression_type> case_expression;
-            args_type args;
-            optional_container<else_expression_type> else_expression;
-        };
-
-        /**
-         *  T is a case expression type
-         *  E is else type (void is ELSE is omitted)
-         *  Args... is a pack of WHEN expressions
-         */
-        template<class R, class T, class E, class... Args>
-        struct simple_case_builder {
-            using return_type = R;
-            using case_expression_type = T;
-            using args_type = std::tuple<Args...>;
-            using else_expression_type = E;
-
-            optional_container<case_expression_type> case_expression;
-            args_type args;
-            optional_container<else_expression_type> else_expression;
-
-            template<class W, class Th>
-            simple_case_builder<R, T, E, Args..., std::pair<W, Th>> when(W w, then_t<Th> t) {
-                using result_args_type = std::tuple<Args..., std::pair<W, Th>>;
-                std::pair<W, Th> newPair{std::move(w), std::move(t.expression)};
-                result_args_type result_args =
-                    std::tuple_cat(std::move(this->args), std::move(std::make_tuple(newPair)));
-                std::get<std::tuple_size<result_args_type>::value - 1>(result_args) = std::move(newPair);
-                return {std::move(this->case_expression), std::move(result_args), std::move(this->else_expression)};
-            }
-
-            simple_case_t<R, T, E, Args...> end() {
-                return {std::move(this->case_expression), std::move(args), std::move(this->else_expression)};
-            }
-
-            template<class El>
-            simple_case_builder<R, T, El, Args...> else_(El el) {
-                return {{std::move(this->case_expression)}, std::move(args), {std::move(el)}};
-            }
-        };
-
-        template<class T>
-        void validate_conditions() {
-            static_assert(count_tuple<T, is_where>::value <= 1, "a single query cannot contain > 1 WHERE blocks");
-            static_assert(count_tuple<T, is_group_by>::value <= 1, "a single query cannot contain > 1 GROUP BY blocks");
-            static_assert(count_tuple<T, is_order_by>::value <= 1, "a single query cannot contain > 1 ORDER BY blocks");
-            static_assert(count_tuple<T, is_limit>::value <= 1, "a single query cannot contain > 1 LIMIT blocks");
-            static_assert(count_tuple<T, is_from>::value <= 1, "a single query cannot contain > 1 FROM blocks");
-        }
-    }
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-    template<class T>
-    internal::as_optional_t<T> as_optional(T value) {
-        return {std::move(value)};
-    }
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-    template<class T>
-    internal::then_t<T> then(T t) {
-        return {std::move(t)};
-    }
-
-    template<class R, class T>
-    internal::simple_case_builder<R, T, void> case_(T t) {
-        return {{std::move(t)}};
-    }
-
-    template<class R>
-    internal::simple_case_builder<R, void, void> case_() {
-        return {};
-    }
-
-    template<class T>
-    internal::distinct_t<T> distinct(T t) {
-        return {std::move(t)};
-    }
-
-    template<class T>
-    internal::all_t<T> all(T t) {
-        return {std::move(t)};
-    }
-
-    template<class... Args>
-    internal::columns_t<Args...> distinct(internal::columns_t<Args...> cols) {
-        cols.distinct = true;
-        return cols;
-    }
-
-    /**
-     *  SET keyword used in UPDATE ... SET queries.
-     *  Args must have `assign_t` type. E.g. set(assign(&User::id, 5)) or set(c(&User::id) = 5)
-     */
-    template<class... Args>
-    internal::set_t<Args...> set(Args... args) {
-        using arg_tuple = std::tuple<Args...>;
-        static_assert(std::tuple_size<arg_tuple>::value ==
-                          internal::count_tuple<arg_tuple, internal::is_assign_t>::value,
-                      "set function accepts assign operators only");
-        return {std::make_tuple(std::forward<Args>(args)...)};
-    }
-
-    template<class... Args>
-    internal::columns_t<Args...> columns(Args... args) {
-        return {std::make_tuple<Args...>(std::forward<Args>(args)...)};
-    }
-
-    /**
-     *  Use it like this:
-     *  struct MyType : BaseType { ... };
-     *  storage.select(column<MyType>(&BaseType::id));
-     */
-    template<class T, class F>
-    internal::column_pointer<T, F> column(F f) {
-        return {std::move(f)};
-    }
-
-    /**
-     *  Public function for subselect query. Is useful in UNION queries.
-     */
-    template<class T, class... Args>
-    internal::select_t<T, Args...> select(T t, Args... args) {
-        using args_tuple = std::tuple<Args...>;
-        internal::validate_conditions<args_tuple>();
-        return {std::move(t), std::make_tuple(std::forward<Args>(args)...)};
-    }
-
-    /**
-     *  Public function for UNION operator.
-     *  lhs and rhs are subselect objects.
-     *  Look through example in examples/union.cpp
-     */
-    template<class L, class R>
-    internal::union_t<L, R> union_(L lhs, R rhs) {
-        return {std::move(lhs), std::move(rhs)};
-    }
-
-    /**
-     *  Public function for EXCEPT operator.
-     *  lhs and rhs are subselect objects.
-     *  Look through example in examples/except.cpp
-     */
-    template<class L, class R>
-    internal::except_t<L, R> except(L lhs, R rhs) {
-        return {std::move(lhs), std::move(rhs)};
-    }
-
-    template<class L, class R>
-    internal::intersect_t<L, R> intersect(L lhs, R rhs) {
-        return {std::move(lhs), std::move(rhs)};
-    }
-
-    /**
-     *  Public function for UNION ALL operator.
-     *  lhs and rhs are subselect objects.
-     *  Look through example in examples/union.cpp
-     */
-    template<class L, class R>
-    internal::union_t<L, R> union_all(L lhs, R rhs) {
-        return {std::move(lhs), std::move(rhs), true};
-    }
-
-    /**
-     * SELECT * FROM T function.
-     * T is typed mapped to a storage.
-     * Example: auto rows = storage.select(asterisk<User>());
-     * // decltype(rows) is std::vector<std::tuple<...all column typed in declared in make_table order...>>
-     * If you need to fetch result as objects not tuple please use `object<T>` instead.
-     */
-    template<class T>
-    internal::asterisk_t<T> asterisk() {
-        return {};
-    }
-
-    /**
-     * SELECT * FROM T function.
-     * T is typed mapped to a storage.
-     * Example: auto rows = storage.select(object<User>());
-     * // decltype(rows) is std::vector<User>
-     * If you need to fetch result as tuples not objects please use `asterisk<T>` instead.
-     */
-    template<class T>
-    internal::object_t<T> object() {
-        return {};
-    }
-}
-#pragma once
-
-#include <string>  //  std::string
-
-namespace sqlite_orm {
-
-    struct table_info {
-        int cid = 0;
-        std::string name;
-        std::string type;
-        bool notnull = false;
-        std::string dflt_value;
-        int pk = 0;
-
-        table_info(decltype(cid) cid_,
-                   decltype(name) name_,
-                   decltype(type) type_,
-                   decltype(notnull) notnull_,
-                   decltype(dflt_value) dflt_value_,
-                   decltype(pk) pk_) :
-            cid(cid_),
-            name(move(name_)), type(move(type_)), notnull(notnull_), dflt_value(move(dflt_value_)), pk(pk_) {}
-    };
-
-}
-#pragma once
-
-#include <memory>  // std::unique_ptr
-#include <sqlite3.h>
-#include <type_traits>  // std::integral_constant
-
-namespace sqlite_orm {
-
-    /**
-     *  Guard class which finalizes `sqlite3_stmt` in dtor
-     */
-    using statement_finalizer =
-        std::unique_ptr<sqlite3_stmt, std::integral_constant<decltype(&sqlite3_finalize), sqlite3_finalize>>;
-}
-#pragma once
-#include <type_traits>
-
-namespace sqlite_orm {
-
-    /**
-     *  Helper classes used by statement_binder and row_extractor.
-     */
-    struct int_or_smaller_tag {};
-    struct bigint_tag {};
-    struct real_tag {};
-
-    template<class V>
-    struct arithmetic_tag {
-        using type = std::conditional_t<std::is_integral<V>::value,
-                                        // Integer class
-                                        std::conditional_t<sizeof(V) <= sizeof(int), int_or_smaller_tag, bigint_tag>,
-                                        // Floating-point class
-                                        real_tag>;
-    };
-
-    template<class V>
-    using arithmetic_tag_t = typename arithmetic_tag<V>::type;
-}
-#pragma once
-
-#include <type_traits>
-#include <memory>
-#include <utility>
-
-// #include "start_macros.h"
-
-// #include "xdestroy_handling.h"
-
-namespace sqlite_orm {
-
-    /**
-     *  Wraps a pointer and tags it with a pointer type,
-     *  used for accepting function parameters,
-     *  facilitating the 'pointer-passing interface'.
-     * 
-     *  Template parameters:
-     *    - P: The value type, possibly const-qualified.
-     *    - T: An integral constant string denoting the pointer type, e.g. carray_pvt_name.
-     *
-     */
-    template<typename P, typename T>
-    struct pointer_arg {
-
-        static_assert(std::is_convertible<typename T::value_type, const char*>::value,
-                      "`std::integral_constant<>` must be convertible to `const char*`");
-
-        using tag = T;
-        P* p_;
-
-        P* ptr() const noexcept {
-            return p_;
-        }
-
-        operator P*() const noexcept {
-            return p_;
-        }
-    };
-
-    /**
-     *  Pointer value with associated deleter function,
-     *  used for returning or binding pointer values
-     *  as part of facilitating the 'pointer-passing interface'.
-     * 
-     *  Template parameters:
-     *    - D: The deleter for the pointer value;
-     *         can be one of:
-     *         - function pointer
-     *         - integral function pointer constant
-     *         - state-less (empty) deleter
-     *         - non-capturing lambda
-     *         - structure implicitly yielding a function pointer
-     *
-     *  @note Use one of the factory functions to create a pointer binding,
-     *  e.g. bindable_carray_pointer or statically_bindable_carray_pointer().
-     *  
-     *  @example
-     *  ```
-     *  int64 rememberedId;
-     *  storage.select(func<remember_fn>(&Object::id, statically_bindable_carray_pointer(&rememberedId)));
-     *  ```
-     */
-    template<typename P, typename T, typename D>
-    class pointer_binding {
-
-        P* p_;
-        SQLITE_ORM_NOUNIQUEADDRESS
-        D d_;
-
-      protected:
-        // Constructing pointer bindings must go through bindable_pointer()
-        template<class T2, class P2, class D2>
-        friend auto bindable_pointer(P2*, D2) noexcept -> pointer_binding<P2, T2, D2>;
-        template<class B>
-        friend B bindable_pointer(typename B::qualified_type*, typename B::deleter_type) noexcept;
-
-        // Construct from pointer and deleter.
-        // Transfers ownership of the passed in object.
-        pointer_binding(P* p, D d = {}) noexcept : p_{p}, d_{std::move(d)} {}
-
-      public:
-        using qualified_type = P;
-        using tag = T;
-        using deleter_type = D;
-
-        pointer_binding(const pointer_binding&) = delete;
-        pointer_binding& operator=(const pointer_binding&) = delete;
-        pointer_binding& operator=(pointer_binding&&) = delete;
-
-        pointer_binding(pointer_binding&& other) noexcept :
-            p_{std::exchange(other.p_, nullptr)}, d_{std::move(other.d_)} {}
-
-        ~pointer_binding() {
-            if(p_) {
-                if(auto xDestroy = get_xdestroy()) {
-                    // note: C-casting `P* -> void*` like statement_binder<pointer_binding<P, T, D>
-                    xDestroy((void*)p_);
-                }
-            }
-        }
-
-        P* ptr() const noexcept {
-            return p_;
-        }
-
-        P* take_ptr() noexcept {
-            return std::exchange(p_, nullptr);
-        }
-
-        xdestroy_fn_t get_xdestroy() const noexcept {
-            return obtain_xdestroy_for(d_, p_);
-        }
-    };
-
-    /**
-     *  Template alias for a static pointer value binding.
-     *  'Static' means that ownership won't be transferred to sqlite,
-     *  sqlite doesn't delete it, and sqlite assumes the object
-     *  pointed to is valid throughout the lifetime of a statement.
-     */
-    template<typename P, typename T>
-    using static_pointer_binding = pointer_binding<P, T, null_xdestroy_t>;
-}
-
-namespace sqlite_orm {
-
-    /**
-     *  Wrap a pointer, its type and its deleter function for binding it to a statement.
-     *  
-     *  Unless the deleter yields a nullptr 'xDestroy' function the ownership of the pointed-to-object
-     *  is transferred to the pointer binding, which will delete it through
-     *  the deleter when the statement finishes.
-     */
-    template<class T, class P, class D>
-    auto bindable_pointer(P* p, D d) noexcept -> pointer_binding<P, T, D> {
-        return {p, std::move(d)};
-    }
-
-    template<class T, class P, class D>
-    auto bindable_pointer(std::unique_ptr<P, D> p) noexcept -> pointer_binding<P, T, D> {
-        return bindable_pointer<T>(p.release(), p.get_deleter());
-    }
-
-    template<typename B>
-    B bindable_pointer(typename B::qualified_type* p, typename B::deleter_type d = {}) noexcept {
-        return B{p, std::move(d)};
-    }
-
-    /**
-     *  Wrap a pointer and its type for binding it to a statement.
-     *  
-     *  Note: 'Static' means that ownership of the pointed-to-object won't be transferred
-     *  and sqlite assumes the object pointed to is valid throughout the lifetime of a statement.
-     */
-    template<class T, class P>
-    auto statically_bindable_pointer(P* p) noexcept -> static_pointer_binding<P, T> {
-        return bindable_pointer<T>(p, null_xdestroy_f);
-    }
-
-    template<typename B>
-    B statically_bindable_pointer(typename B::qualified_type* p,
-                                  typename B::deleter_type* /*exposition*/ = nullptr) noexcept {
-        return bindable_pointer<B>(p);
-    }
-
-    /**
-     *  Forward a pointer value from an argument.
-     */
-    template<class P, class T>
-    auto rebind_statically(const pointer_arg<P, T>& pv) noexcept -> static_pointer_binding<P, T> {
-        return statically_bindable_pointer<T>(pv.ptr());
-    }
-}
-#pragma once
-
-#include <sqlite3.h>
-#include <type_traits>  //  std::enable_if_t, std::is_arithmetic, std::is_same, std::true_type, std::false_type
-#include <memory>  //  std::default_delete
-#include <string>  //  std::string, std::wstring
-#ifndef SQLITE_ORM_OMITS_CODECVT
-#include <codecvt>  //  std::codecvt_utf8_utf16
-#endif  //  SQLITE_ORM_OMITS_CODECVT
-#include <vector>  //  std::vector
-#include <cstddef>  //  std::nullptr_t
-#include <utility>  //  std::declval
-#include <locale>  //  std::wstring_convert
-#include <cstring>  //  ::strncpy, ::strlen
-
-// #include "is_std_ptr.h"
-
-namespace sqlite_orm {
-
-    /**
-     *  Specialization for optional type (std::shared_ptr / std::unique_ptr).
-     */
-    template<typename T>
-    struct is_std_ptr : std::false_type {};
-
-    template<typename T>
-    struct is_std_ptr<std::shared_ptr<T>> : std::true_type {
-        using element_type = T;
-
-        static std::shared_ptr<T> make(const T& v) {
-            return std::make_shared<T>(v);
-        }
-    };
-
-    template<typename T>
-    struct is_std_ptr<std::unique_ptr<T>> : std::true_type {
-        using element_type = T;
-
-        static std::unique_ptr<T> make(const T& v) {
-            return std::make_unique<T>(v);
-        }
-    };
-}
-
-// #include "arithmetic_tag.h"
-
-// #include "xdestroy_handling.h"
-
-// #include "pointer_value.h"
-
-namespace sqlite_orm {
-
-    /**
-     *  Helper class used for binding fields to sqlite3 statements.
-     */
-    template<class V, typename Enable = void>
-    struct statement_binder : std::false_type {};
-
-    /**
-     *  Specialization for 'pointer-passing interface'.
-     */
-    template<class P, class T, class D>
-    struct statement_binder<pointer_binding<P, T, D>, void> {
-        using V = pointer_binding<P, T, D>;
-
-        // ownership of pointed-to-object is left untouched and remains at prepared statement's AST expression
-        int bind(sqlite3_stmt* stmt, int index, const V& value) const {
-            // note: C-casting `P* -> void*`, internal::xdestroy_proxy() does the inverse
-            return sqlite3_bind_pointer(stmt, index, (void*)value.ptr(), T::value, null_xdestroy_f);
-        }
-
-        // ownership of pointed-to-object is transferred to sqlite
-        void result(sqlite3_context* context, V& value) const {
-            // note: C-casting `P* -> void*`,
-            // row_extractor<pointer_arg<P, T>>::extract() and internal::xdestroy_proxy() do the inverse
-            sqlite3_result_pointer(context, (void*)value.take_ptr(), T::value, value.get_xdestroy());
-        }
-    };
-
-    /**
-     *  Specialization for arithmetic types.
-     */
-    template<class V>
-    struct statement_binder<V, std::enable_if_t<std::is_arithmetic<V>::value>> {
-
-        int bind(sqlite3_stmt* stmt, int index, const V& value) const {
-            return this->bind(stmt, index, value, tag());
-        }
-
-        void result(sqlite3_context* context, const V& value) const {
-            this->result(context, value, tag());
-        }
-
-      private:
-        using tag = arithmetic_tag_t<V>;
-
-        int bind(sqlite3_stmt* stmt, int index, const V& value, const int_or_smaller_tag&) const {
-            return sqlite3_bind_int(stmt, index, static_cast<int>(value));
-        }
-
-        void result(sqlite3_context* context, const V& value, const int_or_smaller_tag&) const {
-            sqlite3_result_int(context, static_cast<int>(value));
-        }
-
-        int bind(sqlite3_stmt* stmt, int index, const V& value, const bigint_tag&) const {
-            return sqlite3_bind_int64(stmt, index, static_cast<sqlite3_int64>(value));
-        }
-
-        void result(sqlite3_context* context, const V& value, const bigint_tag&) const {
-            sqlite3_result_int64(context, static_cast<sqlite3_int64>(value));
-        }
-
-        int bind(sqlite3_stmt* stmt, int index, const V& value, const real_tag&) const {
-            return sqlite3_bind_double(stmt, index, static_cast<double>(value));
-        }
-
-        void result(sqlite3_context* context, const V& value, const real_tag&) const {
-            sqlite3_result_double(context, static_cast<double>(value));
-        }
-    };
-
-    /**
-     *  Specialization for std::string and C-string.
-     */
-    template<class V>
-    struct statement_binder<V,
-                            std::enable_if_t<std::is_same<V, std::string>::value || std::is_same<V, const char*>::value
-#ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
-                                             || std::is_same<V, std::string_view>::value
-#endif
-                                             >> {
-
-        int bind(sqlite3_stmt* stmt, int index, const V& value) const {
-            auto stringData = this->string_data(value);
-            return sqlite3_bind_text(stmt, index, std::get<0>(stringData), std::get<1>(stringData), SQLITE_TRANSIENT);
-        }
-
-        void result(sqlite3_context* context, const V& value) const {
-            auto stringData = this->string_data(value);
-            auto stringDataLength = std::get<1>(stringData);
-            auto dataCopy = new char[stringDataLength + 1];
-            constexpr auto deleter = std::default_delete<char[]>{};
-            auto stringChars = std::get<0>(stringData);
-            ::strncpy(dataCopy, stringChars, stringDataLength + 1);
-            sqlite3_result_text(context, dataCopy, stringDataLength, obtain_xdestroy_for(deleter, dataCopy));
-        }
-
-      private:
-        std::tuple<const char*, int> string_data(const std::string& s) const {
-            return {s.c_str(), int(s.size())};
-        }
-
-        std::tuple<const char*, int> string_data(const char* s) const {
-            auto length = int(::strlen(s));
-            return {s, length};
-        }
-
-#ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
-        std::tuple<const char*, int> string_data(const std::string_view& s) const {
-            return {s.data(), int(s.size())};
-        }
-#endif
-    };
-
-#ifndef SQLITE_ORM_OMITS_CODECVT
-    /**
-     *  Specialization for std::wstring and C-wstring.
-     */
-    template<class V>
-    struct statement_binder<
-        V,
-        std::enable_if_t<std::is_same<V, std::wstring>::value || std::is_same<V, const wchar_t*>::value>> {
-
-        int bind(sqlite3_stmt* stmt, int index, const V& value) const {
-            std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
-            std::string utf8Str = converter.to_bytes(value);
-            return statement_binder<decltype(utf8Str)>().bind(stmt, index, utf8Str);
-        }
-
-        void result(sqlite3_context* context, const V& value) const {
-            sqlite3_result_text16(context, (const void*)value.data(), int(value.length()), nullptr);
-        }
-    };
-#endif  //  SQLITE_ORM_OMITS_CODECVT
-
-    /**
-     *  Specialization for std::nullptr_t.
-     */
-    template<>
-    struct statement_binder<std::nullptr_t, void> {
-        int bind(sqlite3_stmt* stmt, int index, const std::nullptr_t&) const {
-            return sqlite3_bind_null(stmt, index);
-        }
-
-        void result(sqlite3_context* context, const std::nullptr_t&) const {
-            sqlite3_result_null(context);
-        }
-    };
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-    /**
-     *  Specialization for std::nullopt_t.
-     */
-    template<>
-    struct statement_binder<std::nullopt_t, void> {
-        int bind(sqlite3_stmt* stmt, int index, const std::nullopt_t&) const {
-            return sqlite3_bind_null(stmt, index);
-        }
-
-        void result(sqlite3_context* context, const std::nullopt_t&) const {
-            sqlite3_result_null(context);
-        }
-    };
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-
-    template<class V>
-    struct statement_binder<V, std::enable_if_t<is_std_ptr<V>::value>> {
-        using value_type = typename is_std_ptr<V>::element_type;
-
-        int bind(sqlite3_stmt* stmt, int index, const V& value) const {
-            if(value) {
-                return statement_binder<value_type>().bind(stmt, index, *value);
-            } else {
-                return statement_binder<std::nullptr_t>().bind(stmt, index, nullptr);
-            }
-        }
-
-        void result(sqlite3_context* context, const V& value) const {
-            if(value) {
-                statement_binder<value_type>().result(context, value);
-            } else {
-                statement_binder<std::nullptr_t>().result(context, nullptr);
-            }
-        }
-    };
-
-    /**
-     *  Specialization for optional type (std::vector<char>).
-     */
-    template<>
-    struct statement_binder<std::vector<char>, void> {
-        int bind(sqlite3_stmt* stmt, int index, const std::vector<char>& value) const {
-            if(value.size()) {
-                return sqlite3_bind_blob(stmt, index, (const void*)&value.front(), int(value.size()), SQLITE_TRANSIENT);
-            } else {
-                return sqlite3_bind_blob(stmt, index, "", 0, SQLITE_TRANSIENT);
-            }
-        }
-
-        void result(sqlite3_context* context, const std::vector<char>& value) const {
-            if(value.size()) {
-                sqlite3_result_blob(context, (const void*)&value.front(), int(value.size()), nullptr);
-            } else {
-                sqlite3_result_blob(context, "", 0, nullptr);
-            }
-        }
-    };
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-    template<class T>
-    struct statement_binder<std::optional<T>, void> {
-        using value_type = T;
-
-        int bind(sqlite3_stmt* stmt, int index, const std::optional<T>& value) const {
-            if(value) {
-                return statement_binder<value_type>().bind(stmt, index, *value);
-            } else {
-                return statement_binder<std::nullopt_t>().bind(stmt, index, std::nullopt);
-            }
-        }
-
-        void result(sqlite3_context* context, const std::optional<T>& value) const {
-            if(value) {
-                statement_binder<value_type>().result(context, value);
-            } else {
-                statement_binder<std::nullopt_t>().result(context, std::nullopt);
-            }
-        }
-    };
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-
-    namespace internal {
-
-        template<class T>
-        using is_bindable = std::integral_constant<bool, !std::is_base_of<std::false_type, statement_binder<T>>::value>;
-
-        struct conditional_binder_base {
-            sqlite3_stmt* stmt = nullptr;
-            int& index;
-
-            conditional_binder_base(decltype(stmt) stmt_, decltype(index) index_) : stmt(stmt_), index(index_) {}
-        };
-
-        template<class T, class C>
-        struct conditional_binder;
-
-        template<class T>
-        struct conditional_binder<T, std::true_type> : conditional_binder_base {
-
-            using conditional_binder_base::conditional_binder_base;
-
-            int operator()(const T& t) const {
-                return statement_binder<T>().bind(this->stmt, this->index++, t);
-            }
-        };
-
-        template<class T>
-        struct conditional_binder<T, std::false_type> : conditional_binder_base {
-            using conditional_binder_base::conditional_binder_base;
-
-            int operator()(const T&) const {
-                return SQLITE_OK;
-            }
-        };
-
-        template<class T, template<class C> class F, class SFINAE = void>
-        struct tuple_filter_single;
-
-        template<class T, template<class C> class F>
-        struct tuple_filter_single<T, F, typename std::enable_if<F<T>::value>::type> {
-            using type = std::tuple<T>;
-        };
-
-        template<class T, template<class C> class F>
-        struct tuple_filter_single<T, F, typename std::enable_if<!F<T>::value>::type> {
-            using type = std::tuple<>;
-        };
-
-        template<class T, template<class C> class F>
-        struct tuple_filter;
-
-        template<class... Args, template<class C> class F>
-        struct tuple_filter<std::tuple<Args...>, F> {
-            using type = typename conc_tuple<typename tuple_filter_single<Args, F>::type...>::type;
-        };
-
-        template<class T>
-        struct bindable_filter_single : tuple_filter_single<T, is_bindable> {};
-
-        template<class T>
-        struct bindable_filter;
-
-        template<class... Args>
-        struct bindable_filter<std::tuple<Args...>> {
-            using type = typename conc_tuple<typename bindable_filter_single<Args>::type...>::type;
-        };
-    }
-}
-#pragma once
-
-#include <sqlite3.h>
-#include <type_traits>  //  std::enable_if_t, std::is_arithmetic, std::is_same, std::enable_if
-#include <stdlib.h>  //  atof, atoi, atoll
-#include <string>  //  std::string, std::wstring
-#ifndef SQLITE_ORM_OMITS_CODECVT
-#include <codecvt>  //  std::wstring_convert, std::codecvt_utf8_utf16
-#endif  //  SQLITE_ORM_OMITS_CODECVT
-#include <vector>  //  std::vector
-#include <cstring>  //  strlen
-#include <algorithm>  //  std::copy
-#include <iterator>  //  std::back_inserter
-#include <tuple>  //  std::tuple, std::tuple_size, std::tuple_element
-
-// #include "arithmetic_tag.h"
-
-// #include "pointer_value.h"
-
-// #include "journal_mode.h"
-
-#include <string>  //  std::string
-#include <memory>  //  std::unique_ptr
-#include <array>  //  std::array
-#include <algorithm>  //  std::transform
-#include <cctype>  // std::toupper
-
-namespace sqlite_orm {
-
-/**
- *  Caps case cause of 1) delete keyword; 2) https://www.sqlite.org/pragma.html#pragma_journal_mode original spelling
- */
-#ifdef DELETE
-#undef DELETE
-#endif
-    enum class journal_mode : signed char {
-        DELETE = 0,
-        TRUNCATE = 1,
-        PERSIST = 2,
-        MEMORY = 3,
-        WAL = 4,
-        OFF = 5,
-    };
-
-    namespace internal {
-
-        inline const std::string& to_string(journal_mode j) {
-            static std::string res[] = {
-                "DELETE",
-                "TRUNCATE",
-                "PERSIST",
-                "MEMORY",
-                "WAL",
-                "OFF",
-            };
-            return res[static_cast<int>(j)];
-        }
-
-        inline std::unique_ptr<journal_mode> journal_mode_from_string(const std::string& str) {
-            std::string upper_str;
-            std::transform(str.begin(), str.end(), std::back_inserter(upper_str), [](char c) {
-                return static_cast<char>(std::toupper(static_cast<int>(c)));
-            });
-            static std::array<journal_mode, 6> all = {{
-                journal_mode::DELETE,
-                journal_mode::TRUNCATE,
-                journal_mode::PERSIST,
-                journal_mode::MEMORY,
-                journal_mode::WAL,
-                journal_mode::OFF,
-            }};
-            for(auto j: all) {
-                if(to_string(j) == upper_str) {
-                    return std::make_unique<journal_mode>(j);
-                }
-            }
-            return {};
-        }
-    }
-}
-
-// #include "error_code.h"
-
-namespace sqlite_orm {
-
-    /**
-     *  Helper class used to cast values from argv to V class
-     *  which depends from column type.
-     *
-     */
-    template<class V, typename Enable = void>
-    struct row_extractor {
-        //  used in sqlite3_exec (select)
-        V extract(const char* row_value) const;
-
-        //  used in sqlite_column (iteration, get_all)
-        V extract(sqlite3_stmt* stmt, int columnIndex) const;
-
-        //  used in user defined functions
-        V extract(sqlite3_value* value) const;
-    };
-
-    /**
-     *  Specialization for the 'pointer-passing interface'.
-     * 
-     *  @note The 'pointer-passing' interface doesn't support (and in fact prohibits)
-     *  extracting pointers from columns.
-     */
-    template<class P, class T>
-    struct row_extractor<pointer_arg<P, T>, void> {
-        using V = pointer_arg<P, T>;
-
-        V extract(sqlite3_value* value) const {
-            return {(P*)sqlite3_value_pointer(value, T::value)};
-        }
-    };
-
-    /**
-     * Undefine using pointer_binding<> for querying values
-     */
-    template<class P, class T, class D>
-    struct row_extractor<pointer_binding<P, T, D>, void>;
-
-    /**
-     *  Specialization for arithmetic types.
-     */
-    template<class V>
-    struct row_extractor<V, std::enable_if_t<std::is_arithmetic<V>::value>> {
-        V extract(const char* row_value) const {
-            return this->extract(row_value, tag());
-        }
-
-        V extract(sqlite3_stmt* stmt, int columnIndex) const {
-            return this->extract(stmt, columnIndex, tag());
-        }
-
-        V extract(sqlite3_value* value) const {
-            return this->extract(value, tag());
-        }
-
-      private:
-        using tag = arithmetic_tag_t<V>;
-
-        V extract(const char* row_value, const int_or_smaller_tag&) const {
-            return static_cast<V>(atoi(row_value));
-        }
-
-        V extract(sqlite3_stmt* stmt, int columnIndex, const int_or_smaller_tag&) const {
-            return static_cast<V>(sqlite3_column_int(stmt, columnIndex));
-        }
-
-        V extract(sqlite3_value* value, const int_or_smaller_tag&) const {
-            return static_cast<V>(sqlite3_value_int(value));
-        }
-
-        V extract(const char* row_value, const bigint_tag&) const {
-            return static_cast<V>(atoll(row_value));
-        }
-
-        V extract(sqlite3_stmt* stmt, int columnIndex, const bigint_tag&) const {
-            return static_cast<V>(sqlite3_column_int64(stmt, columnIndex));
-        }
-
-        V extract(sqlite3_value* value, const bigint_tag&) const {
-            return static_cast<V>(sqlite3_value_int64(value));
-        }
-
-        V extract(const char* row_value, const real_tag&) const {
-            return static_cast<V>(atof(row_value));
-        }
-
-        V extract(sqlite3_stmt* stmt, int columnIndex, const real_tag&) const {
-            return static_cast<V>(sqlite3_column_double(stmt, columnIndex));
-        }
-
-        V extract(sqlite3_value* value, const real_tag&) const {
-            return static_cast<V>(sqlite3_value_double(value));
-        }
-    };
-
-    /**
-     *  Specialization for std::string.
-     */
-    template<>
-    struct row_extractor<std::string, void> {
-        std::string extract(const char* row_value) const {
-            if(row_value) {
-                return row_value;
-            } else {
-                return {};
-            }
-        }
-
-        std::string extract(sqlite3_stmt* stmt, int columnIndex) const {
-            if(auto cStr = (const char*)sqlite3_column_text(stmt, columnIndex)) {
-                return cStr;
-            } else {
-                return {};
-            }
-        }
-
-        std::string extract(sqlite3_value* value) const {
-            if(auto cStr = (const char*)sqlite3_value_text(value)) {
-                return cStr;
-            } else {
-                return {};
-            }
-        }
-    };
-#ifndef SQLITE_ORM_OMITS_CODECVT
-    /**
-     *  Specialization for std::wstring.
-     */
-    template<>
-    struct row_extractor<std::wstring, void> {
-        std::wstring extract(const char* row_value) const {
-            if(row_value) {
-                std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
-                return converter.from_bytes(row_value);
-            } else {
-                return {};
-            }
-        }
-
-        std::wstring extract(sqlite3_stmt* stmt, int columnIndex) const {
-            auto cStr = (const char*)sqlite3_column_text(stmt, columnIndex);
-            if(cStr) {
-                std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
-                return converter.from_bytes(cStr);
-            } else {
-                return {};
-            }
-        }
-
-        std::wstring extract(sqlite3_value* value) const {
-            if(auto cStr = (const wchar_t*)sqlite3_value_text16(value)) {
-                return cStr;
-            } else {
-                return {};
-            }
-        }
-    };
-#endif  //  SQLITE_ORM_OMITS_CODECVT
-
-    template<class V>
-    struct row_extractor<V, std::enable_if_t<is_std_ptr<V>::value>> {
-        using value_type = typename is_std_ptr<V>::element_type;
-
-        V extract(const char* row_value) const {
-            if(row_value) {
-                return is_std_ptr<V>::make(row_extractor<value_type>().extract(row_value));
-            } else {
-                return {};
-            }
-        }
-
-        V extract(sqlite3_stmt* stmt, int columnIndex) const {
-            auto type = sqlite3_column_type(stmt, columnIndex);
-            if(type != SQLITE_NULL) {
-                return is_std_ptr<V>::make(row_extractor<value_type>().extract(stmt, columnIndex));
-            } else {
-                return {};
-            }
-        }
-
-        V extract(sqlite3_value* value) const {
-            auto type = sqlite3_value_type(value);
-            if(type != SQLITE_NULL) {
-                return is_std_ptr<V>::make(row_extractor<value_type>().extract(value));
-            } else {
-                return {};
-            }
-        }
-    };
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-    template<class T>
-    struct row_extractor<std::optional<T>, void> {
-        using value_type = T;
-
-        std::optional<T> extract(const char* row_value) const {
-            if(row_value) {
-                return std::make_optional(row_extractor<value_type>().extract(row_value));
-            } else {
-                return std::nullopt;
-            }
-        }
-
-        std::optional<T> extract(sqlite3_stmt* stmt, int columnIndex) const {
-            auto type = sqlite3_column_type(stmt, columnIndex);
-            if(type != SQLITE_NULL) {
-                return std::make_optional(row_extractor<value_type>().extract(stmt, columnIndex));
-            } else {
-                return std::nullopt;
-            }
-        }
-
-        std::optional<T> extract(sqlite3_value* value) const {
-            auto type = sqlite3_value_type(value);
-            if(type != SQLITE_NULL) {
-                return std::make_optional(row_extractor<value_type>().extract(value));
-            } else {
-                return std::nullopt;
-            }
-        }
-    };
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-    /**
-     *  Specialization for std::vector<char>.
-     */
-    template<>
-    struct row_extractor<std::vector<char>> {
-        std::vector<char> extract(const char* row_value) const {
-            if(row_value) {
-                auto len = ::strlen(row_value);
-                return this->go(row_value, len);
-            } else {
-                return {};
-            }
-        }
-
-        std::vector<char> extract(sqlite3_stmt* stmt, int columnIndex) const {
-            auto bytes = static_cast<const char*>(sqlite3_column_blob(stmt, columnIndex));
-            auto len = static_cast<size_t>(sqlite3_column_bytes(stmt, columnIndex));
-            return this->go(bytes, len);
-        }
-
-        std::vector<char> extract(sqlite3_value* value) const {
-            auto bytes = static_cast<const char*>(sqlite3_value_blob(value));
-            auto len = static_cast<size_t>(sqlite3_value_bytes(value));
-            return this->go(bytes, len);
-        }
-
-      protected:
-        std::vector<char> go(const char* bytes, size_t len) const {
-            if(len) {
-                std::vector<char> res;
-                res.reserve(len);
-                std::copy(bytes, bytes + len, std::back_inserter(res));
-                return res;
-            } else {
-                return {};
-            }
-        }
-    };
-
-    template<class... Args>
-    struct row_extractor<std::tuple<Args...>> {
-
-        std::tuple<Args...> extract(char** argv) const {
-            std::tuple<Args...> res;
-            this->extract<std::tuple_size<decltype(res)>::value>(res, argv);
-            return res;
-        }
-
-        std::tuple<Args...> extract(sqlite3_stmt* stmt, int /*columnIndex*/) const {
-            std::tuple<Args...> res;
-            this->extract<std::tuple_size<decltype(res)>::value>(res, stmt);
-            return res;
-        }
-
-      protected:
-        template<size_t I, typename std::enable_if<I != 0>::type* = nullptr>
-        void extract(std::tuple<Args...>& t, sqlite3_stmt* stmt) const {
-            using tuple_type = typename std::tuple_element<I - 1, typename std::tuple<Args...>>::type;
-            std::get<I - 1>(t) = row_extractor<tuple_type>().extract(stmt, I - 1);
-            this->extract<I - 1>(t, stmt);
-        }
-
-        template<size_t I, typename std::enable_if<I == 0>::type* = nullptr>
-        void extract(std::tuple<Args...>&, sqlite3_stmt*) const {
-            //..
-        }
-
-        template<size_t I, typename std::enable_if<I != 0>::type* = nullptr>
-        void extract(std::tuple<Args...>& t, char** argv) const {
-            using tuple_type = typename std::tuple_element<I - 1, typename std::tuple<Args...>>::type;
-            std::get<I - 1>(t) = row_extractor<tuple_type>().extract(argv[I - 1]);
-            this->extract<I - 1>(t, argv);
-        }
-
-        template<size_t I, typename std::enable_if<I == 0>::type* = nullptr>
-        void extract(std::tuple<Args...>&, char**) const {
-            //..
-        }
-    };
-
-    /**
-     *  Specialization for journal_mode.
-     */
-    template<>
-    struct row_extractor<journal_mode, void> {
-        journal_mode extract(const char* row_value) const {
-            if(row_value) {
-                if(auto res = internal::journal_mode_from_string(row_value)) {
-                    return std::move(*res);
-                } else {
-                    throw std::system_error(std::make_error_code(orm_error_code::incorrect_journal_mode_string));
-                }
-            } else {
-                throw std::system_error(std::make_error_code(orm_error_code::incorrect_journal_mode_string));
-            }
-        }
-
-        journal_mode extract(sqlite3_stmt* stmt, int columnIndex) const {
-            auto cStr = (const char*)sqlite3_column_text(stmt, columnIndex);
-            return this->extract(cStr);
-        }
-    };
-}
-#pragma once
-
-#include <sqlite3.h>
-#include <string>  //  std::string
-#include <system_error>  //  std::system_error, std::error_code
-
-namespace sqlite_orm {
-
-    namespace internal {
-        inline void perform_step(sqlite3* db, sqlite3_stmt* stmt) {
-            auto rc = sqlite3_step(stmt);
-            if(rc == SQLITE_DONE) {
-                //  done..
-            } else {
-                throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                        sqlite3_errmsg(db));
-            }
-        }
-
-        static void perform_void_exec(sqlite3* db, const std::string& query) {
-            int rc = sqlite3_exec(db, query.c_str(), nullptr, nullptr, nullptr);
-            if(rc != SQLITE_OK) {
-                throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                        sqlite3_errmsg(db));
-            }
-        }
-
-        template<class T>
-        inline auto call_insert_impl_and_catch_constraint_failed(const T& insert_impl) {
-            try {
-                return insert_impl();
-            } catch(const std::system_error& e) {
-                if(e.code() == std::error_code(SQLITE_CONSTRAINT, get_sqlite_error_category())) {
-                    std::stringstream ss;
-                    ss << "Attempting to execute 'insert' request resulted in an error like \"" << e.what()
-                       << "\". Perhaps ordinary 'insert' is not acceptable for this table and you should try "
-                          "'replace' or 'insert' with explicit column listing?";
-                    throw std::system_error(e.code(), ss.str());
-                }
-                throw;
-            }
-        }
-    }
-}
-#pragma once
-
-#include <ostream>
-
-namespace sqlite_orm {
-
-    enum class sync_schema_result {
-
-        /**
-         *  created new table, table with the same tablename did not exist
-         */
-        new_table_created,
-
-        /**
-         *  table schema is the same as storage, nothing to be done
-         */
-        already_in_sync,
-
-        /**
-         *  removed excess columns in table (than storage) without dropping a table
-         */
-        old_columns_removed,
-
-        /**
-         *  lacking columns in table (than storage) added without dropping a table
-         */
-        new_columns_added,
-
-        /**
-         *  both old_columns_removed and new_columns_added
-         */
-        new_columns_added_and_old_columns_removed,
-
-        /**
-         *  old table is dropped and new is recreated. Reasons :
-         *      1. delete excess columns in the table than storage if preseve = false
-         *      2. Lacking columns in the table cannot be added due to NULL and DEFAULT constraint
-         *      3. Reasons 1 and 2 both together
-         *      4. data_type mismatch between table and storage.
-         */
-        dropped_and_recreated,
-    };
-
-    inline std::ostream& operator<<(std::ostream& os, sync_schema_result value) {
-        switch(value) {
-            case sync_schema_result::new_table_created:
-                return os << "new table created";
-            case sync_schema_result::already_in_sync:
-                return os << "table and storage is already in sync.";
-            case sync_schema_result::old_columns_removed:
-                return os << "old excess columns removed";
-            case sync_schema_result::new_columns_added:
-                return os << "new columns added";
-            case sync_schema_result::new_columns_added_and_old_columns_removed:
-                return os << "old excess columns removed and new columns added";
-            case sync_schema_result::dropped_and_recreated:
-                return os << "old table dropped and recreated";
-        }
-        return os;
-    }
-}
-#pragma once
-
-#include <tuple>  //  std::tuple, std::make_tuple
-#include <string>  //  std::string
-#include <utility>  //  std::forward
-
-// #include "indexed_column.h"
-
-#include <string>  //  std::string
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        template<class C>
-        struct indexed_column_t {
-            using column_type = C;
-
-            indexed_column_t(column_type _column_or_expression) :
-                column_or_expression(std::move(_column_or_expression)) {}
-
-            column_type column_or_expression;
-            std::string _collation_name;
-            int _order = 0;  //  -1 = desc, 1 = asc, 0 = not specified
-
-            indexed_column_t<column_type> collate(std::string name) {
-                auto res = std::move(*this);
-                res._collation_name = move(name);
-                return res;
-            }
-
-            indexed_column_t<column_type> asc() {
-                auto res = std::move(*this);
-                res._order = 1;
-                return res;
-            }
-
-            indexed_column_t<column_type> desc() {
-                auto res = std::move(*this);
-                res._order = -1;
-                return res;
-            }
-        };
-
-        template<class C>
-        struct indexed_column_maker {
-            using type = indexed_column_t<C>;
-
-            indexed_column_t<C> operator()(C col) const {
-                return {std::move(col)};
-            }
-        };
-
-        template<class C>
-        struct indexed_column_maker<indexed_column_t<C>> {
-            using type = indexed_column_t<C>;
-
-            indexed_column_t<C> operator()(indexed_column_t<C> col) const {
-                return std::move(col);
-            }
-        };
-
-        template<class C>
-        auto make_indexed_column(C col) {
-            indexed_column_maker<C> maker;
-            return maker(std::move(col));
-        }
-
-    }
-
-    /**
-     * Use this function to specify indexed column inside `make_index` function call.
-     * Example: make_index("index_name", indexed_column(&User::id).asc())
-     */
-    template<class C>
-    internal::indexed_column_t<C> indexed_column(C column_or_expression) {
-        return {std::move(column_or_expression)};
-    }
-
-}
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        struct index_base {
-            std::string name;
-            bool unique = false;
-        };
-
-        template<class... Els>
-        struct index_t : index_base {
-            using elements_type = std::tuple<Els...>;
-            using object_type = void;
-
-            index_t(std::string name_, bool unique_, elements_type elements_) :
-                index_base{move(name_), unique_}, elements(move(elements_)) {}
-
-            elements_type elements;
-        };
-    }
-
-    template<class... Cols>
-    internal::index_t<typename internal::indexed_column_maker<Cols>::type...> make_index(const std::string& name,
-                                                                                         Cols... cols) {
-        return {name, false, std::make_tuple(internal::make_indexed_column(cols)...)};
-    }
-
-    template<class... Cols>
-    internal::index_t<typename internal::indexed_column_maker<Cols>::type...> make_unique_index(const std::string& name,
-                                                                                                Cols... cols) {
-        return {name, true, std::make_tuple(internal::make_indexed_column(cols)...)};
-    }
-}
-#pragma once
-
-// #include "alias.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         *  If T is alias than mapped_type_proxy<T>::type is alias::type
-         *  otherwise T is T.
-         */
-        template<class T, class sfinae = void>
-        struct mapped_type_proxy {
-            using type = T;
-        };
-
-        template<class T>
-        struct mapped_type_proxy<T, typename std::enable_if<std::is_base_of<alias_tag, T>::value>::type> {
-            using type = typename T::type;
-        };
-    }
-}
-#pragma once
-
-#include <string>  //  std::string
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        struct rowid_t {
-            operator std::string() const {
-                return "rowid";
-            }
-        };
-
-        struct oid_t {
-            operator std::string() const {
-                return "oid";
-            }
-        };
-
-        struct _rowid_t {
-            operator std::string() const {
-                return "_rowid_";
-            }
-        };
-
-        template<class T>
-        struct table_rowid_t : public rowid_t {
-            using type = T;
-        };
-
-        template<class T>
-        struct table_oid_t : public oid_t {
-            using type = T;
-        };
-        template<class T>
-        struct table__rowid_t : public _rowid_t {
-            using type = T;
-        };
-
-    }
-
-    inline internal::rowid_t rowid() {
-        return {};
-    }
-
-    inline internal::oid_t oid() {
-        return {};
-    }
-
-    inline internal::_rowid_t _rowid_() {
-        return {};
-    }
-
-    template<class T>
-    internal::table_rowid_t<T> rowid() {
-        return {};
-    }
-
-    template<class T>
-    internal::table_oid_t<T> oid() {
-        return {};
-    }
-
-    template<class T>
-    internal::table__rowid_t<T> _rowid_() {
-        return {};
-    }
-}
-#pragma once
-
-#include <type_traits>  //  std::enable_if, std::is_same, std::decay, std::is_arithmetic
-#include <tuple>  //  std::tuple
-#include <functional>  //  std::reference_wrapper
-
-// #include "core_functions.h"
-
-// #include "select_constraints.h"
-
-// #include "operators.h"
-
-// #include "rowid.h"
-
-// #include "alias.h"
-
-// #include "column.h"
-
-// #include "storage_traits.h"
-#include <type_traits>  //  std::is_same, std::enable_if, std::true_type, std::false_type, std::integral_constant
-#include <tuple>  //  std::tuple
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        template<class... Ts>
-        struct storage_impl;
-
-        template<class T, bool WithoutRowId, class... Cs>
-        struct table_t;
-
-        template<class A, class B>
-        struct foreign_key_t;
-
-        namespace storage_traits {
-
-            /**
-             *  S - storage_impl type
-             *  T - mapped or not mapped data type
-             */
-            template<class S, class T, class SFINAE = void>
-            struct type_is_mapped_impl;
-
-            /**
-             *  S - storage
-             *  T - mapped or not mapped data type
-             */
-            template<class S, class T>
-            struct type_is_mapped : type_is_mapped_impl<typename S::impl_type, T> {};
-
-            /**
-             *  Final specialisation
-             */
-            template<class T>
-            struct type_is_mapped_impl<storage_impl<>, T, void> : std::false_type {};
-
-            template<class S, class T>
-            struct type_is_mapped_impl<
-                S,
-                T,
-                typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type>
-                : std::true_type {};
-
-            template<class S, class T>
-            struct type_is_mapped_impl<
-                S,
-                T,
-                typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
-                : type_is_mapped_impl<typename S::super, T> {};
-
-            /**
-             *  S - storage_impl type
-             *  T - mapped or not mapped data type
-             */
-            template<class S, class T, class SFINAE = void>
-            struct storage_columns_count_impl;
-
-            /**
-             *  S - storage
-             *  T - mapped or not mapped data type
-             */
-            template<class S, class T>
-            struct storage_columns_count : storage_columns_count_impl<typename S::impl_type, T> {};
-
-            /**
-             *  Final specialisation
-             */
-            template<class T>
-            struct storage_columns_count_impl<storage_impl<>, T, void> : std::integral_constant<int, 0> {};
-
-            template<class S, class T>
-            struct storage_columns_count_impl<
-                S,
-                T,
-                typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type>
-                : std::integral_constant<int, S::table_type::elements_count> {};
-
-            template<class S, class T>
-            struct storage_columns_count_impl<
-                S,
-                T,
-                typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
-                : storage_columns_count_impl<typename S::super, T> {};
-
-            /**
-             *  T - table type.
-             */
-            template<class T>
-            struct table_types;
-
-            /**
-             *  type is std::tuple of field types of mapped colums.
-             */
-            template<class T, bool WithoutRowId, class... Args>
-            struct table_types<table_t<T, WithoutRowId, Args...>> {
-                using args_tuple = std::tuple<Args...>;
-                using columns_tuple = typename tuple_filter<args_tuple, is_column>::type;
-
-                using type = typename tuple_transformer<columns_tuple, column_field_type>::type;
-            };
-
-            /**
-             *  S - storage_impl type
-             *  T - mapped or not mapped data type
-             */
-            template<class S, class T, class SFINAE = void>
-            struct storage_mapped_columns_impl;
-
-            /**
-             *  S - storage
-             *  T - mapped or not mapped data type
-             */
-            template<class S, class T>
-            struct storage_mapped_columns : storage_mapped_columns_impl<typename S::impl_type, T> {};
-
-            /**
-             *  Final specialisation
-             */
-            template<class T>
-            struct storage_mapped_columns_impl<storage_impl<>, T, void> {
-                using type = std::tuple<>;
-            };
-
-            template<class S, class T>
-            struct storage_mapped_columns_impl<
-                S,
-                T,
-                typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> {
-                using table_type = typename S::table_type;
-                using type = typename table_types<table_type>::type;
-            };
-
-            template<class S, class T>
-            struct storage_mapped_columns_impl<
-                S,
-                T,
-                typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
-                : storage_mapped_columns_impl<typename S::super, T> {};
-
-            /**
-             *  C is any column type: column_t or constraint type
-             *  O - object type references in FOREIGN KEY
-             */
-            template<class C, class O>
-            struct column_foreign_keys_count : std::integral_constant<int, 0> {};
-
-            template<class A, class B, class O>
-            struct column_foreign_keys_count<foreign_key_t<A, B>, O> {
-                using target_type = typename foreign_key_t<A, B>::target_type;
-
-                static constexpr const int value = std::is_same<O, target_type>::value ? 1 : 0;
-            };
-
-            /**
-             * O - object type references in FOREIGN KEY
-             * Cs - column types which are stored in table_t::columns_type
-             */
-            template<class O, class... Cs>
-            struct table_foreign_keys_count_impl;
-
-            template<class O>
-            struct table_foreign_keys_count_impl<O> {
-                static constexpr const int value = 0;
-            };
-
-            template<class O, class H, class... Tail>
-            struct table_foreign_keys_count_impl<O, H, Tail...> {
-                static constexpr const int value =
-                    column_foreign_keys_count<H, O>::value + table_foreign_keys_count_impl<O, Tail...>::value;
-            };
-
-            /**
-             *  T is table_t type
-             *  O is object type which is the reference target (e.g. foreign_key(&Visit::userId).references(&User::id) has O = User)
-             */
-            template<class T, class O>
-            struct table_foreign_keys_count;
-
-            template<class T, class... Cs, class O>
-            struct table_foreign_keys_count<table_t<T, false, Cs...>, O> {
-                using table_type = table_t<T, false, Cs...>;
-
-                static constexpr const int value = table_foreign_keys_count_impl<O, Cs...>::value;
-            };
-
-            /**
-             *  S - storage class
-             *  O - type mapped to S
-             */
-            template<class S, class O>
-            struct storage_foreign_keys_count_impl;
-
-            template<class O>
-            struct storage_foreign_keys_count_impl<storage_impl<>, O> : std::integral_constant<int, 0> {};
-
-            template<class H, class... Ts, class O>
-            struct storage_foreign_keys_count_impl<storage_impl<H, Ts...>, O> {
-                static constexpr const int value = table_foreign_keys_count<H, O>::value +
-                                                   storage_foreign_keys_count_impl<storage_impl<Ts...>, O>::value;
-            };
-
-            /**
-             * S - storage class
-             * O - type mapped to S
-             * This class tells how many types mapped to S have foreign keys to O
-             */
-            template<class S, class O>
-            struct storage_foreign_keys_count {
-                using impl_type = typename S::impl_type;
-
-                static constexpr const int value = storage_foreign_keys_count_impl<impl_type, O>::value;
-            };
-
-            /**
-             * C is any table element type: column_t or constraint type
-             * O - object type references in FOREIGN KEY
-             */
-            template<class C, class O, class SFINAE = void>
-            struct column_fk_references {
-                using type = std::tuple<>;
-            };
-
-            template<class C, class O, class SFINAE = void>
-            struct column_foreign_keys {
-                using type = std::tuple<>;
-            };
-
-            template<class A, class B, class O>
-            struct column_foreign_keys<
-                foreign_key_t<A, B>,
-                O,
-                typename std::enable_if<std::is_same<O, typename foreign_key_t<A, B>::target_type>::value>::type> {
-                using type = std::tuple<foreign_key_t<A, B>>;
-            };
-
-            template<class A, class B, class O>
-            struct column_foreign_keys<
-                foreign_key_t<A, B>,
-                O,
-                typename std::enable_if<!std::is_same<O, typename foreign_key_t<A, B>::target_type>::value>::type> {
-                using type = std::tuple<>;
-            };
-
-            template<class A, class B, class O>
-            struct column_fk_references<
-                foreign_key_t<A, B>,
-                O,
-                typename std::enable_if<std::is_same<O, typename foreign_key_t<A, B>::target_type>::value>::type> {
-                using target_type = typename foreign_key_t<A, B>::source_type;
-
-                using type = std::tuple<target_type>;
-            };
-
-            template<class A, class B, class O>
-            struct column_fk_references<
-                foreign_key_t<A, B>,
-                O,
-                typename std::enable_if<!std::is_same<O, typename foreign_key_t<A, B>::target_type>::value>::type> {
-                using type = std::tuple<>;
-            };
-
-            /**
-             * O - object type references in FOREIGN KEY
-             * Cs - column types which are stored in table_t::columns_type
-             */
-            template<class O, class... Cs>
-            struct table_fk_references_impl;
-
-            template<class O, class... Cs>
-            struct table_foreign_keys_impl;
-
-            template<class O>
-            struct table_fk_references_impl<O> {
-                using type = std::tuple<>;
-            };
-
-            template<class O>
-            struct table_foreign_keys_impl<O> {
-                using type = std::tuple<>;
-            };
-
-            template<class O, class H, class... Tail>
-            struct table_fk_references_impl<O, H, Tail...> {
-                using head_tuple = typename column_fk_references<H, O>::type;
-                using tail_tuple = typename table_fk_references_impl<O, Tail...>::type;
-                using type = typename conc_tuple<head_tuple, tail_tuple>::type;
-            };
-
-            template<class O, class H, class... Tail>
-            struct table_foreign_keys_impl<O, H, Tail...> {
-                using head_tuple = typename column_foreign_keys<H, O>::type;
-                using tail_tuple = typename table_foreign_keys_impl<O, Tail...>::type;
-                using type = typename conc_tuple<head_tuple, tail_tuple>::type;
-            };
-
-            /**
-             *  T is table_t type
-             *  O is object type which is the reference target (e.g. foreign_key(&Visit::userId).references(&User::id) has O = User)
-             */
-            template<class T, class O>
-            struct table_fk_references;
-
-            template<class T, class O>
-            struct table_foreign_keys;
-
-            template<class T, bool WithoutRowId, class... Cs, class O>
-            struct table_fk_references<table_t<T, WithoutRowId, Cs...>, O> {
-                using table_type = table_t<T, WithoutRowId, Cs...>;
-
-                using type = typename table_fk_references_impl<O, Cs...>::type;
-            };
-
-            template<class T, bool WithoutRowId, class... Cs, class O>
-            struct table_foreign_keys<table_t<T, WithoutRowId, Cs...>, O> {
-                using table_type = table_t<T, WithoutRowId, Cs...>;
-
-                using type = typename table_foreign_keys_impl<O, Cs...>::type;
-            };
-
-            /**
-             *  S - storage class
-             *  O - type mapped to S
-             */
-            template<class S, class O>
-            struct storage_fk_references_impl;
-
-            template<class S, class O>
-            struct storage_foreign_keys_impl;
-
-            template<class O>
-            struct storage_fk_references_impl<storage_impl<>, O> {
-                using type = std::tuple<>;
-            };
-
-            template<class O>
-            struct storage_foreign_keys_impl<storage_impl<>, O> {
-                using type = std::tuple<>;
-            };
-
-            template<class H, class... Ts, class O>
-            struct storage_fk_references_impl<storage_impl<H, Ts...>, O> {
-                using head_tuple = typename table_fk_references<H, O>::type;
-                using tail_tuple = typename storage_fk_references_impl<storage_impl<Ts...>, O>::type;
-                using type = typename conc_tuple<head_tuple, tail_tuple>::type;
-            };
-
-            template<class H, class... Ts, class O>
-            struct storage_foreign_keys_impl<storage_impl<H, Ts...>, O> {
-                using head_tuple = typename table_foreign_keys<H, O>::type;
-                using tail_tuple = typename storage_foreign_keys_impl<storage_impl<Ts...>, O>::type;
-                using type = typename conc_tuple<head_tuple, tail_tuple>::type;
-            };
-
-            /**
-             *  S - storage class
-             *  O - type mapped to S
-             *  type holds `std::tuple` with types that has references to O as  foreign keys
-             */
-            template<class S, class O>
-            struct storage_fk_references {
-                using impl_type = typename S::impl_type;
-
-                using type = typename storage_fk_references_impl<impl_type, O>::type;
-            };
-
-            template<class S, class O>
-            struct storage_foreign_keys {
-                using impl_type = typename S::impl_type;
-
-                using type = typename storage_foreign_keys_impl<impl_type, O>::type;
-            };
-
-        }
-    }
-}
-
-// #include "function.h"
-
-#include <string>  //  std::string
-#include <sqlite3.h>
-#include <tuple>  //  std::tuple
-#include <functional>  //  std::function
-#include <algorithm>  //  std::min
-
-// #include "cxx_polyfill.h"
-
-namespace sqlite_orm {
-
-    struct arg_values;
-
-    template<class T, class P>
-    struct pointer_arg;
-    template<class T, class P, class D>
-    class pointer_binding;
-
-    namespace internal {
-
-        struct function_base {
-            using func_call = std::function<
-                void(sqlite3_context* context, void* functionPointer, int argsCount, sqlite3_value** values)>;
-            using final_call = std::function<void(sqlite3_context* context, void* functionPointer)>;
-
-            std::string name;
-            int argumentsCount = 0;
-            std::function<int*()> create;
-            void (*destroy)(int*) = nullptr;
-
-            function_base(decltype(name) name_,
-                          decltype(argumentsCount) argumentsCount_,
-                          decltype(create) create_,
-                          decltype(destroy) destroy_) :
-                name(move(name_)),
-                argumentsCount(argumentsCount_), create(move(create_)), destroy(destroy_) {}
-        };
-
-        struct scalar_function_t : function_base {
-            func_call run;
-
-            scalar_function_t(decltype(name) name_,
-                              int argumentsCount_,
-                              decltype(create) create_,
-                              decltype(run) run_,
-                              decltype(destroy) destroy_) :
-                function_base{move(name_), argumentsCount_, move(create_), destroy_},
-                run(move(run_)) {}
-        };
-
-        struct aggregate_function_t : function_base {
-            func_call step;
-            final_call finalCall;
-
-            aggregate_function_t(decltype(name) name_,
-                                 int argumentsCount_,
-                                 decltype(create) create_,
-                                 decltype(step) step_,
-                                 decltype(finalCall) finalCall_,
-                                 decltype(destroy) destroy_) :
-                function_base{move(name_), argumentsCount_, move(create_), destroy_},
-                step(move(step_)), finalCall(move(finalCall_)) {}
-        };
-
-        //  got it from here https://stackoverflow.com/questions/87372/check-if-a-class-has-a-member-function-of-a-given-signature
-        template<class F>
-        struct is_scalar_function_impl {
-
-            template<class U, class T>
-            struct SFINAE;
-
-            template<class U, class R>
-            struct SFINAE<U, R (U::*)() const> {};
-
-            template<class U>
-            static char test(SFINAE<U, decltype(&U::operator())>*);
-
-            template<class U>
-            static int test(...);
-
-            static constexpr bool has = sizeof(test<F>(0)) == sizeof(char);
-        };
-
-        template<class F>
-        struct is_aggregate_function_impl {
-
-            template<class U, class T>
-            struct SFINAE;
-
-            template<class U, class R>
-            struct SFINAE<U, R (U::*)() const> {};
-
-            template<class U>
-            static char test(SFINAE<U, decltype(&U::step)>*);
-
-            template<class U>
-            static int test(...);
-
-            template<class U>
-            static char test2(SFINAE<U, decltype(&U::fin)>*);
-
-            template<class U>
-            static int test2(...);
-
-            static constexpr bool has = sizeof(test<F>(0)) == sizeof(char);
-            static constexpr bool has2 = sizeof(test2<F>(0)) == sizeof(char);
-            static constexpr bool has_both = has && has2;
-        };
-
-        template<class F>
-        struct is_scalar_function : std::integral_constant<bool, is_scalar_function_impl<F>::has> {};
-
-        template<class F>
-        struct is_aggregate_function : std::integral_constant<bool, is_aggregate_function_impl<F>::has_both> {};
-
-        template<class F>
-        struct scalar_run_member_pointer {
-            using type = decltype(&F::operator());
-        };
-
-        template<class F>
-        struct aggregate_run_member_pointer {
-            using step_type = decltype(&F::step);
-            using fin_type = decltype(&F::fin);
-        };
-
-        template<class T>
-        struct member_function_arguments;
-
-        template<class O, class R, class... Args>
-        struct member_function_arguments<R (O::*)(Args...) const> {
-            using member_function_type = R (O::*)(Args...) const;
-            using tuple_type = std::tuple<typename std::decay<Args>::type...>;
-            using return_type = R;
-        };
-
-        template<class O, class R, class... Args>
-        struct member_function_arguments<R (O::*)(Args...)> {
-            using member_function_type = R (O::*)(Args...);
-            using tuple_type = std::tuple<typename std::decay<Args>::type...>;
-            using return_type = R;
-        };
-
-        template<class F, bool IsScalar>
-        struct callable_arguments_impl;
-
-        template<class F>
-        struct callable_arguments_impl<F, true> {
-            using function_member_pointer = typename scalar_run_member_pointer<F>::type;
-            using args_tuple = typename member_function_arguments<function_member_pointer>::tuple_type;
-            using return_type = typename member_function_arguments<function_member_pointer>::return_type;
-        };
-
-        template<class F>
-        struct callable_arguments_impl<F, false> {
-            using step_function_member_pointer = typename aggregate_run_member_pointer<F>::step_type;
-            using fin_function_member_pointer = typename aggregate_run_member_pointer<F>::fin_type;
-            using args_tuple = typename member_function_arguments<step_function_member_pointer>::tuple_type;
-            using return_type = typename member_function_arguments<fin_function_member_pointer>::return_type;
-        };
-
-        template<class F>
-        struct callable_arguments : callable_arguments_impl<F, is_scalar_function<F>::value> {};
-
-        template<class F, class... Args>
-        struct function_call {
-            using function_type = F;
-            using args_tuple = std::tuple<Args...>;
-
-            args_tuple args;
-        };
-
-        template<class T>
-        struct unpacked_arg {
-            using type = T;
-        };
-        template<class F, class... Args>
-        struct unpacked_arg<function_call<F, Args...>> {
-            using type = typename callable_arguments<F>::return_type;
-        };
-        template<class T>
-        using unpacked_arg_t = typename unpacked_arg<T>::type;
-
-        template<size_t I, class FnArg, class CallArg>
-        SQLITE_ORM_CONSTEVAL bool expected_pointer_value() {
-            static_assert(polyfill::always_false_v<FnArg, CallArg>, "Expected a pointer value for I-th argument");
-            return false;
-        }
-
-        template<size_t I, class FnArg, class CallArg, class EnableIfTag = void>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_same_pvt_v = expected_pointer_value<I, FnArg, CallArg>();
-
-#if __cplusplus >= 201703L  // using C++17 or higher
-        template<size_t I, const char* PointerArg, const char* Binding>
-        SQLITE_ORM_CONSTEVAL bool assert_same_pointer_type() {
-            constexpr bool valid = Binding == PointerArg;
-            static_assert(valid, "Pointer value types of I-th argument do not match");
-            return valid;
-        }
-
-        template<size_t I, class PointerArg, class Binding>
-        SQLITE_ORM_INLINE_VAR constexpr bool
-            is_same_pvt_v<I, PointerArg, Binding, polyfill::void_t<typename PointerArg::tag, typename Binding::tag>> =
-                assert_same_pointer_type<I, PointerArg::tag::value, Binding::tag::value>();
-#else
-        template<size_t I, class PointerArg, class Binding>
-        SQLITE_ORM_CONSTEVAL bool assert_same_pointer_type() {
-            constexpr bool valid = Binding::value == PointerArg::value;
-            static_assert(valid, "Pointer value types of I-th argument do not match");
-            return valid;
-        }
-
-        template<size_t I, class PointerArg, class Binding>
-        SQLITE_ORM_INLINE_VAR constexpr bool
-            is_same_pvt_v<I, PointerArg, Binding, polyfill::void_t<typename PointerArg::tag, typename Binding::tag>> =
-                assert_same_pointer_type<I, typename PointerArg::tag, typename Binding::tag>();
-#endif
-
-        template<size_t I, class FnArg, class CallArg>
-        SQLITE_ORM_CONSTEVAL bool validate_pointer_value_type(std::false_type) {
-            return true;
-        }
-
-        template<size_t I, class FnArg, class CallArg>
-        SQLITE_ORM_CONSTEVAL bool validate_pointer_value_type(std::true_type) {
-            return is_same_pvt_v<I, FnArg, CallArg>;
-        }
-
-        template<class FnArgs, class CallArgs>
-        SQLITE_ORM_CONSTEVAL bool validate_pointer_value_types(polyfill::index_constant<size_t(-1)>) {
-            return true;
-        }
-        template<class FnArgs, class CallArgs, size_t I>
-        SQLITE_ORM_CONSTEVAL bool validate_pointer_value_types(polyfill::index_constant<I>) {
-            using func_arg_t = std::tuple_element_t<I, FnArgs>;
-            using passed_arg_t = unpacked_arg_t<std::tuple_element_t<I, CallArgs>>;
-
-            constexpr bool valid = validate_pointer_value_type<I,
-                                                               std::tuple_element_t<I, FnArgs>,
-                                                               unpacked_arg_t<std::tuple_element_t<I, CallArgs>>>(
-                polyfill::bool_constant < (polyfill::is_specialization_of_v<func_arg_t, pointer_arg>) ||
-                (polyfill::is_specialization_of_v<passed_arg_t, pointer_binding>) > {});
-
-            return validate_pointer_value_types<FnArgs, CallArgs>(polyfill::index_constant<I - 1>{}) && valid;
-        }
-    }
-
-    /**
-     *  Used to call user defined function: `func<MyFunc>(...);`
-     */
-    template<class F, class... Args>
-    internal::function_call<F, Args...> func(Args... args) {
-        using args_tuple = std::tuple<Args...>;
-        using function_args_tuple = typename internal::callable_arguments<F>::args_tuple;
-        constexpr auto argsCount = std::tuple_size<args_tuple>::value;
-        constexpr auto functionArgsCount = std::tuple_size<function_args_tuple>::value;
-        static_assert((argsCount == functionArgsCount &&
-                       !std::is_same<function_args_tuple, std::tuple<arg_values>>::value &&
-                       internal::validate_pointer_value_types<function_args_tuple, args_tuple>(
-                           internal::polyfill::index_constant<std::min<>(functionArgsCount, argsCount) - 1>{})) ||
-                          std::is_same<function_args_tuple, std::tuple<arg_values>>::value,
-                      "Number of arguments does not match");
-        return {std::make_tuple(std::forward<Args>(args)...)};
-    }
-
-}
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         *  This is a proxy class used to define what type must have result type depending on select
-         *  arguments (member pointer, aggregate functions, etc). Below you can see specializations
-         *  for different types. E.g. specialization for internal::length_t has `type` int cause
-         *  LENGTH returns INTEGER in sqlite. Every column_result_t must have `type` type that equals
-         *  c++ SELECT return type for T
-         *  T - C++ type
-         *  SFINAE - sfinae argument
-         */
-        template<class St, class T, class SFINAE = void>
-        struct column_result_t;
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class St, class T>
-        struct column_result_t<St, as_optional_t<T>, void> {
-            using type = std::optional<typename column_result_t<St, T>::type>;
-        };
-
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-
-        template<class St, class O, class F>
-        struct column_result_t<St,
-                               F O::*,
-                               typename std::enable_if<std::is_member_pointer<F O::*>::value &&
-                                                       !std::is_member_function_pointer<F O::*>::value>::type> {
-            using type = F;
-        };
-
-        template<class St, class L, class A>
-        struct column_result_t<St, dynamic_in_t<L, A>, void> {
-            using type = bool;
-        };
-
-        template<class St, class L, class... Args>
-        struct column_result_t<St, in_t<L, Args...>, void> {
-            using type = bool;
-        };
-
-        /**
-         *  Common case for all getter types. Getter types are defined in column.h file
-         */
-        template<class St, class T>
-        struct column_result_t<St, T, typename std::enable_if<is_getter<T>::value>::type> {
-            using type = typename getter_traits<T>::field_type;
-        };
-
-        /**
-         *  Common case for all setter types. Setter types are defined in column.h file
-         */
-        template<class St, class T>
-        struct column_result_t<St, T, typename std::enable_if<is_setter<T>::value>::type> {
-            using type = typename setter_traits<T>::field_type;
-        };
-
-        template<class St, class R, class S, class... Args>
-        struct column_result_t<St, built_in_function_t<R, S, Args...>, void> {
-            using type = R;
-        };
-
-        template<class St, class F, class... Args>
-        struct column_result_t<St, function_call<F, Args...>, void> {
-            using type = typename callable_arguments<F>::return_type;
-        };
-
-        template<class St, class X, class S>
-        struct column_result_t<St, built_in_function_t<internal::unique_ptr_result_of<X>, S, X>, void> {
-            using type = std::unique_ptr<typename column_result_t<St, X>::type>;
-        };
-
-        template<class St, class T>
-        struct column_result_t<St, count_asterisk_t<T>, void> {
-            using type = int;
-        };
-
-        template<class St>
-        struct column_result_t<St, count_asterisk_without_type, void> {
-            using type = int;
-        };
-
-        template<class St, class T>
-        struct column_result_t<St, distinct_t<T>, void> {
-            using type = typename column_result_t<St, T>::type;
-        };
-
-        template<class St, class T>
-        struct column_result_t<St, all_t<T>, void> {
-            using type = typename column_result_t<St, T>::type;
-        };
-
-        template<class St, class L, class R>
-        struct column_result_t<St, conc_t<L, R>, void> {
-            using type = std::string;
-        };
-
-        template<class St, class L, class R>
-        struct column_result_t<St, add_t<L, R>, void> {
-            using type = double;
-        };
-
-        template<class St, class L, class R>
-        struct column_result_t<St, sub_t<L, R>, void> {
-            using type = double;
-        };
-
-        template<class St, class L, class R>
-        struct column_result_t<St, mul_t<L, R>, void> {
-            using type = double;
-        };
-
-        template<class St, class L, class R>
-        struct column_result_t<St, internal::div_t<L, R>, void> {
-            using type = double;
-        };
-
-        template<class St, class L, class R>
-        struct column_result_t<St, mod_t<L, R>, void> {
-            using type = double;
-        };
-
-        template<class St, class L, class R>
-        struct column_result_t<St, bitwise_shift_left_t<L, R>, void> {
-            using type = int;
-        };
-
-        template<class St, class L, class R>
-        struct column_result_t<St, bitwise_shift_right_t<L, R>, void> {
-            using type = int;
-        };
-
-        template<class St, class L, class R>
-        struct column_result_t<St, bitwise_and_t<L, R>, void> {
-            using type = int;
-        };
-
-        template<class St, class L, class R>
-        struct column_result_t<St, bitwise_or_t<L, R>, void> {
-            using type = int;
-        };
-
-        template<class St, class T>
-        struct column_result_t<St, bitwise_not_t<T>, void> {
-            using type = int;
-        };
-
-        template<class St>
-        struct column_result_t<St, rowid_t, void> {
-            using type = int64;
-        };
-
-        template<class St>
-        struct column_result_t<St, oid_t, void> {
-            using type = int64;
-        };
-
-        template<class St>
-        struct column_result_t<St, _rowid_t, void> {
-            using type = int64;
-        };
-
-        template<class St, class T>
-        struct column_result_t<St, table_rowid_t<T>, void> {
-            using type = int64;
-        };
-
-        template<class St, class T>
-        struct column_result_t<St, table_oid_t<T>, void> {
-            using type = int64;
-        };
-
-        template<class St, class T>
-        struct column_result_t<St, table__rowid_t<T>, void> {
-            using type = int64;
-        };
-
-        template<class St, class T, class C>
-        struct column_result_t<St, alias_column_t<T, C>, void> {
-            using type = typename column_result_t<St, C>::type;
-        };
-
-        template<class St, class T, class F>
-        struct column_result_t<St, column_pointer<T, F>> : column_result_t<St, F, void> {};
-
-        template<class St, class... Args>
-        struct column_result_t<St, columns_t<Args...>, void> {
-            using type = std::tuple<typename column_result_t<St, typename std::decay<Args>::type>::type...>;
-        };
-
-        template<class St, class T, class... Args>
-        struct column_result_t<St, select_t<T, Args...>> : column_result_t<St, T, void> {};
-
-        template<class St, class T>
-        struct column_result_t<St, T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
-            using left_type = typename T::left_type;
-            using right_type = typename T::right_type;
-            using left_result = typename column_result_t<St, left_type>::type;
-            using right_result = typename column_result_t<St, right_type>::type;
-            static_assert(std::is_same<left_result, right_result>::value,
-                          "Compound subselect queries must return same types");
-            using type = left_result;
-        };
-
-        template<class St, class T>
-        struct column_result_t<St, T, typename std::enable_if<is_base_of_template<T, binary_condition>::value>::type> {
-            using type = typename T::result_type;
-        };
-
-        /**
-         *  Result for the most simple queries like `SELECT 1`
-         */
-        template<class St, class T>
-        struct column_result_t<St, T, typename std::enable_if<std::is_arithmetic<T>::value>::type> {
-            using type = T;
-        };
-
-        /**
-         *  Result for the most simple queries like `SELECT 'ototo'`
-         */
-        template<class St>
-        struct column_result_t<St, const char*, void> {
-            using type = std::string;
-        };
-
-        template<class St>
-        struct column_result_t<St, std::string, void> {
-            using type = std::string;
-        };
-
-        template<class St, class T, class E>
-        struct column_result_t<St, as_t<T, E>, void> : column_result_t<St, typename std::decay<E>::type, void> {};
-
-        template<class St, class T>
-        struct column_result_t<St, asterisk_t<T>, void> {
-            using type = typename storage_traits::storage_mapped_columns<St, T>::type;
-        };
-
-        template<class St, class T>
-        struct column_result_t<St, object_t<T>, void> {
-            using type = T;
-        };
-
-        template<class St, class T, class E>
-        struct column_result_t<St, cast_t<T, E>, void> {
-            using type = T;
-        };
-
-        template<class St, class R, class T, class E, class... Args>
-        struct column_result_t<St, simple_case_t<R, T, E, Args...>, void> {
-            using type = R;
-        };
-
-        template<class St, class A, class T, class E>
-        struct column_result_t<St, like_t<A, T, E>, void> {
-            using type = bool;
-        };
-
-        template<class St, class A, class T>
-        struct column_result_t<St, glob_t<A, T>, void> {
-            using type = bool;
-        };
-
-        template<class St, class C>
-        struct column_result_t<St, negated_condition_t<C>, void> {
-            using type = bool;
-        };
-
-        template<class St, class T>
-        struct column_result_t<St, std::reference_wrapper<T>, void> : column_result_t<St, T, void> {};
-    }
-}
-#pragma once
-
-#include <string>  //  std::string
-#include <type_traits>  //  std::remove_reference, std::is_same, std::is_base_of
-#include <vector>  //  std::vector
-#include <tuple>  //  std::tuple_size, std::tuple_element
-#include <algorithm>  //  std::reverse, std::find_if
-
-// #include "column_result.h"
-
-// #include "static_magic.h"
-
-// #include "typed_comparator.h"
-
-// #include "constraints.h"
-
-// #include "tuple_helper/tuple_helper.h"
-
-// #include "table_info.h"
-
-// #include "type_printer.h"
-
-// #include "column.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        struct basic_table {
-
-            /**
-             *  Table name.
-             */
-            std::string name;
-        };
-
-        /**
-         *  Table class.
-         */
-        template<class T, bool WithoutRowId, class... Cs>
-        struct table_t : basic_table {
-            using super = basic_table;
-            using object_type = T;
-            using elements_type = std::tuple<Cs...>;
-
-            static constexpr const int elements_count = static_cast<int>(std::tuple_size<elements_type>::value);
-            static constexpr const bool is_without_rowid = WithoutRowId;
-
-            elements_type elements;
-
-            table_t(std::string name_, elements_type elements_) : super{move(name_)}, elements{move(elements_)} {}
-
-            table_t<T, true, Cs...> without_rowid() const {
-                return {this->name, this->elements};
-            }
-
-            /**
-             *  Function used to get field value from object by mapped member pointer/setter/getter
-             */
-            template<class F, class C>
-            const F* get_object_field_pointer(const object_type& obj, C c) const {
-                const F* res = nullptr;
-                this->for_each_column_with_field_type<F>([&res, &c, &obj](auto& col) {
-                    using column_type = typename std::remove_reference<decltype(col)>::type;
-                    using member_pointer_t = typename column_type::member_pointer_t;
-                    using getter_type = typename column_type::getter_type;
-                    using setter_type = typename column_type::setter_type;
-                    // Make static_if have at least one input as a workaround for GCC bug:
-                    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64095
-                    if(!res) {
-                        static_if<std::is_same<C, member_pointer_t>{}>([&res, &obj, &col](const C& c_) {
-                            if(compare_any(col.member_pointer, c_)) {
-                                res = &(obj.*col.member_pointer);
-                            }
-                        })(c);
-                    }
-                    if(!res) {
-                        static_if<std::is_same<C, getter_type>{}>([&res, &obj, &col](const C& c_) {
-                            if(compare_any(col.getter, c_)) {
-                                res = &((obj).*(col.getter))();
-                            }
-                        })(c);
-                    }
-                    if(!res) {
-                        static_if<std::is_same<C, setter_type>{}>([&res, &obj, &col](const C& c_) {
-                            if(compare_any(col.setter, c_)) {
-                                res = &((obj).*(col.getter))();
-                            }
-                        })(c);
-                    }
-                });
-                return res;
-            }
-
-            template<class C>
-            bool exists_in_composite_primary_key(const C& column) const {
-                auto res = false;
-                this->for_each_primary_key([&column, &res](auto& primaryKey) {
-                    iterate_tuple(primaryKey.columns, [&res, &column](auto& value) {
-                        if(!res) {
-                            if(column.member_pointer) {
-                                res = compare_any(value, column.member_pointer);
-                            } else {
-                                res = compare_any(value, column.getter) || compare_any(value, column.setter);
-                            }
-                        }
-                    });
-                });
-                return res;
-            }
-
-            /**
-             *  Calls **l** with every primary key dedicated constraint
-             */
-            template<class L>
-            void for_each_primary_key(const L& lambda) const {
-                iterate_tuple(this->elements, [&lambda](auto& element) {
-                    using element_type = typename std::decay<decltype(element)>::type;
-                    static_if<is_primary_key<element_type>{}>(lambda)(element);
-                });
-            }
-
-            std::vector<std::string> composite_key_columns_names() const {
-                std::vector<std::string> res;
-                this->for_each_primary_key([this, &res](auto& c) {
-                    res = this->composite_key_columns_names(c);
-                });
-                return res;
-            }
-
-            std::vector<std::string> primary_key_column_names() const {
-                std::vector<std::string> res;
-                this->for_each_column_with<primary_key_t<>>([&res](auto& c) {
-                    res.push_back(c.name);
-                });
-                if(!res.size()) {
-                    res = this->composite_key_columns_names();
-                }
-                return res;
-            }
-
-            template<class... Args>
-            std::vector<std::string> composite_key_columns_names(const primary_key_t<Args...>& pk) const {
-                std::vector<std::string> res;
-                using pk_columns_tuple = decltype(pk.columns);
-                res.reserve(std::tuple_size<pk_columns_tuple>::value);
-                iterate_tuple(pk.columns, [this, &res](auto& v) {
-                    if(auto columnName = this->find_column_name(v)) {
-                        res.push_back(*columnName);
-                    } else {
-                        res.push_back({});
-                    }
-                });
-                return res;
-            }
-
-            /**
-             *  Searches column name by class member pointer passed as the first argument.
-             *  @return column name or empty string if nothing found.
-             */
-            template<class F,
-                     class O,
-                     typename = typename std::enable_if<std::is_member_pointer<F O::*>::value &&
-                                                        !std::is_member_function_pointer<F O::*>::value>::type>
-            const std::string* find_column_name(F O::*m) const {
-                const std::string* res = nullptr;
-                this->template for_each_column_with_field_type<F>([&res, m](auto& c) {
-                    if(c.member_pointer == m) {
-                        res = &c.name;
-                    }
-                });
-                return res;
-            }
-
-            /**
-             *  Searches column name by class getter function member pointer passed as first argument.
-             *  @return column name or empty string if nothing found.
-             */
-            template<class G>
-            const std::string* find_column_name(G getter,
-                                                typename std::enable_if<is_getter<G>::value>::type* = nullptr) const {
-                const std::string* res = nullptr;
-                using field_type = typename getter_traits<G>::field_type;
-                this->template for_each_column_with_field_type<field_type>([&res, getter](auto& c) {
-                    if(compare_any(c.getter, getter)) {
-                        res = &c.name;
-                    }
-                });
-                return res;
-            }
-
-            /**
-             *  Searches column name by class setter function member pointer passed as first argument.
-             *  @return column name or empty string if nothing found.
-             */
-            template<class S>
-            const std::string* find_column_name(S setter,
-                                                typename std::enable_if<is_setter<S>::value>::type* = nullptr) const {
-                const std::string* res = nullptr;
-                using field_type = typename setter_traits<S>::field_type;
-                this->template for_each_column_with_field_type<field_type>([&res, setter](auto& c) {
-                    if(compare_any(c.setter, setter)) {
-                        res = &c.name;
-                    }
-                });
-                return res;
-            }
-
-            /**
-             *  Counts and returns amount of columns without GENERATED ALWAYS constraints. Skips table constraints.
-             */
-            int non_generated_columns_count() const {
-                auto res = 0;
-                this->for_each_column([&res](auto& column) {
-                    if(!column.is_generated()) {
-                        ++res;
-                    }
-                });
-                return res;
-            }
-
-            /**
-             *  Counts and returns amount of columns. Skips constraints.
-             */
-            int count_columns_amount() const {
-                auto res = 0;
-                this->for_each_column([&res](auto&) {
-                    ++res;
-                });
-                return res;
-            }
-
-            /**
-             *  Iterates all columns and fires passed lambda. Lambda must have one and only templated argument. Otherwise
-             *  code will not compile. Excludes table constraints (e.g. foreign_key_t) at the end of the columns list. To
-             *  iterate columns with table constraints use iterate_tuple(columns, ...) instead. L is lambda type. Do
-             *  not specify it explicitly.
-             *  @param lambda Lambda to be called per column itself. Must have signature like this [] (auto col) -> void {}
-             */
-            template<class L>
-            void for_each_column(const L& lambda) const {
-                iterate_tuple(this->elements, [&lambda](auto& element) {
-                    using element_type = typename std::decay<decltype(element)>::type;
-                    static_if<is_column<element_type>{}>(lambda)(element);
-                });
-            }
-
-            template<class L>
-            void for_each_foreign_key(const L& lambda) const {
-                iterate_tuple(this->elements, [&lambda](auto& element) {
-                    using element_type = typename std::decay<decltype(element)>::type;
-                    static_if<is_foreign_key<element_type>{}>(lambda)(element);
-                });
-            }
-
-            template<class F, class L>
-            void for_each_column_with_field_type(const L& lambda) const {
-                this->for_each_column([&lambda](auto& column) {
-                    using column_type = typename std::decay<decltype(column)>::type;
-                    using field_type = typename column_field_type<column_type>::type;
-                    static_if<std::is_same<F, field_type>{}>(lambda)(column);
-                });
-            }
-
-            /**
-             *  Iterates all columns that have specified constraints and fires passed lambda.
-             *  Lambda must have one and only templated argument Otherwise code will not compile.
-             *  L is lambda type. Do not specify it explicitly.
-             *  @param lambda Lambda to be called per column itself. Must have signature like this [] (auto col) -> void {}
-             */
-            template<class Op, class L>
-            void for_each_column_with(const L& lambda) const {
-                this->for_each_column([&lambda](auto& column) {
-                    using tuple_helper::tuple_contains_type;
-                    using column_type = typename std::decay<decltype(column)>::type;
-                    using constraints_type = typename column_constraints_type<column_type>::type;
-                    static_if<tuple_contains_type<Op, constraints_type>{}>(lambda)(column);
-                });
-            }
-
-            std::vector<table_info> get_table_info() const {
-                std::vector<table_info> res;
-                res.reserve(size_t(this->elements_count));
-                this->for_each_column([&res](auto& col) {
-                    std::string dft;
-                    using field_type = typename std::decay<decltype(col)>::type::field_type;
-                    if(auto d = col.default_value()) {
-                        dft = *d;
-                    }
-                    table_info i{
-                        -1,
-                        col.name,
-                        type_printer<field_type>().print(),
-                        col.not_null(),
-                        dft,
-                        col.template has<primary_key_t<>>(),
-                    };
-                    res.emplace_back(i);
-                });
-                auto compositeKeyColumnNames = this->composite_key_columns_names();
-                for(size_t i = 0; i < compositeKeyColumnNames.size(); ++i) {
-                    auto& columnName = compositeKeyColumnNames[i];
-                    auto it = std::find_if(res.begin(), res.end(), [&columnName](const table_info& ti) {
-                        return ti.name == columnName;
-                    });
-                    if(it != res.end()) {
-                        it->pk = static_cast<int>(i + 1);
-                    }
-                }
-                return res;
-            }
-        };
-    }
-
-    /**
-     *  Function used for table creation. Do not use table constructor - use this function
-     *  cause table class is templated and its constructing too (just like std::make_unique or std::make_pair).
-     */
-    template<class... Cs, class T = typename std::tuple_element<0, std::tuple<Cs...>>::type::object_type>
-    internal::table_t<T, false, Cs...> make_table(const std::string& name, Cs... args) {
-        return {name, std::make_tuple<Cs...>(std::forward<Cs>(args)...)};
-    }
-
-    template<class T, class... Cs>
-    internal::table_t<T, false, Cs...> make_table(const std::string& name, Cs... args) {
-        return {name, std::make_tuple<Cs...>(std::forward<Cs>(args)...)};
-    }
-}
-#pragma once
-
-#include <string>  //  std::string
-#include <sqlite3.h>
-#include <cstddef>  //  std::nullptr_t
-#include <system_error>  //  std::system_error, std::error_code
-#include <sstream>  //  std::stringstream
-#include <stdlib.h>  //  std::atoi
-#include <type_traits>  //  std::forward, std::enable_if, std::is_same, std::remove_reference, std::false_type, std::true_type
-#include <utility>  //  std::pair, std::make_pair
-#include <vector>  //  std::vector
-#include <algorithm>  //  std::find_if
-#include <typeindex>  //  std::type_index
-
-// #include "error_code.h"
-
-// #include "statement_finalizer.h"
-
-// #include "row_extractor.h"
-
-// #include "util.h"
-
-// #include "constraints.h"
-
-// #include "select_constraints.h"
-
-// #include "field_printer.h"
-
-// #include "table_info.h"
-
-// #include "sync_schema_result.h"
-
-// #include "field_value_holder.h"
-
-#include <type_traits>  //  std::enable_if
-
-// #include "column.h"
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T, class SFINAE = void>
-        struct field_value_holder;
-
-        template<class T>
-        struct field_value_holder<T, typename std::enable_if<getter_traits<T>::returns_lvalue>::type> {
-            using type = typename getter_traits<T>::field_type;
-
-            const type& value;
-        };
-
-        template<class T>
-        struct field_value_holder<T, typename std::enable_if<!getter_traits<T>::returns_lvalue>::type> {
-            using type = typename getter_traits<T>::field_type;
-
-            type value;
-        };
-    }
-}
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        struct storage_impl_base {
-
-            bool table_exists(const std::string& tableName, sqlite3* db) const {
-                auto result = false;
-                std::stringstream ss;
-                ss << "SELECT COUNT(*) FROM sqlite_master WHERE type = '"
-                   << "table"
-                   << "' AND name = '" << tableName << "'";
-                auto query = ss.str();
-                auto rc = sqlite3_exec(
-                    db,
-                    query.c_str(),
-                    [](void* data, int argc, char** argv, char** /*azColName*/) -> int {
-                        auto& res = *(bool*)data;
-                        if(argc) {
-                            res = !!std::atoi(argv[0]);
-                        }
-                        return 0;
-                    },
-                    &result,
-                    nullptr);
-                if(rc != SQLITE_OK) {
-                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                            sqlite3_errmsg(db));
-                }
-                return result;
-            }
-
-            void rename_table(sqlite3* db, const std::string& oldName, const std::string& newName) const {
-                std::stringstream ss;
-                ss << "ALTER TABLE " << oldName << " RENAME TO " << newName;
-                perform_void_exec(db, ss.str());
-            }
-
-            static bool calculate_remove_add_columns(std::vector<table_info*>& columnsToAdd,
-                                                     std::vector<table_info>& storageTableInfo,
-                                                     std::vector<table_info>& dbTableInfo) {
-                bool notEqual = false;
-
-                //  iterate through storage columns
-                for(size_t storageColumnInfoIndex = 0; storageColumnInfoIndex < storageTableInfo.size();
-                    ++storageColumnInfoIndex) {
-
-                    //  get storage's column info
-                    auto& storageColumnInfo = storageTableInfo[storageColumnInfoIndex];
-                    auto& columnName = storageColumnInfo.name;
-
-                    //  search for a column in db eith the same name
-                    auto dbColumnInfoIt = std::find_if(dbTableInfo.begin(), dbTableInfo.end(), [&columnName](auto& ti) {
-                        return ti.name == columnName;
-                    });
-                    if(dbColumnInfoIt != dbTableInfo.end()) {
-                        auto& dbColumnInfo = *dbColumnInfoIt;
-                        auto columnsAreEqual =
-                            dbColumnInfo.name == storageColumnInfo.name &&
-                            dbColumnInfo.notnull == storageColumnInfo.notnull &&
-                            (dbColumnInfo.dflt_value.length() > 0) == (storageColumnInfo.dflt_value.length() > 0) &&
-                            dbColumnInfo.pk == storageColumnInfo.pk;
-                        if(!columnsAreEqual) {
-                            notEqual = true;
-                            break;
-                        }
-                        dbTableInfo.erase(dbColumnInfoIt);
-                        storageTableInfo.erase(storageTableInfo.begin() +
-                                               static_cast<ptrdiff_t>(storageColumnInfoIndex));
-                        --storageColumnInfoIndex;
-                    } else {
-                        columnsToAdd.push_back(&storageColumnInfo);
-                    }
-                }
-                return notEqual;
-            }
-
-            std::vector<table_info> get_table_info(const std::string& tableName, sqlite3* db) const {
-                std::vector<table_info> result;
-                auto query = "PRAGMA table_info('" + tableName + "')";
-                auto rc = sqlite3_exec(
-                    db,
-                    query.c_str(),
-                    [](void* data, int argc, char** argv, char**) -> int {
-                        auto& res = *(std::vector<table_info>*)data;
-                        if(argc) {
-                            auto index = 0;
-                            auto cid = std::atoi(argv[index++]);
-                            std::string name = argv[index++];
-                            std::string type = argv[index++];
-                            bool notnull = !!std::atoi(argv[index++]);
-                            std::string dflt_value = argv[index] ? argv[index] : "";
-                            index++;
-                            auto pk = std::atoi(argv[index++]);
-                            res.push_back(table_info(cid, name, type, notnull, dflt_value, pk));
-                        }
-                        return 0;
-                    },
-                    &result,
-                    nullptr);
-                if(rc != SQLITE_OK) {
-                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                            sqlite3_errmsg(db));
-                }
-                return result;
-            }
-        };
-
-        /**
-         *  This is a generic implementation. Used as a tail in storage_impl inheritance chain
-         */
-        template<class... Ts>
-        struct storage_impl;
-
-        template<class H, class... Ts>
-        struct storage_impl<H, Ts...> : public storage_impl<Ts...> {
-            using table_type = H;
-            using super = storage_impl<Ts...>;
-
-            storage_impl(H h, Ts... ts) : super(std::forward<Ts>(ts)...), table(std::move(h)) {}
-
-            table_type table;
-
-            template<class L>
-            void for_each(const L& l) {
-                this->super::for_each(l);
-                l(*this);
-            }
-
-#if SQLITE_VERSION_NUMBER >= 3006019
-
-            /**
-             *  Returns foreign keys count in table definition
-             */
-            int foreign_keys_count() {
-                auto res = 0;
-                iterate_tuple(this->table.elements, [&res](auto& c) {
-                    if(is_foreign_key<typename std::decay<decltype(c)>::type>::value) {
-                        ++res;
-                    }
-                });
-                return res;
-            }
-
-#endif
-
-            /**
-             *  Is used to get column name by member pointer to a base class.
-             *  Main difference between `column_name` and `column_name_simple` is that
-             *  `column_name` has SFINAE check for type equality but `column_name_simple` has not.
-             */
-            template<class O, class F>
-            const std::string* column_name_simple(F O::*m) const {
-                return this->table.find_column_name(m);
-            }
-
-            /**
-             *  Cute function used to find column name by its type and member pointer. Uses SFINAE to
-             *  skip inequal type O.
-             */
-            template<class O, class F, class HH = typename H::object_type>
-            const std::string* column_name(F O::*m,
-                                           typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) const {
-                return this->table.find_column_name(m);
-            }
-
-            /**
-             *  Opposite version of function defined above. Just calls same function in superclass.
-             */
-            template<class O, class F, class HH = typename H::object_type>
-            const std::string*
-            column_name(F O::*m, typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) const {
-                return this->super::column_name(m);
-            }
-
-            template<class T, class F, class HH = typename H::object_type>
-            const std::string* column_name(const column_pointer<T, F>& c,
-                                           typename std::enable_if<std::is_same<T, HH>::value>::type* = nullptr) const {
-                return this->column_name_simple(c.field);
-            }
-
-            template<class T, class F, class HH = typename H::object_type>
-            const std::string*
-            column_name(const column_pointer<T, F>& c,
-                        typename std::enable_if<!std::is_same<T, HH>::value>::type* = nullptr) const {
-                return this->super::column_name(c);
-            }
-
-            template<class O, class HH = typename H::object_type>
-            const auto& get_impl(typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) const {
-                return *this;
-            }
-
-            template<class O, class HH = typename H::object_type>
-            const auto& get_impl(typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) const {
-                return this->super::template get_impl<O>();
-            }
-
-            template<class O, class HH = typename H::object_type>
-            auto& get_impl(typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) {
-                return *this;
-            }
-
-            template<class O, class HH = typename H::object_type>
-            auto& get_impl(typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) {
-                return this->super::template get_impl<O>();
-            }
-
-            template<class O, class HH = typename H::object_type>
-            const auto* find_table(typename std::enable_if<std::is_same<O, HH>::value>::type* = nullptr) const {
-                return &this->table;
-            }
-
-            template<class O, class HH = typename H::object_type>
-            const auto* find_table(typename std::enable_if<!std::is_same<O, HH>::value>::type* = nullptr) const {
-                return this->super::template find_table<O>();
-            }
-
-            std::string find_table_name(std::type_index ti) const {
-                std::type_index thisTypeIndex{typeid(typename H::object_type)};
-                if(thisTypeIndex == ti) {
-                    return this->table.name;
-                } else {
-                    return this->super::find_table_name(ti);
-                }
-            }
-
-            /**
-             *  Copies current table to another table with a given **name**.
-             *  Performs CREATE TABLE %name% AS SELECT %this->table.columns_names()% FROM &this->table.name%;
-             */
-            void
-            copy_table(sqlite3* db, const std::string& name, const std::vector<table_info*>& columnsToIgnore) const {
-                std::stringstream ss;
-                std::vector<std::string> columnNames;
-                this->table.for_each_column([&columnNames, &columnsToIgnore](auto& c) {
-                    auto& columnName = c.name;
-                    auto columnToIgnoreIt = std::find_if(columnsToIgnore.begin(),
-                                                         columnsToIgnore.end(),
-                                                         [&columnName](auto tableInfoPointer) {
-                                                             return columnName == tableInfoPointer->name;
-                                                         });
-                    if(columnToIgnoreIt == columnsToIgnore.end()) {
-                        columnNames.emplace_back(columnName);
-                    }
-                });
-                auto columnNamesCount = columnNames.size();
-                ss << "INSERT INTO " << name << " (";
-                for(size_t i = 0; i < columnNamesCount; ++i) {
-                    ss << columnNames[i];
-                    if(i < columnNamesCount - 1) {
-                        ss << ",";
-                    }
-                    ss << " ";
-                }
-                ss << ") ";
-                ss << "SELECT ";
-                for(size_t i = 0; i < columnNamesCount; ++i) {
-                    ss << columnNames[i];
-                    if(i < columnNamesCount - 1) {
-                        ss << ", ";
-                    }
-                }
-                ss << " FROM '" << this->table.name << "'";
-                perform_void_exec(db, ss.str());
-            }
-
-            sync_schema_result schema_status(sqlite3* db, bool preserve) const {
-
-                auto res = sync_schema_result::already_in_sync;
-
-                //  first let's see if table with such name exists..
-                auto gottaCreateTable = !this->table_exists(this->table.name, db);
-                if(!gottaCreateTable) {
-
-                    //  get table info provided in `make_table` call..
-                    auto storageTableInfo = this->table.get_table_info();
-
-                    //  now get current table info from db using `PRAGMA table_info` query..
-                    auto dbTableInfo = this->get_table_info(this->table.name, db);
-
-                    //  this vector will contain pointers to columns that gotta be added..
-                    std::vector<table_info*> columnsToAdd;
-
-                    if(this->calculate_remove_add_columns(columnsToAdd, storageTableInfo, dbTableInfo)) {
-                        gottaCreateTable = true;
-                    }
-
-                    if(!gottaCreateTable) {  //  if all storage columns are equal to actual db columns but there are
-                        //  excess columns at the db..
-                        if(dbTableInfo.size() > 0) {
-                            // extra table columns than storage columns
-                            if(!preserve) {
-#if SQLITE_VERSION_NUMBER >= 3035000  //  DROP COLUMN feature exists (v3.35.0)
-                                res = decltype(res)::old_columns_removed;
-#else
-                                gottaCreateTable = true;
-#endif
-                            } else {
-                                res = decltype(res)::old_columns_removed;
-                            }
-                        }
-                    }
-                    if(gottaCreateTable) {
-                        res = decltype(res)::dropped_and_recreated;
-                    } else {
-                        if(columnsToAdd.size()) {
-                            // extra storage columns than table columns
-                            for(auto columnPointer: columnsToAdd) {
-                                auto generatedStorageTypePointer =
-                                    this->find_column_generated_storage_type(columnPointer->name);
-                                if(generatedStorageTypePointer) {
-                                    if(*generatedStorageTypePointer == basic_generated_always::storage_type::stored) {
-                                        gottaCreateTable = true;
-                                        break;
-                                    }
-                                    //  fallback cause VIRTUAL can be added
-                                } else {
-                                    if(columnPointer->notnull && columnPointer->dflt_value.empty()) {
-                                        gottaCreateTable = true;
-                                        break;
-                                    }
-                                }
-                            }
-                            if(!gottaCreateTable) {
-                                if(res == decltype(res)::old_columns_removed) {
-                                    res = decltype(res)::new_columns_added_and_old_columns_removed;
-                                } else {
-                                    res = decltype(res)::new_columns_added;
-                                }
-                            } else {
-                                res = decltype(res)::dropped_and_recreated;
-                            }
-                        } else {
-                            if(res != decltype(res)::old_columns_removed) {
-                                res = decltype(res)::already_in_sync;
-                            }
-                        }
-                    }
-                } else {
-                    res = decltype(res)::new_table_created;
-                }
-                return res;
-            }
-
-          private:
-            using self = storage_impl<H, Ts...>;
-
-            const basic_generated_always::storage_type*
-            find_column_generated_storage_type(const std::string& name) const {
-                const basic_generated_always::storage_type* result = nullptr;
-#if SQLITE_VERSION_NUMBER >= 3031000
-                this->table.for_each_column([&result, &name](auto& column) {
-                    if(column.name != name) {
-                        return;
-                    }
-                    iterate_tuple(column.constraints, [&result](auto& constraint) {
-                        if(result) {
-                            return;
-                        }
-                        using constraint_type = typename std::decay<decltype(constraint)>::type;
-                        static_if<is_generated_always<constraint_type>{}>([&result](auto& generatedAlwaysConstraint) {
-                            result = &generatedAlwaysConstraint.storage;
-                        })(constraint);
-                    });
-                });
-#endif
-                return result;
-            }
-        };
-
-        template<>
-        struct storage_impl<> : storage_impl_base {
-
-            std::string find_table_name(std::type_index) const {
-                return {};
-            }
-
-            template<class L>
-            void for_each(const L&) {}
-
-            int foreign_keys_count() {
-                return 0;
-            }
-
-            template<class O>
-            const void* find_table() const {
-                return nullptr;
-            }
-        };
-
-        template<class T>
-        struct is_storage_impl : std::false_type {};
-
-        template<class... Ts>
-        struct is_storage_impl<storage_impl<Ts...>> : std::true_type {};
-    }
-}
-#pragma once
-
-#include <memory>  //  std::unique/shared_ptr, std::make_unique/shared
-#include <string>  //  std::string
-#include <sqlite3.h>
-#include <type_traits>  //  std::remove_reference, std::is_base_of, std::decay, std::false_type, std::true_type
-#include <cstddef>  //  std::ptrdiff_t
-#include <iterator>  //  std::input_iterator_tag, std::iterator_traits, std::distance
-#include <functional>  //  std::function
-#include <sstream>  //  std::stringstream
-#include <map>  //  std::map
-#include <vector>  //  std::vector
-#include <tuple>  //  std::tuple_size, std::tuple, std::make_tuple
-#include <utility>  //  std::forward, std::pair
-#include <algorithm>  //  std::find
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-#include <optional>  // std::optional
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-// #include "alias.h"
-
-// #include "row_extractor_builder.h"
-
-// #include "row_extractor.h"
-
-// #include "mapped_row_extractor.h"
-
-#include <sqlite3.h>
-
-// #include "object_from_column_builder.h"
-
-#include <sqlite3.h>
-
-// #include "row_extractor.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        struct object_from_column_builder_base {
-            sqlite3_stmt* stmt = nullptr;
-            mutable int index = 0;
-        };
-
-        /**
-         * This is a cute lambda replacement which is used in several places.
-         */
-        template<class O>
-        struct object_from_column_builder : object_from_column_builder_base {
-            using object_type = O;
-
-            object_type& object;
-
-            object_from_column_builder(object_type& object_, sqlite3_stmt* stmt_) :
-                object_from_column_builder_base{stmt_}, object(object_) {}
-
-            template<class C>
-            void operator()(const C& c) const {
-                using field_type = typename C::field_type;
-                auto value = row_extractor<field_type>().extract(this->stmt, this->index++);
-                if(c.member_pointer) {
-                    this->object.*c.member_pointer = std::move(value);
-                } else {
-                    ((this->object).*(c.setter))(std::move(value));
-                }
-            }
-        };
-
-    }
-}
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         * This is a private row extractor class. It is used for extracting rows as objects instead of tuple.
-         * Main difference from regular `row_extractor` is that this class takes table info which is required
-         * for constructing objects by member pointers. To construct please use `row_extractor_builder` class
-         * Type arguments:
-         * V is value type just like regular `row_extractor` has
-         * T is table info class `table_t`
-         */
-        template<class V, class T>
-        struct mapped_row_extractor {
-            using table_info_t = T;
-
-            mapped_row_extractor(const table_info_t& tableInfo_) : tableInfo(tableInfo_) {}
-
-            V extract(sqlite3_stmt* stmt, int /*columnIndex*/) {
-                V res;
-                object_from_column_builder<V> builder{res, stmt};
-                this->tableInfo.for_each_column(builder);
-                return res;
-            }
-
-            const table_info_t& tableInfo;
-        };
-
-    }
-
-}
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         * This builder is used to construct different row extractors depending on type.
-         * It has two specializations: for mapped to storage types (e.g. User, Visit etc) and
-         * for non-mapped (e.g. std::string, QString, int etc). For non mapped its operator() returns
-         * generic `row_extractor`, for mapped it returns `mapped_row_extractor` instance.
-         */
-        template<class T, bool IsMapped, class I>
-        struct row_extractor_builder;
-
-        template<class T, class I>
-        struct row_extractor_builder<T, false, I> {
-
-            row_extractor<T> operator()(const I* /*tableInfo*/) const {
-                return {};
-            }
-        };
-
-        template<class T, class I>
-        struct row_extractor_builder<T, true, I> {
-
-            mapped_row_extractor<T, I> operator()(const I* tableInfo) const {
-                return {*tableInfo};
-            }
-        };
-
-        template<class T, bool IsMapped, class I>
-        auto make_row_extractor(const I* tableInfo) {
-            using builder_t = row_extractor_builder<T, IsMapped, I>;
-            return builder_t{}(tableInfo);
-        }
-
-    }
-
-}
-
-// #include "error_code.h"
-
-// #include "type_printer.h"
-
-// #include "tuple_helper/tuple_helper.h"
-
-// #include "constraints.h"
-
-// #include "type_is_nullable.h"
-
-// #include "field_printer.h"
-
-// #include "rowid.h"
-
-// #include "operators.h"
-
-// #include "select_constraints.h"
-
-// #include "core_functions.h"
-
-// #include "conditions.h"
-
-// #include "statement_binder.h"
-
-// #include "column_result.h"
-
-// #include "mapped_type_proxy.h"
-
-// #include "sync_schema_result.h"
-
-// #include "table_info.h"
-
-// #include "storage_impl.h"
-
-// #include "journal_mode.h"
-
-// #include "field_value_holder.h"
-
-// #include "view.h"
-
-#include <memory>  //  std::shared_ptr
-#include <string>  //  std::string
-#include <utility>  //  std::forward, std::move
-#include <sqlite3.h>
-#include <system_error>  //  std::system_error
-#include <tuple>  //  std::tuple, std::make_tuple
-
-// #include "row_extractor.h"
-
-// #include "statement_finalizer.h"
-
-// #include "error_code.h"
-
-// #include "iterator.h"
-
-#include <memory>  //  std::shared_ptr, std::unique_ptr, std::make_shared
-#include <sqlite3.h>
-#include <type_traits>  //  std::decay
-#include <utility>  //  std::move
-#include <cstddef>  //  std::ptrdiff_t
-#include <iterator>  //  std::input_iterator_tag
-#include <system_error>  //  std::system_error
-#include <ios>  //  std::make_error_code
-
-// #include "row_extractor.h"
-
-// #include "statement_finalizer.h"
-
-// #include "error_code.h"
-
-// #include "object_from_column_builder.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        template<class V>
-        struct iterator_t {
-            using view_type = V;
-            using value_type = typename view_type::mapped_type;
-
-          protected:
-            /**
-             *  The double-indirection is so that copies of the iterator
-             *  share the same sqlite3_stmt from a sqlite3_prepare_v2()
-             *  call. When one finishes iterating it the pointer
-             *  inside the shared_ptr is nulled out in all copies.
-             */
-            std::shared_ptr<statement_finalizer> stmt;
-
-            // only null for the default constructed iterator
-            view_type* view;
-
-            /**
-             *  shared_ptr is used over unique_ptr here
-             *  so that the iterator can be copyable.
-             */
-            std::shared_ptr<value_type> current;
-
-            void extract_value() {
-                auto& storage = this->view->storage;
-                auto& impl = storage.template get_impl<value_type>();
-                this->current = std::make_shared<value_type>();
-                object_from_column_builder<value_type> builder{*this->current, this->stmt->get()};
-                impl.table.for_each_column(builder);
-            }
-
-          public:
-            using difference_type = std::ptrdiff_t;
-            using pointer = value_type*;
-            using reference = value_type&;
-            using iterator_category = std::input_iterator_tag;
-
-            iterator_t() : view(nullptr){};
-
-            iterator_t(sqlite3_stmt* stmt_, view_type& view_) :
-                stmt(std::make_shared<statement_finalizer>(stmt_)), view(&view_) {
-                next();
-            }
-
-            const value_type& operator*() const {
-                if(!this->stmt || !this->current) {
-                    throw std::system_error(std::make_error_code(orm_error_code::trying_to_dereference_null_iterator));
-                }
-                return *this->current;
-            }
-
-            const value_type* operator->() const {
-                return &(this->operator*());
-            }
-
-          private:
-            void next() {
-                this->current.reset();
-                if(this->stmt) {
-                    auto statementPointer = this->stmt->get();
-                    auto ret = sqlite3_step(statementPointer);
-                    switch(ret) {
-                        case SQLITE_ROW:
-                            this->extract_value();
-                            break;
-                        case SQLITE_DONE:
-                            this->stmt.reset();
-                            break;
-                        default: {
-                            auto db = this->view->connection.get();
-                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                    sqlite3_errmsg(db));
-                        }
-                    }
-                }
-            }
-
-          public:
-            iterator_t<V>& operator++() {
-                next();
-                return *this;
-            }
-
-            void operator++(int) {
-                this->operator++();
-            }
-
-            bool operator==(const iterator_t& other) const {
-                return this->current == other.current;
-            }
-
-            bool operator!=(const iterator_t& other) const {
-                return !(*this == other);
-            }
-        };
-    }
-}
-
-// #include "ast_iterator.h"
-
-#include <vector>  //  std::vector
-#include <functional>  //  std::reference_wrapper
-
-// #include "conditions.h"
-
-// #include "select_constraints.h"
-
-// #include "operators.h"
-
-// #include "tuple_helper/tuple_helper.h"
-
-// #include "core_functions.h"
-
-// #include "prepared_statement.h"
-
-#include <sqlite3.h>
-#include <iterator>  //  std::iterator_traits
-#include <string>  //  std::string
-#include <type_traits>  //  std::true_type, std::false_type
-#include <utility>  //  std::pair
-
-// #include "connection_holder.h"
-
-#include <sqlite3.h>
-#include <string>  //  std::string
-#include <system_error>  //  std::system_error
-
-// #include "error_code.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        struct connection_holder {
-
-            connection_holder(std::string filename_) : filename(move(filename_)) {}
-
-            void retain() {
-                ++this->_retain_count;
-                if(1 == this->_retain_count) {
-                    auto rc = sqlite3_open(this->filename.c_str(), &this->db);
-                    if(rc != SQLITE_OK) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(this->db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(this->db));
-                    }
-                }
-            }
-
-            void release() {
-                --this->_retain_count;
-                if(0 == this->_retain_count) {
-                    auto rc = sqlite3_close(this->db);
-                    if(rc != SQLITE_OK) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(this->db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(this->db));
-                    }
-                }
-            }
-
-            sqlite3* get() const {
-                return this->db;
-            }
-
-            int retain_count() const {
-                return this->_retain_count;
-            }
-
-            const std::string filename;
-
-          protected:
-            sqlite3* db = nullptr;
-            int _retain_count = 0;
-        };
-
-        struct connection_ref {
-            connection_ref(connection_holder& holder_) : holder(holder_) {
-                this->holder.retain();
-            }
-
-            connection_ref(const connection_ref& other) : holder(other.holder) {
-                this->holder.retain();
-            }
-
-            connection_ref(connection_ref&& other) : holder(other.holder) {
-                this->holder.retain();
-            }
-
-            ~connection_ref() {
-                this->holder.release();
-            }
-
-            sqlite3* get() const {
-                return this->holder.get();
-            }
-
-          protected:
-            connection_holder& holder;
-        };
-    }
-}
-
-// #include "select_constraints.h"
-
-// #include "values.h"
-
-#include <vector>  //  std::vector
-#include <initializer_list>
-#include <tuple>  //  std::tuple
-#include <type_traits>  //  std::false_type, std::true_type
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        template<class... Args>
-        struct values_t {
-            using args_tuple = std::tuple<Args...>;
-
-            args_tuple tuple;
-        };
-
-        template<class T>
-        struct is_values : std::false_type {};
-
-        template<class... Args>
-        struct is_values<values_t<Args...>> : std::true_type {};
-
-        template<class T>
-        struct dynamic_values_t {
-            std::vector<T> vector;
-        };
-
-    }
-
-    template<class... Args>
-    internal::values_t<Args...> values(Args... args) {
-        return {{std::forward<Args>(args)...}};
-    }
-
-    template<class T>
-    internal::dynamic_values_t<T> values(std::vector<T> vector) {
-        return {{move(vector)}};
-    }
-
-}
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        struct prepared_statement_base {
-            sqlite3_stmt* stmt = nullptr;
-            connection_ref con;
-
-            ~prepared_statement_base() {
-                if(this->stmt) {
-                    sqlite3_finalize(this->stmt);
-                    this->stmt = nullptr;
-                }
-            }
-
-            std::string sql() const {
-                if(this->stmt) {
-                    if(auto res = sqlite3_sql(this->stmt)) {
-                        return res;
-                    } else {
-                        return {};
-                    }
-                } else {
-                    return {};
-                }
-            }
-
-#if SQLITE_VERSION_NUMBER >= 3014000
-            std::string expanded_sql() const {
-                if(this->stmt) {
-                    if(auto res = sqlite3_expanded_sql(this->stmt)) {
-                        std::string result = res;
-                        sqlite3_free(res);
-                        return result;
-                    } else {
-                        return {};
-                    }
-                } else {
-                    return {};
-                }
-            }
-#endif
-#if SQLITE_VERSION_NUMBER >= 3026000 and defined(SQLITE_ENABLE_NORMALIZE)
-            std::string normalized_sql() const {
-                if(this->stmt) {
-                    if(auto res = sqlite3_normalized_sql(this->stmt)) {
-                        return res;
-                    } else {
-                        return {};
-                    }
-                } else {
-                    return {};
-                }
-            }
-#endif
-        };
-
-        template<class T>
-        struct prepared_statement_t : prepared_statement_base {
-            using expression_type = T;
-
-            expression_type expression;
-
-            prepared_statement_t(T expression_, sqlite3_stmt* stmt_, connection_ref con_) :
-                prepared_statement_base{stmt_, std::move(con_)}, expression(std::move(expression_)) {}
-
-            prepared_statement_t(prepared_statement_t&& prepared_stmt) :
-                prepared_statement_base{prepared_stmt.stmt, std::move(prepared_stmt.con)},
-                expression(std::move(prepared_stmt.expression)) {
-                prepared_stmt.stmt = nullptr;
-            }
-        };
-
-        template<class T>
-        struct is_prepared_statement : std::false_type {};
-
-        template<class T>
-        struct is_prepared_statement<prepared_statement_t<T>> : std::true_type {};
-
-        /**
-         *  T - type of object to obtain from a database
-         */
-        template<class T, class R, class... Args>
-        struct get_all_t {
-            using type = T;
-            using return_type = R;
-
-            using conditions_type = std::tuple<Args...>;
-
-            conditions_type conditions;
-        };
-
-        template<class T, class R, class... Args>
-        struct get_all_pointer_t {
-            using type = T;
-            using return_type = R;
-
-            using conditions_type = std::tuple<Args...>;
-
-            conditions_type conditions;
-        };
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class T, class R, class... Args>
-        struct get_all_optional_t {
-            using type = T;
-            using return_type = R;
-
-            using conditions_type = std::tuple<Args...>;
-
-            conditions_type conditions;
-        };
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-        template<class T, class... Wargs>
-        struct update_all_t;
-
-        template<class... Args, class... Wargs>
-        struct update_all_t<set_t<Args...>, Wargs...> {
-            using set_type = set_t<Args...>;
-            using conditions_type = std::tuple<Wargs...>;
-
-            set_type set;
-            conditions_type conditions;
-        };
-
-        template<class T, class... Args>
-        struct remove_all_t {
-            using type = T;
-            using conditions_type = std::tuple<Args...>;
-
-            conditions_type conditions;
-        };
-
-        template<class T, class... Ids>
-        struct get_t {
-            using type = T;
-            using ids_type = std::tuple<Ids...>;
-
-            ids_type ids;
-        };
-
-        template<class T, class... Ids>
-        struct get_pointer_t {
-            using type = T;
-            using ids_type = std::tuple<Ids...>;
-
-            ids_type ids;
-        };
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class T, class... Ids>
-        struct get_optional_t {
-            using type = T;
-            using ids_type = std::tuple<Ids...>;
-
-            ids_type ids;
-        };
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-        template<class T>
-        struct update_t {
-            using type = T;
-
-            type object;
-        };
-
-        template<class T, class... Ids>
-        struct remove_t {
-            using type = T;
-            using ids_type = std::tuple<Ids...>;
-
-            ids_type ids;
-        };
-
-        template<class T>
-        struct insert_t {
-            using type = T;
-
-            type object;
-        };
-
-        template<class T>
-        struct is_insert : std::false_type {};
-
-        template<class T>
-        struct is_insert<insert_t<T>> : std::true_type {};
-
-        template<class T, class... Cols>
-        struct insert_explicit {
-            using type = T;
-            using columns_type = columns_t<Cols...>;
-
-            type obj;
-            columns_type columns;
-        };
-
-        template<class T>
-        struct replace_t {
-            using type = T;
-
-            type object;
-        };
-
-        template<class T>
-        struct is_replace : std::false_type {};
-
-        template<class T>
-        struct is_replace<replace_t<T>> : std::true_type {};
-
-        template<class It, class L, class O>
-        struct insert_range_t {
-            using iterator_type = It;
-            using container_object_type = typename std::iterator_traits<iterator_type>::value_type;
-            using transformer_type = L;
-            using object_type = O;
-
-            std::pair<iterator_type, iterator_type> range;
-            transformer_type transformer;
-        };
-
-        template<class T>
-        struct is_insert_range : std::false_type {};
-
-        template<class It, class L, class O>
-        struct is_insert_range<insert_range_t<It, L, O>> : std::true_type {};
-
-        template<class It, class L, class O>
-        struct replace_range_t {
-            using iterator_type = It;
-            using container_object_type = typename std::iterator_traits<iterator_type>::value_type;
-            using transformer_type = L;
-            using object_type = O;
-
-            std::pair<iterator_type, iterator_type> range;
-            transformer_type transformer;
-        };
-
-        template<class T>
-        struct is_replace_range : std::false_type {};
-
-        template<class It, class L, class O>
-        struct is_replace_range<replace_range_t<It, L, O>> : std::true_type {};
-
-        template<class... Args>
-        struct insert_raw_t {
-            using args_tuple = std::tuple<Args...>;
-
-            args_tuple args;
-        };
-
-        template<class T>
-        struct is_insert_raw : std::false_type {};
-
-        template<class... Args>
-        struct is_insert_raw<insert_raw_t<Args...>> : std::true_type {};
-
-        template<class... Args>
-        struct replace_raw_t {
-            using args_tuple = std::tuple<Args...>;
-
-            args_tuple args;
-        };
-
-        template<class T>
-        struct is_replace_raw : std::false_type {};
-
-        template<class... Args>
-        struct is_replace_raw<replace_raw_t<Args...>> : std::true_type {};
-
-        struct default_transformer {
-
-            template<class T>
-            const T& operator()(const T& object) const {
-                return object;
-            }
-        };
-
-        struct default_values_t {};
-
-        template<class T>
-        using is_default_values = std::is_same<default_values_t, T>;
-
-        enum class conflict_action {
-            abort,
-            fail,
-            ignore,
-            replace,
-            rollback,
-        };
-
-        struct insert_constraint {
-            conflict_action action = conflict_action::abort;
-        };
-
-        template<class T>
-        using is_insert_constraint = std::is_same<insert_constraint, T>;
-
-        template<class T>
-        struct is_upsert_clause;
-    }
-
-    inline internal::insert_constraint or_rollback() {
-        return internal::insert_constraint{internal::conflict_action::rollback};
-    }
-
-    inline internal::insert_constraint or_replace() {
-        return internal::insert_constraint{internal::conflict_action::replace};
-    }
-
-    inline internal::insert_constraint or_ignore() {
-        return internal::insert_constraint{internal::conflict_action::ignore};
-    }
-
-    inline internal::insert_constraint or_fail() {
-        return internal::insert_constraint{internal::conflict_action::fail};
-    }
-
-    inline internal::insert_constraint or_abort() {
-        return internal::insert_constraint{internal::conflict_action::abort};
-    }
-
-    /**
-     *  Use this function to add `DEFAULT VALUES` modifier to raw `INSERT`.
-     *
-     *  @example
-     *  ```
-     *  storage.insert(into<Singer>(), default_values());
-     *  ```
-     */
-    inline internal::default_values_t default_values() {
-        return {};
-    }
-
-    /**
-     *  Raw insert statement creation routine. Use this if `insert` with object does not fit you. This insert is designed to be able
-     *  to call any type of `INSERT` query with no limitations.
-     *  @example
-     *  ```sql
-     *  INSERT INTO users (id, name) VALUES(5, 'Little Mix')
-     *  ```
-     *  will be
-     *  ```c++
-     *  auto statement = storage.prepare(insert(into<User>, columns(&User::id, &User::name), values(std::make_tuple(5, "Little Mix"))));
-     *  storage.execute(statement));
-     *  ```
-     *  One more example:
-     *  ```sql
-     *  INSERT INTO singers (name) VALUES ('Sofia Reyes')('Kungs')
-     *  ```
-     *  will be
-     *  ```c++
-     *  auto statement = storage.prepare(insert(into<Singer>(), columns(&Singer::name), values(std::make_tuple("Sofia Reyes"), std::make_tuple("Kungs"))));
-     *  storage.execute(statement));
-     *  ```
-     *  One can use `default_values` to add `DEFAULT VALUES` modifier:
-     *  ```sql
-     *  INSERT INTO users DEFAULT VALUES
-     *  ```
-     *  will be
-     *  ```c++
-     *  auto statement = storage.prepare(insert(into<Singer>(), default_values()));
-     *  storage.execute(statement));
-     *  ```
-     *  Also one can use `INSERT OR ABORT`/`INSERT OR FAIL`/`INSERT OR IGNORE`/`INSERT OR REPLACE`/`INSERT ROLLBACK`:
-     *  ```c++
-     *  auto statement = storage.prepare(insert(or_ignore(), into<Singer>(), columns(&Singer::name), values(std::make_tuple("Sofia Reyes"), std::make_tuple("Kungs"))));
-     *  auto statement2 = storage.prepare(insert(or_rollback(), into<Singer>(), default_values()));
-     *  auto statement3 = storage.prepare(insert(or_abort(), into<User>, columns(&User::id, &User::name), values(std::make_tuple(5, "Little Mix"))));
-     *  ```
-     */
-    template<class... Args>
-    internal::insert_raw_t<Args...> insert(Args... args) {
-        using args_tuple = std::tuple<Args...>;
-        using internal::count_tuple;
-        using internal::is_columns;
-        using internal::is_insert_constraint;
-        using internal::is_into;
-        using internal::is_select;
-        using internal::is_upsert_clause;
-        using internal::is_values;
-
-        constexpr int orArgsCount = count_tuple<args_tuple, is_insert_constraint>::value;
-        static_assert(orArgsCount < 2, "Raw insert must have only one OR... argument");
-
-        constexpr int intoArgsCount = count_tuple<args_tuple, is_into>::value;
-        static_assert(intoArgsCount != 0, "Raw insert must have into<T> argument");
-        static_assert(intoArgsCount < 2, "Raw insert must have only one into<T> argument");
-
-        constexpr int columnsArgsCount = count_tuple<args_tuple, is_columns>::value;
-        static_assert(columnsArgsCount < 2, "Raw insert must have only one columns(...) argument");
-
-        constexpr int valuesArgsCount = count_tuple<args_tuple, is_values>::value;
-        static_assert(valuesArgsCount < 2, "Raw insert must have only one values(...) argument");
-
-        constexpr int defaultValuesCount = count_tuple<args_tuple, internal::is_default_values>::value;
-        static_assert(defaultValuesCount < 2, "Raw insert must have only one default_values() argument");
-
-        constexpr int selectsArgsCount = count_tuple<args_tuple, is_select>::value;
-        static_assert(selectsArgsCount < 2, "Raw insert must have only one select(...) argument");
-
-        constexpr int upsertClausesCount = count_tuple<args_tuple, is_upsert_clause>::value;
-        static_assert(upsertClausesCount <= 2, "Raw insert can contain 2 instances of upsert clause maximum");
-
-        constexpr int argsCount = int(std::tuple_size<args_tuple>::value);
-        static_assert(argsCount == intoArgsCount + columnsArgsCount + valuesArgsCount + defaultValuesCount +
-                                       selectsArgsCount + orArgsCount + upsertClausesCount,
-                      "Raw insert has invalid arguments");
-
-        return {{std::forward<Args>(args)...}};
-    }
-
-    /**
-     *  Raw replace statement creation routine. Use this if `replace` with object does not fit you. This replace is designed to be able
-     *  to call any type of `REPLACE` query with no limitations. Actually this is the same query as raw insert except `OR...` option existance.
-     *  @example
-     *  ```sql
-     *  REPLACE INTO users (id, name) VALUES(5, 'Little Mix')
-     *  ```
-     *  will be
-     *  ```c++
-     *  auto statement = storage.prepare(replace(into<User>, columns(&User::id, &User::name), values(std::make_tuple(5, "Little Mix"))));
-     *  storage.execute(statement));
-     *  ```
-     *  One more example:
-     *  ```sql
-     *  REPLACE INTO singers (name) VALUES ('Sofia Reyes')('Kungs')
-     *  ```
-     *  will be
-     *  ```c++
-     *  auto statement = storage.prepare(replace(into<Singer>(), columns(&Singer::name), values(std::make_tuple("Sofia Reyes"), std::make_tuple("Kungs"))));
-     *  storage.execute(statement));
-     *  ```
-     *  One can use `default_values` to add `DEFAULT VALUES` modifier:
-     *  ```sql
-     *  REPLACE INTO users DEFAULT VALUES
-     *  ```
-     *  will be
-     *  ```c++
-     *  auto statement = storage.prepare(replace(into<Singer>(), default_values()));
-     *  storage.execute(statement));
-     *  ```
-     */
-    template<class... Args>
-    internal::replace_raw_t<Args...> replace(Args... args) {
-        using args_tuple = std::tuple<Args...>;
-        using internal::count_tuple;
-        using internal::is_columns;
-        using internal::is_into;
-        using internal::is_values;
-
-        constexpr int intoArgsCount = count_tuple<args_tuple, is_into>::value;
-        static_assert(intoArgsCount != 0, "Raw replace must have into<T> argument");
-        static_assert(intoArgsCount < 2, "Raw replace must have only one into<T> argument");
-
-        constexpr int columnsArgsCount = count_tuple<args_tuple, is_columns>::value;
-        static_assert(columnsArgsCount < 2, "Raw replace must have only one columns(...) argument");
-
-        constexpr int valuesArgsCount = count_tuple<args_tuple, is_values>::value;
-        static_assert(valuesArgsCount < 2, "Raw replace must have only one values(...) argument");
-
-        constexpr int defaultValuesCount = count_tuple<args_tuple, internal::is_default_values>::value;
-        static_assert(defaultValuesCount < 2, "Raw replace must have only one default_values() argument");
-
-        constexpr int selectsArgsCount = count_tuple<args_tuple, internal::is_select>::value;
-        static_assert(selectsArgsCount < 2, "Raw replace must have only one select(...) argument");
-
-        constexpr int argsCount = int(std::tuple_size<args_tuple>::value);
-        static_assert(argsCount ==
-                          intoArgsCount + columnsArgsCount + valuesArgsCount + defaultValuesCount + selectsArgsCount,
-                      "Raw replace has invalid arguments");
-
-        return {{std::forward<Args>(args)...}};
-    }
-
-    /**
-     *  Create a replace range statement
-     *
-     *  @example
-     *  ```
-     *  std::vector<User> users;
-     *  users.push_back(User{1, "Leony"});
-     *  auto statement = storage.prepare(replace_range(users.begin(), users.end()));
-     *  storage.execute(statement);
-     *  ```
-     */
-    template<class It>
-    internal::replace_range_t<It, internal::default_transformer, typename std::iterator_traits<It>::value_type>
-    replace_range(It from, It to) {
-        return {{std::move(from), std::move(to)}};
-    }
-
-    /**
-     *  Create an replace range statement with explicit transformer. Transformer is used to apply containers with no strict objects with other kind of objects like pointers,
-     *  optionals or whatever.
-     *  @example
-     *  ```
-     *  std::vector<std::unique_ptr<User>> userPointers;
-     *  userPointers.push_back(std::make_unique<User>(1, "Eneli"));
-     *  auto statement = storage.prepare(replace_range<User>(userPointers.begin(), userPointers.end(), [](const std::unique_ptr<User> &userPointer) -> const User & {
-     *      return *userPointer;
-     *  }));
-     *  storage.execute(statement);
-     *  ```
-     */
-    template<class T, class It, class L>
-    internal::replace_range_t<It, L, T> replace_range(It from, It to, L transformer) {
-        return {{std::move(from), std::move(to)}, std::move(transformer)};
-    }
-
-    /**
-     *  Create an insert range statement
-     *  @example
-     *  ```
-     *  std::vector<User> users;
-     *  users.push_back(User{1, "Leony"});
-     *  auto statement = storage.prepare(insert_range(users.begin(), users.end()));
-     *  storage.execute(statement);
-     *  ```
-     */
-    template<class It>
-    internal::insert_range_t<It, internal::default_transformer, typename std::iterator_traits<It>::value_type>
-    insert_range(It from, It to) {
-        return {{std::move(from), std::move(to)}, internal::default_transformer{}};
-    }
-
-    /**
-     *  Create an insert range statement with explicit transformer. Transformer is used to apply containers with no strict objects with other kind of objects like pointers,
-     *  optionals or whatever.
-     *  @example
-     *  ```
-     *  std::vector<std::unique_ptr<User>> userPointers;
-     *  userPointers.push_back(std::make_unique<User>(1, "Eneli"));
-     *  auto statement = storage.prepare(insert_range<User>(userPointers.begin(), userPointers.end(), [](const std::unique_ptr<User> &userPointer) -> const User & {
-     *      return *userPointer;
-     *  }));
-     *  storage.execute(statement);
-     *  ```
-     */
-    template<class T, class It, class L>
-    internal::insert_range_t<It, L, T> insert_range(It from, It to, L transformer) {
-        return {{std::move(from), std::move(to)}, std::move(transformer)};
-    }
-    /**
-     *  Create a replace statement.
-     *  T is an object type mapped to a storage.
-     *  Usage: storage.replace(myUserInstance);
-     *  Parameter obj is accepted by value. If you want to accept it by ref
-     *  please use std::ref function: storage.replace(std::ref(myUserInstance));
-     */
-    template<class T>
-    internal::replace_t<T> replace(T obj) {
-        return {std::move(obj)};
-    }
-
-    /**
-     *  Create an insert statement.
-     *  T is an object type mapped to a storage.
-     *  Usage: storage.insert(myUserInstance);
-     *  Parameter obj is accepted by value. If you want to accept it by ref
-     *  please use std::ref function: storage.insert(std::ref(myUserInstance));
-     */
-    template<class T>
-    internal::insert_t<T> insert(T obj) {
-        return {std::move(obj)};
-    }
-
-    /**
-     *  Create an explicit insert statement.
-     *  T is an object type mapped to a storage.
-     *  Cols is columns types aparameter pack. Must contain member pointers
-     *  Usage: storage.insert(myUserInstance, columns(&User::id, &User::name));
-     *  Parameter obj is accepted by value. If you want to accept it by ref
-     *  please use std::ref function: storage.insert(std::ref(myUserInstance), columns(&User::id, &User::name));
-     */
-    template<class T, class... Cols>
-    internal::insert_explicit<T, Cols...> insert(T obj, internal::columns_t<Cols...> cols) {
-        return {std::move(obj), std::move(cols)};
-    }
-
-    /**
-     *  Create a remove statement
-     *  T is an object type mapped to a storage.
-     *  Usage: remove<User>(5);
-     */
-    template<class T, class... Ids>
-    internal::remove_t<T, Ids...> remove(Ids... ids) {
-        std::tuple<Ids...> idsTuple{std::forward<Ids>(ids)...};
-        return {move(idsTuple)};
-    }
-
-    /**
-     *  Create an update statement.
-     *  T is an object type mapped to a storage.
-     *  Usage: storage.update(myUserInstance);
-     *  Parameter obj is accepted by value. If you want to accept it by ref
-     *  please use std::ref function: storage.update(std::ref(myUserInstance));
-     */
-    template<class T>
-    internal::update_t<T> update(T obj) {
-        return {std::move(obj)};
-    }
-
-    /**
-     *  Create a get statement.
-     *  T is an object type mapped to a storage.
-     *  Usage: get<User>(5);
-     */
-    template<class T, class... Ids>
-    internal::get_t<T, Ids...> get(Ids... ids) {
-        std::tuple<Ids...> idsTuple{std::forward<Ids>(ids)...};
-        return {move(idsTuple)};
-    }
-
-    /**
-     *  Create a get pointer statement.
-     *  T is an object type mapped to a storage.
-     *  Usage: get_pointer<User>(5);
-     */
-    template<class T, class... Ids>
-    internal::get_pointer_t<T, Ids...> get_pointer(Ids... ids) {
-        std::tuple<Ids...> idsTuple{std::forward<Ids>(ids)...};
-        return {move(idsTuple)};
-    }
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-    /**
-     *  Create a get optional statement.
-     *  T is an object type mapped to a storage.
-     *  Usage: get_optional<User>(5);
-     */
-    template<class T, class... Ids>
-    internal::get_optional_t<T, Ids...> get_optional(Ids... ids) {
-        std::tuple<Ids...> idsTuple{std::forward<Ids>(ids)...};
-        return {move(idsTuple)};
-    }
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-    /**
-     *  Create a remove all statement.
-     *  T is an object type mapped to a storage.
-     *  Usage: storage.remove_all<User>(...);
-     */
-    template<class T, class... Args>
-    internal::remove_all_t<T, Args...> remove_all(Args... args) {
-        using args_tuple = std::tuple<Args...>;
-        internal::validate_conditions<args_tuple>();
-        args_tuple conditions{std::forward<Args>(args)...};
-        return {move(conditions)};
-    }
-
-    /**
-     *  Create a get all statement.
-     *  T is an object type mapped to a storage.
-     *  Usage: storage.get_all<User>(...);
-     */
-    template<class T, class... Args>
-    internal::get_all_t<T, std::vector<T>, Args...> get_all(Args... args) {
-        using args_tuple = std::tuple<Args...>;
-        internal::validate_conditions<args_tuple>();
-        args_tuple conditions{std::forward<Args>(args)...};
-        return {move(conditions)};
-    }
-
-    /**
-     *  Create a get all statement.
-     *  T is an object type mapped to a storage.
-     *  R is a container type. std::vector<T> is default
-     *  Usage: storage.get_all<User>(...);
-    */
-    template<class T, class R, class... Args>
-    internal::get_all_t<T, R, Args...> get_all(Args... args) {
-        using args_tuple = std::tuple<Args...>;
-        internal::validate_conditions<args_tuple>();
-        args_tuple conditions{std::forward<Args>(args)...};
-        return {move(conditions)};
-    }
-
-    /**
-     *  Create an update all statement.
-     *  Usage: storage.update_all(set(...), ...);
-     */
-    template<class... Args, class... Wargs>
-    internal::update_all_t<internal::set_t<Args...>, Wargs...> update_all(internal::set_t<Args...> set, Wargs... wh) {
-        using args_tuple = std::tuple<Wargs...>;
-        internal::validate_conditions<args_tuple>();
-        args_tuple conditions{std::forward<Wargs>(wh)...};
-        return {std::move(set), move(conditions)};
-    }
-
-    /**
-     *  Create a get all pointer statement.
-     *  T is an object type mapped to a storage.
-     *  Usage: storage.get_all_pointer<User>(...);
-     */
-    template<class T, class... Args>
-    internal::get_all_pointer_t<T, std::vector<std::unique_ptr<T>>, Args...> get_all_pointer(Args... args) {
-        using args_tuple = std::tuple<Args...>;
-        internal::validate_conditions<args_tuple>();
-        args_tuple conditions{std::forward<Args>(args)...};
-        return {move(conditions)};
-    }
-    /**
-     *  Create a get all pointer statement.
-     *  T is an object type mapped to a storage.
-     *  R is a container return type. std::vector<std::unique_ptr<T>> is default
-     *  Usage: storage.get_all_pointer<User>(...);
-    */
-    template<class T, class R, class... Args>
-    internal::get_all_pointer_t<T, R, Args...> get_all_pointer(Args... args) {
-        using args_tuple = std::tuple<Args...>;
-        internal::validate_conditions<args_tuple>();
-        args_tuple conditions{std::forward<Args>(args)...};
-        return {move(conditions)};
-    }
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-    /**
-     *  Create a get all optional statement.
-     *  T is an object type mapped to a storage.
-     *  Usage: storage.get_all_optional<User>(...);
-     */
-    template<class T, class... Args>
-    internal::get_all_optional_t<T, std::vector<std::optional<T>>, Args...> get_all_optional(Args... args) {
-        using args_tuple = std::tuple<Args...>;
-        internal::validate_conditions<args_tuple>();
-        args_tuple conditions{std::forward<Args>(args)...};
-        return {move(conditions)};
-    }
-
-    /**
-     *  Create a get all optional statement.
-     *  T is an object type mapped to a storage.
-     *  R is a container return type. std::vector<std::optional<T>> is default
-     *  Usage: storage.get_all_optional<User>(...);
-     */
-    template<class T, class R, class... Args>
-    internal::get_all_optional_t<T, R, Args...> get_all_optional(Args... args) {
-        using args_tuple = std::tuple<Args...>;
-        internal::validate_conditions<args_tuple>();
-        args_tuple conditions{std::forward<Args>(args)...};
-        return {move(conditions)};
-    }
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-}
-
-// #include "values.h"
-
-// #include "function.h"
-
-// #include "ast/excluded.h"
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T>
-        struct excluded_t {
-            using expression_type = T;
-
-            expression_type expression;
-        };
-    }
-
-    template<class T>
-    internal::excluded_t<T> excluded(T expression) {
-        return {std::move(expression)};
-    }
-}
-
-// #include "ast/upsert_clause.h"
-
-#include <tuple>  //  std::tuple, std::make_tuple
-#include <type_traits>  //  std::false_type, std::true_type, std::forward
-
-namespace sqlite_orm {
-    namespace internal {
-#if SQLITE_VERSION_NUMBER >= 3024000
-        template<class T, class A>
-        struct upsert_clause;
-
-        template<class... Args>
-        struct conflict_target {
-            using args_tuple = std::tuple<Args...>;
-
-            args_tuple args;
-
-            upsert_clause<args_tuple, std::tuple<>> do_nothing() {
-                return {move(this->args), {}};
-            }
-
-            template<class... ActionsArgs>
-            upsert_clause<args_tuple, std::tuple<ActionsArgs...>> do_update(ActionsArgs... actions) {
-                return {move(this->args), {std::make_tuple(std::forward<ActionsArgs>(actions)...)}};
-            }
-        };
-
-        template<class... TargetArgs, class... ActionsArgs>
-        struct upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>> {
-            using target_args_tuple = std::tuple<TargetArgs...>;
-            using actions_tuple = std::tuple<ActionsArgs...>;
-
-            target_args_tuple target_args;
-
-            actions_tuple actions;
-        };
-
-        template<class T>
-        struct is_upsert_clause : std::false_type {};
-
-        template<class T, class A>
-        struct is_upsert_clause<upsert_clause<T, A>> : std::true_type {};
-    }
-
-    /**
-     *  ON CONFLICT upsert clause builder function.
-     *  @example
-     *  storage.insert(into<Employee>(),
-     *            columns(&Employee::id, &Employee::name, &Employee::age, &Employee::address, &Employee::salary),
-     *            values(std::make_tuple(3, "Sofia", 26, "Madrid", 15000.0),
-     *                 std::make_tuple(4, "Doja", 26, "LA", 25000.0)),
-     *            on_conflict(&Employee::id).do_update(set(c(&Employee::name) = excluded(&Employee::name),
-     *                                           c(&Employee::age) = excluded(&Employee::age),
-     *                                           c(&Employee::address) = excluded(&Employee::address),
-     *                                           c(&Employee::salary) = excluded(&Employee::salary))));
-     */
-    template<class... Args>
-    internal::conflict_target<Args...> on_conflict(Args... args) {
-        return {std::tuple<Args...>(std::forward<Args>(args)...)};
-    }
-#endif
-}
-
-// #include "ast/where.h"
-
-// #include "ast/into.h"
-
-#include <type_traits>  //  std::true_type, std::false_type
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T>
-        struct into_t {
-            using type = T;
-        };
-
-        template<class T>
-        struct is_into : std::false_type {};
-
-        template<class T>
-        struct is_into<into_t<T>> : std::true_type {};
-    }
-
-    template<class T>
-    internal::into_t<T> into() {
-        return {};
-    }
-}
-
-// #include "ast/group_by.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         *  ast_iterator accepts any expression and a callable object
-         *  which will be called for any node of provided expression.
-         *  E.g. if we pass `where(is_equal(5, max(&User::id, 10))` then
-         *  callable object will be called with 5, &User::id and 10.
-         *  ast_iterator is used mostly in finding literals to be bound to
-         *  a statement. To use it just call `iterate_ast(object, callable);`
-         *  T is an ast element. E.g. where_t
-         */
-        template<class T, class SFINAE = void>
-        struct ast_iterator {
-            using node_type = T;
-
-            /**
-             *  L is a callable type. Mostly is a templated lambda
-             */
-            template<class L>
-            void operator()(const T& t, const L& l) const {
-                l(t);
-            }
-        };
-
-        /**
-         *  Simplified API
-         */
-        template<class T, class L>
-        void iterate_ast(const T& t, const L& l) {
-            ast_iterator<T> iterator;
-            iterator(t, l);
-        }
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class T>
-        struct ast_iterator<as_optional_t<T>, void> {
-            using node_type = as_optional_t<T>;
-
-            template<class L>
-            void operator()(const node_type& node, const L& lambda) const {
-                iterate_ast(node.value, lambda);
-            }
-        };
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-
-        template<class T>
-        struct ast_iterator<std::reference_wrapper<T>, void> {
-            using node_type = std::reference_wrapper<T>;
-
-            template<class L>
-            void operator()(const node_type& expression, const L& lambda) const {
-                iterate_ast(expression.get(), lambda);
-            }
-        };
-
-        template<class... Args>
-        struct ast_iterator<group_by_t<Args...>, void> {
-            using node_type = group_by_t<Args...>;
-
-            template<class L>
-            void operator()(const node_type& expression, const L& lambda) const {
-                iterate_ast(expression.args, lambda);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<excluded_t<T>, void> {
-            using node_type = excluded_t<T>;
-
-            template<class L>
-            void operator()(const node_type& expression, const L& lambda) const {
-                iterate_ast(expression.expression, lambda);
-            }
-        };
-
-        template<class... TargetArgs, class... ActionsArgs>
-        struct ast_iterator<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void> {
-            using node_type = upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>;
-
-            template<class L>
-            void operator()(const node_type& expression, const L& lambda) const {
-                iterate_ast(expression.actions, lambda);
-            }
-        };
-
-        template<class C>
-        struct ast_iterator<where_t<C>, void> {
-            using node_type = where_t<C>;
-
-            template<class L>
-            void operator()(const node_type& expression, const L& lambda) const {
-                iterate_ast(expression.expression, lambda);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<T, typename std::enable_if<is_base_of_template<T, binary_condition>::value>::type> {
-            using node_type = T;
-
-            template<class L>
-            void operator()(const node_type& binaryCondition, const L& l) const {
-                iterate_ast(binaryCondition.l, l);
-                iterate_ast(binaryCondition.r, l);
-            }
-        };
-
-        template<class L, class R, class... Ds>
-        struct ast_iterator<binary_operator<L, R, Ds...>, void> {
-            using node_type = binary_operator<L, R, Ds...>;
-
-            template<class C>
-            void operator()(const node_type& binaryOperator, const C& l) const {
-                iterate_ast(binaryOperator.lhs, l);
-                iterate_ast(binaryOperator.rhs, l);
-            }
-        };
-
-        template<class... Args>
-        struct ast_iterator<columns_t<Args...>, void> {
-            using node_type = columns_t<Args...>;
-
-            template<class L>
-            void operator()(const node_type& cols, const L& l) const {
-                iterate_ast(cols.columns, l);
-            }
-        };
-
-        template<class L, class A>
-        struct ast_iterator<dynamic_in_t<L, A>, void> {
-            using node_type = dynamic_in_t<L, A>;
-
-            template<class C>
-            void operator()(const node_type& in, const C& l) const {
-                iterate_ast(in.left, l);
-                iterate_ast(in.argument, l);
-            }
-        };
-
-        template<class L, class... Args>
-        struct ast_iterator<in_t<L, Args...>, void> {
-            using node_type = in_t<L, Args...>;
-
-            template<class C>
-            void operator()(const node_type& in, const C& l) const {
-                iterate_ast(in.left, l);
-                iterate_ast(in.argument, l);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<std::vector<T>, void> {
-            using node_type = std::vector<T>;
-
-            template<class L>
-            void operator()(const node_type& vec, const L& l) const {
-                for(auto& i: vec) {
-                    iterate_ast(i, l);
-                }
-            }
-        };
-
-        template<>
-        struct ast_iterator<std::vector<char>, void> {
-            using node_type = std::vector<char>;
-
-            template<class L>
-            void operator()(const node_type& vec, const L& l) const {
-                l(vec);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
-            using node_type = T;
-
-            template<class L>
-            void operator()(const node_type& c, const L& l) const {
-                iterate_ast(c.left, l);
-                iterate_ast(c.right, l);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<into_t<T>, void> {
-            using node_type = into_t<T>;
-
-            template<class L>
-            void operator()(const node_type& node, const L& l) const {
-                //..
-            }
-        };
-
-        template<class... Args>
-        struct ast_iterator<insert_raw_t<Args...>, void> {
-            using node_type = insert_raw_t<Args...>;
-
-            template<class L>
-            void operator()(const node_type& node, const L& l) const {
-                iterate_ast(node.args, l);
-            }
-        };
-
-        template<class... Args>
-        struct ast_iterator<replace_raw_t<Args...>, void> {
-            using node_type = replace_raw_t<Args...>;
-
-            template<class L>
-            void operator()(const node_type& node, const L& l) const {
-                iterate_ast(node.args, l);
-            }
-        };
-
-        template<class T, class... Args>
-        struct ast_iterator<select_t<T, Args...>, void> {
-            using node_type = select_t<T, Args...>;
-
-            template<class L>
-            void operator()(const node_type& sel, const L& l) const {
-                iterate_ast(sel.col, l);
-                iterate_ast(sel.conditions, l);
-            }
-        };
-
-        template<class T, class R, class... Args>
-        struct ast_iterator<get_all_t<T, R, Args...>, void> {
-            using node_type = get_all_t<T, R, Args...>;
-
-            template<class L>
-            void operator()(const node_type& get, const L& l) const {
-                iterate_ast(get.conditions, l);
-            }
-        };
-
-        template<class T, class... Args>
-        struct ast_iterator<get_all_pointer_t<T, Args...>, void> {
-            using node_type = get_all_pointer_t<T, Args...>;
-
-            template<class L>
-            void operator()(const node_type& get, const L& l) const {
-                iterate_ast(get.conditions, l);
-            }
-        };
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class T, class... Args>
-        struct ast_iterator<get_all_optional_t<T, Args...>, void> {
-            using node_type = get_all_optional_t<T, Args...>;
-
-            template<class L>
-            void operator()(const node_type& get, const L& l) const {
-                iterate_ast(get.conditions, l);
-            }
-        };
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-        template<class... Args, class... Wargs>
-        struct ast_iterator<update_all_t<set_t<Args...>, Wargs...>, void> {
-            using node_type = update_all_t<set_t<Args...>, Wargs...>;
-
-            template<class L>
-            void operator()(const node_type& u, const L& l) const {
-                iterate_ast(u.set, l);
-                iterate_ast(u.conditions, l);
-            }
-        };
-
-        template<class T, class... Args>
-        struct ast_iterator<remove_all_t<T, Args...>, void> {
-            using node_type = remove_all_t<T, Args...>;
-
-            template<class L>
-            void operator()(const node_type& r, const L& l) const {
-                iterate_ast(r.conditions, l);
-            }
-        };
-
-        template<class... Args>
-        struct ast_iterator<set_t<Args...>, void> {
-            using node_type = set_t<Args...>;
-
-            template<class L>
-            void operator()(const node_type& s, const L& l) const {
-                iterate_ast(s.assigns, l);
-            }
-        };
-
-        template<class... Args>
-        struct ast_iterator<std::tuple<Args...>, void> {
-            using node_type = std::tuple<Args...>;
-
-            template<class L>
-            void operator()(const node_type& node, const L& l) const {
-                iterate_tuple(node, [&l](auto& v) {
-                    iterate_ast(v, l);
-                });
-            }
-        };
-
-        template<class T, class... Args>
-        struct ast_iterator<group_by_with_having<T, Args...>, void> {
-            using node_type = group_by_with_having<T, Args...>;
-
-            template<class L>
-            void operator()(const node_type& node, const L& lambda) const {
-                iterate_ast(node.args, lambda);
-                iterate_ast(node.expression, lambda);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<having_t<T>, void> {
-            using node_type = having_t<T>;
-
-            template<class L>
-            void operator()(const node_type& node, const L& lambda) const {
-                iterate_ast(node.expression, lambda);
-            }
-        };
-
-        template<class T, class E>
-        struct ast_iterator<cast_t<T, E>, void> {
-            using node_type = cast_t<T, E>;
-
-            template<class L>
-            void operator()(const node_type& c, const L& l) const {
-                iterate_ast(c.expression, l);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<exists_t<T>, void> {
-            using node_type = exists_t<T>;
-
-            template<class L>
-            void operator()(const node_type& e, const L& l) const {
-                iterate_ast(e.t, l);
-            }
-        };
-
-        template<class A, class T, class E>
-        struct ast_iterator<like_t<A, T, E>, void> {
-            using node_type = like_t<A, T, E>;
-
-            template<class L>
-            void operator()(const node_type& lk, const L& l) const {
-                iterate_ast(lk.arg, l);
-                iterate_ast(lk.pattern, l);
-                lk.arg3.apply([&l](auto& value) {
-                    iterate_ast(value, l);
-                });
-            }
-        };
-
-        template<class A, class T>
-        struct ast_iterator<glob_t<A, T>, void> {
-            using node_type = glob_t<A, T>;
-
-            template<class L>
-            void operator()(const node_type& lk, const L& l) const {
-                iterate_ast(lk.arg, l);
-                iterate_ast(lk.pattern, l);
-            }
-        };
-
-        template<class A, class T>
-        struct ast_iterator<between_t<A, T>, void> {
-            using node_type = between_t<A, T>;
-
-            template<class L>
-            void operator()(const node_type& b, const L& l) const {
-                iterate_ast(b.expr, l);
-                iterate_ast(b.b1, l);
-                iterate_ast(b.b2, l);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<named_collate<T>, void> {
-            using node_type = named_collate<T>;
-
-            template<class L>
-            void operator()(const node_type& col, const L& l) const {
-                iterate_ast(col.expr, l);
-            }
-        };
-
-        template<class C>
-        struct ast_iterator<negated_condition_t<C>, void> {
-            using node_type = negated_condition_t<C>;
-
-            template<class L>
-            void operator()(const node_type& neg, const L& l) const {
-                iterate_ast(neg.c, l);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<is_null_t<T>, void> {
-            using node_type = is_null_t<T>;
-
-            template<class L>
-            void operator()(const node_type& i, const L& l) const {
-                iterate_ast(i.t, l);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<is_not_null_t<T>, void> {
-            using node_type = is_not_null_t<T>;
-
-            template<class L>
-            void operator()(const node_type& i, const L& l) const {
-                iterate_ast(i.t, l);
-            }
-        };
-
-        template<class F, class... Args>
-        struct ast_iterator<function_call<F, Args...>, void> {
-            using node_type = function_call<F, Args...>;
-
-            template<class L>
-            void operator()(const node_type& f, const L& l) const {
-                iterate_ast(f.args, l);
-            }
-        };
-
-        template<class R, class S, class... Args>
-        struct ast_iterator<built_in_function_t<R, S, Args...>, void> {
-            using node_type = built_in_function_t<R, S, Args...>;
-
-            template<class L>
-            void operator()(const node_type& f, const L& l) const {
-                iterate_ast(f.args, l);
-            }
-        };
-
-        template<class T, class O>
-        struct ast_iterator<left_join_t<T, O>, void> {
-            using node_type = left_join_t<T, O>;
-
-            template<class L>
-            void operator()(const node_type& j, const L& l) const {
-                iterate_ast(j.constraint, l);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<on_t<T>, void> {
-            using node_type = on_t<T>;
-
-            template<class L>
-            void operator()(const node_type& o, const L& l) const {
-                iterate_ast(o.arg, l);
-            }
-        };
-
-        template<class T, class O>
-        struct ast_iterator<join_t<T, O>, void> {
-            using node_type = join_t<T, O>;
-
-            template<class L>
-            void operator()(const node_type& j, const L& l) const {
-                iterate_ast(j.constraint, l);
-            }
-        };
-
-        template<class T, class O>
-        struct ast_iterator<left_outer_join_t<T, O>, void> {
-            using node_type = left_outer_join_t<T, O>;
-
-            template<class L>
-            void operator()(const node_type& j, const L& l) const {
-                iterate_ast(j.constraint, l);
-            }
-        };
-
-        template<class T, class O>
-        struct ast_iterator<inner_join_t<T, O>, void> {
-            using node_type = inner_join_t<T, O>;
-
-            template<class L>
-            void operator()(const node_type& j, const L& l) const {
-                iterate_ast(j.constraint, l);
-            }
-        };
-
-        template<class R, class T, class E, class... Args>
-        struct ast_iterator<simple_case_t<R, T, E, Args...>, void> {
-            using node_type = simple_case_t<R, T, E, Args...>;
-
-            template<class L>
-            void operator()(const node_type& c, const L& l) const {
-                c.case_expression.apply([&l](auto& c_) {
-                    iterate_ast(c_, l);
-                });
-                iterate_tuple(c.args, [&l](auto& pair) {
-                    iterate_ast(pair.first, l);
-                    iterate_ast(pair.second, l);
-                });
-                c.else_expression.apply([&l](auto& el) {
-                    iterate_ast(el, l);
-                });
-            }
-        };
-
-        template<class T, class E>
-        struct ast_iterator<as_t<T, E>, void> {
-            using node_type = as_t<T, E>;
-
-            template<class L>
-            void operator()(const node_type& a, const L& l) const {
-                iterate_ast(a.expression, l);
-            }
-        };
-
-        template<class T, bool OI>
-        struct ast_iterator<limit_t<T, false, OI, void>, void> {
-            using node_type = limit_t<T, false, OI, void>;
-
-            template<class L>
-            void operator()(const node_type& a, const L& l) const {
-                iterate_ast(a.lim, l);
-            }
-        };
-
-        template<class T, class O>
-        struct ast_iterator<limit_t<T, true, false, O>, void> {
-            using node_type = limit_t<T, true, false, O>;
-
-            template<class L>
-            void operator()(const node_type& a, const L& l) const {
-                iterate_ast(a.lim, l);
-                a.off.apply([&l](auto& value) {
-                    iterate_ast(value, l);
-                });
-            }
-        };
-
-        template<class T, class O>
-        struct ast_iterator<limit_t<T, true, true, O>, void> {
-            using node_type = limit_t<T, true, true, O>;
-
-            template<class L>
-            void operator()(const node_type& a, const L& l) const {
-                a.off.apply([&l](auto& value) {
-                    iterate_ast(value, l);
-                });
-                iterate_ast(a.lim, l);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<distinct_t<T>, void> {
-            using node_type = distinct_t<T>;
-
-            template<class L>
-            void operator()(const node_type& a, const L& l) const {
-                iterate_ast(a.value, l);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<all_t<T>, void> {
-            using node_type = all_t<T>;
-
-            template<class L>
-            void operator()(const node_type& a, const L& l) const {
-                iterate_ast(a.value, l);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<bitwise_not_t<T>, void> {
-            using node_type = bitwise_not_t<T>;
-
-            template<class L>
-            void operator()(const node_type& a, const L& l) const {
-                iterate_ast(a.argument, l);
-            }
-        };
-
-        template<class... Args>
-        struct ast_iterator<values_t<Args...>, void> {
-            using node_type = values_t<Args...>;
-
-            template<class L>
-            void operator()(const node_type& node, const L& l) const {
-                iterate_ast(node.tuple, l);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<dynamic_values_t<T>, void> {
-            using node_type = dynamic_values_t<T>;
-
-            template<class L>
-            void operator()(const node_type& node, const L& l) const {
-                iterate_ast(node.vector, l);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<order_by_t<T>, void> {
-            using node_type = order_by_t<T>;
-
-            template<class L>
-            void operator()(const node_type& node, const L& l) const {
-                iterate_ast(node.expression, l);
-            }
-        };
-
-        template<class T>
-        struct ast_iterator<collate_t<T>, void> {
-            using node_type = collate_t<T>;
-
-            template<class L>
-            void operator()(const node_type& node, const L& l) const {
-                iterate_ast(node.expr, l);
-            }
-        };
-
-    }
-}
-
-// #include "prepared_statement.h"
-
-// #include "connection_holder.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         * This class does not related to SQL view. This is a container like class which is returned by
-         * by storage_t::iterate function. This class contains STL functions:
-         *  -   size_t size()
-         *  -   bool empty()
-         *  -   iterator end()
-         *  -   iterator begin()
-         *  All these functions are not right const cause all of them may open SQLite connections.
-         */
-        template<class T, class S, class... Args>
-        struct view_t {
-            using mapped_type = T;
-            using storage_type = S;
-            using self = view_t<T, S, Args...>;
-
-            storage_type& storage;
-            connection_ref connection;
-            get_all_t<T, std::vector<T>, Args...> args;
-
-            view_t(storage_type& stor, decltype(connection) conn, Args&&... args_) :
-                storage(stor), connection(std::move(conn)), args{std::make_tuple(std::forward<Args>(args_)...)} {}
-
-            size_t size() {
-                return this->storage.template count<T>();
-            }
-
-            bool empty() {
-                return !this->size();
-            }
-
-            iterator_t<self> begin() {
-                sqlite3_stmt* stmt = nullptr;
-                auto db = this->connection.get();
-                using context_t = serializator_context<typename storage_type::impl_type>;
-                context_t context{this->storage.impl};
-                context.skip_table_name = false;
-                context.replace_bindable_with_question = true;
-                auto query = serialize(this->args, context);
-                auto ret = sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr);
-                if(ret == SQLITE_OK) {
-                    auto index = 1;
-                    iterate_ast(this->args.conditions, [&index, stmt, db](auto& node) {
-                        using node_type = typename std::decay<decltype(node)>::type;
-                        conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
-                        if(SQLITE_OK != binder(node)) {
-                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                    sqlite3_errmsg(db));
-                        }
-                    });
-                    return {stmt, *this};
-                } else {
-                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                            sqlite3_errmsg(db));
-                }
-            }
-
-            iterator_t<self> end() {
-                return {};
-            }
-        };
-    }
-}
-
-// #include "ast_iterator.h"
-
-// #include "storage_base.h"
-
-#include <functional>  //  std::function, std::bind
-#include <sqlite3.h>
-#include <string>  //  std::string
-#include <sstream>  //  std::stringstream
-#include <utility>  //  std::move
-#include <system_error>  //  std::system_error, std::error_code, std::make_error_code
-#include <vector>  //  std::vector
-#include <memory>  //  std::make_shared, std::shared_ptr
-#include <map>  //  std::map
-#include <type_traits>  //  std::decay, std::is_same
-#include <algorithm>  //  std::iter_swap
-
-// #include "pragma.h"
-
-#include <string>  //  std::string
-#include <sqlite3.h>
-#include <functional>  //  std::function
-#include <memory>  // std::shared_ptr
-#include <vector>  //  std::vector
-
-// #include "error_code.h"
-
-// #include "util.h"
-
-// #include "row_extractor.h"
-
-// #include "journal_mode.h"
-
-// #include "connection_holder.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-        struct storage_base;
-
-        template<class T>
-        int getPragmaCallback(void* data, int argc, char** argv, char**) {
-            auto& res = *(T*)data;
-            if(argc) {
-                res = row_extractor<T>().extract(argv[0]);
-            }
-            return 0;
-        }
-
-        template<>
-        inline int getPragmaCallback<std::vector<std::string>>(void* data, int argc, char** argv, char**) {
-            auto& res = *(std::vector<std::string>*)data;
-            res.reserve(argc);
-            for(decltype(argc) i = 0; i < argc; ++i) {
-                auto rowString = row_extractor<std::string>().extract(argv[i]);
-                res.push_back(move(rowString));
-            }
-            return 0;
-        }
-
-        struct pragma_t {
-            using get_connection_t = std::function<internal::connection_ref()>;
-
-            pragma_t(get_connection_t get_connection_) : get_connection(move(get_connection_)) {}
-
-            void busy_timeout(int value) {
-                this->set_pragma("busy_timeout", value);
-            }
-
-            int busy_timeout() {
-                return this->get_pragma<int>("busy_timeout");
-            }
-
-            sqlite_orm::journal_mode journal_mode() {
-                return this->get_pragma<sqlite_orm::journal_mode>("journal_mode");
-            }
-
-            void journal_mode(sqlite_orm::journal_mode value) {
-                this->_journal_mode = -1;
-                this->set_pragma("journal_mode", value);
-                this->_journal_mode = static_cast<decltype(this->_journal_mode)>(value);
-            }
-
-            /**
-             *  https://www.sqlite.org/pragma.html#pragma_application_id
-             */
-            int application_id() {
-                return this->get_pragma<int>("application_id");
-            }
-
-            /**
-             *  https://www.sqlite.org/pragma.html#pragma_application_id
-             */
-            void application_id(int value) {
-                this->set_pragma("application_id", value);
-            }
-
-            int synchronous() {
-                return this->get_pragma<int>("synchronous");
-            }
-
-            void synchronous(int value) {
-                this->_synchronous = -1;
-                this->set_pragma("synchronous", value);
-                this->_synchronous = value;
-            }
-
-            int user_version() {
-                return this->get_pragma<int>("user_version");
-            }
-
-            void user_version(int value) {
-                this->set_pragma("user_version", value);
-            }
-
-            int auto_vacuum() {
-                return this->get_pragma<int>("auto_vacuum");
-            }
-
-            void auto_vacuum(int value) {
-                this->set_pragma("auto_vacuum", value);
-            }
-
-            std::vector<std::string> integrity_check() {
-                return this->get_pragma<std::vector<std::string>>("integrity_check");
-            }
-
-            template<class T>
-            std::vector<std::string> integrity_check(T table_name) {
-                std::ostringstream oss;
-                oss << "integrity_check(" << table_name << ")";
-                return this->get_pragma<std::vector<std::string>>(oss.str());
-            }
-
-            std::vector<std::string> integrity_check(int n) {
-                std::ostringstream oss;
-                oss << "integrity_check(" << n << ")";
-                return this->get_pragma<std::vector<std::string>>(oss.str());
-            }
-
-          private:
-            friend struct storage_base;
-
-            int _synchronous = -1;
-            signed char _journal_mode = -1;  //  if != -1 stores static_cast<sqlite_orm::journal_mode>(journal_mode)
-            get_connection_t get_connection;
-
-            template<class T>
-            T get_pragma(const std::string& name) {
-                auto connection = this->get_connection();
-                auto query = "PRAGMA " + name;
-                T result;
-                auto db = connection.get();
-                auto rc = sqlite3_exec(db, query.c_str(), getPragmaCallback<T>, &result, nullptr);
-                if(rc == SQLITE_OK) {
-                    return result;
-                } else {
-                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                            sqlite3_errmsg(db));
-                }
-            }
-
-            /**
-             *  Yevgeniy Zakharov: I wanted to refactor this function with statements and value bindings
-             *  but it turns out that bindings in pragma statements are not supported.
-             */
-            template<class T>
-            void set_pragma(const std::string& name, const T& value, sqlite3* db = nullptr) {
-                auto con = this->get_connection();
-                if(!db) {
-                    db = con.get();
-                }
-                std::stringstream ss;
-                ss << "PRAGMA " << name << " = " << value;
-                internal::perform_void_exec(db, ss.str());
-            }
-
-            void set_pragma(const std::string& name, const sqlite_orm::journal_mode& value, sqlite3* db = nullptr) {
-                auto con = this->get_connection();
-                if(!db) {
-                    db = con.get();
-                }
-                std::stringstream ss;
-                ss << "PRAGMA " << name << " = " << internal::to_string(value);
-                internal::perform_void_exec(db, ss.str());
-            }
-        };
-    }
-}
-
-// #include "limit_accesor.h"
-
-#include <sqlite3.h>
-#include <map>  //  std::map
-#include <functional>  //  std::function
-#include <memory>  //  std::shared_ptr
-
-// #include "connection_holder.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        struct limit_accesor {
-            using get_connection_t = std::function<connection_ref()>;
-
-            limit_accesor(get_connection_t get_connection_) : get_connection(std::move(get_connection_)) {}
-
-            int length() {
-                return this->get(SQLITE_LIMIT_LENGTH);
-            }
-
-            void length(int newValue) {
-                this->set(SQLITE_LIMIT_LENGTH, newValue);
-            }
-
-            int sql_length() {
-                return this->get(SQLITE_LIMIT_SQL_LENGTH);
-            }
-
-            void sql_length(int newValue) {
-                this->set(SQLITE_LIMIT_SQL_LENGTH, newValue);
-            }
-
-            int column() {
-                return this->get(SQLITE_LIMIT_COLUMN);
-            }
-
-            void column(int newValue) {
-                this->set(SQLITE_LIMIT_COLUMN, newValue);
-            }
-
-            int expr_depth() {
-                return this->get(SQLITE_LIMIT_EXPR_DEPTH);
-            }
-
-            void expr_depth(int newValue) {
-                this->set(SQLITE_LIMIT_EXPR_DEPTH, newValue);
-            }
-
-            int compound_select() {
-                return this->get(SQLITE_LIMIT_COMPOUND_SELECT);
-            }
-
-            void compound_select(int newValue) {
-                this->set(SQLITE_LIMIT_COMPOUND_SELECT, newValue);
-            }
-
-            int vdbe_op() {
-                return this->get(SQLITE_LIMIT_VDBE_OP);
-            }
-
-            void vdbe_op(int newValue) {
-                this->set(SQLITE_LIMIT_VDBE_OP, newValue);
-            }
-
-            int function_arg() {
-                return this->get(SQLITE_LIMIT_FUNCTION_ARG);
-            }
-
-            void function_arg(int newValue) {
-                this->set(SQLITE_LIMIT_FUNCTION_ARG, newValue);
-            }
-
-            int attached() {
-                return this->get(SQLITE_LIMIT_ATTACHED);
-            }
-
-            void attached(int newValue) {
-                this->set(SQLITE_LIMIT_ATTACHED, newValue);
-            }
-
-            int like_pattern_length() {
-                return this->get(SQLITE_LIMIT_LIKE_PATTERN_LENGTH);
-            }
-
-            void like_pattern_length(int newValue) {
-                this->set(SQLITE_LIMIT_LIKE_PATTERN_LENGTH, newValue);
-            }
-
-            int variable_number() {
-                return this->get(SQLITE_LIMIT_VARIABLE_NUMBER);
-            }
-
-            void variable_number(int newValue) {
-                this->set(SQLITE_LIMIT_VARIABLE_NUMBER, newValue);
-            }
-
-            int trigger_depth() {
-                return this->get(SQLITE_LIMIT_TRIGGER_DEPTH);
-            }
-
-            void trigger_depth(int newValue) {
-                this->set(SQLITE_LIMIT_TRIGGER_DEPTH, newValue);
-            }
-
-#if SQLITE_VERSION_NUMBER >= 3008007
-            int worker_threads() {
-                return this->get(SQLITE_LIMIT_WORKER_THREADS);
-            }
-
-            void worker_threads(int newValue) {
-                this->set(SQLITE_LIMIT_WORKER_THREADS, newValue);
-            }
-#endif
-
-          protected:
-            get_connection_t get_connection;
-
-            friend struct storage_base;
-
-            /**
-             *  Stores limit set between connections.
-             */
-            std::map<int, int> limits;
-
-            int get(int id) {
-                auto connection = this->get_connection();
-                return sqlite3_limit(connection.get(), id, -1);
-            }
-
-            void set(int id, int newValue) {
-                this->limits[id] = newValue;
-                auto connection = this->get_connection();
-                sqlite3_limit(connection.get(), id, newValue);
-            }
-        };
-    }
-}
-
-// #include "transaction_guard.h"
-
-#include <functional>  //  std::function
-
-// #include "connection_holder.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         *  Class used as a guard for a transaction. Calls `ROLLBACK` in destructor.
-         *  Has explicit `commit()` and `rollback()` functions. After explicit function is fired
-         *  guard won't do anything in d-tor. Also you can set `commit_on_destroy` to true to
-         *  make it call `COMMIT` on destroy.
-         */
-        struct transaction_guard_t {
-            /**
-             *  This is a public lever to tell a guard what it must do in its destructor
-             *  if `gotta_fire` is true
-             */
-            bool commit_on_destroy = false;
-
-            transaction_guard_t(connection_ref connection_,
-                                std::function<void()> commit_func_,
-                                std::function<void()> rollback_func_) :
-                connection(std::move(connection_)),
-                commit_func(std::move(commit_func_)), rollback_func(std::move(rollback_func_)) {}
-
-            ~transaction_guard_t() {
-                if(this->gotta_fire) {
-                    if(!this->commit_on_destroy) {
-                        this->rollback_func();
-                    } else {
-                        this->commit_func();
-                    }
-                }
-            }
-
-            /**
-             *  Call `COMMIT` explicitly. After this call
-             *  guard will not call `COMMIT` or `ROLLBACK`
-             *  in its destructor.
-             */
-            void commit() {
-                this->commit_func();
-                this->gotta_fire = false;
-            }
-
-            /**
-             *  Call `ROLLBACK` explicitly. After this call
-             *  guard will not call `COMMIT` or `ROLLBACK`
-             *  in its destructor.
-             */
-            void rollback() {
-                this->rollback_func();
-                this->gotta_fire = false;
-            }
-
-          protected:
-            connection_ref connection;
-            std::function<void()> commit_func;
-            std::function<void()> rollback_func;
-            bool gotta_fire = true;
-        };
-    }
-}
-
-// #include "statement_finalizer.h"
-
-// #include "type_printer.h"
-
-// #include "tuple_helper/tuple_helper.h"
-
-// #include "row_extractor.h"
-
-// #include "util.h"
-
-// #include "connection_holder.h"
-
-// #include "backup.h"
-
-#include <sqlite3.h>
-#include <string>  //  std::string
-#include <memory>
-
-// #include "error_code.h"
-
-// #include "connection_holder.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         *  A backup class. Don't construct it as is, call storage.make_backup_from or storage.make_backup_to instead.
-         *  An instance of this class represents a wrapper around sqlite3_backup pointer. Use this class
-         *  to have maximum control on a backup operation. In case you need a single backup in one line you
-         *  can skip creating a backup_t instance and just call storage.backup_from or storage.backup_to function.
-         */
-        struct backup_t {
-            backup_t(connection_ref to_,
-                     const std::string& zDestName,
-                     connection_ref from_,
-                     const std::string& zSourceName,
-                     std::unique_ptr<connection_holder> holder_) :
-                handle(sqlite3_backup_init(to_.get(), zDestName.c_str(), from_.get(), zSourceName.c_str())),
-                holder(move(holder_)), to(to_), from(from_) {
-                if(!this->handle) {
-                    throw std::system_error(std::make_error_code(orm_error_code::failed_to_init_a_backup));
-                }
-            }
-
-            backup_t(backup_t&& other) :
-                handle(other.handle), holder(move(other.holder)), to(other.to), from(other.from) {
-                other.handle = nullptr;
-            }
-
-            ~backup_t() {
-                if(this->handle) {
-                    (void)sqlite3_backup_finish(this->handle);
-                    this->handle = nullptr;
-                }
-            }
-
-            /**
-             *  Calls sqlite3_backup_step with pages argument
-             */
-            int step(int pages) {
-                return sqlite3_backup_step(this->handle, pages);
-            }
-
-            /**
-             *  Returns sqlite3_backup_remaining result
-             */
-            int remaining() const {
-                return sqlite3_backup_remaining(this->handle);
-            }
-
-            /**
-             *  Returns sqlite3_backup_pagecount result
-             */
-            int pagecount() const {
-                return sqlite3_backup_pagecount(this->handle);
-            }
-
-          protected:
-            sqlite3_backup* handle = nullptr;
-            std::unique_ptr<connection_holder> holder;
-            connection_ref to;
-            connection_ref from;
-        };
-    }
-}
-
-// #include "function.h"
-
-// #include "values_to_tuple.h"
-
-#include <sqlite3.h>
-#include <tuple>  //  std::get, std::tuple_element
-
-// #include "row_extractor.h"
-
-// #include "arg_values.h"
-
-#include <sqlite3.h>
-
-// #include "row_extractor.h"
-
-namespace sqlite_orm {
-
-    struct arg_value {
-
-        arg_value() : arg_value(nullptr) {}
-
-        arg_value(sqlite3_value* value_) : value(value_) {}
-
-        template<class T>
-        T get() const {
-            return row_extractor<T>().extract(this->value);
-        }
-
-        bool is_null() const {
-            auto type = sqlite3_value_type(this->value);
-            return type == SQLITE_NULL;
-        }
-
-        bool is_text() const {
-            auto type = sqlite3_value_type(this->value);
-            return type == SQLITE_TEXT;
-        }
-
-        bool is_integer() const {
-            auto type = sqlite3_value_type(this->value);
-            return type == SQLITE_INTEGER;
-        }
-
-        bool is_float() const {
-            auto type = sqlite3_value_type(this->value);
-            return type == SQLITE_FLOAT;
-        }
-
-        bool is_blob() const {
-            auto type = sqlite3_value_type(this->value);
-            return type == SQLITE_BLOB;
-        }
-
-        bool empty() const {
-            return this->value == nullptr;
-        }
-
-      private:
-        sqlite3_value* value = nullptr;
-    };
-
-    struct arg_values {
-
-        struct iterator {
-
-            iterator(const arg_values& container_, int index_) :
-                container(container_), index(index_),
-                currentValue(index_ < int(container_.size()) ? container_[index_] : arg_value()) {}
-
-            iterator& operator++() {
-                ++this->index;
-                if(this->index < int(this->container.size())) {
-                    this->currentValue = this->container[this->index];
-                } else {
-                    this->currentValue = {};
-                }
-                return *this;
-            }
-
-            iterator operator++(int) {
-                auto res = *this;
-                ++this->index;
-                if(this->index < int(this->container.size())) {
-                    this->currentValue = this->container[this->index];
-                } else {
-                    this->currentValue = {};
-                }
-                return res;
-            }
-
-            arg_value operator*() const {
-                if(this->index < int(this->container.size()) && this->index >= 0) {
-                    return this->currentValue;
-                } else {
-                    throw std::system_error(std::make_error_code(orm_error_code::index_is_out_of_bounds));
-                }
-            }
-
-            arg_value* operator->() const {
-                return &this->currentValue;
-            }
-
-            bool operator==(const iterator& other) const {
-                return &other.container == &this->container && other.index == this->index;
-            }
-
-            bool operator!=(const iterator& other) const {
-                return !(*this == other);
-            }
-
-          private:
-            const arg_values& container;
-            int index = 0;
-            mutable arg_value currentValue;
-        };
-
-        arg_values() : arg_values(0, nullptr) {}
-
-        arg_values(int argsCount_, sqlite3_value** values_) : argsCount(argsCount_), values(values_) {}
-
-        size_t size() const {
-            return this->argsCount;
-        }
-
-        bool empty() const {
-            return 0 == this->argsCount;
-        }
-
-        arg_value operator[](int index) const {
-            if(index < this->argsCount && index >= 0) {
-                auto valuePointer = this->values[index];
-                return {valuePointer};
-            } else {
-                throw std::system_error(std::make_error_code(orm_error_code::index_is_out_of_bounds));
-            }
-        }
-
-        arg_value at(int index) const {
-            return this->operator[](index);
-        }
-
-        iterator begin() const {
-            return {*this, 0};
-        }
-
-        iterator end() const {
-            return {*this, this->argsCount};
-        }
-
-      private:
-        int argsCount = 0;
-        sqlite3_value** values = nullptr;
-    };
-}
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         *  T is a std::tuple type
-         *  I is index to extract value from values C array to tuple. I must me < std::tuple_size<T>::value
-         */
-        template<class T, size_t I>
-        struct values_to_tuple {
-
-            void extract(sqlite3_value** values, T& tuple, int argsCount) const {
-                using element_type = typename std::tuple_element<I, T>::type;
-                std::get<I>(tuple) = row_extractor<element_type>().extract(values[I]);
-
-                values_to_tuple<T, I - 1>().extract(values, tuple, argsCount);
-            }
-        };
-
-        template<class T>
-        struct values_to_tuple<T, size_t(-1)> {
-            void extract(sqlite3_value** values, T& tuple, int argsCount) const {
-                //..
-            }
-        };
-
-        template<>
-        struct values_to_tuple<std::tuple<arg_values>, 0> {
-            void extract(sqlite3_value** values, std::tuple<arg_values>& tuple, int argsCount) const {
-                std::get<0>(tuple) = arg_values(argsCount, values);
-            }
-        };
-    }
-}
-
-// #include "arg_values.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        struct storage_base {
-            using collating_function = std::function<int(int, const void*, int, const void*)>;
-
-            std::function<void(sqlite3*)> on_open;
-            pragma_t pragma;
-            limit_accesor limit;
-
-            transaction_guard_t transaction_guard() {
-                this->begin_transaction();
-                auto commitFunc = std::bind(static_cast<void (storage_base::*)()>(&storage_base::commit), this);
-                auto rollbackFunc = std::bind(static_cast<void (storage_base::*)()>(&storage_base::rollback), this);
-                return {this->get_connection(), move(commitFunc), move(rollbackFunc)};
-            }
-
-            void drop_index(const std::string& indexName) {
-                std::stringstream ss;
-                ss << "DROP INDEX '" << indexName + "'";
-                perform_void_exec(get_connection().get(), ss.str());
-            }
-
-            void vacuum() {
-                perform_void_exec(get_connection().get(), "VACUUM");
-            }
-
-            /**
-             *  Drops table with given name.
-             */
-            void drop_table(const std::string& tableName) {
-                auto con = this->get_connection();
-                this->drop_table_internal(tableName, con.get());
-            }
-
-            /**
-             * Rename table named `from` to `to`.
-             */
-            void rename_table(const std::string& from, const std::string& to) {
-                std::stringstream ss;
-                ss << "ALTER TABLE '" << from << "' RENAME TO '" << to << "'";
-                perform_void_exec(get_connection().get(), ss.str());
-            }
-
-            /**
-             *  sqlite3_changes function.
-             */
-            int changes() {
-                auto con = this->get_connection();
-                return sqlite3_changes(con.get());
-            }
-
-            /**
-             *  sqlite3_total_changes function.
-             */
-            int total_changes() {
-                auto con = this->get_connection();
-                return sqlite3_total_changes(con.get());
-            }
-
-            int64 last_insert_rowid() {
-                auto con = this->get_connection();
-                return sqlite3_last_insert_rowid(con.get());
-            }
-
-            int busy_timeout(int ms) {
-                auto con = this->get_connection();
-                return sqlite3_busy_timeout(con.get(), ms);
-            }
-
-            /**
-             *  Returns libsqltie3 lib version, not sqlite_orm
-             */
-            std::string libversion() {
-                return sqlite3_libversion();
-            }
-
-            bool transaction(const std::function<bool()>& f) {
-                auto guard = transaction_guard();
-                auto shouldCommit = f();
-                if(shouldCommit) {
-                    guard.commit();
-                } else {
-                    guard.rollback();
-                }
-                return shouldCommit;
-            }
-
-            std::string current_timestamp() {
-                auto con = this->get_connection();
-                return this->current_timestamp(con.get());
-            }
-
-#if SQLITE_VERSION_NUMBER >= 3007010
-            /**
-             * \fn db_release_memory
-             * \brief Releases freeable memory of database. It is function can/should be called periodically by
-             * application, if application has less memory usage constraint. \note sqlite3_db_release_memory added
-             * in 3.7.10 https://sqlite.org/changes.html
-             */
-            int db_release_memory() {
-                auto con = this->get_connection();
-                return sqlite3_db_release_memory(con.get());
-            }
-#endif
-
-            /**
-             *  Returns existing permanent table names in database. Doesn't check storage itself - works only with
-             * actual database.
-             *  @return Returns list of tables in database.
-             */
-            std::vector<std::string> table_names() {
-                auto con = this->get_connection();
-                std::vector<std::string> tableNames;
-                std::string sql = "SELECT name FROM sqlite_master WHERE type='table'";
-                using data_t = std::vector<std::string>;
-                auto db = con.get();
-                int res = sqlite3_exec(
-                    db,
-                    sql.c_str(),
-                    [](void* data, int argc, char** argv, char** /*columnName*/) -> int {
-                        auto& tableNames_ = *(data_t*)data;
-                        for(int i = 0; i < argc; i++) {
-                            if(argv[i]) {
-                                tableNames_.push_back(argv[i]);
-                            }
-                        }
-                        return 0;
-                    },
-                    &tableNames,
-                    nullptr);
-
-                if(res != SQLITE_OK) {
-                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                            sqlite3_errmsg(db));
-                }
-                return tableNames;
-            }
-
-            void open_forever() {
-                this->isOpenedForever = true;
-                this->connection->retain();
-                if(1 == this->connection->retain_count()) {
-                    this->on_open_internal(this->connection->get());
-                }
-            }
-
-            /**
-             * Call this to create user defined scalar function. Can be called at any time no matter connection is opened or no.
-             * T - function class. T must have operator() overload and static name function like this:
-             * ```
-             *  struct SqrtFunction {
-             *
-             *      double operator()(double arg) const {
-             *          return std::sqrt(arg);
-             *      }
-             *
-             *      static const char *name() {
-             *          return "SQRT";
-             *      }
-             *  };
-             * ```
-             */
-            template<class F>
-            void create_scalar_function() {
-                static_assert(is_scalar_function<F>::value, "F cannot be a scalar function");
-
-                std::stringstream ss;
-                ss << F::name();
-                auto name = ss.str();
-                using args_tuple = typename callable_arguments<F>::args_tuple;
-                using return_type = typename callable_arguments<F>::return_type;
-                auto argsCount = int(std::tuple_size<args_tuple>::value);
-                if(std::is_same<args_tuple, std::tuple<arg_values>>::value) {
-                    argsCount = -1;
-                }
-                this->scalarFunctions.emplace_back(new scalar_function_t{
-                    move(name),
-                    argsCount,
-                    []() -> int* {
-                        return (int*)(new F());
-                    },
-                    /* call = */
-                    [](sqlite3_context* context, void* functionVoidPointer, int argsCount, sqlite3_value** values) {
-                        auto& functionPointer = *static_cast<F*>(functionVoidPointer);
-                        args_tuple argsTuple;
-                        using tuple_size = std::tuple_size<args_tuple>;
-                        values_to_tuple<args_tuple, tuple_size::value - 1>().extract(values, argsTuple, argsCount);
-                        auto result = call(functionPointer, std::move(argsTuple));
-                        statement_binder<return_type>().result(context, result);
-                    },
-                    delete_function_callback<F>,
-                });
-
-                if(this->connection->retain_count() > 0) {
-                    auto db = this->connection->get();
-                    try_to_create_function(db, static_cast<scalar_function_t&>(*this->scalarFunctions.back()));
-                }
-            }
-
-            /**
-             * Call this to create user defined aggregate function. Can be called at any time no matter connection is opened or no.
-             * T - function class. T must have step member function, fin member function and static name function like this:
-             * ```
-             *   struct MeanFunction {
-             *       double total = 0;
-             *       int count = 0;
-             *
-             *       void step(double value) {
-             *           total += value;
-             *           ++count;
-             *       }
-             *
-             *       int fin() const {
-             *           return total / count;
-             *       }
-             *
-             *       static std::string name() {
-             *           return "MEAN";
-             *       }
-             *   };
-             * ```
-             */
-            template<class F>
-            void create_aggregate_function() {
-                static_assert(is_aggregate_function<F>::value, "F cannot be an aggregate function");
-
-                std::stringstream ss;
-                ss << F::name();
-                auto name = ss.str();
-                using args_tuple = typename callable_arguments<F>::args_tuple;
-                using return_type = typename callable_arguments<F>::return_type;
-                auto argsCount = int(std::tuple_size<args_tuple>::value);
-                if(std::is_same<args_tuple, std::tuple<arg_values>>::value) {
-                    argsCount = -1;
-                }
-                this->aggregateFunctions.emplace_back(new aggregate_function_t{
-                    move(name),
-                    argsCount,
-                    /* create = */
-                    []() -> int* {
-                        return (int*)(new F());
-                    },
-                    /* step = */
-                    [](sqlite3_context* context, void* functionVoidPointer, int argsCount, sqlite3_value** values) {
-                        auto& functionPointer = *static_cast<F*>(functionVoidPointer);
-                        args_tuple argsTuple;
-                        using tuple_size = std::tuple_size<args_tuple>;
-                        values_to_tuple<args_tuple, tuple_size::value - 1>().extract(values, argsTuple, argsCount);
-                        call(functionPointer, &F::step, move(argsTuple));
-                    },
-                    /* finalCall = */
-                    [](sqlite3_context* context, void* functionVoidPointer) {
-                        auto& functionPointer = *static_cast<F*>(functionVoidPointer);
-                        auto result = functionPointer.fin();
-                        statement_binder<return_type>().result(context, result);
-                    },
-                    delete_function_callback<F>,
-                });
-
-                if(this->connection->retain_count() > 0) {
-                    auto db = this->connection->get();
-                    try_to_create_function(db, static_cast<aggregate_function_t&>(*this->aggregateFunctions.back()));
-                }
-            }
-
-            /**
-             *  Use it to delete scalar function you created before. Can be called at any time no matter connection is open or no.
-             */
-            template<class F>
-            void delete_scalar_function() {
-                static_assert(is_scalar_function<F>::value, "F cannot be a scalar function");
-                std::stringstream ss;
-                ss << F::name();
-                auto name = ss.str();
-                this->delete_function_impl(name, this->scalarFunctions);
-            }
-
-            /**
-             *  Use it to delete aggregate function you created before. Can be called at any time no matter connection is open or no.
-             */
-            template<class F>
-            void delete_aggregate_function() {
-                static_assert(is_aggregate_function<F>::value, "F cannot be an aggregate function");
-                std::stringstream ss;
-                ss << F::name();
-                auto name = ss.str();
-                this->delete_function_impl(name, this->aggregateFunctions);
-            }
-
-            template<class C>
-            void create_collation() {
-                collating_function func = [](int leftLength, const void* lhs, int rightLength, const void* rhs) {
-                    C collatingObject;
-                    return collatingObject(leftLength, lhs, rightLength, rhs);
-                };
-                std::stringstream ss;
-                ss << C::name();
-                auto name = ss.str();
-                ss.flush();
-                this->create_collation(name, move(func));
-            }
-
-            void create_collation(const std::string& name, collating_function f) {
-                collating_function* functionPointer = nullptr;
-                const auto functionExists = bool(f);
-                if(functionExists) {
-                    functionPointer = &(collatingFunctions[name] = std::move(f));
-                } else {
-                    collatingFunctions.erase(name);
-                }
-
-                //  create collations if db is open
-                if(this->connection->retain_count() > 0) {
-                    auto db = this->connection->get();
-                    auto resultCode = sqlite3_create_collation(db,
-                                                               name.c_str(),
-                                                               SQLITE_UTF8,
-                                                               functionPointer,
-                                                               functionExists ? collate_callback : nullptr);
-                    if(resultCode != SQLITE_OK) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                }
-            }
-
-            template<class C>
-            void delete_collation() {
-                std::stringstream ss;
-                ss << C::name();
-                auto name = ss.str();
-                ss.flush();
-                this->create_collation(name, {});
-            }
-
-            void begin_transaction() {
-                this->connection->retain();
-                if(1 == this->connection->retain_count()) {
-                    this->on_open_internal(this->connection->get());
-                }
-                auto db = this->connection->get();
-                perform_void_exec(db, "BEGIN TRANSACTION");
-            }
-
-            void commit() {
-                auto db = this->connection->get();
-                perform_void_exec(db, "COMMIT");
-                this->connection->release();
-                if(this->connection->retain_count() < 0) {
-                    throw std::system_error(std::make_error_code(orm_error_code::no_active_transaction));
-                }
-            }
-
-            void rollback() {
-                auto db = this->connection->get();
-                perform_void_exec(db, "ROLLBACK");
-                this->connection->release();
-                if(this->connection->retain_count() < 0) {
-                    throw std::system_error(std::make_error_code(orm_error_code::no_active_transaction));
-                }
-            }
-
-            void backup_to(const std::string& filename) {
-                auto backup = this->make_backup_to(filename);
-                backup.step(-1);
-            }
-
-            void backup_to(storage_base& other) {
-                auto backup = this->make_backup_to(other);
-                backup.step(-1);
-            }
-
-            void backup_from(const std::string& filename) {
-                auto backup = this->make_backup_from(filename);
-                backup.step(-1);
-            }
-
-            void backup_from(storage_base& other) {
-                auto backup = this->make_backup_from(other);
-                backup.step(-1);
-            }
-
-            backup_t make_backup_to(const std::string& filename) {
-                auto holder = std::make_unique<connection_holder>(filename);
-                connection_ref conRef{*holder};
-                return {conRef, "main", this->get_connection(), "main", move(holder)};
-            }
-
-            backup_t make_backup_to(storage_base& other) {
-                return {other.get_connection(), "main", this->get_connection(), "main", {}};
-            }
-
-            backup_t make_backup_from(const std::string& filename) {
-                auto holder = std::make_unique<connection_holder>(filename);
-                connection_ref conRef{*holder};
-                return {this->get_connection(), "main", conRef, "main", move(holder)};
-            }
-
-            backup_t make_backup_from(storage_base& other) {
-                return {this->get_connection(), "main", other.get_connection(), "main", {}};
-            }
-
-            const std::string& filename() const {
-                return this->connection->filename;
-            }
-
-            /**
-             * Checks whether connection to database is opened right now.
-             * Returns always `true` for in memory databases.
-             */
-            bool is_opened() const {
-                return this->connection->retain_count() > 0;
-            }
-
-            int busy_handler(std::function<int(int)> handler) {
-                _busy_handler = move(handler);
-                if(this->is_opened()) {
-                    if(_busy_handler) {
-                        return sqlite3_busy_handler(this->connection->get(), busy_handler_callback, this);
-                    } else {
-                        return sqlite3_busy_handler(this->connection->get(), nullptr, nullptr);
-                    }
-                } else {
-                    return SQLITE_OK;
-                }
-            }
-
-          protected:
-            storage_base(const std::string& filename_, int foreignKeysCount) :
-                pragma(std::bind(&storage_base::get_connection, this)),
-                limit(std::bind(&storage_base::get_connection, this)),
-                inMemory(filename_.empty() || filename_ == ":memory:"),
-                connection(std::make_unique<connection_holder>(filename_)), cachedForeignKeysCount(foreignKeysCount) {
-                if(this->inMemory) {
-                    this->connection->retain();
-                    this->on_open_internal(this->connection->get());
-                }
-            }
-
-            storage_base(const storage_base& other) :
-                on_open(other.on_open), pragma(std::bind(&storage_base::get_connection, this)),
-                limit(std::bind(&storage_base::get_connection, this)), inMemory(other.inMemory),
-                connection(std::make_unique<connection_holder>(other.connection->filename)),
-                cachedForeignKeysCount(other.cachedForeignKeysCount) {
-                if(this->inMemory) {
-                    this->connection->retain();
-                    this->on_open_internal(this->connection->get());
-                }
-            }
-
-            ~storage_base() {
-                if(this->isOpenedForever) {
-                    this->connection->release();
-                }
-                if(this->inMemory) {
-                    this->connection->release();
-                }
-            }
-
-            connection_ref get_connection() {
-                connection_ref res{*this->connection};
-                if(1 == this->connection->retain_count()) {
-                    this->on_open_internal(this->connection->get());
-                }
-                return res;
-            }
-
-#if SQLITE_VERSION_NUMBER >= 3006019
-
-            void foreign_keys(sqlite3* db, bool value) {
-                std::stringstream ss;
-                ss << "PRAGMA foreign_keys = " << value;
-                perform_void_exec(db, ss.str());
-            }
-
-            bool foreign_keys(sqlite3* db) {
-                std::string query = "PRAGMA foreign_keys";
-                auto result = false;
-                auto rc = sqlite3_exec(
-                    db,
-                    query.c_str(),
-                    [](void* data, int argc, char** argv, char**) -> int {
-                        auto& res = *(bool*)data;
-                        if(argc) {
-                            res = row_extractor<bool>().extract(argv[0]);
-                        }
-                        return 0;
-                    },
-                    &result,
-                    nullptr);
-                if(rc != SQLITE_OK) {
-                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                            sqlite3_errmsg(db));
-                }
-                return result;
-            }
-
-#endif
-            void on_open_internal(sqlite3* db) {
-
-#if SQLITE_VERSION_NUMBER >= 3006019
-                if(this->cachedForeignKeysCount) {
-                    this->foreign_keys(db, true);
-                }
-#endif
-                if(this->pragma._synchronous != -1) {
-                    this->pragma.synchronous(this->pragma._synchronous);
-                }
-
-                if(this->pragma._journal_mode != -1) {
-                    this->pragma.set_pragma("journal_mode", static_cast<journal_mode>(this->pragma._journal_mode), db);
-                }
-
-                for(auto& p: this->collatingFunctions) {
-                    auto resultCode =
-                        sqlite3_create_collation(db, p.first.c_str(), SQLITE_UTF8, &p.second, collate_callback);
-                    if(resultCode != SQLITE_OK) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                }
-
-                for(auto& p: this->limit.limits) {
-                    sqlite3_limit(db, p.first, p.second);
-                }
-
-                if(_busy_handler) {
-                    sqlite3_busy_handler(this->connection->get(), busy_handler_callback, this);
-                }
-
-                for(auto& functionPointer: this->scalarFunctions) {
-                    try_to_create_function(db, static_cast<scalar_function_t&>(*functionPointer));
-                }
-
-                for(auto& functionPointer: this->aggregateFunctions) {
-                    try_to_create_function(db, static_cast<aggregate_function_t&>(*functionPointer));
-                }
-
-                if(this->on_open) {
-                    this->on_open(db);
-                }
-            }
-
-            void delete_function_impl(const std::string& name,
-                                      std::vector<std::unique_ptr<function_base>>& functionsVector) const {
-                auto it = find_if(functionsVector.begin(), functionsVector.end(), [&name](auto& functionPointer) {
-                    return functionPointer->name == name;
-                });
-                if(it != functionsVector.end()) {
-                    functionsVector.erase(it);
-                    it = functionsVector.end();
-
-                    if(this->connection->retain_count() > 0) {
-                        auto db = this->connection->get();
-                        auto resultCode = sqlite3_create_function_v2(db,
-                                                                     name.c_str(),
-                                                                     0,
-                                                                     SQLITE_UTF8,
-                                                                     nullptr,
-                                                                     nullptr,
-                                                                     nullptr,
-                                                                     nullptr,
-                                                                     nullptr);
-                        if(resultCode != SQLITE_OK) {
-                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                    sqlite3_errmsg(db));
-                        }
-                    }
-                } else {
-                    throw std::system_error(std::make_error_code(orm_error_code::function_not_found));
-                }
-            }
-
-            void try_to_create_function(sqlite3* db, scalar_function_t& function) {
-                auto resultCode = sqlite3_create_function_v2(db,
-                                                             function.name.c_str(),
-                                                             function.argumentsCount,
-                                                             SQLITE_UTF8,
-                                                             &function,
-                                                             scalar_function_callback,
-                                                             nullptr,
-                                                             nullptr,
-                                                             nullptr);
-                if(resultCode != SQLITE_OK) {
-                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                            sqlite3_errmsg(db));
-                }
-            }
-
-            void try_to_create_function(sqlite3* db, aggregate_function_t& function) {
-                auto resultCode = sqlite3_create_function(db,
-                                                          function.name.c_str(),
-                                                          function.argumentsCount,
-                                                          SQLITE_UTF8,
-                                                          &function,
-                                                          nullptr,
-                                                          aggregate_function_step_callback,
-                                                          aggregate_function_final_callback);
-                if(resultCode != SQLITE_OK) {
-                    throw std::system_error(std::error_code(resultCode, get_sqlite_error_category()),
-                                            sqlite3_errstr(resultCode));
-                }
-            }
-
-            static void
-            aggregate_function_step_callback(sqlite3_context* context, int argsCount, sqlite3_value** values) {
-                auto functionVoidPointer = sqlite3_user_data(context);
-                auto functionPointer = static_cast<aggregate_function_t*>(functionVoidPointer);
-                auto aggregateContextVoidPointer = sqlite3_aggregate_context(context, sizeof(int**));
-                auto aggregateContextIntPointer = static_cast<int**>(aggregateContextVoidPointer);
-                if(*aggregateContextIntPointer == nullptr) {
-                    *aggregateContextIntPointer = functionPointer->create();
-                }
-                functionPointer->step(context, *aggregateContextIntPointer, argsCount, values);
-            }
-
-            static void aggregate_function_final_callback(sqlite3_context* context) {
-                auto functionVoidPointer = sqlite3_user_data(context);
-                auto functionPointer = static_cast<aggregate_function_t*>(functionVoidPointer);
-                auto aggregateContextVoidPointer = sqlite3_aggregate_context(context, sizeof(int**));
-                auto aggregateContextIntPointer = static_cast<int**>(aggregateContextVoidPointer);
-                functionPointer->finalCall(context, *aggregateContextIntPointer);
-                functionPointer->destroy(*aggregateContextIntPointer);
-            }
-
-            static void scalar_function_callback(sqlite3_context* context, int argsCount, sqlite3_value** values) {
-                auto functionVoidPointer = sqlite3_user_data(context);
-                auto functionPointer = static_cast<scalar_function_t*>(functionVoidPointer);
-                std::unique_ptr<int, void (*)(int*)> callablePointer(functionPointer->create(),
-                                                                     functionPointer->destroy);
-                if(functionPointer->argumentsCount != -1 && functionPointer->argumentsCount != argsCount) {
-                    throw std::system_error(std::make_error_code(orm_error_code::arguments_count_does_not_match));
-                }
-                functionPointer->run(context, functionPointer, argsCount, values);
-            }
-
-            template<class F>
-            static void delete_function_callback(int* pointer) {
-                auto voidPointer = static_cast<void*>(pointer);
-                auto fPointer = static_cast<F*>(voidPointer);
-                delete fPointer;
-            }
-
-            std::string current_timestamp(sqlite3* db) {
-                std::string result;
-                std::stringstream ss;
-                ss << "SELECT CURRENT_TIMESTAMP";
-                auto query = ss.str();
-                auto rc = sqlite3_exec(
-                    db,
-                    query.c_str(),
-                    [](void* data, int argc, char** argv, char**) -> int {
-                        auto& res = *(std::string*)data;
-                        if(argc) {
-                            if(argv[0]) {
-                                res = row_extractor<std::string>().extract(argv[0]);
-                            }
-                        }
-                        return 0;
-                    },
-                    &result,
-                    nullptr);
-                if(rc != SQLITE_OK) {
-                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                            sqlite3_errmsg(db));
-                }
-                return result;
-            }
-
-            void drop_table_internal(const std::string& tableName, sqlite3* db) {
-                std::stringstream ss;
-                ss << "DROP TABLE '" << tableName + "'";
-                perform_void_exec(db, ss.str());
-            }
-
-            static int collate_callback(void* arg, int leftLen, const void* lhs, int rightLen, const void* rhs) {
-                auto& f = *(collating_function*)arg;
-                return f(leftLen, lhs, rightLen, rhs);
-            }
-
-            static int busy_handler_callback(void* selfPointer, int triesCount) {
-                auto& storage = *static_cast<storage_base*>(selfPointer);
-                if(storage._busy_handler) {
-                    return storage._busy_handler(triesCount);
-                } else {
-                    return 0;
-                }
-            }
-
-            //  returns foreign keys count in storage definition
-            template<class T>
-            static int foreign_keys_count(T& storageImpl) {
-                auto res = 0;
-                storageImpl.for_each([&res](auto& impl) {
-                    res += impl.foreign_keys_count();
-                });
-                return res;
-            }
-
-            const bool inMemory;
-            bool isOpenedForever = false;
-            std::unique_ptr<connection_holder> connection;
-            std::map<std::string, collating_function> collatingFunctions;
-            const int cachedForeignKeysCount;
-            std::function<int(int)> _busy_handler;
-            std::vector<std::unique_ptr<function_base>> scalarFunctions;
-            std::vector<std::unique_ptr<function_base>> aggregateFunctions;
-        };
-    }
-}
-
-// #include "prepared_statement.h"
-
-// #include "expression_object_type.h"
-
-#include <type_traits>  //  std::decay
-#include <functional>  //  std::reference_wrapper
-
-// #include "prepared_statement.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        template<class T, class SFINAE = void>
-        struct expression_object_type;
-
-        template<class T>
-        struct expression_object_type<update_t<T>> {
-            using type = typename std::decay<T>::type;
-        };
-
-        template<class T>
-        struct expression_object_type<update_t<std::reference_wrapper<T>>> {
-            using type = typename std::decay<T>::type;
-        };
-
-        template<class T>
-        struct expression_object_type<replace_t<T>> {
-            using type = typename std::decay<T>::type;
-        };
-
-        template<class T>
-        struct expression_object_type<replace_t<std::reference_wrapper<T>>> {
-            using type = typename std::decay<T>::type;
-        };
-
-        template<class It, class L, class O>
-        struct expression_object_type<replace_range_t<It, L, O>> {
-            using type = typename replace_range_t<It, L, O>::object_type;
-        };
-
-        template<class It, class L, class O>
-        struct expression_object_type<replace_range_t<std::reference_wrapper<It>, L, O>> {
-            using type = typename replace_range_t<std::reference_wrapper<It>, L, O>::object_type;
-        };
-
-        template<class T>
-        struct expression_object_type<insert_t<T>> {
-            using type = typename std::decay<T>::type;
-        };
-
-        template<class T>
-        struct expression_object_type<insert_t<std::reference_wrapper<T>>> {
-            using type = typename std::decay<T>::type;
-        };
-
-        template<class It, class L, class O>
-        struct expression_object_type<insert_range_t<It, L, O>> {
-            using transformer_type = L;
-            using type = typename insert_range_t<It, L, O>::object_type;
-        };
-
-        template<class It, class L, class O>
-        struct expression_object_type<insert_range_t<std::reference_wrapper<It>, L, O>> {
-            using type = typename insert_range_t<std::reference_wrapper<It>, L, O>::object_type;
-        };
-
-        template<class T, class... Cols>
-        struct expression_object_type<insert_explicit<T, Cols...>> {
-            using type = typename std::decay<T>::type;
-        };
-
-        template<class T, class... Cols>
-        struct expression_object_type<insert_explicit<std::reference_wrapper<T>, Cols...>> {
-            using type = typename std::decay<T>::type;
-        };
-
-        template<class T>
-        struct get_ref_t {
-
-            template<class O>
-            auto& operator()(O& t) const {
-                return t;
-            }
-        };
-
-        template<class T>
-        struct get_ref_t<std::reference_wrapper<T>> {
-
-            template<class O>
-            auto& operator()(O& t) const {
-                return t.get();
-            }
-        };
-
-        template<class T>
-        auto& get_ref(T& t) {
-            using arg_type = typename std::decay<T>::type;
-            get_ref_t<arg_type> g;
-            return g(t);
-        }
-
-        template<class T>
-        struct get_object_t;
-
-        template<class T>
-        struct get_object_t<const T> : get_object_t<T> {};
-
-        template<class T>
-        auto& get_object(T& t) {
-            using expression_type = typename std::decay<T>::type;
-            get_object_t<expression_type> obj;
-            return obj(t);
-        }
-
-        template<class T>
-        struct get_object_t<replace_t<T>> {
-            using expression_type = replace_t<T>;
-
-            template<class O>
-            auto& operator()(O& e) const {
-                return get_ref(e.object);
-            }
-        };
-
-        template<class T>
-        struct get_object_t<insert_t<T>> {
-            using expression_type = insert_t<T>;
-
-            template<class O>
-            auto& operator()(O& e) const {
-                return get_ref(e.object);
-            }
-        };
-
-        template<class T>
-        struct get_object_t<update_t<T>> {
-            using expression_type = update_t<T>;
-
-            template<class O>
-            auto& operator()(O& e) const {
-                return get_ref(e.object);
-            }
-        };
-    }
-}
-
-// #include "statement_serializator.h"
-
-#include <sstream>  //  std::stringstream
-#include <string>  //  std::string
-#include <type_traits>  //  std::enable_if, std::remove_pointer
-#include <vector>  //  std::vector
-#include <algorithm>  //  std::iter_swap
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-#include <optional>
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-
-// #include "core_functions.h"
-
-// #include "constraints.h"
-
-// #include "conditions.h"
-
-// #include "column.h"
-
-// #include "rowid.h"
-
-// #include "type_printer.h"
-
-// #include "table_name_collector.h"
-
-#include <set>  //  std::set
-#include <string>  //  std::string
-#include <functional>  //  std::function
-#include <typeindex>  //  std::type_index
-
-// #include "select_constraints.h"
-
-// #include "alias.h"
-
-// #include "core_functions.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        struct table_name_collector {
-            using table_name_set = std::set<std::pair<std::string, std::string>>;
-            using find_table_name_t = std::function<std::string(std::type_index)>;
-
-            find_table_name_t find_table_name;
-            mutable table_name_set table_names;
-
-            table_name_collector() = default;
-
-            table_name_collector(find_table_name_t _find_table_name) : find_table_name(std::move(_find_table_name)) {}
-
-            template<class T>
-            table_name_set operator()(const T&) const {
-                return {};
-            }
-
-            template<class F, class O>
-            void operator()(F O::*, std::string alias = {}) const {
-                if(this->find_table_name) {
-                    table_names.insert(std::make_pair(this->find_table_name(typeid(O)), move(alias)));
-                }
-            }
-
-            template<class T, class F>
-            void operator()(const column_pointer<T, F>&) const {
-                if(this->find_table_name) {
-                    table_names.insert({this->find_table_name(typeid(T)), ""});
-                }
-            }
-
-            template<class T, class C>
-            void operator()(const alias_column_t<T, C>& a) const {
-                (*this)(a.column, alias_extractor<T>::get());
-            }
-
-            template<class T>
-            void operator()(const count_asterisk_t<T>&) const {
-                if(this->find_table_name) {
-                    auto tableName = this->find_table_name(typeid(T));
-                    if(!tableName.empty()) {
-                        table_names.insert(std::make_pair(move(tableName), ""));
-                    }
-                }
-            }
-
-            template<class T>
-            void operator()(const asterisk_t<T>&) const {
-                if(this->find_table_name) {
-                    auto tableName = this->find_table_name(typeid(T));
-                    table_names.insert(std::make_pair(move(tableName), ""));
-                }
-            }
-
-            template<class T>
-            void operator()(const object_t<T>&) const {
-                if(this->find_table_name) {
-                    auto tableName = this->find_table_name(typeid(T));
-                    table_names.insert(std::make_pair(move(tableName), ""));
-                }
-            }
-
-            template<class T>
-            void operator()(const table_rowid_t<T>&) const {
-                if(this->find_table_name) {
-                    auto tableName = this->find_table_name(typeid(T));
-                    table_names.insert(std::make_pair(move(tableName), ""));
-                }
-            }
-
-            template<class T>
-            void operator()(const table_oid_t<T>&) const {
-                if(this->find_table_name) {
-                    auto tableName = this->find_table_name(typeid(T));
-                    table_names.insert(std::make_pair(move(tableName), ""));
-                }
-            }
-
-            template<class T>
-            void operator()(const table__rowid_t<T>&) const {
-                if(this->find_table_name) {
-                    auto tableName = this->find_table_name(typeid(T));
-                    table_names.insert(std::make_pair(move(tableName), ""));
-                }
-            }
-        };
-
-    }
-
-}
-
-// #include "column_names_getter.h"
-
-#include <string>  //  std::string
-#include <vector>  //  std::vector
-#include <functional>  //  std::reference_wrapper
-
-// #include "error_code.h"
-
-// #include "select_constraints.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        template<class T, class C>
-        std::string serialize(const T& t, const C& context);
-
-        template<class T, class SFINAE = void>
-        struct column_names_getter {
-            using expression_type = T;
-
-            template<class C>
-            std::vector<std::string> operator()(const expression_type& t, const C& context) {
-                auto newContext = context;
-                newContext.skip_table_name = false;
-                auto columnName = serialize(t, newContext);
-                if(columnName.length()) {
-                    return {move(columnName)};
-                } else {
-                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
-                }
-            }
-        };
-
-        template<class T, class C>
-        std::vector<std::string> get_column_names(const T& t, const C& context) {
-            column_names_getter<T> serializator;
-            return serializator(t, context);
-        }
-
-        template<class T>
-        struct column_names_getter<std::reference_wrapper<T>, void> {
-            using expression_type = std::reference_wrapper<T>;
-
-            template<class C>
-            std::vector<std::string> operator()(const expression_type& expression, const C& context) {
-                return get_column_names(expression.get(), context);
-            }
-        };
-
-        template<class T>
-        struct column_names_getter<asterisk_t<T>, void> {
-            using expression_type = asterisk_t<T>;
-
-            template<class C>
-            std::vector<std::string> operator()(const expression_type&, const C&) {
-                std::vector<std::string> res;
-                res.push_back("*");
-                return res;
-            }
-        };
-
-        template<class T>
-        struct column_names_getter<object_t<T>, void> {
-            using expression_type = object_t<T>;
-
-            template<class C>
-            std::vector<std::string> operator()(const expression_type&, const C&) {
-                std::vector<std::string> res;
-                res.push_back("*");
-                return res;
-            }
-        };
-
-        template<class... Args>
-        struct column_names_getter<columns_t<Args...>, void> {
-            using expression_type = columns_t<Args...>;
-
-            template<class C>
-            std::vector<std::string> operator()(const expression_type& cols, const C& context) {
-                std::vector<std::string> columnNames;
-                columnNames.reserve(static_cast<size_t>(cols.count));
-                auto newContext = context;
-                newContext.skip_table_name = false;
-                iterate_tuple(cols.columns, [&columnNames, &newContext](auto& m) {
-                    auto columnName = serialize(m, newContext);
-                    if(columnName.length()) {
-                        columnNames.push_back(columnName);
-                    } else {
-                        throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
-                    }
-                });
-                return columnNames;
-            }
-        };
-
-    }
-}
-
-// #include "order_by_serializator.h"
-
-#include <string>  //  std::string
-#include <vector>  //  std::vector
-#include <sstream>  //  std::stringstream
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        template<class T, class SFINAE = void>
-        struct order_by_serializator;
-
-        template<class T, class C>
-        std::string serialize_order_by(const T& t, const C& context) {
-            order_by_serializator<T> serializator;
-            return serializator(t, context);
-        }
-
-        template<class O>
-        struct order_by_serializator<order_by_t<O>, void> {
-            using statement_type = order_by_t<O>;
-
-            template<class C>
-            std::string operator()(const statement_type& orderBy, const C& context) const {
-                std::stringstream ss;
-                auto newContext = context;
-                newContext.skip_table_name = false;
-                auto columnName = serialize(orderBy.expression, newContext);
-                ss << columnName << " ";
-                if(orderBy._collate_argument.length()) {
-                    ss << "COLLATE " << orderBy._collate_argument << " ";
-                }
-                switch(orderBy.asc_desc) {
-                    case 1:
-                        ss << "ASC";
-                        break;
-                    case -1:
-                        ss << "DESC";
-                        break;
-                }
-                return ss.str();
-            }
-        };
-
-        template<class S>
-        struct order_by_serializator<dynamic_order_by_t<S>, void> {
-            using statement_type = dynamic_order_by_t<S>;
-
-            template<class C>
-            std::string operator()(const statement_type& orderBy, const C&) const {
-                std::vector<std::string> expressions;
-                for(auto& entry: orderBy) {
-                    std::string entryString;
-                    {
-                        std::stringstream ss;
-                        ss << entry.name << " ";
-                        if(!entry._collate_argument.empty()) {
-                            ss << "COLLATE " << entry._collate_argument << " ";
-                        }
-                        switch(entry.asc_desc) {
-                            case 1:
-                                ss << "ASC";
-                                break;
-                            case -1:
-                                ss << "DESC";
-                                break;
-                        }
-                        entryString = ss.str();
-                    }
-                    expressions.push_back(move(entryString));
-                };
-                std::stringstream ss;
-                ss << static_cast<std::string>(orderBy) << " ";
-                for(size_t i = 0; i < expressions.size(); ++i) {
-                    ss << expressions[i];
-                    if(i < expressions.size() - 1) {
-                        ss << ", ";
-                    }
-                }
-                ss << " ";
-                return ss.str();
-            }
-        };
-
-    }
-}
-
-// #include "values.h"
-
-// #include "table_type.h"
-
-// #include "indexed_column.h"
-
-// #include "function.h"
-
-// #include "ast/upsert_clause.h"
-
-// #include "ast/excluded.h"
-
-// #include "ast/group_by.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        template<class T, class SFINAE = void>
-        struct statement_serializator;
-
-        template<class T, class C>
-        std::string serialize(const T& t, const C& context) {
-            statement_serializator<T> serializator;
-            return serializator(t, context);
-        }
-
-        template<class T>
-        struct statement_serializator<T, typename std::enable_if<is_bindable<T>::value>::type> {
-            using statement_type = T;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) {
-                if(context.replace_bindable_with_question) {
-                    return "?";
-                } else {
-                    return field_printer<T>{}(statement);
-                }
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<excluded_t<T>, void> {
-            using statement_type = excluded_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) {
-                std::stringstream ss;
-                ss << "excluded.";
-                if(auto columnNamePointer = context.impl.column_name(statement.expression)) {
-                    ss << "\"" << *columnNamePointer << "\"";
-                } else {
-                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
-                }
-                return ss.str();
-            }
-        };
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class T>
-        struct statement_serializator<as_optional_t<T>, void> {
-            using statement_type = as_optional_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) {
-                return serialize(statement.value, context);
-            }
-        };
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class T>
-        struct statement_serializator<std::reference_wrapper<T>, void> {
-            using statement_type = std::reference_wrapper<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& s, const C& context) {
-                return serialize(s.get(), context);
-            }
-        };
-
-        template<>
-        struct statement_serializator<std::nullptr_t, void> {
-            using statement_type = std::nullptr_t;
-
-            template<class C>
-            std::string operator()(const statement_type&, const C&) {
-                return "?";
-            }
-        };
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<>
-        struct statement_serializator<std::nullopt_t, void> {
-            using statement_type = std::nullopt_t;
-
-            template<class C>
-            std::string operator()(const statement_type&, const C&) {
-                return "?";
-            }
-        };
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class T>
-        struct statement_serializator<alias_holder<T>, void> {
-            using statement_type = alias_holder<T>;
-
-            template<class C>
-            std::string operator()(const statement_type&, const C&) {
-                return T::get();
-            }
-        };
-
-        template<class... TargetArgs, class... ActionsArgs>
-        struct statement_serializator<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void> {
-            using statement_type = upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                ss << "ON CONFLICT";
-                iterate_tuple(statement.target_args, [&ss, &context](auto& value) {
-                    using value_type = typename std::decay<decltype(value)>::type;
-                    auto needParenthesis = std::is_member_pointer<value_type>::value;
-                    ss << ' ';
-                    if(needParenthesis) {
-                        ss << '(';
-                    }
-                    ss << serialize(value, context);
-                    if(needParenthesis) {
-                        ss << ')';
-                    }
-                });
-                ss << ' ' << "DO";
-                if(std::tuple_size<typename statement_type::actions_tuple>::value == 0) {
-                    ss << " NOTHING";
-                } else {
-                    ss << " UPDATE";
-                    auto updateContext = context;
-                    updateContext.use_parentheses = false;
-                    iterate_tuple(statement.actions, [&ss, &updateContext](auto& value) {
-                        ss << ' ' << serialize(value, updateContext);
-                    });
-                }
-                return ss.str();
-            }
-        };
-
-        template<class R, class S, class... Args>
-        struct statement_serializator<built_in_function_t<R, S, Args...>, void> {
-            using statement_type = built_in_function_t<R, S, Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                ss << statement.serialize() << "(";
-                std::vector<std::string> args;
-                using args_type = typename std::decay<decltype(statement)>::type::args_type;
-                args.reserve(std::tuple_size<args_type>::value);
-                iterate_tuple(statement.args, [&args, &context](auto& v) {
-                    args.push_back(serialize(v, context));
-                });
-                for(size_t i = 0; i < args.size(); ++i) {
-                    ss << args[i];
-                    if(i < args.size() - 1) {
-                        ss << ", ";
-                    }
-                }
-                ss << ")";
-                return ss.str();
-            }
-        };
-
-        template<class F, class... Args>
-        struct statement_serializator<function_call<F, Args...>, void> {
-            using statement_type = function_call<F, Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                using args_tuple = std::tuple<Args...>;
-
-                std::stringstream ss;
-                ss << F::name() << "(";
-                auto index = 0;
-                iterate_tuple(statement.args, [&context, &ss, &index](auto& v) {
-                    auto value = serialize(v, context);
-                    ss << value;
-                    if(index < std::tuple_size<args_tuple>::value - 1) {
-                        ss << ", ";
-                    }
-                    ++index;
-                });
-                ss << ")";
-                return ss.str();
-            }
-        };
-
-        template<class T, class E>
-        struct statement_serializator<as_t<T, E>, void> {
-            using statement_type = as_t<T, E>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                auto tableAliasString = alias_extractor<T>::get();
-                return serialize(c.expression, context) + " AS " + tableAliasString;
-            }
-        };
-
-        template<class T, class P>
-        struct statement_serializator<alias_column_t<T, P>, void> {
-            using statement_type = alias_column_t<T, P>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                if(!context.skip_table_name) {
-                    ss << "'" << T::get() << "'.";
-                }
-                auto newContext = context;
-                newContext.skip_table_name = true;
-                ss << serialize(c.column, newContext);
-                return ss.str();
-            }
-        };
-
-        template<>
-        struct statement_serializator<std::string, void> {
-            using statement_type = std::string;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                if(context.replace_bindable_with_question) {
-                    return "?";
-                } else {
-                    return "'" + c + "'";
-                }
-            }
-        };
-
-        template<>
-        struct statement_serializator<const char*, void> {
-            using statement_type = const char*;
-
-            template<class C>
-            std::string operator()(const char* c, const C& context) const {
-                if(context.replace_bindable_with_question) {
-                    return "?";
-                } else {
-                    return std::string("'") + c + "'";
-                }
-            }
-        };
-
-#ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
-        template<>
-        struct statement_serializator<std::string_view, void> {
-            using statement_type = std::string_view;
-
-            template<class C>
-            std::string operator()(const std::string_view& c, const C& context) const {
-                if(context.replace_bindable_with_question) {
-                    return "?";
-                } else {
-                    return "'" + std::string(c) + "'";
-                }
-            }
-        };
-#endif
-
-        template<class O, class F>
-        struct statement_serializator<F O::*, void> {
-            using statement_type = F O::*;
-
-            template<class C>
-            std::string operator()(const statement_type& m, const C& context) const {
-                std::stringstream ss;
-                if(!context.skip_table_name) {
-                    ss << "\"" << context.impl.find_table_name(typeid(O)) << "\".";
-                }
-                if(auto columnnamePointer = context.column_name(m)) {
-                    ss << "\"" << *columnnamePointer << "\"";
-                } else {
-                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
-                }
-                return ss.str();
-            }
-        };
-
-        template<>
-        struct statement_serializator<rowid_t, void> {
-            using statement_type = rowid_t;
-
-            template<class C>
-            std::string operator()(const statement_type& s, const C&) {
-                return static_cast<std::string>(s);
-            }
-        };
-
-        template<>
-        struct statement_serializator<oid_t, void> {
-            using statement_type = oid_t;
-
-            template<class C>
-            std::string operator()(const statement_type& s, const C&) {
-                return static_cast<std::string>(s);
-            }
-        };
-
-        template<>
-        struct statement_serializator<_rowid_t, void> {
-            using statement_type = _rowid_t;
-
-            template<class C>
-            std::string operator()(const statement_type& s, const C&) {
-                return static_cast<std::string>(s);
-            }
-        };
-
-        template<class O>
-        struct statement_serializator<table_rowid_t<O>, void> {
-            using statement_type = table_rowid_t<O>;
-
-            template<class C>
-            std::string operator()(const statement_type& s, const C& context) {
-                std::stringstream ss;
-                if(!context.skip_table_name) {
-                    ss << "'" << context.impl.find_table_name(typeid(O)) << "'.";
-                }
-                ss << static_cast<std::string>(s);
-                return ss.str();
-            }
-        };
-
-        template<class O>
-        struct statement_serializator<table_oid_t<O>, void> {
-            using statement_type = table_oid_t<O>;
-
-            template<class C>
-            std::string operator()(const statement_type& s, const C& context) {
-                std::stringstream ss;
-                if(!context.skip_table_name) {
-                    ss << "'" << context.impl.find_table_name(typeid(O)) << "'.";
-                }
-                ss << static_cast<std::string>(s);
-                return ss.str();
-            }
-        };
-
-        template<class O>
-        struct statement_serializator<table__rowid_t<O>, void> {
-            using statement_type = table__rowid_t<O>;
-
-            template<class C>
-            std::string operator()(const statement_type& s, const C& context) {
-                std::stringstream ss;
-                if(!context.skip_table_name) {
-                    ss << "'" << context.impl.find_table_name(typeid(O)) << "'.";
-                }
-                ss << static_cast<std::string>(s);
-                return ss.str();
-            }
-        };
-
-        template<class L, class R, class... Ds>
-        struct statement_serializator<binary_operator<L, R, Ds...>, void> {
-            using statement_type = binary_operator<L, R, Ds...>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                auto lhs = serialize(c.lhs, context);
-                auto rhs = serialize(c.rhs, context);
-                std::stringstream ss;
-                if(context.use_parentheses) {
-                    ss << '(';
-                }
-                ss << lhs << " " << static_cast<std::string>(c) << " " << rhs;
-                if(context.use_parentheses) {
-                    ss << ')';
-                }
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<count_asterisk_t<T>, void> {
-            using statement_type = count_asterisk_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type&, const C& context) const {
-                return serialize(count_asterisk_without_type{}, context);
-            }
-        };
-
-        template<>
-        struct statement_serializator<count_asterisk_without_type, void> {
-            using statement_type = count_asterisk_without_type;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C&) const {
-                std::stringstream ss;
-                auto functionName = c.serialize();
-                ss << functionName << "(*)";
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<distinct_t<T>, void> {
-            using statement_type = distinct_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                auto expr = serialize(c.value, context);
-                ss << static_cast<std::string>(c) << "(" << expr << ")";
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<all_t<T>, void> {
-            using statement_type = all_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                auto expr = serialize(c.value, context);
-                ss << static_cast<std::string>(c) << "(" << expr << ")";
-                return ss.str();
-            }
-        };
-
-        template<class T, class F>
-        struct statement_serializator<column_pointer<T, F>, void> {
-            using statement_type = column_pointer<T, F>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                if(!context.skip_table_name) {
-                    ss << "'" << context.impl.find_table_name(typeid(T)) << "'.";
-                }
-                if(auto columnNamePointer = context.impl.column_name_simple(c.field)) {
-                    ss << "\"" << *columnNamePointer << "\"";
-                } else {
-                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
-                }
-                return ss.str();
-            }
-        };
-
-        template<class T, class E>
-        struct statement_serializator<cast_t<T, E>, void> {
-            using statement_type = cast_t<T, E>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                ss << static_cast<std::string>(c) << " (";
-                ss << serialize(c.expression, context) << " AS " << type_printer<T>().print() << ")";
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<T,
-                                      typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
-            using statement_type = T;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                ss << serialize(c.left, context) << " ";
-                ss << static_cast<std::string>(c) << " ";
-                ss << serialize(c.right, context);
-                return ss.str();
-            }
-        };
-
-        template<class R, class T, class E, class... Args>
-        struct statement_serializator<simple_case_t<R, T, E, Args...>, void> {
-            using statement_type = simple_case_t<R, T, E, Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                ss << "CASE ";
-                c.case_expression.apply([&ss, context](auto& c_) {
-                    ss << serialize(c_, context) << " ";
-                });
-                iterate_tuple(c.args, [&ss, context](auto& pair) {
-                    ss << "WHEN " << serialize(pair.first, context) << " ";
-                    ss << "THEN " << serialize(pair.second, context) << " ";
-                });
-                c.else_expression.apply([&ss, context](auto& el) {
-                    ss << "ELSE " << serialize(el, context) << " ";
-                });
-                ss << "END";
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<is_null_t<T>, void> {
-            using statement_type = is_null_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                ss << serialize(c.t, context) << " " << static_cast<std::string>(c);
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<is_not_null_t<T>, void> {
-            using statement_type = is_not_null_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                ss << serialize(c.t, context) << " " << static_cast<std::string>(c);
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<bitwise_not_t<T>, void> {
-            using statement_type = bitwise_not_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                ss << static_cast<std::string>(c) << " ";
-                auto cString = serialize(c.argument, context);
-                ss << " (" << cString << " )";
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<negated_condition_t<T>, void> {
-            using statement_type = negated_condition_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                ss << static_cast<std::string>(c) << " ";
-                auto cString = serialize(c.c, context);
-                ss << " (" << cString << " )";
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<T,
-                                      typename std::enable_if<is_base_of_template<T, binary_condition>::value>::type> {
-            using statement_type = T;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                auto leftString = serialize(c.l, context);
-                auto rightString = serialize(c.r, context);
-                std::stringstream ss;
-                if(context.use_parentheses) {
-                    ss << "(";
-                }
-                ss << leftString << " " << static_cast<std::string>(c) << " " << rightString;
-                if(context.use_parentheses) {
-                    ss << ")";
-                }
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<named_collate<T>, void> {
-            using statement_type = named_collate<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                auto newContext = context;
-                newContext.use_parentheses = false;
-                auto res = serialize(c.expr, newContext);
-                return res + " " + static_cast<std::string>(c);
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<collate_t<T>, void> {
-            using statement_type = collate_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                auto newContext = context;
-                newContext.use_parentheses = false;
-                auto res = serialize(c.expr, newContext);
-                return res + " " + static_cast<std::string>(c);
-            }
-        };
-
-        template<class L, class A>
-        struct statement_serializator<dynamic_in_t<L, A>, void> {
-            using statement_type = dynamic_in_t<L, A>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                auto leftString = serialize(c.left, context);
-                ss << leftString << " " << static_cast<std::string>(c) << " ";
-                auto newContext = context;
-                newContext.use_parentheses = true;
-                ss << serialize(c.argument, newContext);
-                return ss.str();
-            }
-        };
-
-        template<class L, class E>
-        struct statement_serializator<dynamic_in_t<L, std::vector<E>>, void> {
-            using statement_type = dynamic_in_t<L, std::vector<E>>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                auto leftString = serialize(c.left, context);
-                ss << leftString << " " << static_cast<std::string>(c) << " (";
-                for(size_t index = 0; index < c.argument.size(); ++index) {
-                    auto& value = c.argument[index];
-                    ss << serialize(value, context);
-                    if(index < c.argument.size() - 1) {
-                        ss << ", ";
-                    }
-                }
-                ss << ")";
-                return ss.str();
-            }
-        };
-
-        template<class L, class... Args>
-        struct statement_serializator<in_t<L, Args...>, void> {
-            using statement_type = in_t<L, Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                auto leftString = serialize(c.left, context);
-                ss << leftString << " " << static_cast<std::string>(c) << " (";
-                std::vector<std::string> args;
-                using args_type = std::tuple<Args...>;
-                args.reserve(std::tuple_size<args_type>::value);
-                iterate_tuple(c.argument, [&args, &context](auto& v) {
-                    args.push_back(serialize(v, context));
-                });
-                for(size_t i = 0; i < args.size(); ++i) {
-                    ss << args[i];
-                    if(i < args.size() - 1) {
-                        ss << ", ";
-                    }
-                }
-                ss << ")";
-                return ss.str();
-            }
-        };
-
-        template<class A, class T, class E>
-        struct statement_serializator<like_t<A, T, E>, void> {
-            using statement_type = like_t<A, T, E>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                ss << serialize(c.arg, context) << " ";
-                ss << static_cast<std::string>(c) << " ";
-                ss << serialize(c.pattern, context);
-                c.arg3.apply([&ss, &context](auto& value) {
-                    ss << " ESCAPE " << serialize(value, context);
-                });
-                return ss.str();
-            }
-        };
-
-        template<class A, class T>
-        struct statement_serializator<glob_t<A, T>, void> {
-            using statement_type = glob_t<A, T>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                ss << serialize(c.arg, context) << " ";
-                ss << static_cast<std::string>(c) << " ";
-                ss << serialize(c.pattern, context);
-                return ss.str();
-            }
-        };
-
-        template<class A, class T>
-        struct statement_serializator<between_t<A, T>, void> {
-            using statement_type = between_t<A, T>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                auto expr = serialize(c.expr, context);
-                ss << expr << " " << static_cast<std::string>(c) << " ";
-                ss << serialize(c.b1, context);
-                ss << " AND ";
-                ss << serialize(c.b2, context);
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<exists_t<T>, void> {
-            using statement_type = exists_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                ss << static_cast<std::string>(c) << " ";
-                ss << serialize(c.t, context);
-                return ss.str();
-            }
-        };
-
-        template<>
-        struct statement_serializator<autoincrement_t, void> {
-            using statement_type = autoincrement_t;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C&) const {
-                return "AUTOINCREMENT";
-            }
-        };
-
-        template<class... Cs>
-        struct statement_serializator<primary_key_t<Cs...>, void> {
-            using statement_type = primary_key_t<Cs...>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                auto res = static_cast<std::string>(c);
-                using columns_tuple = typename statement_type::columns_tuple;
-                auto columnsCount = std::tuple_size<columns_tuple>::value;
-                if(columnsCount) {
-                    res += "(";
-                    decltype(columnsCount) columnIndex = 0;
-                    iterate_tuple(c.columns, [&context, &res, &columnIndex, columnsCount](auto& column) {
-                        if(auto columnNamePointer = context.column_name(column)) {
-                            res += *columnNamePointer;
-                            if(columnIndex < columnsCount - 1) {
-                                res += ", ";
-                            }
-                            ++columnIndex;
-                        } else {
-                            throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
-                        }
-                    });
-                    res += ")";
-                }
-                return res;
-            }
-        };
-
-        template<class... Args>
-        struct statement_serializator<unique_t<Args...>, void> {
-            using statement_type = unique_t<Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                auto res = static_cast<std::string>(c);
-                using columns_tuple = typename statement_type::columns_tuple;
-                auto columnsCount = std::tuple_size<columns_tuple>::value;
-                if(columnsCount) {
-                    res += "(";
-                    decltype(columnsCount) columnIndex = 0;
-                    iterate_tuple(c.columns, [&context, &res, &columnIndex, columnsCount](auto& column) {
-                        if(auto columnNamePointer = context.column_name(column)) {
-                            res += *columnNamePointer;
-                            if(columnIndex < columnsCount - 1) {
-                                res += ", ";
-                            }
-                            ++columnIndex;
-                        } else {
-                            throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
-                        }
-                    });
-                    res += ")";
-                }
-                return res;
-            }
-        };
-
-        template<>
-        struct statement_serializator<collate_constraint_t, void> {
-            using statement_type = collate_constraint_t;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C&) const {
-                return static_cast<std::string>(c);
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<default_t<T>, void> {
-            using statement_type = default_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                return static_cast<std::string>(c) + " (" + serialize(c.value, context) + ")";
-            }
-        };
-
-        template<class... Cs, class... Rs>
-        struct statement_serializator<foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>>, void> {
-            using statement_type = foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>>;
-
-            template<class C>
-            std::string operator()(const statement_type& fk, const C& context) const {
-                std::stringstream ss;
-                std::vector<std::string> columnNames;
-                using columns_type_t = typename std::decay<decltype(fk)>::type::columns_type;
-                constexpr const size_t columnsCount = std::tuple_size<columns_type_t>::value;
-                columnNames.reserve(columnsCount);
-                iterate_tuple(fk.columns, [&columnNames, &context](auto& v) {
-                    if(auto columnNamePointer = context.impl.column_name(v)) {
-                        columnNames.push_back(*columnNamePointer);
-                    } else {
-                        columnNames.push_back({});
-                    }
-                });
-                ss << "FOREIGN KEY(";
-                for(size_t i = 0; i < columnNames.size(); ++i) {
-                    ss << "'" << columnNames[i] << "'";
-                    if(i < columnNames.size() - 1) {
-                        ss << ", ";
-                    }
-                }
-                ss << ") REFERENCES ";
-                std::vector<std::string> referencesNames;
-                using references_type_t = typename std::decay<decltype(fk)>::type::references_type;
-                constexpr const size_t referencesCount = std::tuple_size<references_type_t>::value;
-                referencesNames.reserve(referencesCount);
-                {
-                    using first_reference_t = typename std::tuple_element<0, references_type_t>::type;
-                    using first_reference_mapped_type = typename internal::table_type<first_reference_t>::type;
-                    auto refTableName = context.impl.find_table_name(typeid(first_reference_mapped_type));
-                    ss << '\'' << refTableName << '\'';
-                }
-                iterate_tuple(fk.references, [&referencesNames, &context](auto& v) {
-                    if(auto columnNamePointer = context.impl.column_name(v)) {
-                        referencesNames.push_back(*columnNamePointer);
-                    } else {
-                        referencesNames.push_back({});
-                    }
-                });
-                ss << "(";
-                for(size_t i = 0; i < referencesNames.size(); ++i) {
-                    ss << "'" << referencesNames[i] << "'";
-                    if(i < referencesNames.size() - 1) {
-                        ss << ", ";
-                    }
-                }
-                ss << ")";
-                if(fk.on_update) {
-                    ss << ' ' << static_cast<std::string>(fk.on_update) << " " << fk.on_update._action;
-                }
-                if(fk.on_delete) {
-                    ss << ' ' << static_cast<std::string>(fk.on_delete) << " " << fk.on_delete._action;
-                }
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<check_t<T>, void> {
-            using statement_type = check_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                return static_cast<std::string>(statement) + " " + serialize(statement.expression, context);
-            }
-        };
-#if SQLITE_VERSION_NUMBER >= 3031000
-        template<class T>
-        struct statement_serializator<generated_always_t<T>, void> {
-            using statement_type = generated_always_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                if(statement.full) {
-                    ss << "GENERATED ALWAYS ";
-                }
-                ss << "AS ";
-                ss << serialize(statement.expression, context);
-                switch(statement.storage) {
-                    case decltype(statement.storage)::not_specified:
-                        //..
-                        break;
-                    case decltype(statement.storage)::virtual_:
-                        ss << " VIRTUAL";
-                        break;
-                    case decltype(statement.storage)::stored:
-                        ss << " STORED";
-                        break;
-                }
-                return ss.str();
-            }
-        };
-#endif
-        template<class O, class T, class G, class S, class... Op>
-        struct statement_serializator<column_t<O, T, G, S, Op...>, void> {
-            using statement_type = column_t<O, T, G, S, Op...>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                ss << "'" << c.name << "' ";
-                using column_type = typename std::decay<decltype(c)>::type;
-                using field_type = typename column_type::field_type;
-                using constraints_type = typename column_type::constraints_type;
-                ss << type_printer<field_type>().print() << " ";
-                {
-                    std::vector<std::string> constraintsStrings;
-                    constexpr const size_t constraintsCount = std::tuple_size<constraints_type>::value;
-                    constraintsStrings.reserve(constraintsCount);
-                    int primaryKeyIndex = -1;
-                    int autoincrementIndex = -1;
-                    int tupleIndex = 0;
-                    iterate_tuple(
-                        c.constraints,
-                        [&constraintsStrings, &primaryKeyIndex, &autoincrementIndex, &tupleIndex, &context](auto& v) {
-                            using constraint_type = typename std::decay<decltype(v)>::type;
-                            constraintsStrings.push_back(serialize(v, context));
-                            if(is_primary_key<constraint_type>::value) {
-                                primaryKeyIndex = tupleIndex;
-                            } else if(std::is_same<autoincrement_t, constraint_type>::value) {
-                                autoincrementIndex = tupleIndex;
-                            }
-                            ++tupleIndex;
-                        });
-                    if(primaryKeyIndex != -1 && autoincrementIndex != -1 && autoincrementIndex < primaryKeyIndex) {
-                        iter_swap(constraintsStrings.begin() + primaryKeyIndex,
-                                  constraintsStrings.begin() + autoincrementIndex);
-                    }
-                    for(auto& str: constraintsStrings) {
-                        ss << str << ' ';
-                    }
-                }
-                if(c.not_null()) {
-                    ss << "NOT NULL ";
-                }
-                return ss.str();
-            }
-        };
-
-        template<class T, class... Args>
-        struct statement_serializator<remove_all_t<T, Args...>, void> {
-            using statement_type = remove_all_t<T, Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& rem, const C& context) const {
-                auto& tImpl = context.impl.template get_impl<T>();
-                std::stringstream ss;
-                ss << "DELETE FROM '" << tImpl.table.name << "' ";
-                iterate_tuple(rem.conditions, [&context, &ss](auto& v) {
-                    ss << serialize(v, context);
-                });
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<replace_t<T>, void> {
-            using statement_type = replace_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                using expression_type = typename std::decay<decltype(statement)>::type;
-                using object_type = typename expression_object_type<expression_type>::type;
-                auto& tImpl = context.impl.template get_impl<object_type>();
-                std::stringstream ss;
-                ss << "REPLACE INTO '" << tImpl.table.name << "' (";
-
-                auto columnIndex = 0;
-                auto columnsCount = tImpl.table.non_generated_columns_count();
-                tImpl.table.for_each_column([&ss, &columnIndex, columnsCount](auto& column) {
-                    if(column.is_generated()) {
-                        return;
-                    }
-                    ss << "\"" << column.name << "\"";
-                    if(columnIndex < columnsCount - 1) {
-                        ss << ", ";
-                    } else {
-                        ss << ")";
-                    }
-                    ++columnIndex;
-                });
-                ss << " VALUES (";
-                columnIndex = 0;
-                auto& object = get_ref(statement.object);
-                tImpl.table.for_each_column([&ss, &columnIndex, columnsCount, &object, &context](auto& column) {
-                    if(column.is_generated()) {
-                        return;
-                    }
-                    if(column.member_pointer) {
-                        ss << serialize(object.*column.member_pointer, context);
-                    } else {
-                        ss << serialize((object.*column.getter)(), context);
-                    }
-                    if(columnIndex < columnsCount - 1) {
-                        ss << ", ";
-                    } else {
-                        ss << ")";
-                    }
-                    ++columnIndex;
-                });
-                return ss.str();
-            }
-        };
-
-        template<class T, class... Cols>
-        struct statement_serializator<insert_explicit<T, Cols...>, void> {
-            using statement_type = insert_explicit<T, Cols...>;
-
-            template<class C>
-            std::string operator()(const statement_type& ins, const C& context) const {
-                constexpr const size_t colsCount = std::tuple_size<std::tuple<Cols...>>::value;
-                static_assert(colsCount > 0, "Use insert or replace with 1 argument instead");
-                using expression_type = typename std::decay<decltype(ins)>::type;
-                using object_type = typename expression_object_type<expression_type>::type;
-                auto& tImpl = context.impl.template get_impl<object_type>();
-                std::stringstream ss;
-                ss << "INSERT INTO '" << tImpl.table.name << "' ";
-                std::vector<std::string> columnNames;
-                columnNames.reserve(colsCount);
-                {
-                    auto columnsContext = context;
-                    columnsContext.skip_table_name = true;
-                    iterate_tuple(ins.columns.columns, [&columnNames, &columnsContext](auto& m) {
-                        auto columnName = serialize(m, columnsContext);
-                        if(!columnName.empty()) {
-                            columnNames.push_back(columnName);
-                        } else {
-                            throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
-                        }
-                    });
-                }
-                ss << "(";
-                for(size_t i = 0; i < columnNames.size(); ++i) {
-                    ss << columnNames[i];
-                    if(i < columnNames.size() - 1) {
-                        ss << ",";
-                    } else {
-                        ss << ")";
-                    }
-                    ss << " ";
-                }
-                ss << "VALUES (";
-                for(size_t i = 0; i < columnNames.size(); ++i) {
-                    ss << "?";
-                    if(i < columnNames.size() - 1) {
-                        ss << ",";
-                    } else {
-                        ss << ")";
-                    }
-                    ss << " ";
-                }
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<update_t<T>, void> {
-            using statement_type = update_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                using expression_type = typename std::decay<decltype(statement)>::type;
-                using object_type = typename expression_object_type<expression_type>::type;
-                auto& tImpl = context.impl.template get_impl<object_type>();
-
-                std::stringstream ss;
-                ss << "UPDATE '" << tImpl.table.name << "' SET";
-                //                std::vector<std::string> setColumnNames;
-                auto columnIndex = 0;
-                auto& object = get_ref(statement.object);
-                tImpl.table.for_each_column([&tImpl, &columnIndex, &ss, &object, &context](auto& column) {
-                    if(!column.template has<primary_key_t<>>() &&
-                       !tImpl.table.exists_in_composite_primary_key(column)) {
-                        if(0 == columnIndex) {
-                            ss << ' ';
-                        } else {
-                            ss << ", ";
-                        }
-                        ss << "\"" << column.name << "\" = ";
-                        if(column.member_pointer) {
-                            ss << serialize(object.*column.member_pointer, context);
-                        } else {
-                            ss << serialize((object.*column.getter)(), context);
-                        }
-                        ++columnIndex;
-                    }
-                });
-                ss << " WHERE";
-                columnIndex = 0;
-                tImpl.table.for_each_column([&tImpl, &columnIndex, &ss, &object, &context](auto& column) {
-                    if(column.template has<primary_key_t<>>() || tImpl.table.exists_in_composite_primary_key(column)) {
-                        if(0 == columnIndex) {
-                            ss << ' ';
-                        } else {
-                            ss << " AND ";
-                        }
-                        ss << "\"" << column.name << "\" = ";
-                        if(column.member_pointer) {
-                            ss << serialize(object.*column.member_pointer, context);
-                        } else {
-                            ss << serialize((object.*column.getter)(), context);
-                        }
-                        ++columnIndex;
-                    }
-                });
-                return ss.str();
-            }
-        };
-
-        template<class... Args>
-        struct statement_serializator<set_t<Args...>, void> {
-            using statement_type = set_t<Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                ss << static_cast<std::string>(statement);
-                auto assignsCount = std::tuple_size<typename statement_type::assigns_type>::value;
-                decltype(assignsCount) assignIndex = 0;
-                auto leftContext = context;
-                leftContext.skip_table_name = true;
-                iterate_tuple(statement.assigns,
-                              [&ss, &context, &leftContext, &assignIndex, assignsCount](auto& value) {
-                                  ss << ' ' << serialize(value.lhs, leftContext);
-                                  ss << ' ' << static_cast<std::string>(value) << ' ';
-                                  ss << serialize(value.rhs, context);
-                                  if(assignIndex < assignsCount - 1) {
-                                      ss << ",";
-                                  }
-                                  ++assignIndex;
-                              });
-                return ss.str();
-            }
-        };
-
-        template<class... Args, class... Wargs>
-        struct statement_serializator<update_all_t<set_t<Args...>, Wargs...>, void> {
-            using statement_type = update_all_t<set_t<Args...>, Wargs...>;
-
-            template<class C>
-            std::string operator()(const statement_type& upd, const C& context) const {
-                std::stringstream ss;
-                ss << "UPDATE";
-                table_name_collector collector([&context](std::type_index ti) {
-                    return context.impl.find_table_name(ti);
-                });
-                iterate_ast(upd.set.assigns, collector);
-                if(!collector.table_names.empty()) {
-                    if(collector.table_names.size() == 1) {
-                        ss << " '" << collector.table_names.begin()->first << "' ";
-                        ss << static_cast<std::string>(upd.set) << " ";
-                        std::vector<std::string> setPairs;
-                        auto leftContext = context;
-                        leftContext.skip_table_name = true;
-                        iterate_tuple(upd.set.assigns, [&context, &leftContext, &setPairs](auto& asgn) {
-                            std::stringstream sss;
-                            sss << serialize(asgn.lhs, leftContext);
-                            sss << " " << static_cast<std::string>(asgn) << " ";
-                            sss << serialize(asgn.rhs, context);
-                            setPairs.push_back(sss.str());
-                        });
-                        auto setPairsCount = setPairs.size();
-                        for(size_t i = 0; i < setPairsCount; ++i) {
-                            ss << setPairs[i] << " ";
-                            if(i < setPairsCount - 1) {
-                                ss << ", ";
-                            }
-                        }
-                        iterate_tuple(upd.conditions, [&context, &ss](auto& v) {
-                            ss << serialize(v, context);
-                        });
-                        return ss.str();
-                    } else {
-                        throw std::system_error(std::make_error_code(orm_error_code::too_many_tables_specified));
-                    }
-                } else {
-                    throw std::system_error(std::make_error_code(orm_error_code::incorrect_set_fields_specified));
-                }
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<insert_t<T>, void> {
-            using statement_type = insert_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                using object_type = typename expression_object_type<statement_type>::type;
-                auto& tImpl = context.impl.template get_impl<object_type>();
-
-                std::stringstream ss;
-                ss << "INSERT INTO '" << tImpl.table.name << "' ";
-
-                auto columnIndex = 0;
-                tImpl.table.for_each_column([&tImpl, &columnIndex, &ss](auto& column) {
-                    using table_type = typename std::decay<decltype(tImpl.table)>::type;
-                    if(table_type::is_without_rowid ||
-                       (!column.template has<primary_key_t<>>() &&
-                        !tImpl.table.exists_in_composite_primary_key(column) && !column.is_generated())) {
-                        if(0 == columnIndex) {
-                            ss << '(';
-                        } else {
-                            ss << ", ";
-                        }
-                        ss << "\"" << column.name << "\"";
-                        ++columnIndex;
-                    }
-                });
-                auto columnsToInsertCount = columnIndex;
-                if(columnsToInsertCount > 0) {
-                    ss << ')';
-                } else {
-                    ss << "DEFAULT";
-                }
-                ss << " VALUES ";
-                if(columnsToInsertCount) {
-                    ss << "(";
-                    columnIndex = 0;
-                    auto& object = get_ref(statement.object);
-                    tImpl.table.for_each_column(
-                        [&tImpl, &columnIndex, &ss, columnsToInsertCount, &context, &object](auto& column) {
-                            using table_type = typename std::decay<decltype(tImpl.table)>::type;
-                            if(table_type::is_without_rowid ||
-                               (!column.template has<primary_key_t<>>() &&
-                                !tImpl.table.exists_in_composite_primary_key(column) && !column.is_generated())) {
-                                if(column.member_pointer) {
-                                    ss << serialize(object.*column.member_pointer, context);
-                                } else {
-                                    ss << serialize((object.*column.getter)(), context);
-                                }
-                                if(columnIndex < columnsToInsertCount - 1) {
-                                    ss << ", ";
-                                }
-                                ++columnIndex;
-                            }
-                        });
-                    ss << ")";
-                }
-
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<into_t<T>, void> {
-            using statement_type = into_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                auto& tImpl = context.impl.template get_impl<T>();
-                ss << "INTO " << tImpl.table.name;
-                return ss.str();
-            }
-        };
-
-        template<class... Args>
-        struct statement_serializator<columns_t<Args...>, void> {
-            using statement_type = columns_t<Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                auto index = 0;
-                if(context.use_parentheses) {
-                    ss << '(';
-                }
-                iterate_tuple(statement.columns, [&context, &ss, &index](auto& value) {
-                    ss << serialize(value, context);
-                    if(index < int(std::tuple_size<std::tuple<Args...>>::value) - 1) {
-                        ss << ", ";
-                    }
-                    ++index;
-                });
-                if(context.use_parentheses) {
-                    ss << ')';
-                }
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<
-            T,
-            typename std::enable_if<is_insert_raw<T>::value || is_replace_raw<T>::value>::type> {
-            using statement_type = T;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                if(is_insert_raw<T>::value) {
-                    ss << "INSERT";
-                } else {
-                    ss << "REPLACE";
-                }
-                iterate_tuple(statement.args, [&context, &ss](auto& value) {
-                    using value_type = typename std::decay<decltype(value)>::type;
-                    ss << ' ';
-                    if(is_columns<value_type>::value) {
-                        auto newContext = context;
-                        newContext.skip_table_name = true;
-                        newContext.use_parentheses = true;
-                        ss << serialize(value, newContext);
-                    } else if(is_values<value_type>::value || is_select<value_type>::value) {
-                        auto newContext = context;
-                        newContext.use_parentheses = false;
-                        ss << serialize(value, newContext);
-                    } else {
-                        ss << serialize(value, context);
-                    }
-                });
-                return ss.str();
-            }
-        };
-
-        template<class T, class... Ids>
-        struct statement_serializator<remove_t<T, Ids...>, void> {
-            using statement_type = remove_t<T, Ids...>;
-
-            template<class C>
-            std::string operator()(const statement_type&, const C& context) const {
-                auto& tImpl = context.impl.template get_impl<T>();
-                std::stringstream ss;
-                ss << "DELETE FROM '" << tImpl.table.name << "' ";
-                ss << "WHERE ";
-                auto primaryKeyColumnNames = tImpl.table.primary_key_column_names();
-                for(size_t i = 0; i < primaryKeyColumnNames.size(); ++i) {
-                    ss << "\"" << primaryKeyColumnNames[i] << "\""
-                       << " = ? ";
-                    if(i < primaryKeyColumnNames.size() - 1) {
-                        ss << "AND ";
-                    }
-                }
-                return ss.str();
-            }
-        };
-
-        template<class It, class L, class O>
-        struct statement_serializator<replace_range_t<It, L, O>, void> {
-            using statement_type = replace_range_t<It, L, O>;
-
-            template<class C>
-            std::string operator()(const statement_type& rep, const C& context) const {
-                auto valuesCount = static_cast<int>(std::distance(rep.range.first, rep.range.second));
-                using expression_type = typename std::decay<decltype(rep)>::type;
-                using object_type = typename expression_object_type<expression_type>::type;
-                auto& tImpl = context.impl.template get_impl<object_type>();
-                std::stringstream ss;
-                ss << "REPLACE INTO '" << tImpl.table.name << "' (";
-
-                auto columnIndex = 0;
-                auto columnsCount = tImpl.table.non_generated_columns_count();
-                tImpl.table.for_each_column([&ss, &columnIndex, columnsCount](auto& column) {
-                    if(column.is_generated()) {
-                        return;
-                    }
-                    ss << " \"" << column.name << "\"";
-                    if(columnIndex < columnsCount - 1) {
-                        ss << ",";
-                    } else {
-                        ss << ")";
-                    }
-                    ++columnIndex;
-                });
-                ss << " VALUES ";
-                auto valuesString = [columnsCount] {
-                    std::stringstream ss_;
-                    ss_ << "(";
-                    for(auto i = 0; i < columnsCount; ++i) {
-                        ss_ << "?";
-                        if(i < columnsCount - 1) {
-                            ss_ << ", ";
-                        } else {
-                            ss_ << ")";
-                        }
-                    }
-                    return ss_.str();
-                }();
-                for(auto i = 0; i < valuesCount; ++i) {
-                    ss << valuesString;
-                    if(i < valuesCount - 1) {
-                        ss << ",";
-                    }
-                    ss << " ";
-                }
-                return ss.str();
-            }
-        };
-
-        template<class It, class L, class O>
-        struct statement_serializator<insert_range_t<It, L, O>, void> {
-            using statement_type = insert_range_t<It, L, O>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                const auto valuesCount = static_cast<int>(std::distance(statement.range.first, statement.range.second));
-                using object_type = typename expression_object_type<statement_type>::type;
-                auto& tImpl = context.impl.template get_impl<object_type>();
-
-                std::stringstream ss;
-                ss << "INSERT INTO '" << tImpl.table.name << "' ";
-                std::vector<std::string> columnNames;
-
-                tImpl.table.for_each_column([&columnNames, &tImpl](auto& column) {
-                    using table_type = typename std::decay<decltype(tImpl.table)>::type;
-                    if(table_type::is_without_rowid ||
-                       (!column.template has<primary_key_t<>>() &&
-                        !tImpl.table.exists_in_composite_primary_key(column) && !column.is_generated())) {
-                        columnNames.emplace_back(column.name);
-                    }
-                });
-
-                const auto columnNamesCount = columnNames.size();
-                if(columnNamesCount) {
-                    ss << "(";
-                    for(size_t i = 0; i < columnNamesCount; ++i) {
-                        ss << "\"" << columnNames[i] << "\"";
-                        if(i < columnNamesCount - 1) {
-                            ss << ",";
-                        } else {
-                            ss << ")";
-                        }
-                        ss << " ";
-                    }
-                } else {
-                    ss << "DEFAULT ";
-                }
-                ss << "VALUES ";
-                if(columnNamesCount) {
-                    auto valuesString = [columnNamesCount] {
-                        std::stringstream ss_;
-                        ss_ << "(";
-                        for(size_t i = 0; i < columnNamesCount; ++i) {
-                            ss_ << "?";
-                            if(i < columnNamesCount - 1) {
-                                ss_ << ", ";
-                            } else {
-                                ss_ << ")";
-                            }
-                        }
-                        return ss_.str();
-                    }();
-                    for(auto i = 0; i < valuesCount; ++i) {
-                        ss << valuesString;
-                        if(i < valuesCount - 1) {
-                            ss << ",";
-                        }
-                        ss << " ";
-                    }
-                } else if(valuesCount != 1) {
-                    throw std::system_error(std::make_error_code(orm_error_code::cannot_use_default_value));
-                }
-                return ss.str();
-            }
-        };
-
-        template<class T, class C>
-        std::string serialize_get_all_impl(const T& get, const C& context) {
-            using primary_type = typename T::type;
-
-            table_name_collector collector;
-            collector.table_names.insert(
-                std::make_pair(context.impl.find_table_name(typeid(primary_type)), std::string{}));
-            iterate_ast(get.conditions, collector);
-            std::stringstream ss;
-            ss << "SELECT";
-            auto& tImpl = context.impl.template get_impl<primary_type>();
-            auto columnIndex = 0;
-            auto columnsCount = tImpl.table.count_columns_amount();
-            tImpl.table.for_each_column([&ss, &columnIndex, columnsCount, &tImpl](auto& column) {
-                ss << " \"" << tImpl.table.name << "\"."
-                   << "\"" << column.name << "\"";
-                if(columnIndex < columnsCount - 1) {
-                    ss << ",";
-                }
-                ++columnIndex;
-            });
-            ss << " FROM ";
-            std::vector<std::pair<std::string, std::string>> tableNames(collector.table_names.begin(),
-                                                                        collector.table_names.end());
-            for(size_t i = 0; i < tableNames.size(); ++i) {
-                auto& tableNamePair = tableNames[i];
-                ss << "'" << tableNamePair.first << "' ";
-                if(!tableNamePair.second.empty()) {
-                    ss << tableNamePair.second << " ";
-                }
-                if(int(i) < int(tableNames.size()) - 1) {
-                    ss << ",";
-                }
-                ss << " ";
-            }
-            iterate_tuple(get.conditions, [&context, &ss](auto& v) {
-                ss << serialize(v, context);
-            });
-            return ss.str();
-        }
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class T, class R, class... Args>
-        struct statement_serializator<get_all_optional_t<T, R, Args...>, void> {
-            using statement_type = get_all_optional_t<T, R, Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& get, const C& context) const {
-                return serialize_get_all_impl(get, context);
-            }
-        };
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-
-        template<class T, class R, class... Args>
-        struct statement_serializator<get_all_pointer_t<T, R, Args...>, void> {
-            using statement_type = get_all_pointer_t<T, R, Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& get, const C& context) const {
-                return serialize_get_all_impl(get, context);
-            }
-        };
-
-        template<class T, class R, class... Args>
-        struct statement_serializator<get_all_t<T, R, Args...>, void> {
-            using statement_type = get_all_t<T, R, Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& get, const C& context) const {
-                return serialize_get_all_impl(get, context);
-            }
-        };
-
-        template<class T, class C>
-        std::string serialize_get_impl(const T&, const C& context) {
-            using primary_type = typename T::type;
-            auto& tImpl = context.impl.template get_impl<primary_type>();
-            std::stringstream ss;
-            ss << "SELECT";
-            auto columnIndex = 0;
-            auto columnsCount = tImpl.table.count_columns_amount();
-            tImpl.table.for_each_column([&ss, &columnIndex, columnsCount](auto& column) {
-                ss << " \"" << column.name << "\"";
-                if(columnIndex < columnsCount - 1) {
-                    ss << ", ";
-                }
-                ++columnIndex;
-            });
-            ss << " FROM '" << tImpl.table.name << "' WHERE ";
-            auto primaryKeyColumnNames = tImpl.table.primary_key_column_names();
-            if(!primaryKeyColumnNames.empty()) {
-                for(size_t i = 0; i < primaryKeyColumnNames.size(); ++i) {
-                    ss << " \"" << primaryKeyColumnNames[i] << "\""
-                       << " = ?";
-                    if(i < primaryKeyColumnNames.size() - 1) {
-                        ss << " AND";
-                    }
-                }
-                return ss.str();
-            } else {
-                throw std::system_error(std::make_error_code(orm_error_code::table_has_no_primary_key_column));
-            }
-        }
-
-        template<class T, class... Ids>
-        struct statement_serializator<get_t<T, Ids...>, void> {
-            using statement_type = get_t<T, Ids...>;
-
-            template<class C>
-            std::string operator()(const statement_type& get, const C& context) const {
-                return serialize_get_impl(get, context);
-            }
-        };
-
-        template<class T, class... Ids>
-        struct statement_serializator<get_pointer_t<T, Ids...>, void> {
-            using statement_type = get_pointer_t<T, Ids...>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                return serialize_get_impl(statement, context);
-            }
-        };
-
-        template<>
-        struct statement_serializator<conflict_action, void> {
-            using statement_type = conflict_action;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                switch(statement) {
-                    case conflict_action::replace:
-                        return "REPLACE";
-                    case conflict_action::abort:
-                        return "ABORT";
-                    case conflict_action::fail:
-                        return "FAIL";
-                    case conflict_action::ignore:
-                        return "IGNORE";
-                    case conflict_action::rollback:
-                        return "ROLLBACK";
-                }
-            }
-        };
-
-        template<>
-        struct statement_serializator<insert_constraint, void> {
-            using statement_type = insert_constraint;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                return "OR " + serialize(statement.action, context);
-            }
-        };
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class T, class... Ids>
-        struct statement_serializator<get_optional_t<T, Ids...>, void> {
-            using statement_type = get_optional_t<T, Ids...>;
-
-            template<class C>
-            std::string operator()(const statement_type& get, const C& context) const {
-                return serialize_get_impl(get, context);
-            }
-        };
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class T, class... Args>
-        struct statement_serializator<select_t<T, Args...>, void> {
-            using statement_type = select_t<T, Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& sel, const C& context) const {
-                std::stringstream ss;
-                const auto isCompoundOperator = is_base_of_template<T, compound_operator>::value;
-                if(!isCompoundOperator) {
-                    if(!sel.highest_level && context.use_parentheses) {
-                        ss << "(";
-                    }
-                    ss << "SELECT ";
-                }
-                if(get_distinct(sel.col)) {
-                    ss << static_cast<std::string>(distinct(0)) << " ";
-                }
-                auto columnNames = get_column_names(sel.col, context);
-                for(size_t i = 0; i < columnNames.size(); ++i) {
-                    ss << columnNames[i];
-                    if(i < columnNames.size() - 1) {
-                        ss << ", ";
-                    }
-                }
-                table_name_collector collector([&context](std::type_index ti) {
-                    return context.impl.find_table_name(ti);
-                });
-                const auto explicitFromItemsCount = count_tuple<std::tuple<Args...>, is_from>::value;
-                if(!explicitFromItemsCount) {
-                    iterate_ast(sel.col, collector);
-                    iterate_ast(sel.conditions, collector);
-                    join_iterator<Args...>()([&collector, &context](const auto& c) {
-                        using original_join_type = typename std::decay<decltype(c)>::type::join_type::type;
-                        using cross_join_type = typename internal::mapped_type_proxy<original_join_type>::type;
-                        auto crossJoinedTableName = context.impl.find_table_name(typeid(cross_join_type));
-                        auto tableAliasString = alias_extractor<original_join_type>::get();
-                        std::pair<std::string, std::string> tableNameWithAlias(std::move(crossJoinedTableName),
-                                                                               std::move(tableAliasString));
-                        collector.table_names.erase(tableNameWithAlias);
-                    });
-                    if(!collector.table_names.empty() && !isCompoundOperator) {
-                        ss << " FROM ";
-                        std::vector<std::pair<std::string, std::string>> tableNames(collector.table_names.begin(),
-                                                                                    collector.table_names.end());
-                        for(size_t i = 0; i < tableNames.size(); ++i) {
-                            auto& tableNamePair = tableNames[i];
-                            ss << "'" << tableNamePair.first << "'";
-                            if(!tableNamePair.second.empty()) {
-                                ss << ' ' << tableNamePair.second;
-                            }
-                            if(int(i) < int(tableNames.size()) - 1) {
-                                ss << ", ";
-                            }
-                        }
-                    }
-                }
-                iterate_tuple(sel.conditions, [&context, &ss](auto& v) {
-                    ss << ' ' << serialize(v, context);
-                });
-                if(!is_base_of_template<T, compound_operator>::value) {
-                    if(!sel.highest_level && context.use_parentheses) {
-                        ss << ")";
-                    }
-                }
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<indexed_column_t<T>, void> {
-            using statement_type = indexed_column_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                ss << serialize(statement.column_or_expression, context);
-                if(!statement._collation_name.empty()) {
-                    ss << " COLLATE " << statement._collation_name;
-                }
-                if(statement._order) {
-                    switch(statement._order) {
-                        case -1:
-                            ss << " DESC";
-                            break;
-                        case 1:
-                            ss << " ASC";
-                            break;
-                        default:
-                            throw std::system_error(std::make_error_code(orm_error_code::incorrect_order));
-                    }
-                }
-                return ss.str();
-            }
-        };
-
-        template<class... Cols>
-        struct statement_serializator<index_t<Cols...>, void> {
-            using statement_type = index_t<Cols...>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                ss << "CREATE ";
-                if(statement.unique) {
-                    ss << "UNIQUE ";
-                }
-                using elements_type = typename std::decay<decltype(statement)>::type::elements_type;
-                using head_t = typename std::tuple_element<0, elements_type>::type::column_type;
-                using indexed_type = typename table_type<head_t>::type;
-                ss << "INDEX IF NOT EXISTS '" << statement.name << "' ON '"
-                   << context.impl.find_table_name(typeid(indexed_type)) << "' (";
-                std::vector<std::string> columnNames;
-                iterate_tuple(statement.elements, [&columnNames, &context](auto& v) {
-                    auto columnName = serialize(v, context);
-                    columnNames.push_back(move(columnName));
-                });
-                for(size_t i = 0; i < columnNames.size(); ++i) {
-                    ss << columnNames[i];
-                    if(i < columnNames.size() - 1) {
-                        ss << ", ";
-                    }
-                }
-                ss << ")";
-                return ss.str();
-            }
-        };
-
-        template<class... Args>
-        struct statement_serializator<from_t<Args...>, void> {
-            using statement_type = from_t<Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                using tuple = std::tuple<Args...>;
-
-                std::stringstream ss;
-                ss << "FROM ";
-                size_t index = 0;
-                iterate_tuple<tuple>([&context, &ss, &index](auto* itemPointer) {
-                    using mapped_type = typename std::remove_pointer<decltype(itemPointer)>::type;
-
-                    auto aliasString = alias_extractor<mapped_type>::get();
-                    ss << "'" << context.impl.find_table_name(typeid(typename mapped_type_proxy<mapped_type>::type))
-                       << "'";
-                    if(aliasString.length()) {
-                        ss << " '" << aliasString << "'";
-                    }
-                    if(index < std::tuple_size<tuple>::value - 1) {
-                        ss << ", ";
-                    }
-                    ++index;
-                });
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<where_t<T>, void> {
-            using statement_type = where_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                ss << statement.serialize() << " ";
-                auto whereString = serialize(statement.expression, context);
-                ss << '(' << whereString << ')';
-                return ss.str();
-            }
-        };
-
-        template<class O>
-        struct statement_serializator<order_by_t<O>, void> {
-            using statement_type = order_by_t<O>;
-
-            template<class C>
-            std::string operator()(const statement_type& orderBy, const C& context) const {
-                std::stringstream ss;
-                ss << static_cast<std::string>(orderBy) << " ";
-                auto orderByString = serialize_order_by(orderBy, context);
-                ss << orderByString << " ";
-                return ss.str();
-            }
-        };
-
-        template<class C>
-        struct statement_serializator<dynamic_order_by_t<C>, void> {
-            using statement_type = dynamic_order_by_t<C>;
-
-            template<class CC>
-            std::string operator()(const statement_type& orderBy, const CC& context) const {
-                return serialize_order_by(orderBy, context);
-            }
-        };
-
-        template<class... Args>
-        struct statement_serializator<multi_order_by_t<Args...>, void> {
-            using statement_type = multi_order_by_t<Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& orderBy, const C& context) const {
-                std::stringstream ss;
-                std::vector<std::string> expressions;
-                iterate_tuple(orderBy.args, [&expressions, &context](auto& v) {
-                    auto expression = serialize_order_by(v, context);
-                    expressions.push_back(move(expression));
-                });
-                ss << static_cast<std::string>(orderBy) << " ";
-                for(size_t i = 0; i < expressions.size(); ++i) {
-                    ss << expressions[i];
-                    if(i < expressions.size() - 1) {
-                        ss << ", ";
-                    }
-                }
-                ss << " ";
-                return ss.str();
-            }
-        };
-
-        template<class O>
-        struct statement_serializator<cross_join_t<O>, void> {
-            using statement_type = cross_join_t<O>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                ss << static_cast<std::string>(c) << " ";
-                ss << " '" << context.impl.find_table_name(typeid(O)) << "'";
-                return ss.str();
-            }
-        };
-
-        template<class T, class O>
-        struct statement_serializator<inner_join_t<T, O>, void> {
-            using statement_type = inner_join_t<T, O>;
-
-            template<class C>
-            std::string operator()(const statement_type& l, const C& context) const {
-                std::stringstream ss;
-                ss << static_cast<std::string>(l) << " ";
-                auto aliasString = alias_extractor<T>::get();
-                ss << " '" << context.impl.find_table_name(typeid(typename mapped_type_proxy<T>::type)) << "' ";
-                if(aliasString.length()) {
-                    ss << "'" << aliasString << "' ";
-                }
-                ss << serialize(l.constraint, context);
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<on_t<T>, void> {
-            using statement_type = on_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& t, const C& context) const {
-                std::stringstream ss;
-                auto newContext = context;
-                newContext.skip_table_name = false;
-                ss << static_cast<std::string>(t) << " " << serialize(t.arg, newContext) << " ";
-                return ss.str();
-            }
-        };
-
-        template<class T, class O>
-        struct statement_serializator<join_t<T, O>, void> {
-            using statement_type = join_t<T, O>;
-
-            template<class C>
-            std::string operator()(const statement_type& l, const C& context) const {
-                std::stringstream ss;
-                ss << static_cast<std::string>(l) << " ";
-                auto aliasString = alias_extractor<T>::get();
-                ss << " '" << context.impl.find_table_name(typeid(typename mapped_type_proxy<T>::type)) << "' ";
-                if(aliasString.length()) {
-                    ss << "'" << aliasString << "' ";
-                }
-                ss << serialize(l.constraint, context);
-                return ss.str();
-            }
-        };
-
-        template<class T, class O>
-        struct statement_serializator<left_join_t<T, O>, void> {
-            using statement_type = left_join_t<T, O>;
-
-            template<class C>
-            std::string operator()(const statement_type& l, const C& context) const {
-                std::stringstream ss;
-                ss << static_cast<std::string>(l) << " ";
-                auto aliasString = alias_extractor<T>::get();
-                ss << " '" << context.impl.find_table_name(typeid(typename mapped_type_proxy<T>::type)) << "' ";
-                if(aliasString.length()) {
-                    ss << "'" << aliasString << "' ";
-                }
-                ss << serialize(l.constraint, context);
-                return ss.str();
-            }
-        };
-
-        template<class T, class O>
-        struct statement_serializator<left_outer_join_t<T, O>, void> {
-            using statement_type = left_outer_join_t<T, O>;
-
-            template<class C>
-            std::string operator()(const statement_type& l, const C& context) const {
-                std::stringstream ss;
-                ss << static_cast<std::string>(l) << " ";
-                auto aliasString = alias_extractor<T>::get();
-                ss << " '" << context.impl.find_table_name(typeid(typename mapped_type_proxy<T>::type)) << "' ";
-                if(aliasString.length()) {
-                    ss << "'" << aliasString << "' ";
-                }
-                ss << serialize(l.constraint, context);
-                return ss.str();
-            }
-        };
-
-        template<class O>
-        struct statement_serializator<natural_join_t<O>, void> {
-            using statement_type = natural_join_t<O>;
-
-            template<class C>
-            std::string operator()(const statement_type& c, const C& context) const {
-                std::stringstream ss;
-                ss << static_cast<std::string>(c) << " ";
-                ss << " '" << context.impl.find_table_name(typeid(O)) << "'";
-                return ss.str();
-            }
-        };
-
-        template<class T, class... Args>
-        struct statement_serializator<group_by_with_having<T, Args...>, void> {
-            using statement_type = group_by_with_having<T, Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                std::vector<std::string> expressions;
-                auto newContext = context;
-                newContext.skip_table_name = false;
-                iterate_tuple(statement.args, [&expressions, &newContext](auto& v) {
-                    auto expression = serialize(v, newContext);
-                    expressions.push_back(expression);
-                });
-                ss << "GROUP BY";
-                for(size_t i = 0; i < expressions.size(); ++i) {
-                    ss << ' ' << expressions[i];
-                    if(i < expressions.size() - 1) {
-                        ss << ",";
-                    }
-                }
-                ss << " HAVING";
-                ss << ' ' << serialize(statement.expression, context);
-                return ss.str();
-            }
-        };
-
-        template<class... Args>
-        struct statement_serializator<group_by_t<Args...>, void> {
-            using statement_type = group_by_t<Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                std::vector<std::string> expressions;
-                auto newContext = context;
-                newContext.skip_table_name = false;
-                iterate_tuple(statement.args, [&expressions, &newContext](auto& v) {
-                    auto expression = serialize(v, newContext);
-                    expressions.push_back(expression);
-                });
-                ss << "GROUP BY";
-                for(size_t i = 0; i < expressions.size(); ++i) {
-                    ss << ' ' << expressions[i];
-                    if(i < expressions.size() - 1) {
-                        ss << ",";
-                    }
-                }
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<having_t<T>, void> {
-            using statement_type = having_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                auto newContext = context;
-                newContext.skip_table_name = false;
-                ss << "HAVING";
-                ss << " " << serialize(statement.expression, newContext);
-                return ss.str();
-            }
-        };
-
-        /**
-         *  HO - has offset
-         *  OI - offset is implicit
-         */
-        template<class T, bool HO, bool OI, class O>
-        struct statement_serializator<limit_t<T, HO, OI, O>, void> {
-            using statement_type = limit_t<T, HO, OI, O>;
-
-            template<class C>
-            std::string operator()(const statement_type& limt, const C& context) const {
-                auto newContext = context;
-                newContext.skip_table_name = false;
-                std::stringstream ss;
-                ss << static_cast<std::string>(limt) << " ";
-                if(HO) {
-                    if(OI) {
-                        limt.off.apply([&newContext, &ss](auto& value) {
-                            ss << serialize(value, newContext);
-                        });
-                        ss << ", ";
-                        ss << serialize(limt.lim, newContext);
-                    } else {
-                        ss << serialize(limt.lim, newContext) << " OFFSET ";
-                        limt.off.apply([&newContext, &ss](auto& value) {
-                            ss << serialize(value, newContext);
-                        });
-                    }
-                } else {
-                    ss << serialize(limt.lim, newContext);
-                }
-                return ss.str();
-            }
-        };
-
-        template<>
-        struct statement_serializator<default_values_t, void> {
-            using statement_type = default_values_t;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                return "DEFAULT VALUES";
-            }
-        };
-
-        template<class F, class O>
-        struct statement_serializator<using_t<F, O>, void> {
-            using statement_type = using_t<F, O>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                auto newContext = context;
-                newContext.skip_table_name = true;
-                return static_cast<std::string>(statement) + " (" + serialize(statement.column, newContext) + " )";
-            }
-        };
-
-        template<class... Args>
-        struct statement_serializator<std::tuple<Args...>, void> {
-            using statement_type = std::tuple<Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                ss << '(';
-                auto index = 0;
-                using TupleSize = std::tuple_size<statement_type>;
-                iterate_tuple(statement, [&context, &index, &ss](auto& value) {
-                    ss << serialize(value, context);
-                    if(index < TupleSize::value - 1) {
-                        ss << ", ";
-                    }
-                    ++index;
-                });
-                ss << ')';
-                return ss.str();
-            }
-        };
-
-        template<class... Args>
-        struct statement_serializator<values_t<Args...>, void> {
-            using statement_type = values_t<Args...>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                if(context.use_parentheses) {
-                    ss << '(';
-                }
-                ss << "VALUES ";
-                {
-                    auto index = 0;
-                    auto& tuple = statement.tuple;
-                    using tuple_type = typename std::decay<decltype(tuple)>::type;
-                    using TupleSize = std::tuple_size<tuple_type>;
-                    iterate_tuple(tuple, [&context, &index, &ss](auto& value) {
-                        ss << serialize(value, context);
-                        if(index < TupleSize::value - 1) {
-                            ss << ", ";
-                        }
-                        ++index;
-                    });
-                }
-                if(context.use_parentheses) {
-                    ss << ')';
-                }
-                return ss.str();
-            }
-        };
-
-        template<class T>
-        struct statement_serializator<dynamic_values_t<T>, void> {
-            using statement_type = dynamic_values_t<T>;
-
-            template<class C>
-            std::string operator()(const statement_type& statement, const C& context) const {
-                std::stringstream ss;
-                if(context.use_parentheses) {
-                    ss << '(';
-                }
-                ss << "VALUES ";
-                {
-                    auto vectorSize = statement.vector.size();
-                    for(decltype(vectorSize) index = 0; index < vectorSize; ++index) {
-                        auto& value = statement.vector[index];
-                        ss << serialize(value, context);
-                        if(index < vectorSize - 1) {
-                            ss << ", ";
-                        }
-                    }
-                }
-                if(context.use_parentheses) {
-                    ss << ')';
-                }
-                return ss.str();
-            }
-        };
-
-    }
-}
-
-// #include "table_name_collector.h"
-
-// #include "object_from_column_builder.h"
-
-// #include "table.h"
-
-// #include "column.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         *  Storage class itself. Create an instanse to use it as an interfacto to sqlite db by calling `make_storage`
-         *  function.
-         */
-        template<class... Ts>
-        struct storage_t : storage_base {
-            using self = storage_t<Ts...>;
-            using impl_type = storage_impl<Ts...>;
-
-            /**
-             *  @param filename database filename.
-             *  @param impl_ storage_impl head
-             */
-            storage_t(const std::string& filename, impl_type impl_) :
-                storage_base{filename, foreign_keys_count(impl_)}, impl(std::move(impl_)) {}
-
-            storage_t(const storage_t& other) : storage_base(other), impl(other.impl) {}
-
-          protected:
-            impl_type impl;
-
-            template<class T, class S, class... Args>
-            friend struct view_t;
-
-            template<class S>
-            friend struct dynamic_order_by_t;
-
-            template<class V>
-            friend struct iterator_t;
-
-            template<class S>
-            friend struct serializator_context_builder;
-
-            template<class I>
-            void create_table(sqlite3* db, const std::string& tableName, const I& tableImpl) {
-                using table_type = typename std::decay<decltype(tableImpl.table)>::type;
-                std::stringstream ss;
-                ss << "CREATE TABLE '" << tableName << "' ( ";
-                auto elementsCount = tableImpl.table.elements_count;
-                auto index = 0;
-                using context_t = serializator_context<impl_type>;
-                context_t context{this->impl};
-                iterate_tuple(tableImpl.table.elements, [elementsCount, &index, &ss, &context](auto& element) {
-                    ss << serialize(element, context);
-                    if(index < elementsCount - 1) {
-                        ss << ", ";
-                    }
-                    index++;
-                });
-                ss << ")";
-                if(table_type::is_without_rowid) {
-                    ss << " WITHOUT ROWID";
-                }
-                perform_void_exec(db, ss.str());
-            }
-#if SQLITE_VERSION_NUMBER >= 3035000  //  DROP COLUMN feature exists (v3.35.0)
-            void drop_column(sqlite3* db, const std::string& tableName, const std::string& columnName) {
-                std::stringstream ss;
-                ss << "ALTER TABLE '" << tableName << "' DROP COLUMN \"" << columnName << "\"";
-                perform_void_exec(db, ss.str());
-            }
-#endif
-            template<class I>
-            void backup_table(sqlite3* db, const I& tableImpl, const std::vector<table_info*>& columnsToIgnore) {
-
-                //  here we copy source table to another with a name with '_backup' suffix, but in case table with such
-                //  a name already exists we append suffix 1, then 2, etc until we find a free name..
-                auto backupTableName = tableImpl.table.name + "_backup";
-                if(tableImpl.table_exists(backupTableName, db)) {
-                    int suffix = 1;
-                    do {
-                        std::stringstream stream;
-                        stream << suffix;
-                        auto anotherBackupTableName = backupTableName + stream.str();
-                        if(!tableImpl.table_exists(anotherBackupTableName, db)) {
-                            backupTableName = anotherBackupTableName;
-                            break;
-                        }
-                        ++suffix;
-                    } while(true);
-                }
-
-                this->create_table(db, backupTableName, tableImpl);
-
-                tableImpl.copy_table(db, backupTableName, columnsToIgnore);
-
-                this->drop_table_internal(tableImpl.table.name, db);
-
-                tableImpl.rename_table(db, backupTableName, tableImpl.table.name);
-            }
-
-            template<class O>
-            void assert_mapped_type() const {
-                using mapped_types_tuples = std::tuple<typename Ts::object_type...>;
-                static_assert(tuple_helper::has_type<O, mapped_types_tuples>::value, "type is not mapped to a storage");
-            }
-
-            template<class O>
-            void assert_insertable_type() const {
-                auto& tImpl = this->get_impl<O>();
-                using table_type = typename std::decay<decltype(tImpl.table)>::type;
-                using elements_type = typename std::decay<decltype(tImpl.table.elements)>::type;
-
-                using is_without_rowid = std::integral_constant<bool, table_type::is_without_rowid>;
-
-                static_if<is_without_rowid{}>(
-                    [](auto&) {},  // all right. it's a "without_rowid" table
-                    [](auto& tImpl) {  // unfortunately, this static_assert's can't see any composite keys((
-                        std::ignore = tImpl;
-                        static_assert(
-                            count_tuple<elements_type, is_column_with_insertable_primary_key>::value <= 1,
-                            "Attempting to execute 'insert' request into an noninsertable table was detected. "
-                            "Insertable table cannot contain > 1 primary keys. Please use 'replace' instead of "
-                            "'insert', or you can use 'insert' with explicit column listing.");
-                        static_assert(
-                            count_tuple<elements_type, is_column_with_noninsertable_primary_key>::value == 0,
-                            "Attempting to execute 'insert' request into an noninsertable table was detected. "
-                            "Insertable table cannot contain non-standard primary keys. Please use 'replace' instead "
-                            "of 'insert', or you can use 'insert' with explicit column listing.");
-                    })(tImpl);
-            }
-
-            template<class O>
-            auto& get_impl() const {
-                return this->impl.template get_impl<O>();
-            }
-
-            template<class O>
-            auto& get_impl() {
-                return this->impl.template get_impl<O>();
-            }
-
-          public:
-            template<class T, class... Args>
-            view_t<T, self, Args...> iterate(Args&&... args) {
-                this->assert_mapped_type<T>();
-
-                auto con = this->get_connection();
-                return {*this, std::move(con), std::forward<Args>(args)...};
-            }
-
-            /**
-             * Delete from routine.
-             * O is an object's type. Must be specified explicitly.
-             * @param args optional conditions: `where`, `join` etc
-             * @example: storage.remove_all<User>(); - DELETE FROM users
-             * @example: storage.remove_all<User>(where(in(&User::id, {5, 6, 7}))); - DELETE FROM users WHERE id IN (5, 6, 7)
-             */
-            template<class O, class... Args>
-            void remove_all(Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto statement = this->prepare(sqlite_orm::remove_all<O>(std::forward<Args>(args)...));
-                this->execute(statement);
-            }
-
-            /**
-             *  Delete routine.
-             *  O is an object's type. Must be specified explicitly.
-             *  @param ids ids of object to be removed.
-             */
-            template<class O, class... Ids>
-            void remove(Ids... ids) {
-                this->assert_mapped_type<O>();
-                auto statement = this->prepare(sqlite_orm::remove<O>(std::forward<Ids>(ids)...));
-                this->execute(statement);
-            }
-
-            /**
-             *  Update routine. Sets all non primary key fields where primary key is equal.
-             *  O is an object type. May be not specified explicitly cause it can be deduced by
-             *      compiler from first parameter.
-             *  @param o object to be updated.
-             */
-            template<class O>
-            void update(const O& o) {
-                this->assert_mapped_type<O>();
-                auto statement = this->prepare(sqlite_orm::update(std::ref(o)));
-                this->execute(statement);
-            }
-
-            template<class... Args, class... Wargs>
-            void update_all(internal::set_t<Args...> set, Wargs... wh) {
-                auto statement = this->prepare(sqlite_orm::update_all(std::move(set), std::forward<Wargs>(wh)...));
-                this->execute(statement);
-            }
-
-          protected:
-            template<class F, class O, class... Args>
-            std::string group_concat_internal(F O::*m, std::unique_ptr<std::string> y, Args&&... args) {
-                this->assert_mapped_type<O>();
-                std::vector<std::string> rows;
-                if(y) {
-                    rows = this->select(sqlite_orm::group_concat(m, move(*y)), std::forward<Args>(args)...);
-                } else {
-                    rows = this->select(sqlite_orm::group_concat(m), std::forward<Args>(args)...);
-                }
-                if(!rows.empty()) {
-                    return move(rows.front());
-                } else {
-                    return {};
-                }
-            }
-
-          public:
-            /**
-             *  SELECT * routine.
-             *  O is an object type to be extracted. Must be specified explicitly.
-             *  @return All objects of type O stored in database at the moment in `std::vector`.
-             *  @note If you need to return the result in a different container type then use a different `get_all` function overload `get_all<User, std::list<User>>`
-             *  @example: storage.get_all<User>() - SELECT * FROM users
-             *  @example: storage.get_all<User>(where(like(&User::name, "N%")), order_by(&User::id)); - SELECT * FROM users WHERE name LIKE 'N%' ORDER BY id
-             */
-            template<class O, class... Args>
-            auto get_all(Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto statement = this->prepare(sqlite_orm::get_all<O>(std::forward<Args>(args)...));
-                return this->execute(statement);
-            }
-
-            /**
-             *  SELECT * routine.
-             *  O is an object type to be extracted. Must be specified explicitly.
-             *  R is an explicit return type. This type must have `push_back(O &&)` function.
-             *  @return All objects of type O stored in database at the moment in `R`.
-             *  @example: storage.get_all<User, std::list<User>>(); - SELECT * FROM users
-             *  @example: storage.get_all<User, std::list<User>>(where(like(&User::name, "N%")), order_by(&User::id)); - SELECT * FROM users WHERE name LIKE 'N%' ORDER BY id
-            */
-            template<class O, class R, class... Args>
-            auto get_all(Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto statement = this->prepare(sqlite_orm::get_all<O, R>(std::forward<Args>(args)...));
-                return this->execute(statement);
-            }
-
-            /**
-             *  SELECT * routine.
-             *  O is an object type to be extracted. Must be specified explicitly.
-             *  @return All objects of type O as `std::unique_ptr<O>` inside a `std::vector` stored in database at the moment.
-             *  @note If you need to return the result in a different container type then use a different `get_all_pointer` function overload `get_all_pointer<User, std::list<User>>`
-             *  @example: storage.get_all_pointer<User>(); - SELECT * FROM users
-             *  @example: storage.get_all_pointer<User>(where(length(&User::name) > 6)); - SELECT * FROM users WHERE LENGTH(name)  > 6
-             */
-            template<class O, class... Args>
-            auto get_all_pointer(Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto statement = this->prepare(sqlite_orm::get_all_pointer<O>(std::forward<Args>(args)...));
-                return this->execute(statement);
-            }
-
-            /**
-             *  SELECT * routine.
-             *  O is an object type to be extracted. Must be specified explicitly.
-             *  R is a container type. std::vector<std::unique_ptr<O>> is default
-             *  @return All objects of type O as std::unique_ptr<O> stored in database at the moment.
-             *  @example: storage.get_all_pointer<User, std::list<User>>(); - SELECT * FROM users
-             *  @example: storage.get_all_pointer<User, std::list<User>>(where(length(&User::name) > 6)); - SELECT * FROM users WHERE LENGTH(name)  > 6
-            */
-            template<class O, class R, class... Args>
-            auto get_all_pointer(Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto statement = this->prepare(sqlite_orm::get_all_pointer<O, R>(std::forward<Args>(args)...));
-                return this->execute(statement);
-            }
-
-            /**
-             *  Select * by id routine.
-             *  throws std::system_error(orm_error_code::not_found, orm_error_category) if object not found with given
-             * id. throws std::system_error with orm_error_category in case of db error. O is an object type to be
-             * extracted. Must be specified explicitly.
-             *  @return Object of type O where id is equal parameter passed or throws
-             * `std::system_error(orm_error_code::not_found, orm_error_category)` if there is no object with such id.
-             */
-            template<class O, class... Ids>
-            O get(Ids... ids) {
-                this->assert_mapped_type<O>();
-                auto statement = this->prepare(sqlite_orm::get<O>(std::forward<Ids>(ids)...));
-                return this->execute(statement);
-            }
-
-            /**
-             *  The same as `get` function but doesn't throw an exception if noting found but returns std::unique_ptr
-             * with null value. throws std::system_error in case of db error.
-             */
-            template<class O, class... Ids>
-            std::unique_ptr<O> get_pointer(Ids... ids) {
-                this->assert_mapped_type<O>();
-                auto statement = this->prepare(sqlite_orm::get_pointer<O>(std::forward<Ids>(ids)...));
-                return this->execute(statement);
-            }
-
-            /**
-             * A previous version of get_pointer() that returns a shared_ptr
-             * instead of a unique_ptr. New code should prefer get_pointer()
-             * unless the data needs to be shared.
-             *
-             * @note
-             * Most scenarios don't need shared ownership of data, so we should prefer
-             * unique_ptr when possible. It's more efficient, doesn't require atomic
-             * ops for a reference count (which can cause major slowdowns on
-             * weakly-ordered platforms like ARM), and can be easily promoted to a
-             * shared_ptr, exactly like we're doing here.
-             * (Conversely, you _can't_ go from shared back to unique.)
-             */
-            template<class O, class... Ids>
-            std::shared_ptr<O> get_no_throw(Ids... ids) {
-                return std::shared_ptr<O>(get_pointer<O>(std::forward<Ids>(ids)...));
-            }
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-            /**
-             *  The same as `get` function but doesn't throw an exception if noting found but
-             * returns an empty std::optional. throws std::system_error in case of db error.
-             */
-            template<class O, class... Ids>
-            std::optional<O> get_optional(Ids... ids) {
-                this->assert_mapped_type<O>();
-                auto statement = this->prepare(sqlite_orm::get_optional<O>(std::forward<Ids>(ids)...));
-                return this->execute(statement);
-            }
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-            /**
-             *  SELECT COUNT(*) https://www.sqlite.org/lang_aggfunc.html#count
-             *  @return Number of O object in table.
-             */
-            template<class O, class... Args, class R = typename mapped_type_proxy<O>::type>
-            int count(Args&&... args) {
-                this->assert_mapped_type<R>();
-                auto rows = this->select(sqlite_orm::count<R>(), std::forward<Args>(args)...);
-                if(!rows.empty()) {
-                    return rows.front();
-                } else {
-                    return 0;
-                }
-            }
-
-            /**
-             *  SELECT COUNT(X) https://www.sqlite.org/lang_aggfunc.html#count
-             *  @param m member pointer to class mapped to the storage.
-             *  @return count of `m` values from database.
-             */
-            template<class F, class O, class... Args>
-            int count(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::count(m), std::forward<Args>(args)...);
-                if(!rows.empty()) {
-                    return rows.front();
-                } else {
-                    return 0;
-                }
-            }
-
-            /**
-             *  AVG(X) query.   https://www.sqlite.org/lang_aggfunc.html#avg
-             *  @param m is a class member pointer (the same you passed into make_column).
-             *  @return average value from database.
-             */
-            template<class F, class O, class... Args>
-            double avg(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::avg(m), std::forward<Args>(args)...);
-                if(!rows.empty()) {
-                    return rows.front();
-                } else {
-                    return 0;
-                }
-            }
-
-            template<class F, class O>
-            std::string group_concat(F O::*m) {
-                return this->group_concat_internal(m, {});
-            }
-
-            /**
-             *  GROUP_CONCAT(X) query.  https://www.sqlite.org/lang_aggfunc.html#groupconcat
-             *  @param m is a class member pointer (the same you passed into make_column).
-             *  @return group_concat query result.
-             */
-            template<class F,
-                     class O,
-                     class... Args,
-                     class Tuple = std::tuple<Args...>,
-                     typename sfinae = typename std::enable_if<std::tuple_size<Tuple>::value >= 1>::type>
-            std::string group_concat(F O::*m, Args&&... args) {
-                return this->group_concat_internal(m, {}, std::forward<Args>(args)...);
-            }
-
-            /**
-             *  GROUP_CONCAT(X, Y) query.   https://www.sqlite.org/lang_aggfunc.html#groupconcat
-             *  @param m is a class member pointer (the same you passed into make_column).
-             *  @return group_concat query result.
-             */
-            template<class F, class O, class... Args>
-            std::string group_concat(F O::*m, std::string y, Args&&... args) {
-                return this->group_concat_internal(m,
-                                                   std::make_unique<std::string>(move(y)),
-                                                   std::forward<Args>(args)...);
-            }
-
-            template<class F, class O, class... Args>
-            std::string group_concat(F O::*m, const char* y, Args&&... args) {
-                std::unique_ptr<std::string> str;
-                if(y) {
-                    str = std::make_unique<std::string>(y);
-                } else {
-                    str = std::make_unique<std::string>();
-                }
-                return this->group_concat_internal(m, move(str), std::forward<Args>(args)...);
-            }
-
-            /**
-             *  MAX(x) query.
-             *  @param m is a class member pointer (the same you passed into make_column).
-             *  @return std::unique_ptr with max value or null if sqlite engine returned null.
-             */
-            template<class F, class O, class... Args, class Ret = typename column_result_t<self, F O::*>::type>
-            std::unique_ptr<Ret> max(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::max(m), std::forward<Args>(args)...);
-                if(!rows.empty()) {
-                    return std::move(rows.front());
-                } else {
-                    return {};
-                }
-            }
-
-            /**
-             *  MIN(x) query.
-             *  @param m is a class member pointer (the same you passed into make_column).
-             *  @return std::unique_ptr with min value or null if sqlite engine returned null.
-             */
-            template<class F, class O, class... Args, class Ret = typename column_result_t<self, F O::*>::type>
-            std::unique_ptr<Ret> min(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::min(m), std::forward<Args>(args)...);
-                if(!rows.empty()) {
-                    return std::move(rows.front());
-                } else {
-                    return {};
-                }
-            }
-
-            /**
-             *  SUM(x) query.
-             *  @param m is a class member pointer (the same you passed into make_column).
-             *  @return std::unique_ptr with sum value or null if sqlite engine returned null.
-             */
-            template<class F, class O, class... Args, class Ret = typename column_result_t<self, F O::*>::type>
-            std::unique_ptr<Ret> sum(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                std::vector<std::unique_ptr<double>> rows =
-                    this->select(sqlite_orm::sum(m), std::forward<Args>(args)...);
-                if(!rows.empty()) {
-                    if(rows.front()) {
-                        return std::make_unique<Ret>(std::move(*rows.front()));
-                    } else {
-                        return {};
-                    }
-                } else {
-                    return {};
-                }
-            }
-
-            /**
-             *  TOTAL(x) query.
-             *  @param m is a class member pointer (the same you passed into make_column).
-             *  @return total value (the same as SUM but not nullable. More details here
-             * https://www.sqlite.org/lang_aggfunc.html)
-             */
-            template<class F, class O, class... Args>
-            double total(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::total(m), std::forward<Args>(args)...);
-                if(!rows.empty()) {
-                    return std::move(rows.front());
-                } else {
-                    return {};
-                }
-            }
-
-            /**
-             *  Select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
-             *  For a single column use `auto rows = storage.select(&User::id, where(...));
-             *  For multicolumns use `auto rows = storage.select(columns(&User::id, &User::name), where(...));
-             */
-            template<class T, class... Args, class R = typename column_result_t<self, T>::type>
-            std::vector<R> select(T m, Args... args) {
-                static_assert(!is_base_of_template<T, compound_operator>::value ||
-                                  std::tuple_size<std::tuple<Args...>>::value == 0,
-                              "Cannot use args with a compound operator");
-                auto statement = this->prepare(sqlite_orm::select(std::move(m), std::forward<Args>(args)...));
-                return this->execute(statement);
-            }
-
-            template<class T>
-            typename std::enable_if<is_prepared_statement<T>::value, std::string>::type
-            dump(const T& preparedStatement) const {
-                using context_t = serializator_context<impl_type>;
-                context_t context{this->impl};
-                return serialize(preparedStatement.expression, context);
-            }
-
-            /**
-             *  Returns a string representation of object of a class mapped to the storage.
-             *  Type of string has json-like style.
-             */
-            template<class O>
-            typename std::enable_if<storage_traits::type_is_mapped<self, O>::value, std::string>::type
-            dump(const O& o) {
-                auto& tImpl = this->get_impl<O>();
-                std::stringstream ss;
-                ss << "{ ";
-                using pair = std::pair<std::string, std::string>;
-                std::vector<pair> pairs;
-                tImpl.table.for_each_column([&pairs, &o](auto& c) {
-                    using column_type = typename std::decay<decltype(c)>::type;
-                    using field_type = typename column_type::field_type;
-                    pair p{c.name, std::string()};
-                    if(c.member_pointer) {
-                        p.second = field_printer<field_type>()(o.*c.member_pointer);
-                    } else {
-                        using getter_type = typename column_type::getter_type;
-                        field_value_holder<getter_type> valueHolder{((o).*(c.getter))()};
-                        p.second = field_printer<field_type>()(valueHolder.value);
-                    }
-                    pairs.push_back(move(p));
-                });
-                for(size_t i = 0; i < pairs.size(); ++i) {
-                    auto& p = pairs[i];
-                    ss << p.first << " : '" << p.second << "'";
-                    if(i < pairs.size() - 1) {
-                        ss << ", ";
-                    } else {
-                        ss << " }";
-                    }
-                }
-                return ss.str();
-            }
-
-            /**
-             *  This is REPLACE (INSERT OR REPLACE) function.
-             *  Also if you need to insert value with knows id you should
-             *  also you this function instead of insert cause inserts ignores
-             *  id and creates own one.
-             */
-            template<class O>
-            void replace(const O& o) {
-                this->assert_mapped_type<O>();
-                auto statement = this->prepare(sqlite_orm::replace(std::ref(o)));
-                this->execute(statement);
-            }
-
-            template<class It>
-            void replace_range(It from, It to) {
-                using O = typename std::iterator_traits<It>::value_type;
-                this->assert_mapped_type<O>();
-                if(from == to) {
-                    return;
-                }
-
-                auto statement = this->prepare(sqlite_orm::replace_range(from, to));
-                this->execute(statement);
-            }
-
-            template<class T, class It, class L>
-            void replace_range(It from, It to, L transformer) {
-                this->assert_mapped_type<T>();
-                if(from == to) {
-                    return;
-                }
-
-                auto statement = this->prepare(sqlite_orm::replace_range<T>(from, to, std::move(transformer)));
-                this->execute(statement);
-            }
-
-            template<class O, class... Cols>
-            int insert(const O& o, columns_t<Cols...> cols) {
-                constexpr const size_t colsCount = std::tuple_size<std::tuple<Cols...>>::value;
-                static_assert(colsCount > 0, "Use insert or replace with 1 argument instead");
-                this->assert_mapped_type<O>();
-                auto statement = this->prepare(sqlite_orm::insert(std::ref(o), std::move(cols)));
-                return int(this->execute(statement));
-            }
-
-            /**
-             *  Insert routine. Inserts object with all non primary key fields in passed object. Id of passed
-             *  object doesn't matter.
-             *  @return id of just created object.
-             */
-            template<class O>
-            int insert(const O& o) {
-                this->assert_mapped_type<O>();
-                this->assert_insertable_type<O>();
-
-                return call_insert_impl_and_catch_constraint_failed([this, &o]() {
-                    auto statement = this->prepare(sqlite_orm::insert(std::ref(o)));
-                    return int(this->execute(statement));
-                });
-            }
-
-            /**
-             *  Raw insert routine. Use this if `insert` with object does not fit you. This insert is designed to be able
-             *  to call any type of `INSERT` query with no limitations.
-             *  @example
-             *  ```sql
-             *  INSERT INTO users (id, name) VALUES(5, 'Little Mix')
-             *  ```
-             *  will be
-             *  ```c++
-             *  storage.insert(into<User>, columns(&User::id, &User::name), values(std::make_tuple(5, "Little Mix")));
-             *  ```
-             *  One more example:
-             *  ```sql
-             *  INSERT INTO singers (name) VALUES ('Sofia Reyes')('Kungs')
-             *  ```
-             *  will be
-             *  ```c++
-             *  storage.insert(into<Singer>(), columns(&Singer::name), values(std::make_tuple("Sofia Reyes"), std::make_tuple("Kungs")));
-             *  ```
-             *  One can use `default_values` to add `DEFAULT VALUES` modifier:
-             *  ```sql
-             *  INSERT INTO users DEFAULT VALUES
-             *  ```
-             *  will be
-             *  ```c++
-             *  storage.insert(into<Singer>(), default_values());
-             *  ```
-             *  Also one can use `INSERT OR ABORT`/`INSERT OR FAIL`/`INSERT OR IGNORE`/`INSERT OR REPLACE`/`INSERT ROLLBACK`:
-             *  ```c++
-             *  storage.insert(or_ignore(), into<Singer>(), columns(&Singer::name), values(std::make_tuple("Sofia Reyes"), std::make_tuple("Kungs")));
-             *  storage.insert(or_rollback(), into<Singer>(), default_values());
-             *  storage.insert(or_abort(), into<User>, columns(&User::id, &User::name), values(std::make_tuple(5, "Little Mix")));
-             *  ```
-             */
-            template<class... Args>
-            void insert(Args... args) {
-                auto statement = this->prepare(sqlite_orm::insert(std::forward<Args>(args)...));
-                this->execute(statement);
-            }
-
-            /**
-             *  Raw replace statement creation routine. Use this if `replace` with object does not fit you. This replace is designed to be able
-             *  to call any type of `REPLACE` query with no limitations. Actually this is the same query as raw insert except `OR...` option existance.
-             *  @example
-             *  ```sql
-             *  REPLACE INTO users (id, name) VALUES(5, 'Little Mix')
-             *  ```
-             *  will be
-             *  ```c++
-             *  storage.prepare(replace(into<User>, columns(&User::id, &User::name), values(std::make_tuple(5, "Little Mix"))));
-             *  ```
-             *  One more example:
-             *  ```sql
-             *  REPLACE INTO singers (name) VALUES ('Sofia Reyes')('Kungs')
-             *  ```
-             *  will be
-             *  ```c++
-             *  storage.prepare(replace(into<Singer>(), columns(&Singer::name), values(std::make_tuple("Sofia Reyes"), std::make_tuple("Kungs"))));
-             *  ```
-             *  One can use `default_values` to add `DEFAULT VALUES` modifier:
-             *  ```sql
-             *  REPLACE INTO users DEFAULT VALUES
-             *  ```
-             *  will be
-             *  ```c++
-             *  storage.prepare(replace(into<Singer>(), default_values()));
-             *  ```
-             */
-            template<class... Args>
-            void replace(Args... args) {
-                auto statement = this->prepare(sqlite_orm::replace(std::forward<Args>(args)...));
-                this->execute(statement);
-            }
-
-            template<class It>
-            void insert_range(It from, It to) {
-                using O = typename std::iterator_traits<It>::value_type;
-                this->assert_mapped_type<O>();
-                this->assert_insertable_type<O>();
-                if(from == to) {
-                    return;
-                }
-
-                call_insert_impl_and_catch_constraint_failed([this, from, to]() {
-                    auto statement = this->prepare(sqlite_orm::insert_range(from, to));
-                    this->execute(statement);
-                });
-            }
-
-            template<class T, class It, class L>
-            void insert_range(It from, It to, L transformer) {
-                this->assert_mapped_type<T>();
-                this->assert_insertable_type<T>();
-                if(from == to) {
-                    return;
-                }
-                call_insert_impl_and_catch_constraint_failed([this, from, to, transformer = std::move(transformer)]() {
-                    auto statement = this->prepare(sqlite_orm::insert_range<T>(from, to, std::move(transformer)));
-                    this->execute(statement);
-                });
-            }
-
-            /**
-             * Change table name inside storage's schema info. This function does not
-             * affect database
-             */
-            template<class O>
-            void rename_table(std::string name) {
-                this->assert_mapped_type<O>();
-                auto& tImpl = this->get_impl<O>();
-                tImpl.table.name = move(name);
-            }
-
-            using storage_base::rename_table;
-
-            /**
-             * Get table's name stored in storage's schema info. This function does not call
-             * any SQLite queries
-             */
-            template<class O>
-            const std::string& tablename() const {
-                this->assert_mapped_type<O>();
-                auto& tImpl = this->get_impl<O>();
-                return tImpl.table.name;
-            }
-
-            template<class F, class O>
-            const std::string* column_name(F O::*memberPointer) const {
-                return this->impl.column_name(memberPointer);
-            }
-
-          protected:
-            template<class... Tss, class... Cols>
-            sync_schema_result schema_status(const storage_impl<index_t<Cols...>, Tss...>&, sqlite3*, bool) {
-                return sync_schema_result::already_in_sync;
-            }
-
-            template<class T, bool WithoutRowId, class... Cs, class... Tss>
-            sync_schema_result schema_status(const storage_impl<table_t<T, WithoutRowId, Cs...>, Tss...>& tImpl,
-                                             sqlite3* db,
-                                             bool preserve) {
-                return tImpl.schema_status(db, preserve);
-            }
-
-            template<class... Tss, class... Cols>
-            sync_schema_result sync_table(const storage_impl<index_t<Cols...>, Tss...>& tableImpl, sqlite3* db, bool) {
-                auto res = sync_schema_result::already_in_sync;
-                using context_t = serializator_context<impl_type>;
-                context_t context{this->impl};
-                auto query = serialize(tableImpl.table, context);
-                perform_void_exec(db, query);
-                return res;
-            }
-
-            template<class T, bool WithoutRowId, class... Args, class... Tss>
-            sync_schema_result sync_table(const storage_impl<table_t<T, WithoutRowId, Args...>, Tss...>& tImpl,
-                                          sqlite3* db,
-                                          bool preserve) {
-                auto res = sync_schema_result::already_in_sync;
-
-                auto schema_stat = tImpl.schema_status(db, preserve);
-                if(schema_stat != decltype(schema_stat)::already_in_sync) {
-                    if(schema_stat == decltype(schema_stat)::new_table_created) {
-                        this->create_table(db, tImpl.table.name, tImpl);
-                        res = decltype(res)::new_table_created;
-                    } else {
-                        if(schema_stat == sync_schema_result::old_columns_removed ||
-                           schema_stat == sync_schema_result::new_columns_added ||
-                           schema_stat == sync_schema_result::new_columns_added_and_old_columns_removed) {
-
-                            //  get table info provided in `make_table` call..
-                            auto storageTableInfo = tImpl.table.get_table_info();
-
-                            //  now get current table info from db using `PRAGMA table_info` query..
-                            auto dbTableInfo = tImpl.get_table_info(tImpl.table.name, db);
-
-                            //  this vector will contain pointers to columns that gotta be added..
-                            std::vector<table_info*> columnsToAdd;
-
-                            tImpl.calculate_remove_add_columns(columnsToAdd, storageTableInfo, dbTableInfo);
-
-                            if(schema_stat == sync_schema_result::old_columns_removed) {
-#if SQLITE_VERSION_NUMBER >= 3035000  //  DROP COLUMN feature exists (v3.35.0)
-                                for(auto& tableInfo: dbTableInfo) {
-                                    this->drop_column(db, tImpl.table.name, tableInfo.name);
-                                }
-                                res = decltype(res)::old_columns_removed;
-#else
-                                    //  extra table columns than storage columns
-                                    this->backup_table(db, tImpl, {});
-                                    res = decltype(res)::old_columns_removed;
-#endif
-                            }
-
-                            if(schema_stat == sync_schema_result::new_columns_added) {
-                                for(auto columnPointer: columnsToAdd) {
-                                    tImpl.table.for_each_column([this, columnPointer, &tImpl, db](auto& column) {
-                                        if(column.name != columnPointer->name) {
-                                            return;
-                                        }
-                                        this->add_column(tImpl.table.name, column, db);
-                                    });
-                                }
-                                res = decltype(res)::new_columns_added;
-                            }
-
-                            if(schema_stat == sync_schema_result::new_columns_added_and_old_columns_removed) {
-
-                                // remove extra columns
-                                this->backup_table(db, tImpl, columnsToAdd);
-                                res = decltype(res)::new_columns_added_and_old_columns_removed;
-                            }
-                        } else if(schema_stat == sync_schema_result::dropped_and_recreated) {
-                            this->drop_table_internal(tImpl.table.name, db);
-                            this->create_table(db, tImpl.table.name, tImpl);
-                            res = decltype(res)::dropped_and_recreated;
-                        }
-                    }
-                }
-                return res;
-            }
-
-            template<class C>
-            void add_column(const std::string& tableName, const C& column, sqlite3* db) const {
-                std::stringstream ss;
-                ss << "ALTER TABLE " << tableName << " ADD COLUMN ";
-                using context_t = serializator_context<impl_type>;
-                context_t context{this->impl};
-                ss << serialize(column, context);
-                perform_void_exec(db, ss.str());
-            }
-
-            template<typename S>
-            prepared_statement_t<S> prepare_impl(S statement) {
-                auto con = this->get_connection();
-                sqlite3_stmt* stmt;
-                auto db = con.get();
-                using context_t = serializator_context<impl_type>;
-                context_t context{this->impl};
-                context.skip_table_name = false;
-                context.replace_bindable_with_question = true;
-                auto query = serialize(statement, context);
-                if(sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) == SQLITE_OK) {
-                    return prepared_statement_t<S>{std::forward<S>(statement), stmt, con};
-                } else {
-                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                            sqlite3_errmsg(db));
-                }
-            }
-
-          public:
-            /**
-             *  This is a cute function used to replace migration up/down functionality.
-             *  It performs check storage schema with actual db schema and:
-             *  * if there are excess tables exist in db they are ignored (not dropped)
-             *  * every table from storage is compared with it's db analog and
-             *      * if table doesn't exist it is being created
-             *      * if table exists its colums are being compared with table_info from db and
-             *          * if there are columns in db that do not exist in storage (excess) table will be dropped and
-             * recreated
-             *          * if there are columns in storage that do not exist in db they will be added using `ALTER TABLE
-             * ... ADD COLUMN ...' command
-             *          * if there is any column existing in both db and storage but differs by any of
-             * properties/constraints (pk, notnull, dflt_value) table will be dropped and recreated. Be aware that
-             * `sync_schema` doesn't guarantee that data will not be dropped. It guarantees only that it will make db
-             * schema the same as you specified in `make_storage` function call. A good point is that if you have no db
-             * file at all it will be created and all tables also will be created with exact tables and columns you
-             * specified in `make_storage`, `make_table` and `make_column` calls. The best practice is to call this
-             * function right after storage creation.
-             *  @param preserve affects function's behaviour in case it is needed to remove a column. If it is `false`
-             * so table will be dropped if there is column to remove if SQLite version is < 3.35.0 and rmeove column if SQLite version >= 3.35.0,
-             * if `true` -  table is being copied into another table, dropped and copied table is renamed with source table name.
-             * Warning: sync_schema doesn't check foreign keys cause it is unable to do so in sqlite3. If you know how to get foreign key info please
-             * submit an issue https://github.com/fnc12/sqlite_orm/issues
-             *  @return std::map with std::string key equal table name and `sync_schema_result` as value.
-             * `sync_schema_result` is a enum value that stores table state after syncing a schema. `sync_schema_result`
-             * can be printed out on std::ostream with `operator<<`.
-             */
-            std::map<std::string, sync_schema_result> sync_schema(bool preserve = false) {
-                auto con = this->get_connection();
-                std::map<std::string, sync_schema_result> result;
-                auto db = con.get();
-                this->impl.for_each([&result, db, preserve, this](auto& storageImpl) {
-                    auto res = this->sync_table(storageImpl, db, preserve);
-                    result.insert({storageImpl.table.name, res});
-                });
-                return result;
-            }
-
-            /**
-             *  This function returns the same map that `sync_schema` returns but it
-             *  doesn't perform `sync_schema` actually - just simulates it in case you want to know
-             *  what will happen if you sync your schema.
-             */
-            std::map<std::string, sync_schema_result> sync_schema_simulate(bool preserve = false) {
-                auto con = this->get_connection();
-                std::map<std::string, sync_schema_result> result;
-                auto db = con.get();
-                this->impl.for_each([&result, db, preserve, this](auto& tableImpl) {
-                    auto schemaStatus = this->schema_status(tableImpl, db, preserve);
-                    result.insert({tableImpl.table.name, schemaStatus});
-                });
-                return result;
-            }
-
-            /**
-             *  Checks whether table exists in db. Doesn't check storage itself - works only with actual database.
-             *  Note: table can be not mapped to a storage
-             *  @return true if table with a given name exists in db, false otherwise.
-             */
-            bool table_exists(const std::string& tableName) {
-                auto con = this->get_connection();
-                return this->impl.table_exists(tableName, con.get());
-            }
-
-            template<class T, class... Args>
-            prepared_statement_t<select_t<T, Args...>> prepare(select_t<T, Args...> sel) {
-                sel.highest_level = true;
-                return prepare_impl<select_t<T, Args...>>(std::move(sel));
-            }
-
-            template<class T, class... Args>
-            prepared_statement_t<get_all_t<T, Args...>> prepare(get_all_t<T, Args...> get_) {
-                return prepare_impl<get_all_t<T, Args...>>(std::move(get_));
-            }
-
-            template<class T, class... Args>
-            prepared_statement_t<get_all_pointer_t<T, Args...>> prepare(get_all_pointer_t<T, Args...> get_) {
-                return prepare_impl<get_all_pointer_t<T, Args...>>(std::move(get_));
-            }
-
-            template<class... Args>
-            prepared_statement_t<replace_raw_t<Args...>> prepare(replace_raw_t<Args...> ins) {
-                return prepare_impl<replace_raw_t<Args...>>(std::move(ins));
-            }
-
-            template<class... Args>
-            prepared_statement_t<insert_raw_t<Args...>> prepare(insert_raw_t<Args...> ins) {
-                return prepare_impl<insert_raw_t<Args...>>(std::move(ins));
-            }
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-            template<class T, class R, class... Args>
-            prepared_statement_t<get_all_optional_t<T, R, Args...>> prepare(get_all_optional_t<T, R, Args...> get_) {
-                return prepare_impl<get_all_optional_t<T, R, Args...>>(std::move(get_));
-            }
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-            template<class... Args, class... Wargs>
-            prepared_statement_t<update_all_t<set_t<Args...>, Wargs...>>
-            prepare(update_all_t<set_t<Args...>, Wargs...> upd) {
-                return prepare_impl<update_all_t<set_t<Args...>, Wargs...>>(std::move(upd));
-            }
-
-            template<class T, class... Args>
-            prepared_statement_t<remove_all_t<T, Args...>> prepare(remove_all_t<T, Args...> rem) {
-                return prepare_impl<remove_all_t<T, Args...>>(std::move(rem));
-            }
-
-            template<class T, class... Ids>
-            prepared_statement_t<get_t<T, Ids...>> prepare(get_t<T, Ids...> get_) {
-                return prepare_impl<get_t<T, Ids...>>(std::move(get_));
-            }
-
-            template<class T, class... Ids>
-            prepared_statement_t<get_pointer_t<T, Ids...>> prepare(get_pointer_t<T, Ids...> get_) {
-                return prepare_impl<get_pointer_t<T, Ids...>>(std::move(get_));
-            }
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-            template<class T, class... Ids>
-            prepared_statement_t<get_optional_t<T, Ids...>> prepare(get_optional_t<T, Ids...> get_) {
-                return prepare_impl<get_optional_t<T, Ids...>>(std::move(get_));
-            }
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-            template<class T>
-            prepared_statement_t<update_t<T>> prepare(update_t<T> upd) {
-                return prepare_impl<update_t<T>>(std::move(upd));
-            }
-
-            template<class T, class... Ids>
-            prepared_statement_t<remove_t<T, Ids...>> prepare(remove_t<T, Ids...> rem) {
-                return prepare_impl<remove_t<T, Ids...>>(std::move(rem));
-            }
-
-            template<class T>
-            prepared_statement_t<insert_t<T>> prepare(insert_t<T> ins) {
-                using object_type = typename expression_object_type<decltype(ins)>::type;
-                this->assert_mapped_type<object_type>();
-                this->assert_insertable_type<object_type>();
-                return prepare_impl<insert_t<T>>(std::move(ins));
-            }
-
-            template<class T>
-            prepared_statement_t<replace_t<T>> prepare(replace_t<T> rep) {
-                using object_type = typename expression_object_type<decltype(rep)>::type;
-                this->assert_mapped_type<object_type>();
-                return prepare_impl<replace_t<T>>(std::move(rep));
-            }
-
-            template<class It, class L, class O>
-            prepared_statement_t<insert_range_t<It, L, O>> prepare(insert_range_t<It, L, O> statement) {
-                using object_type = typename expression_object_type<decltype(statement)>::type;
-                this->assert_mapped_type<object_type>();
-                this->assert_insertable_type<object_type>();
-                return prepare_impl<insert_range_t<It, L, O>>(std::move(statement));
-            }
-
-            template<class It, class L, class O>
-            prepared_statement_t<replace_range_t<It, L, O>> prepare(replace_range_t<It, L, O> rep) {
-                return prepare_impl<replace_range_t<It, L, O>>(std::move(rep));
-            }
-
-            template<class T, class... Cols>
-            prepared_statement_t<insert_explicit<T, Cols...>> prepare(insert_explicit<T, Cols...> ins) {
-                using object_type = typename expression_object_type<decltype(ins)>::type;
-                this->assert_mapped_type<object_type>();
-                return prepare_impl<insert_explicit<T, Cols...>>(std::move(ins));
-            }
-
-            template<class... Args>
-            void execute(const prepared_statement_t<replace_raw_t<Args...>>& statement) {
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                sqlite3_reset(stmt);
-                auto index = 1;
-                iterate_ast(statement.expression.args, [stmt, &index, db](auto& node) {
-                    using node_type = typename std::decay<decltype(node)>::type;
-                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
-                    if(SQLITE_OK != binder(node)) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                });
-                perform_step(db, stmt);
-            }
-
-            template<class... Args>
-            void execute(const prepared_statement_t<insert_raw_t<Args...>>& statement) {
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                sqlite3_reset(stmt);
-                auto index = 1;
-                iterate_ast(statement.expression.args, [stmt, &index, db](auto& node) {
-                    using node_type = typename std::decay<decltype(node)>::type;
-                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
-                    if(SQLITE_OK != binder(node)) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                });
-                perform_step(db, stmt);
-            }
-
-            template<class T, class... Cols>
-            int64 execute(const prepared_statement_t<insert_explicit<T, Cols...>>& statement) {
-                using statement_type = typename std::decay<decltype(statement)>::type;
-                using expression_type = typename statement_type::expression_type;
-                using object_type = typename expression_object_type<expression_type>::type;
-                auto index = 1;
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                auto& tImpl = this->get_impl<object_type>();
-                auto& o = statement.expression.obj;
-                sqlite3_reset(stmt);
-                iterate_tuple(statement.expression.columns.columns, [&o, &index, &stmt, &tImpl, db](auto& m) {
-                    using column_type = typename std::decay<decltype(m)>::type;
-                    using field_type = typename column_result_t<self, column_type>::type;
-                    const field_type* value = tImpl.table.template get_object_field_pointer<field_type>(o, m);
-                    if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, *value)) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                });
-                perform_step(db, stmt);
-                return sqlite3_last_insert_rowid(db);
-            }
-
-            template<class T,
-                     typename std::enable_if<(is_replace_range<T>::value || is_replace<T>::value)>::type* = nullptr>
-            void execute(const prepared_statement_t<T>& statement) {
-                using statement_type = typename std::decay<decltype(statement)>::type;
-                using expression_type = typename statement_type::expression_type;
-                using object_type = typename expression_object_type<expression_type>::type;
-                auto& tImpl = this->get_impl<object_type>();
-                auto index = 1;
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                sqlite3_reset(stmt);
-
-                auto processObject = [&index, &stmt, &tImpl, db](auto& object) {
-                    tImpl.table.for_each_column([&index, stmt, &object, db](auto& column) {
-                        if(column.is_generated()) {
-                            return;
-                        }
-                        using column_type = typename std::decay<decltype(column)>::type;
-                        using field_type = typename column_type::field_type;
-                        if(column.member_pointer) {
-                            if(SQLITE_OK !=
-                               statement_binder<field_type>().bind(stmt, index++, object.*column.member_pointer)) {
-                                throw std::system_error(
-                                    std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                    sqlite3_errmsg(db));
-                            }
-                        } else {
-                            using getter_type = typename column_type::getter_type;
-                            field_value_holder<getter_type> valueHolder{((object).*(column.getter))()};
-                            if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, valueHolder.value)) {
-                                throw std::system_error(
-                                    std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                    sqlite3_errmsg(db));
-                            }
-                        }
-                    });
-                };
-
-                static_if<is_replace_range<T>{}>(
-                    [&processObject](auto& statement) {
-                        auto& transformer = statement.expression.transformer;
-                        std::for_each(  ///
-                            statement.expression.range.first,
-                            statement.expression.range.second,
-                            [&processObject, &transformer](auto& object) {
-                                auto& realObject = transformer(object);
-                                processObject(realObject);
-                            });
-                    },
-                    [&processObject](auto& statement) {
-                        auto& o = get_object(statement.expression);
-                        processObject(o);
-                    })(statement);
-                perform_step(db, stmt);
-            }
-
-            template<class T,
-                     typename std::enable_if<(is_insert_range<T>::value || is_insert<T>::value)>::type* = nullptr>
-            int64 execute(const prepared_statement_t<T>& statement) {
-                using statement_type = typename std::decay<decltype(statement)>::type;
-                using expression_type = typename statement_type::expression_type;
-                using object_type = typename expression_object_type<expression_type>::type;
-                auto index = 1;
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                auto& tImpl = this->get_impl<object_type>();
-                sqlite3_reset(stmt);
-                auto processObject = [&index, stmt, &tImpl, db](auto& object) {
-                    tImpl.table.for_each_column([&tImpl, &index, &object, db, stmt](auto& column) {
-                        using table_type = typename std::decay<decltype(tImpl.table)>::type;
-                        if(table_type::is_without_rowid ||
-                           (!column.template has<primary_key_t<>>() &&
-                            !tImpl.table.exists_in_composite_primary_key(column) && !column.is_generated())) {
-                            using column_type = typename std::decay<decltype(column)>::type;
-                            using field_type = typename column_type::field_type;
-                            if(column.member_pointer) {
-                                if(SQLITE_OK !=
-                                   statement_binder<field_type>().bind(stmt, index++, object.*column.member_pointer)) {
-                                    throw std::system_error(
-                                        std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                        sqlite3_errmsg(db));
-                                }
-                            } else {
-                                using getter_type = typename column_type::getter_type;
-                                field_value_holder<getter_type> valueHolder{((object).*(column.getter))()};
-                                if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, valueHolder.value)) {
-                                    throw std::system_error(
-                                        std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                        sqlite3_errmsg(db));
-                                }
-                            }
-                        }
-                    });
-                };
-
-                static_if<is_insert_range<T>{}>(
-                    [&processObject](auto& statement) {
-                        auto& transformer = statement.expression.transformer;
-                        std::for_each(  ///
-                            statement.expression.range.first,
-                            statement.expression.range.second,
-                            [&processObject, &transformer](auto& object) {
-                                auto& realObject = transformer(object);
-                                processObject(realObject);
-                            });
-                    },
-                    [&processObject](auto& statement) {
-                        auto& o = get_object(statement.expression);
-                        processObject(o);
-                    })(statement);
-
-                perform_step(db, stmt);
-                return sqlite3_last_insert_rowid(db);
-            }
-
-            template<class T, class... Ids>
-            void execute(const prepared_statement_t<remove_t<T, Ids...>>& statement) {
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                auto index = 1;
-                sqlite3_reset(stmt);
-                iterate_ast(statement.expression.ids, [stmt, &index, db](auto& v) {
-                    using field_type = typename std::decay<decltype(v)>::type;
-                    if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, v)) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                });
-                perform_step(db, stmt);
-            }
-
-            template<class T>
-            void execute(const prepared_statement_t<update_t<T>>& statement) {
-                using statement_type = typename std::decay<decltype(statement)>::type;
-                using expression_type = typename statement_type::expression_type;
-                using object_type = typename expression_object_type<expression_type>::type;
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto& tImpl = this->get_impl<object_type>();
-                auto stmt = statement.stmt;
-                auto index = 1;
-                auto& o = get_object(statement.expression);
-                sqlite3_reset(stmt);
-                tImpl.table.for_each_column([&o, stmt, &index, db, &tImpl](auto& column) {
-                    if(!column.template has<primary_key_t<>>() &&
-                       !tImpl.table.exists_in_composite_primary_key(column)) {
-                        using column_type = typename std::decay<decltype(column)>::type;
-                        using field_type = typename column_type::field_type;
-                        if(column.member_pointer) {
-                            auto bind_res =
-                                statement_binder<field_type>().bind(stmt, index++, o.*column.member_pointer);
-                            if(SQLITE_OK != bind_res) {
-                                throw std::system_error(
-                                    std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                    sqlite3_errmsg(db));
-                            }
-                        } else {
-                            using getter_type = typename column_type::getter_type;
-                            field_value_holder<getter_type> valueHolder{((o).*(column.getter))()};
-                            if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, valueHolder.value)) {
-                                throw std::system_error(
-                                    std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                    sqlite3_errmsg(db));
-                            }
-                        }
-                    }
-                });
-                tImpl.table.for_each_column([&o, stmt, &index, db, &tImpl](auto& column) {
-                    if(column.template has<primary_key_t<>>() || tImpl.table.exists_in_composite_primary_key(column)) {
-                        using column_type = typename std::decay<decltype(column)>::type;
-                        using field_type = typename column_type::field_type;
-                        if(column.member_pointer) {
-                            if(SQLITE_OK !=
-                               statement_binder<field_type>().bind(stmt, index++, o.*column.member_pointer)) {
-                                throw std::system_error(
-                                    std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                    sqlite3_errmsg(db));
-                            }
-                        } else {
-                            using getter_type = typename column_type::getter_type;
-                            field_value_holder<getter_type> valueHolder{((o).*(column.getter))()};
-                            if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, valueHolder.value)) {
-                                throw std::system_error(
-                                    std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                    sqlite3_errmsg(db));
-                            }
-                        }
-                    }
-                });
-                perform_step(db, stmt);
-            }
-
-            template<class T, class... Ids>
-            std::unique_ptr<T> execute(const prepared_statement_t<get_pointer_t<T, Ids...>>& statement) {
-                auto& tImpl = this->get_impl<T>();
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                auto index = 1;
-                sqlite3_reset(stmt);
-                iterate_ast(statement.expression.ids, [stmt, &index, db](auto& v) {
-                    using field_type = typename std::decay<decltype(v)>::type;
-                    if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, v)) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                });
-                auto stepRes = sqlite3_step(stmt);
-                switch(stepRes) {
-                    case SQLITE_ROW: {
-                        auto res = std::make_unique<T>();
-                        object_from_column_builder<T> builder{*res, stmt};
-                        tImpl.table.for_each_column(builder);
-                        return res;
-                    } break;
-                    case SQLITE_DONE: {
-                        return {};
-                    } break;
-                    default: {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                }
-            }
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-            template<class T, class... Ids>
-            std::optional<T> execute(const prepared_statement_t<get_optional_t<T, Ids...>>& statement) {
-                auto& tImpl = this->get_impl<T>();
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                auto index = 1;
-                sqlite3_reset(stmt);
-                iterate_ast(statement.expression.ids, [stmt, &index, db](auto& v) {
-                    using field_type = typename std::decay<decltype(v)>::type;
-                    if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, v)) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                });
-                auto stepRes = sqlite3_step(stmt);
-                switch(stepRes) {
-                    case SQLITE_ROW: {
-                        auto res = std::make_optional<T>();
-                        object_from_column_builder<T> builder{res.value(), stmt};
-                        tImpl.table.for_each_column(builder);
-                        return res;
-                    } break;
-                    case SQLITE_DONE: {
-                        return {};
-                    } break;
-                    default: {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                }
-            }
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-            template<class T, class... Ids>
-            T execute(const prepared_statement_t<get_t<T, Ids...>>& statement) {
-                auto& tImpl = this->get_impl<T>();
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                auto index = 1;
-                sqlite3_reset(stmt);
-                iterate_ast(statement.expression.ids, [stmt, &index, db](auto& v) {
-                    using field_type = typename std::decay<decltype(v)>::type;
-                    if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, v)) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                });
-                auto stepRes = sqlite3_step(stmt);
-                switch(stepRes) {
-                    case SQLITE_ROW: {
-                        T res;
-                        object_from_column_builder<T> builder{res, stmt};
-                        tImpl.table.for_each_column(builder);
-                        return res;
-                    } break;
-                    case SQLITE_DONE: {
-                        throw std::system_error(std::make_error_code(sqlite_orm::orm_error_code::not_found));
-                    } break;
-                    default: {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                }
-            }
-
-            template<class T, class... Args>
-            void execute(const prepared_statement_t<remove_all_t<T, Args...>>& statement) {
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                auto index = 1;
-                sqlite3_reset(stmt);
-                iterate_ast(statement.expression.conditions, [stmt, &index, db](auto& node) {
-                    using node_type = typename std::decay<decltype(node)>::type;
-                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
-                    if(SQLITE_OK != binder(node)) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                });
-                perform_step(db, stmt);
-            }
-
-            template<class... Args, class... Wargs>
-            void execute(const prepared_statement_t<update_all_t<set_t<Args...>, Wargs...>>& statement) {
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                auto index = 1;
-                sqlite3_reset(stmt);
-                iterate_tuple(statement.expression.set.assigns, [&index, stmt, db](auto& setArg) {
-                    iterate_ast(setArg, [&index, stmt, db](auto& node) {
-                        using node_type = typename std::decay<decltype(node)>::type;
-                        conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
-                        if(SQLITE_OK != binder(node)) {
-                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                    sqlite3_errmsg(db));
-                        }
-                    });
-                });
-                iterate_ast(statement.expression.conditions, [stmt, &index, db](auto& node) {
-                    using node_type = typename std::decay<decltype(node)>::type;
-                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
-                    if(SQLITE_OK != binder(node)) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                });
-                perform_step(db, stmt);
-            }
-
-            template<class T, class... Args, class R = typename column_result_t<self, T>::type>
-            std::vector<R> execute(const prepared_statement_t<select_t<T, Args...>>& statement) {
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                auto index = 1;
-                sqlite3_reset(stmt);
-                iterate_ast(statement.expression, [stmt, &index, db](auto& node) {
-                    using node_type = typename std::decay<decltype(node)>::type;
-                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
-                    if(SQLITE_OK != binder(node)) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                });
-                std::vector<R> res;
-                auto tableInfoPointer = this->impl.template find_table<R>();
-                int stepRes;
-                do {
-                    stepRes = sqlite3_step(stmt);
-                    switch(stepRes) {
-                        case SQLITE_ROW: {
-                            using table_info_pointer_t = typename std::remove_pointer<decltype(tableInfoPointer)>::type;
-                            using table_info_t = typename std::decay<table_info_pointer_t>::type;
-                            row_extractor_builder<R, storage_traits::type_is_mapped<self, R>::value, table_info_t>
-                                builder;
-                            auto rowExtractor = builder(tableInfoPointer);
-                            res.push_back(rowExtractor.extract(stmt, 0));
-                        } break;
-                        case SQLITE_DONE:
-                            break;
-                        default: {
-                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                    sqlite3_errmsg(db));
-                        }
-                    }
-                } while(stepRes != SQLITE_DONE);
-                return res;
-            }
-
-            template<class T, class R, class... Args>
-            R execute(const prepared_statement_t<get_all_t<T, R, Args...>>& statement) {
-                auto& tImpl = this->get_impl<T>();
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                auto index = 1;
-                sqlite3_reset(stmt);
-                iterate_ast(statement.expression, [stmt, &index, db](auto& node) {
-                    using node_type = typename std::decay<decltype(node)>::type;
-                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
-                    if(SQLITE_OK != binder(node)) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                });
-                R res;
-                int stepRes;
-                do {
-                    stepRes = sqlite3_step(stmt);
-                    switch(stepRes) {
-                        case SQLITE_ROW: {
-                            T obj;
-                            object_from_column_builder<T> builder{obj, stmt};
-                            tImpl.table.for_each_column(builder);
-                            res.push_back(std::move(obj));
-                        } break;
-                        case SQLITE_DONE:
-                            break;
-                        default: {
-                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                    sqlite3_errmsg(db));
-                        }
-                    }
-                } while(stepRes != SQLITE_DONE);
-                return res;
-            }
-
-            template<class T, class R, class... Args>
-            R execute(const prepared_statement_t<get_all_pointer_t<T, R, Args...>>& statement) {
-                auto& tImpl = this->get_impl<T>();
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                auto index = 1;
-                sqlite3_reset(stmt);
-                iterate_ast(statement.expression, [stmt, &index, db](auto& node) {
-                    using node_type = typename std::decay<decltype(node)>::type;
-                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
-                    if(SQLITE_OK != binder(node)) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                });
-                R res;
-                int stepRes;
-                do {
-                    stepRes = sqlite3_step(stmt);
-                    switch(stepRes) {
-                        case SQLITE_ROW: {
-                            auto obj = std::make_unique<T>();
-                            object_from_column_builder<T> builder{*obj, stmt};
-                            tImpl.table.for_each_column(builder);
-                            res.push_back(move(obj));
-                        } break;
-                        case SQLITE_DONE:
-                            break;
-                        default: {
-                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                    sqlite3_errmsg(db));
-                        }
-                    }
-                } while(stepRes != SQLITE_DONE);
-                return res;
-            }
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-            template<class T, class R, class... Args>
-            R execute(const prepared_statement_t<get_all_optional_t<T, R, Args...>>& statement) {
-                auto& tImpl = this->get_impl<T>();
-                auto con = this->get_connection();
-                auto db = con.get();
-                auto stmt = statement.stmt;
-                auto index = 1;
-                sqlite3_reset(stmt);
-                iterate_ast(statement.expression, [stmt, &index, db](auto& node) {
-                    using node_type = typename std::decay<decltype(node)>::type;
-                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
-                    if(SQLITE_OK != binder(node)) {
-                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                    }
-                });
-                R res;
-                int stepRes;
-                do {
-                    stepRes = sqlite3_step(stmt);
-                    switch(stepRes) {
-                        case SQLITE_ROW: {
-                            auto obj = std::make_optional<T>();
-                            object_from_column_builder<T> builder{*obj, stmt};
-                            tImpl.table.for_each_column(builder);
-                            res.push_back(move(obj));
-                        } break;
-                        case SQLITE_DONE:
-                            break;
-                        default: {
-                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                    sqlite3_errmsg(db));
-                        }
-                    }
-                } while(stepRes != SQLITE_DONE);
-                return res;
-            }
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-            template<class O>
-            bool has_dependent_rows(const O& object) {
-                auto res = false;
-                this->impl.for_each([this, &object, &res](auto& storageImpl) {
-                    if(res) {
-                        return;
-                    }
-                    storageImpl.table.for_each_foreign_key([&storageImpl, this, &object, &res](auto& foreignKey) {
-                        using ForeignKey = typename std::decay<decltype(foreignKey)>::type;
-                        using TargetType = typename ForeignKey::target_type;
-                        if(std::is_same<TargetType, O>::value) {
-                            std::stringstream ss;
-                            ss << "SELECT COUNT(*)";
-                            ss << " FROM " << storageImpl.table.name;
-                            ss << " WHERE";
-                            auto columnIndex = 0;
-                            iterate_tuple(foreignKey.columns, [&ss, &columnIndex, &storageImpl](auto& column) {
-                                if(columnIndex > 0) {
-                                    ss << " AND";
-                                }
-                                if(auto columnName = storageImpl.table.find_column_name(column)) {
-                                    ss << ' ' << *columnName << " = ?";
-                                } else {
-                                    throw std::system_error(
-                                        std::make_error_code(sqlite_orm::orm_error_code::column_not_found));
-                                }
-                                ++columnIndex;
-                            });
-                            auto query = ss.str();
-                            ss.flush();
-                            auto con = this->get_connection();
-                            sqlite3_stmt* stmt;
-                            auto db = con.get();
-                            if(sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) == SQLITE_OK) {
-                                statement_finalizer finalizer(stmt);
-                                columnIndex = 1;
-                                iterate_tuple(
-                                    foreignKey.references,
-                                    [&columnIndex, stmt, &object, db](auto& memberPointer) {
-                                        using MemberPointer = typename std::decay<decltype(memberPointer)>::type;
-                                        using field_type = typename member_traits<MemberPointer>::field_type;
-                                        //                                    if(column.member_pointer) {
-                                        if(SQLITE_OK != statement_binder<field_type>().bind(stmt,
-                                                                                            columnIndex++,
-                                                                                            object.*memberPointer)) {
-                                            throw std::system_error(
-                                                std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                                        }
-                                        /*} else {
-                                        using getter_type = typename column_type::getter_type;
-                                        field_value_holder<getter_type> valueHolder{((object).*(column.getter))()};
-                                        if(SQLITE_OK != statement_binder<field_type>().bind(stmt, columnIndex++, valueHolder.value)) {
-                                            throw std::system_error(
-                                                std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                                sqlite3_errmsg(db));
-                                        }
-                                    }*/
-                                    });
-                                if(SQLITE_ROW != sqlite3_step(stmt)) {
-                                    throw std::system_error(
-                                        std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                        sqlite3_errmsg(db));
-                                }
-                                auto countResult = sqlite3_column_int(stmt, 0);
-                                res = countResult > 0;
-                                if(SQLITE_DONE != sqlite3_step(stmt)) {
-                                    throw std::system_error(
-                                        std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                        sqlite3_errmsg(db));
-                                }
-                            } else {
-                                throw std::system_error(
-                                    std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
-                                    sqlite3_errmsg(db));
-                            }
-                        }
-                    });
-                });
-                return res;
-            }
-        };  // struct storage_t
-
-        template<class T>
-        struct is_storage : std::false_type {};
-
-        template<class... Ts>
-        struct is_storage<storage_t<Ts...>> : std::true_type {};
-    }
-
-    template<class... Ts>
-    internal::storage_t<Ts...> make_storage(const std::string& filename, Ts... tables) {
-        return {filename, internal::storage_impl<Ts...>(std::forward<Ts>(tables)...)};
-    }
-
-    /**
-     *  sqlite3_threadsafe() interface.
-     */
-    inline int threadsafe() {
-        return sqlite3_threadsafe();
-    }
-}
-#pragma once
-
-#if defined(_MSC_VER)
-#if defined(__RESTORE_MIN__)
-__pragma(pop_macro("min"))
-#undef __RESTORE_MIN__
-#endif
-#if defined(__RESTORE_MAX__)
-    __pragma(pop_macro("max"))
-#undef __RESTORE_MAX__
-#endif
-#endif  // defined(_MSC_VER)
-#pragma once
-
-#include <tuple>  //  std::tuple
-#include <utility>  //  std::pair
-#include <functional>  //  std::reference_wrapper
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-#include <optional>  // std::optional
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-    // #include "conditions.h"
-
-    // #include "operators.h"
-
-    // #include "select_constraints.h"
-
-    // #include "prepared_statement.h"
-
-    // #include "optional_container.h"
-
-    // #include "core_functions.h"
-
-    // #include "function.h"
-
-    // #include "ast/excluded.h"
-
-    // #include "ast/upsert_clause.h"
-
-    // #include "ast/where.h"
-
-    // #include "ast/into.h"
-
-    // #include "ast/group_by.h"
-
-    namespace sqlite_orm {
-
-    namespace internal {
-
-        template<class T, class SFINAE = void>
-        struct node_tuple {
-            using type = std::tuple<T>;
-        };
-
-        template<>
-        struct node_tuple<void, void> {
-            using type = std::tuple<>;
-        };
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class T>
-        struct node_tuple<as_optional_t<T>, void> {
-            using type = typename node_tuple<T>::type;
-        };
-#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class T>
-        struct node_tuple<std::reference_wrapper<T>, void> {
-            using type = typename node_tuple<T>::type;
-        };
-
-        template<class... Args>
-        struct node_tuple<group_by_t<Args...>, void> {
-            using type = typename node_tuple<std::tuple<Args...>>::type;
-        };
-
-        template<class T, class... Args>
-        struct node_tuple<group_by_with_having<T, Args...>, void> {
-            using args_tuple = typename node_tuple<std::tuple<Args...>>::type;
-            using expression_tuple = typename node_tuple<T>::type;
-            using type = typename conc_tuple<args_tuple, expression_tuple>::type;
-        };
-
-        template<class... TargetArgs, class... ActionsArgs>
-        struct node_tuple<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void> {
-            using type = typename node_tuple<std::tuple<ActionsArgs...>>::type;
-        };
-
-        template<class... Args>
-        struct node_tuple<set_t<Args...>, void> {
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-        };
-
-        template<class T>
-        struct node_tuple<excluded_t<T>, void> {
-            using type = typename node_tuple<T>::type;
-        };
-
-        template<class C>
-        struct node_tuple<where_t<C>, void> {
-            using node_type = where_t<C>;
-            using type = typename node_tuple<C>::type;
-        };
-
-        template<class T>
-        struct node_tuple<T, typename std::enable_if<is_base_of_template<T, binary_condition>::value>::type> {
-            using node_type = T;
-            using left_type = typename node_type::left_type;
-            using right_type = typename node_type::right_type;
-            using left_node_tuple = typename node_tuple<left_type>::type;
-            using right_node_tuple = typename node_tuple<right_type>::type;
-            using type = typename conc_tuple<left_node_tuple, right_node_tuple>::type;
-        };
-
-        template<class L, class R, class... Ds>
-        struct node_tuple<binary_operator<L, R, Ds...>, void> {
-            using node_type = binary_operator<L, R, Ds...>;
-            using left_type = typename node_type::left_type;
-            using right_type = typename node_type::right_type;
-            using left_node_tuple = typename node_tuple<left_type>::type;
-            using right_node_tuple = typename node_tuple<right_type>::type;
-            using type = typename conc_tuple<left_node_tuple, right_node_tuple>::type;
-        };
-
-        template<class... Args>
-        struct node_tuple<columns_t<Args...>, void> {
-            using node_type = columns_t<Args...>;
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-        };
-
-        template<class L, class A>
-        struct node_tuple<dynamic_in_t<L, A>, void> {
-            using node_type = dynamic_in_t<L, A>;
-            using left_tuple = typename node_tuple<L>::type;
-            using right_tuple = typename node_tuple<A>::type;
-            using type = typename conc_tuple<left_tuple, right_tuple>::type;
-        };
-
-        template<class L, class... Args>
-        struct node_tuple<in_t<L, Args...>, void> {
-            using node_type = in_t<L, Args...>;
-            using left_tuple = typename node_tuple<L>::type;
-            using right_tuple = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-            using type = typename conc_tuple<left_tuple, right_tuple>::type;
-        };
-
-        template<class T>
-        struct node_tuple<T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
-            using node_type = T;
-            using left_type = typename node_type::left_type;
-            using right_type = typename node_type::right_type;
-            using left_tuple = typename node_tuple<left_type>::type;
-            using right_tuple = typename node_tuple<right_type>::type;
-            using type = typename conc_tuple<left_tuple, right_tuple>::type;
-        };
-
-        template<class T, class... Args>
-        struct node_tuple<select_t<T, Args...>, void> {
-            using node_type = select_t<T, Args...>;
-            using columns_tuple = typename node_tuple<T>::type;
-            using args_tuple = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-            using type = typename conc_tuple<columns_tuple, args_tuple>::type;
-        };
-
-        template<class... Args>
-        struct node_tuple<insert_raw_t<Args...>, void> {
-            using node_type = insert_raw_t<Args...>;
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-        };
-
-        template<class... Args>
-        struct node_tuple<replace_raw_t<Args...>, void> {
-            using node_type = replace_raw_t<Args...>;
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-        };
-
-        template<class T>
-        struct node_tuple<into_t<T>, void> {
-            using node_type = into_t<T>;
-            using type = std::tuple<>;
-        };
-
-        template<class... Args>
-        struct node_tuple<values_t<Args...>, void> {
-            using node_type = values_t<Args...>;
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-        };
-
-        template<class... Args>
-        struct node_tuple<std::tuple<Args...>, void> {
-            using node_type = std::tuple<Args...>;
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-        };
-
-        template<class T, class R, class... Args>
-        struct node_tuple<get_all_t<T, R, Args...>, void> {
-            using node_type = get_all_t<T, R, Args...>;
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-        };
-
-        template<class T, class... Args>
-        struct node_tuple<get_all_pointer_t<T, Args...>, void> {
-            using node_type = get_all_pointer_t<T, Args...>;
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-        };
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-        template<class T, class... Args>
-        struct node_tuple<get_all_optional_t<T, Args...>, void> {
-            using node_type = get_all_optional_t<T, Args...>;
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-        };
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-        template<class... Args, class... Wargs>
-        struct node_tuple<update_all_t<set_t<Args...>, Wargs...>, void> {
-            using node_type = update_all_t<set_t<Args...>, Wargs...>;
-            using set_tuple = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-            using conditions_tuple = typename conc_tuple<typename node_tuple<Wargs>::type...>::type;
-            using type = typename conc_tuple<set_tuple, conditions_tuple>::type;
-        };
-
-        template<class T, class... Args>
-        struct node_tuple<remove_all_t<T, Args...>, void> {
-            using node_type = remove_all_t<T, Args...>;
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-        };
-
-        template<class T>
-        struct node_tuple<having_t<T>, void> {
-            using node_type = having_t<T>;
-            using type = typename node_tuple<T>::type;
-        };
-
-        template<class T, class E>
-        struct node_tuple<cast_t<T, E>, void> {
-            using node_type = cast_t<T, E>;
-            using type = typename node_tuple<E>::type;
-        };
-
-        template<class T>
-        struct node_tuple<exists_t<T>, void> {
-            using node_type = exists_t<T>;
-            using type = typename node_tuple<T>::type;
-        };
-
-        template<class T>
-        struct node_tuple<optional_container<T>, void> {
-            using node_type = optional_container<T>;
-            using type = typename node_tuple<T>::type;
-        };
-
-        template<>
-        struct node_tuple<optional_container<void>, void> {
-            using node_type = optional_container<void>;
-            using type = std::tuple<>;
-        };
-
-        template<class A, class T, class E>
-        struct node_tuple<like_t<A, T, E>, void> {
-            using node_type = like_t<A, T, E>;
-            using arg_tuple = typename node_tuple<A>::type;
-            using pattern_tuple = typename node_tuple<T>::type;
-            using escape_tuple = typename node_tuple<E>::type;
-            using type = typename conc_tuple<arg_tuple, pattern_tuple, escape_tuple>::type;
-        };
-
-        template<class A, class T>
-        struct node_tuple<glob_t<A, T>, void> {
-            using node_type = glob_t<A, T>;
-            using arg_tuple = typename node_tuple<A>::type;
-            using pattern_tuple = typename node_tuple<T>::type;
-            using type = typename conc_tuple<arg_tuple, pattern_tuple>::type;
-        };
-
-        template<class A, class T>
-        struct node_tuple<between_t<A, T>, void> {
-            using node_type = between_t<A, T>;
-            using expression_tuple = typename node_tuple<A>::type;
-            using lower_tuple = typename node_tuple<T>::type;
-            using upper_tuple = typename node_tuple<T>::type;
-            using type = typename conc_tuple<expression_tuple, lower_tuple, upper_tuple>::type;
-        };
-
-        template<class T>
-        struct node_tuple<named_collate<T>, void> {
-            using node_type = named_collate<T>;
-            using type = typename node_tuple<T>::type;
-        };
-
-        template<class T>
-        struct node_tuple<is_null_t<T>, void> {
-            using node_type = is_null_t<T>;
-            using type = typename node_tuple<T>::type;
-        };
-
-        template<class T>
-        struct node_tuple<is_not_null_t<T>, void> {
-            using node_type = is_not_null_t<T>;
-            using type = typename node_tuple<T>::type;
-        };
-
-        template<class C>
-        struct node_tuple<negated_condition_t<C>, void> {
-            using node_type = negated_condition_t<C>;
-            using type = typename node_tuple<C>::type;
-        };
-
-        template<class R, class S, class... Args>
-        struct node_tuple<built_in_function_t<R, S, Args...>, void> {
-            using node_type = built_in_function_t<R, S, Args...>;
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-        };
-
-        template<class F, class... Args>
-        struct node_tuple<function_call<F, Args...>, void> {
-            using node_type = function_call<F, Args...>;
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-        };
-
-        template<class T, class O>
-        struct node_tuple<left_join_t<T, O>, void> {
-            using node_type = left_join_t<T, O>;
-            using type = typename node_tuple<O>::type;
-        };
-
-        template<class T>
-        struct node_tuple<on_t<T>, void> {
-            using node_type = on_t<T>;
-            using type = typename node_tuple<T>::type;
-        };
-
-        template<class T, class O>
-        struct node_tuple<join_t<T, O>, void> {
-            using node_type = join_t<T, O>;
-            using type = typename node_tuple<O>::type;
-        };
-
-        template<class T, class O>
-        struct node_tuple<left_outer_join_t<T, O>, void> {
-            using node_type = left_outer_join_t<T, O>;
-            using type = typename node_tuple<O>::type;
-        };
-
-        template<class T, class O>
-        struct node_tuple<inner_join_t<T, O>, void> {
-            using node_type = inner_join_t<T, O>;
-            using type = typename node_tuple<O>::type;
-        };
-
-        template<class R, class T, class E, class... Args>
-        struct node_tuple<simple_case_t<R, T, E, Args...>, void> {
-            using node_type = simple_case_t<R, T, E, Args...>;
-            using case_tuple = typename node_tuple<T>::type;
-            using args_tuple = typename conc_tuple<typename node_tuple<Args>::type...>::type;
-            using else_tuple = typename node_tuple<E>::type;
-            using type = typename conc_tuple<case_tuple, args_tuple, else_tuple>::type;
-        };
-
-        template<class L, class R>
-        struct node_tuple<std::pair<L, R>, void> {
-            using node_type = std::pair<L, R>;
-            using left_tuple = typename node_tuple<L>::type;
-            using right_tuple = typename node_tuple<R>::type;
-            using type = typename conc_tuple<left_tuple, right_tuple>::type;
-        };
-
-        template<class T, class E>
-        struct node_tuple<as_t<T, E>, void> {
-            using node_type = as_t<T, E>;
-            using type = typename node_tuple<E>::type;
-        };
-
-        template<class T>
-        struct node_tuple<limit_t<T, false, false, void>, void> {
-            using node_type = limit_t<T, false, false, void>;
-            using type = typename node_tuple<T>::type;
-        };
-
-        template<class T, class O>
-        struct node_tuple<limit_t<T, true, false, O>, void> {
-            using node_type = limit_t<T, true, false, O>;
-            using type = typename conc_tuple<typename node_tuple<T>::type, typename node_tuple<O>::type>::type;
-        };
-
-        template<class T, class O>
-        struct node_tuple<limit_t<T, true, true, O>, void> {
-            using node_type = limit_t<T, true, true, O>;
-            using type = typename conc_tuple<typename node_tuple<O>::type, typename node_tuple<T>::type>::type;
-        };
-    }
-}
-#pragma once
-
-#include <type_traits>  //  std::is_same, std::decay, std::remove_reference
-
-// #include "prepared_statement.h"
-
-// #include "ast_iterator.h"
-
-// #include "static_magic.h"
-
-// #include "expression_object_type.h"
-
-namespace sqlite_orm {
-
-    template<int N, class It, class L, class O>
-    auto& get(internal::prepared_statement_t<internal::insert_range_t<It, L, O>>& statement) {
-        return std::get<N>(statement.expression.range);
-    }
-
-    template<int N, class It, class L, class O>
-    const auto& get(const internal::prepared_statement_t<internal::insert_range_t<It, L, O>>& statement) {
-        return std::get<N>(statement.expression.range);
-    }
-
-    template<int N, class It, class L, class O>
-    auto& get(internal::prepared_statement_t<internal::replace_range_t<It, L, O>>& statement) {
-        return std::get<N>(statement.expression.range);
-    }
-
-    template<int N, class It, class L, class O>
-    const auto& get(const internal::prepared_statement_t<internal::replace_range_t<It, L, O>>& statement) {
-        return std::get<N>(statement.expression.range);
-    }
-
-    template<int N, class T, class... Ids>
-    auto& get(internal::prepared_statement_t<internal::get_t<T, Ids...>>& statement) {
-        return internal::get_ref(std::get<N>(statement.expression.ids));
-    }
-
-    template<int N, class T, class... Ids>
-    const auto& get(const internal::prepared_statement_t<internal::get_t<T, Ids...>>& statement) {
-        return internal::get_ref(std::get<N>(statement.expression.ids));
-    }
-
-    template<int N, class T, class... Ids>
-    auto& get(internal::prepared_statement_t<internal::get_pointer_t<T, Ids...>>& statement) {
-        return internal::get_ref(std::get<N>(statement.expression.ids));
-    }
-
-    template<int N, class T, class... Ids>
-    const auto& get(const internal::prepared_statement_t<internal::get_pointer_t<T, Ids...>>& statement) {
-        return internal::get_ref(std::get<N>(statement.expression.ids));
-    }
-
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-    template<int N, class T, class... Ids>
-    auto& get(internal::prepared_statement_t<internal::get_optional_t<T, Ids...>>& statement) {
-        return internal::get_ref(std::get<N>(statement.expression.ids));
-    }
-
-    template<int N, class T, class... Ids>
-    const auto& get(const internal::prepared_statement_t<internal::get_optional_t<T, Ids...>>& statement) {
-        return internal::get_ref(std::get<N>(statement.expression.ids));
-    }
-#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
-
-    template<int N, class T, class... Ids>
-    auto& get(internal::prepared_statement_t<internal::remove_t<T, Ids...>>& statement) {
-        return internal::get_ref(std::get<N>(statement.expression.ids));
-    }
-
-    template<int N, class T, class... Ids>
-    const auto& get(const internal::prepared_statement_t<internal::remove_t<T, Ids...>>& statement) {
-        return internal::get_ref(std::get<N>(statement.expression.ids));
-    }
-
-    template<int N, class T>
-    auto& get(internal::prepared_statement_t<internal::update_t<T>>& statement) {
-        static_assert(N == 0, "get<> works only with 0 argument for update statement");
-        return internal::get_ref(statement.expression.object);
-    }
-
-    template<int N, class T>
-    const auto& get(const internal::prepared_statement_t<internal::update_t<T>>& statement) {
-        static_assert(N == 0, "get<> works only with 0 argument for update statement");
-        return internal::get_ref(statement.expression.object);
-    }
-
-    template<int N, class T, class... Cols>
-    auto& get(internal::prepared_statement_t<internal::insert_explicit<T, Cols...>>& statement) {
-        static_assert(N == 0, "get<> works only with 0 argument for insert statement");
-        return internal::get_ref(statement.expression.obj);
-    }
-
-    template<int N, class T, class... Cols>
-    const auto& get(const internal::prepared_statement_t<internal::insert_explicit<T, Cols...>>& statement) {
-        static_assert(N == 0, "get<> works only with 0 argument for insert statement");
-        return internal::get_ref(statement.expression.obj);
-    }
-
-    template<int N, class T>
-    auto& get(internal::prepared_statement_t<internal::replace_t<T>>& statement) {
-        static_assert(N == 0, "get<> works only with 0 argument for replace statement");
-        return internal::get_ref(statement.expression.object);
-    }
-
-    template<int N, class T>
-    const auto& get(const internal::prepared_statement_t<internal::replace_t<T>>& statement) {
-        static_assert(N == 0, "get<> works only with 0 argument for replace statement");
-        return internal::get_ref(statement.expression.object);
-    }
-
-    template<int N, class T>
-    auto& get(internal::prepared_statement_t<internal::insert_t<T>>& statement) {
-        static_assert(N == 0, "get<> works only with 0 argument for insert statement");
-        return internal::get_ref(statement.expression.object);
-    }
-
-    template<int N, class T>
-    const auto& get(const internal::prepared_statement_t<internal::insert_t<T>>& statement) {
-        static_assert(N == 0, "get<> works only with 0 argument for insert statement");
-        return internal::get_ref(statement.expression.object);
-    }
-
-    template<int N, class T>
-    const auto& get(const internal::prepared_statement_t<T>& statement) {
-        using statement_type = typename std::decay<decltype(statement)>::type;
-        using expression_type = typename statement_type::expression_type;
-        using node_tuple = typename internal::node_tuple<expression_type>::type;
-        using bind_tuple = typename internal::bindable_filter<node_tuple>::type;
-        using result_tupe = typename std::tuple_element<static_cast<size_t>(N), bind_tuple>::type;
-        const result_tupe* result = nullptr;
-        auto index = -1;
-        internal::iterate_ast(statement.expression, [&result, &index](auto& node) {
-            using node_type = typename std::decay<decltype(node)>::type;
-            if(internal::is_bindable<node_type>::value) {
-                ++index;
-            }
-            if(index == N) {
-                internal::static_if<std::is_same<result_tupe, node_type>{}>([](auto& r, auto& n) {
-                    r = const_cast<typename std::remove_reference<decltype(r)>::type>(&n);
-                })(result, node);
-            }
-        });
-        return internal::get_ref(*result);
-    }
-
-    template<int N, class T>
-    auto& get(internal::prepared_statement_t<T>& statement) {
-        using statement_type = typename std::decay<decltype(statement)>::type;
-        using expression_type = typename statement_type::expression_type;
-        using node_tuple = typename internal::node_tuple<expression_type>::type;
-        using bind_tuple = typename internal::bindable_filter<node_tuple>::type;
-        using result_tupe = typename std::tuple_element<static_cast<size_t>(N), bind_tuple>::type;
-        result_tupe* result = nullptr;
-        auto index = -1;
-        internal::iterate_ast(statement.expression, [&result, &index](auto& node) {
-            using node_type = typename std::decay<decltype(node)>::type;
-            if(internal::is_bindable<node_type>::value) {
-                ++index;
-            }
-            if(index == N) {
-                internal::static_if<std::is_same<result_tupe, node_type>{}>([](auto& r, auto& n) {
-                    r = const_cast<typename std::remove_reference<decltype(r)>::type>(&n);
-                })(result, node);
-            }
-        });
-        return internal::get_ref(*result);
-    }
-}
-#pragma once
-
-#include <type_traits>
-
-// #include "start_macros.h"
-
-// #include "pointer_value.h"
-
-namespace sqlite_orm {
-
-    SQLITE_ORM_INLINE_VAR constexpr const char carray_pvt_name[] = "carray";
-    using carray_pvt = std::integral_constant<const char*, carray_pvt_name>;
-
-    template<typename P>
-    using carray_pointer_arg = pointer_arg<P, carray_pvt>;
-    template<typename P, typename D>
-    using carray_pointer_binding = pointer_binding<P, carray_pvt, D>;
-    template<typename P>
-    using static_carray_pointer_binding = static_pointer_binding<P, carray_pvt>;
-
-    /**
-     *  Wrap a pointer of type 'carray' and its deleter function for binding it to a statement.
-     *  
-     *  Unless the deleter yields a nullptr 'xDestroy' function the ownership of the pointed-to-object
-     *  is transferred to the pointer binding, which will delete it through
-     *  the deleter when the statement finishes.
-     */
-    template<class P, class D>
-    auto bindable_carray_pointer(P* p, D d) noexcept -> pointer_binding<P, carray_pvt, D> {
-        return bindable_pointer<carray_pvt>(p, std::move(d));
-    }
-
-    /**
-     *  Wrap a pointer of type 'carray' for binding it to a statement.
-     *  
-     *  Note: 'Static' means that ownership of the pointed-to-object won't be transferred
-     *  and sqlite assumes the object pointed to is valid throughout the lifetime of a statement.
-     */
-    template<class P>
-    auto statically_bindable_carray_pointer(P* p) noexcept -> static_pointer_binding<P, carray_pvt> {
-        return statically_bindable_pointer<carray_pvt>(p);
-    }
-
-    /**
-     *  Generalized form of the 'remember' SQL function that is a pass-through for values
-     *  (it returns its argument unchanged using move semantics) but also saves the
-     *  value that is passed through into a bound variable.
-     */
-    template<typename P>
-    struct note_value_fn {
-        P operator()(P&& value, carray_pointer_arg<P> pv) const {
-            if(P* observer = pv) {
-                *observer = value;
-            }
-            return std::move(value);
-        }
-
-        static constexpr const char* name() {
-            return "note_value";
-        }
-    };
-
-    /**
-     *  remember(V, $PTR) extension function https://sqlite.org/src/file/ext/misc/remember.c
-     */
-    struct remember_fn : note_value_fn<int64> {
-        static constexpr const char* name() {
-            return "remember";
-        }
-    };
-}
+#pragma once
+
+#if defined(_MSC_VER)
+#if defined(min)
+__pragma(push_macro("min"))
+#undef min
+#define __RESTORE_MIN__
+#endif
+#if defined(max)
+    __pragma(push_macro("max"))
+#undef max
+#define __RESTORE_MAX__
+#endif
+#endif  // defined(_MSC_VER)
+
+#include <ciso646>  //  due to #166
+
+#if __cplusplus >= 201703L  // use of C++17 or higher
+// Enables use of std::optional in SQLITE_ORM.
+#define SQLITE_ORM_OPTIONAL_SUPPORTED
+#define SQLITE_ORM_STRING_VIEW_SUPPORTED
+#define SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
+#define SQLITE_ORM_INLINE_VAR inline
+#if __cplusplus >= 202002L  // use of C++20 or higher
+#define SQLITE_ORM_CONSTEVAL consteval
+#define SQLITE_ORM_NOUNIQUEADDRESS [[no_unique_address]]
+#else
+#define SQLITE_ORM_CONSTEVAL constexpr
+#define SQLITE_ORM_NOUNIQUEADDRESS
+#endif
+#else
+#define SQLITE_ORM_INLINE_VAR
+#define SQLITE_ORM_CONSTEVAL constexpr
+#define SQLITE_ORM_NOUNIQUEADDRESS
+#endif
+#pragma once
+
+#include <system_error>  // std::error_code, std::system_error
+#include <string>  //  std::string
+#include <sqlite3.h>
+#include <stdexcept>
+#include <sstream>  //  std::ostringstream
+
+        namespace sqlite_orm {
+
+    enum class orm_error_code {
+        not_found = 1,
+        type_is_not_mapped_to_storage,
+        trying_to_dereference_null_iterator,
+        too_many_tables_specified,
+        incorrect_set_fields_specified,
+        column_not_found,
+        table_has_no_primary_key_column,
+        cannot_start_a_transaction_within_a_transaction,
+        no_active_transaction,
+        incorrect_journal_mode_string,
+        invalid_collate_argument_enum,
+        failed_to_init_a_backup,
+        unknown_member_value,
+        incorrect_order,
+        cannot_use_default_value,
+        arguments_count_does_not_match,
+        function_not_found,
+        index_is_out_of_bounds,
+    };
+}
+
+namespace sqlite_orm {
+
+    class orm_error_category : public std::error_category {
+      public:
+        const char* name() const noexcept override final {
+            return "ORM error";
+        }
+
+        std::string message(int c) const override final {
+            switch(static_cast<orm_error_code>(c)) {
+                case orm_error_code::not_found:
+                    return "Not found";
+                case orm_error_code::type_is_not_mapped_to_storage:
+                    return "Type is not mapped to storage";
+                case orm_error_code::trying_to_dereference_null_iterator:
+                    return "Trying to dereference null iterator";
+                case orm_error_code::too_many_tables_specified:
+                    return "Too many tables specified";
+                case orm_error_code::incorrect_set_fields_specified:
+                    return "Incorrect set fields specified";
+                case orm_error_code::column_not_found:
+                    return "Column not found";
+                case orm_error_code::table_has_no_primary_key_column:
+                    return "Table has no primary key column";
+                case orm_error_code::cannot_start_a_transaction_within_a_transaction:
+                    return "Cannot start a transaction within a transaction";
+                case orm_error_code::no_active_transaction:
+                    return "No active transaction";
+                case orm_error_code::invalid_collate_argument_enum:
+                    return "Invalid collate_argument enum";
+                case orm_error_code::failed_to_init_a_backup:
+                    return "Failed to init a backup";
+                case orm_error_code::unknown_member_value:
+                    return "Unknown member value";
+                case orm_error_code::incorrect_order:
+                    return "Incorrect order";
+                case orm_error_code::cannot_use_default_value:
+                    return "The statement 'INSERT INTO * DEFAULT VALUES' can be used with only one row";
+                case orm_error_code::arguments_count_does_not_match:
+                    return "Arguments count does not match";
+                case orm_error_code::function_not_found:
+                    return "Function not found";
+                case orm_error_code::index_is_out_of_bounds:
+                    return "Index is out of bounds";
+                default:
+                    return "unknown error";
+            }
+        }
+    };
+
+    class sqlite_error_category : public std::error_category {
+      public:
+        const char* name() const noexcept override final {
+            return "SQLite error";
+        }
+
+        std::string message(int c) const override final {
+            return sqlite3_errstr(c);
+        }
+    };
+
+    inline const orm_error_category& get_orm_error_category() {
+        static orm_error_category res;
+        return res;
+    }
+
+    inline const sqlite_error_category& get_sqlite_error_category() {
+        static sqlite_error_category res;
+        return res;
+    }
+
+    template<typename... T>
+    std::string get_error_message(sqlite3* db, T&&... args) {
+        std::ostringstream stream;
+        using unpack = int[];
+        static_cast<void>(unpack{0, (static_cast<void>(static_cast<void>(stream << args)), 0)...});
+        stream << sqlite3_errmsg(db);
+        return stream.str();
+    }
+
+    template<typename... T>
+    [[noreturn]] void throw_error(sqlite3* db, T&&... args) {
+        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                get_error_message(db, std::forward<T>(args)...));
+    }
+}
+
+namespace std {
+    template<>
+    struct is_error_code_enum<sqlite_orm::orm_error_code> : std::true_type {};
+
+    inline std::error_code make_error_code(sqlite_orm::orm_error_code errorCode) {
+        return std::error_code(static_cast<int>(errorCode), sqlite_orm::get_orm_error_category());
+    }
+}
+#pragma once
+
+#include <cstddef>
+#include <type_traits>  //  std::false_type, std::true_type
+#include <tuple>  //  std::tuple, std::get, std::tuple_element, std::tuple_size
+
+// #include "../static_magic.h"
+
+#include <type_traits>  //  std::false_type, std::true_type, std::integral_constant
+
+namespace sqlite_orm {
+
+    //  got from here
+    //  https://stackoverflow.com/questions/37617677/implementing-a-compile-time-static-if-logic-for-different-string-types-in-a-co
+    namespace internal {
+
+        static inline decltype(auto) empty_callable() {
+            static auto res = [](auto&&...) {};
+            return (res);
+        }
+
+        template<typename T, typename F>
+        decltype(auto) static_if(std::true_type, const T& t, const F&) {
+            return (t);
+        }
+
+        template<typename T, typename F>
+        decltype(auto) static_if(std::false_type, const T&, const F& f) {
+            return (f);
+        }
+
+        template<bool B, typename T, typename F>
+        decltype(auto) static_if(const T& t, const F& f) {
+            return static_if(std::integral_constant<bool, B>{}, t, f);
+        }
+
+        template<bool B, typename T>
+        decltype(auto) static_if(const T& t) {
+            return static_if(std::integral_constant<bool, B>{}, t, empty_callable());
+        }
+
+        template<typename T>
+        using static_not = std::integral_constant<bool, !T::value>;
+    }
+
+}
+
+namespace sqlite_orm {
+
+    //  got from here http://stackoverflow.com/questions/25958259/how-do-i-find-out-if-a-tuple-contains-a-type
+    namespace tuple_helper {
+
+        /**
+         *  HAS_TYPE type trait
+         */
+        template<typename T, typename Tuple>
+        struct has_type;
+
+        template<typename T>
+        struct has_type<T, std::tuple<>> : std::false_type {};
+
+        template<typename T, typename U, typename... Ts>
+        struct has_type<T, std::tuple<U, Ts...>> : has_type<T, std::tuple<Ts...>> {};
+
+        template<typename T, typename... Ts>
+        struct has_type<T, std::tuple<T, Ts...>> : std::true_type {};
+
+        template<typename T, typename Tuple>
+        using tuple_contains_type = typename has_type<T, Tuple>::type;
+
+        /**
+         *  HAS_SOME_TYPE type trait
+         */
+        template<template<class> class TT, typename Tuple>
+        struct has_some_type;
+
+        template<template<class> class TT>
+        struct has_some_type<TT, std::tuple<>> : std::false_type {};
+
+        template<template<class> class TT, typename U, typename... Ts>
+        struct has_some_type<TT, std::tuple<U, Ts...>> : has_some_type<TT, std::tuple<Ts...>> {};
+
+        template<template<class> class TT, typename T, typename... Ts>
+        struct has_some_type<TT, std::tuple<TT<T>, Ts...>> : std::true_type {};
+
+        template<template<class> class TT, typename Tuple>
+        using tuple_contains_some_type = typename has_some_type<TT, Tuple>::type;
+
+        template<size_t N, class... Args>
+        struct iterator_impl {
+
+            template<class L>
+            void operator()(const std::tuple<Args...>& tuple, const L& lambda, bool reverse = true) {
+                if(reverse) {
+                    lambda(std::get<N>(tuple));
+                    iterator_impl<N - 1, Args...>()(tuple, lambda, reverse);
+                } else {
+                    iterator_impl<N - 1, Args...>()(tuple, lambda, reverse);
+                    lambda(std::get<N>(tuple));
+                }
+            }
+
+            template<class L>
+            void operator()(const L& lambda) {
+                iterator_impl<N - 1, Args...>()(lambda);
+                lambda((const typename std::tuple_element<N - 1, std::tuple<Args...>>::type*)nullptr);
+            }
+        };
+
+        template<class... Args>
+        struct iterator_impl<0, Args...> {
+
+            template<class L>
+            void operator()(const std::tuple<Args...>& tuple, const L& lambda, bool /*reverse*/ = true) {
+                lambda(std::get<0>(tuple));
+            }
+
+            template<class L>
+            void operator()(const L& lambda) {
+                lambda((const typename std::tuple_element<0, std::tuple<Args...>>::type*)nullptr);
+            }
+        };
+
+        template<size_t N>
+        struct iterator_impl<N> {
+
+            template<class L>
+            void operator()(const std::tuple<>&, const L&, bool /*reverse*/ = true) {
+                //..
+            }
+
+            template<class L>
+            void operator()(const L&) {
+                //..
+            }
+        };
+
+        template<class... Args>
+        struct iterator_impl2;
+
+        template<>
+        struct iterator_impl2<> {
+
+            template<class L>
+            void operator()(const L&) const {
+                //..
+            }
+        };
+
+        template<class H, class... Tail>
+        struct iterator_impl2<H, Tail...> {
+
+            template<class L>
+            void operator()(const L& lambda) const {
+                lambda((const H*)nullptr);
+                iterator_impl2<Tail...>{}(lambda);
+            }
+        };
+
+        template<class T>
+        struct iterator;
+
+        template<class... Args>
+        struct iterator<std::tuple<Args...>> {
+
+            template<class L>
+            void operator()(const L& lambda) const {
+                iterator_impl2<Args...>{}(lambda);
+            }
+        };
+    }
+
+    namespace internal {
+
+        //  got it form here https://stackoverflow.com/questions/7858817/unpacking-a-tuple-to-call-a-matching-function-pointer
+        template<class Function, class FunctionPointer, class Tuple, size_t... I>
+        auto call_impl(Function& f, FunctionPointer functionPointer, Tuple t, std::index_sequence<I...>) {
+            return (f.*functionPointer)(std::get<I>(move(t))...);
+        }
+
+        template<class Function, class FunctionPointer, class Tuple>
+        auto call(Function& f, FunctionPointer functionPointer, Tuple t) {
+            static constexpr auto size = std::tuple_size<Tuple>::value;
+            return call_impl(f, functionPointer, move(t), std::make_index_sequence<size>{});
+        }
+
+        template<class Function, class Tuple>
+        auto call(Function& f, Tuple t) {
+            return call(f, &Function::operator(), move(t));
+        }
+
+        template<size_t N, size_t I, class L, class R>
+        void move_tuple_impl(L& lhs, R& rhs) {
+            std::get<I>(lhs) = std::move(std::get<I>(rhs));
+            static_if<std::integral_constant<bool, N != I + 1>{}>([](auto& l, auto& r) {
+                move_tuple_impl<N, I + 1>(l, r);
+            })(lhs, rhs);
+        }
+
+        template<size_t N, class L, class R>
+        void move_tuple(L& lhs, R& rhs) {
+            using bool_type = std::integral_constant<bool, N != 0>;
+            static_if<bool_type{}>([](auto& l, auto& r) {
+                move_tuple_impl<N, 0>(l, r);
+            })(lhs, rhs);
+        }
+
+        template<class L, class... Args>
+        void iterate_tuple(const std::tuple<Args...>& tuple, const L& lambda) {
+            using tuple_type = std::tuple<Args...>;
+            tuple_helper::iterator_impl<std::tuple_size<tuple_type>::value - 1, Args...>()(tuple, lambda, false);
+        }
+
+        template<class T, class L>
+        void iterate_tuple(const L& lambda) {
+            tuple_helper::iterator<T>{}(lambda);
+        }
+
+        template<typename... input_t>
+        using tuple_cat_t = decltype(std::tuple_cat(std::declval<input_t>()...));
+
+        template<class... Args>
+        struct conc_tuple {
+            using type = tuple_cat_t<Args...>;
+        };
+    }
+}
+#pragma once
+
+#include <tuple>  //  std::tuple
+#include <type_traits>  //  std::enable_if
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T, template<class> class C, class SFINAE = void>
+        struct find_in_tuple;
+
+        template<template<class> class C>
+        struct find_in_tuple<std::tuple<>, C, void> {
+            using type = void;
+        };
+
+        template<class H, class... Args, template<class> class C>
+        struct find_in_tuple<std::tuple<H, Args...>, C, typename std::enable_if<C<H>::value>::type> {
+            using type = H;
+        };
+
+        template<class H, class... Args, template<class> class C>
+        struct find_in_tuple<std::tuple<H, Args...>, C, typename std::enable_if<!C<H>::value>::type> {
+            using type = typename find_in_tuple<std::tuple<Args...>, C>::type;
+        };
+    }
+}
+#pragma once
+
+#include <tuple>  //  std::tuple
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T, template<class C> class F>
+        struct tuple_transformer;
+
+        template<class... Args, template<class C> class F>
+        struct tuple_transformer<std::tuple<Args...>, F> {
+            using type = std::tuple<typename F<Args>::type...>;
+        };
+    }
+}
+#pragma once
+
+#include <tuple>  //  std::tuple
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T, template<class> class C>
+        struct count_tuple;
+
+        template<template<class> class C>
+        struct count_tuple<std::tuple<>, C> {
+            static constexpr const int value = 0;
+        };
+
+        template<class H, class... Args, template<class> class C>
+        struct count_tuple<std::tuple<H, Args...>, C> {
+            static constexpr const int value = C<H>::value + count_tuple<std::tuple<Args...>, C>::value;
+        };
+    }
+}
+#pragma once
+
+namespace sqlite_orm {
+    namespace internal {
+
+        /**
+         *  Accepts any number of arguments and evaluates `type` alias as T if all arguments are the same or void otherwise
+         */
+        template<class... Args>
+        struct same_or_void {
+            using type = void;
+        };
+
+        template<class A>
+        struct same_or_void<A> {
+            using type = A;
+        };
+
+        template<class A, class B>
+        struct same_or_void<A, B> {
+            using type = void;
+        };
+
+        template<class A>
+        struct same_or_void<A, A> {
+            using type = A;
+        };
+
+        template<class A, class... Args>
+        struct same_or_void<A, A, Args...> {
+            using type = typename same_or_void<A, Args...>::type;
+        };
+
+    }
+}
+#pragma once
+
+#include <type_traits>  // std::integral_constant
+#ifdef __cpp_lib_concepts
+#include <concepts>
+#endif
+
+// #include "start_macros.h"
+
+// #include "cxx_polyfill.h"
+
+#include <type_traits>
+
+// #include "start_macros.h"
+
+namespace sqlite_orm {
+    namespace internal {
+        namespace polyfill {
+#if __cplusplus < 201703L  // before C++17
+            template<typename...>
+            using void_t = void;
+
+            template<bool v>
+            using bool_constant = std::integral_constant<bool, v>;
+
+            template<typename...>
+            struct conjunction : std::true_type {};
+            template<typename B1>
+            struct conjunction<B1> : B1 {};
+            template<typename B1, typename... Bn>
+            struct conjunction<B1, Bn...> : std::conditional_t<B1::value, conjunction<Bn...>, B1> {};
+            template<typename... Bs>
+            constexpr bool conjunction_v = conjunction<Bs...>::value;
+
+            template<typename...>
+            struct disjunction : std::false_type {};
+            template<typename B1>
+            struct disjunction<B1> : B1 {};
+            template<typename B1, typename... Bn>
+            struct disjunction<B1, Bn...> : std::conditional_t<bool(B1::value), B1, disjunction<Bn...>> {};
+            template<typename... Bs>
+            constexpr bool disjunction_v = disjunction<Bs...>::value;
+#else
+            using std::bool_constant;
+            using std::conjunction;
+            using std::conjunction_v;
+            using std::disjunction;
+            using std::disjunction_v;
+            using std::void_t;
+#endif
+
+#if __cplusplus < 202002L
+            template<class T>
+            struct remove_cvref : std::remove_cv<std::remove_reference_t<T>> {};
+
+            template<class T>
+            using remove_cvref_t = typename remove_cvref<T>::type;
+#else
+            using std::remove_cvref;
+            using std::remove_cvref_t;
+#endif
+
+#if __cplusplus < 202312L  // before C++23
+            template<typename Type, template<typename...> class Primary>
+            SQLITE_ORM_INLINE_VAR constexpr bool is_specialization_of_v = false;
+
+            template<template<typename...> class Primary, class... Types>
+            SQLITE_ORM_INLINE_VAR constexpr bool is_specialization_of_v<Primary<Types...>, Primary> = true;
+
+            template<typename Type, template<typename...> class Primary>
+            struct is_specialization_of : bool_constant<is_specialization_of_v<Type, Primary>> {};
+
+            template<typename... T>
+            using is_specialization_of_t = typename is_specialization_of<T...>::type;
+#else
+            using std::is_specialization_of, std::is_specialization_of_t, std::is_specialization_of_v;
+#endif
+
+            template<typename...>
+            SQLITE_ORM_INLINE_VAR constexpr bool always_false_v = false;
+
+            template<size_t I>
+            using index_constant = std::integral_constant<size_t, I>;
+
+#if 1  // library fundamentals TS v2
+            struct nonesuch {
+                ~nonesuch() = delete;
+                nonesuch(const nonesuch&) = delete;
+                void operator=(const nonesuch&) = delete;
+            };
+
+            template<class Default, class AlwaysVoid, template<class...> class Op, class... Args>
+            struct detector {
+                using value_t = std::false_type;
+                using type = Default;
+            };
+
+            template<class Default, template<class...> class Op, class... Args>
+            struct detector<Default, polyfill::void_t<Op<Args...>>, Op, Args...> {
+                using value_t = std::true_type;
+                using type = Op<Args...>;
+            };
+
+            template<template<class...> class Op, class... Args>
+            using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
+
+            template<template<class...> class Op, class... Args>
+            using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
+
+            template<class Default, template<class...> class Op, class... Args>
+            using detected_or = detector<Default, void, Op, Args...>;
+
+            template<class Default, template<class...> class Op, class... Args>
+            using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+            template<template<class...> class Op, class... Args>
+            SQLITE_ORM_INLINE_VAR constexpr bool is_detected_v = is_detected<Op, Args...>::value;
+#endif
+
+            template<template<typename...> typename Base, typename... Fs>
+            Base<Fs...>& as_template_base(Base<Fs...>& base) {
+                return base;
+            }
+            template<template<typename...> typename Base, typename... Fs>
+            const Base<Fs...>& as_template_base(const Base<Fs...>& base) {
+                return base;
+            }
+            template<template<typename...> typename Base, typename... Fs>
+            Base<Fs...>&& as_template_base(Base<Fs...>&& base) {
+                return std::move(base);
+            }
+            template<template<typename...> typename Base, typename... Fs>
+            const Base<Fs...>&& as_template_base(const Base<Fs...>&& base) {
+                return std::move(base);
+            }
+
+            /** @short Deduce template base specialization from a derived type */
+            template<template<typename...> class Base, class Derived>
+            using as_template_base_t = decltype(as_template_base<Base>(std::declval<Derived>()));
+
+            template<template<typename...> class Base, class Derived, typename SFINAE = void>
+            struct is_template_base_of : std::false_type {};
+
+            template<template<typename...> class Base, class Derived>
+            struct is_template_base_of<Base, Derived, polyfill::void_t<as_template_base_t<Base, Derived>>>
+                : std::true_type {};
+
+            template<template<typename...> class Base, class Derived>
+            using is_template_base_of_t = typename is_template_base_of<Base, Derived>::type;
+
+            template<template<typename...> class Base, class Derived>
+            SQLITE_ORM_INLINE_VAR constexpr bool is_template_base_of_v = is_template_base_of<Base, Derived>::value;
+        }
+    }
+
+    namespace polyfill = internal::polyfill;
+}
+
+namespace sqlite_orm {
+
+    using xdestroy_fn_t = void (*)(void*);
+    using null_xdestroy_t = std::integral_constant<xdestroy_fn_t, nullptr>;
+    SQLITE_ORM_INLINE_VAR constexpr null_xdestroy_t null_xdestroy_f{};
+}
+
+namespace sqlite_orm {
+    namespace internal {
+#ifdef __cpp_concepts
+        /**
+         *  Constraints a deleter to be state-less.
+         */
+        template<typename D>
+        concept stateless_deleter = std::is_empty_v<D> && std::is_default_constructible_v<D>;
+
+        /**
+         *  Constraints a deleter to be an integral function constant.
+         */
+        template<typename D>
+        concept integral_fp_c = requires {
+            typename D::value_type;
+            D::value;
+            requires std::is_function_v<std::remove_pointer_t<typename D::value_type>>;
+        };
+
+        /**
+         *  Constraints a deleter to be or to yield a function pointer.
+         */
+        template<typename D>
+        concept can_yield_fp = requires(D d) {
+            // yielding function pointer by using the plus trick
+            {+d};
+            requires std::is_function_v<std::remove_pointer_t<decltype(+d)>>;
+        };
+#endif
+
+#ifdef __cpp_lib_concepts
+        /**
+         *  Yield a deleter's function pointer.
+         */
+        template<can_yield_fp D>
+        struct yield_fp_of {
+            using type = decltype(+std::declval<D>());
+        };
+#else
+
+        template<typename D>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_stateless_deleter_v =
+            std::is_empty<D>::value&& std::is_default_constructible<D>::value;
+
+        template<typename D, typename SFINAE = void>
+        struct is_integral_fp_c : std::false_type {};
+        template<typename D>
+        struct is_integral_fp_c<
+            D,
+            polyfill::void_t<typename D::value_type,
+                             decltype(D::value),
+                             std::enable_if_t<std::is_function<std::remove_pointer_t<typename D::value_type>>::value>>>
+            : std::true_type {};
+        template<typename D>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_integral_fp_c_v = is_integral_fp_c<D>::value;
+
+        template<typename D, typename SFINAE = void>
+        struct can_yield_fp : std::false_type {};
+        template<typename D>
+        struct can_yield_fp<
+            D,
+            polyfill::void_t<
+                decltype(+std::declval<D>()),
+                std::enable_if_t<std::is_function<std::remove_pointer_t<decltype(+std::declval<D>())>>::value>>>
+            : std::true_type {};
+        template<typename D>
+        SQLITE_ORM_INLINE_VAR constexpr bool can_yield_fp_v = can_yield_fp<D>::value;
+
+        template<typename D, bool = can_yield_fp_v<D>>
+        struct yield_fp_of {
+            using type = polyfill::void_t<>;
+        };
+        template<typename D>
+        struct yield_fp_of<D, true> {
+            using type = decltype(+std::declval<D>());
+        };
+#endif
+        template<typename D>
+        using yielded_fn_t = typename yield_fp_of<D>::type;
+
+#ifdef __cpp_lib_concepts
+        template<typename D>
+        concept is_unusable_for_xdestroy = (!stateless_deleter<D> &&
+                                            (can_yield_fp<D> && !std::same_as<yielded_fn_t<D>, xdestroy_fn_t>));
+
+        template<typename D>
+        concept can_yield_xdestroy = can_yield_fp<D> && std::same_as<yielded_fn_t<D>, xdestroy_fn_t>;
+
+        template<typename D, typename P>
+        concept needs_xdestroy_proxy = (stateless_deleter<D> &&
+                                        (!can_yield_fp<D> || !std::same_as<yielded_fn_t<D>, xdestroy_fn_t>));
+
+        /**
+         *  xDestroy function that constructs and invokes the stateless deleter.
+         *  
+         *  Requires that the deleter can be called with the q-qualified pointer argument;
+         *  it doesn't check so explicitly, but a compiler error will occur.
+         */
+        template<typename D, typename P>
+        requires(!integral_fp_c<D>) void xdestroy_proxy(void* p) noexcept {
+            // C-casting `void* -> P*` like statement_binder<pointer_binding<P, T, D>>
+            auto o = (P*)p;
+            // ignoring return code
+            (void)D{}(o);
+        }
+
+        /**
+         *  xDestroy function that invokes the integral function pointer constant.
+         *  
+         *  Performs a const-cast of the argument pointer in order to allow for C API functions
+         *  that take a non-const parameter, but user code passes a pointer to a const object.
+         */
+        template<integral_fp_c D, typename P>
+        void xdestroy_proxy(void* p) noexcept {
+            // C-casting `void* -> P*` like statement_binder<pointer_binding<P, T, D>>,
+            auto o = (std::remove_cv_t<P>*)(P*)p;
+            // ignoring return code
+            (void)D{}(o);
+        }
+#else
+        template<typename D>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_unusable_for_xdestroy_v =
+            !is_stateless_deleter_v<D> && (can_yield_fp_v<D> && !std::is_same<yielded_fn_t<D>, xdestroy_fn_t>::value);
+
+        template<typename D>
+        SQLITE_ORM_INLINE_VAR constexpr bool can_yield_xdestroy_v =
+            can_yield_fp_v<D>&& std::is_same<yielded_fn_t<D>, xdestroy_fn_t>::value;
+
+        template<typename D, typename P>
+        SQLITE_ORM_INLINE_VAR constexpr bool
+            needs_xdestroy_proxy_v = is_stateless_deleter_v<D> &&
+                                     (!can_yield_fp_v<D> || !std::is_same<yielded_fn_t<D>, xdestroy_fn_t>::value);
+
+        template<typename D, typename P>
+        std::enable_if_t<!is_integral_fp_c_v<D>, void> xdestroy_proxy(void* p) noexcept {
+            // C-casting `void* -> P*` like statement_binder<pointer_binding<P, T, D>>
+            auto o = (P*)p;
+            // ignoring return code
+            (void)D{}(o);
+        }
+
+        template<typename D, typename P>
+        std::enable_if_t<is_integral_fp_c_v<D>, void> xdestroy_proxy(void* p) noexcept {
+            // C-casting `void* -> P*` like statement_binder<pointer_binding<P, T, D>>,
+            auto o = (std::remove_cv_t<P>*)(P*)p;
+            // ignoring return code
+            (void)D{}(o);
+        }
+#endif
+    }
+}
+
+namespace sqlite_orm {
+
+#ifdef __cpp_lib_concepts
+    /**
+     *  Prohibits using a yielded function pointer, which is not of type xdestroy_fn_t.
+     *  
+     *  Explicitly declared for better error messages.
+     */
+    template<typename D, typename P>
+    constexpr xdestroy_fn_t obtain_xdestroy_for(D, P*) noexcept requires(internal::is_unusable_for_xdestroy<D>) {
+        static_assert(std::is_same<D, void>::value,
+                      "A function pointer, which is not of type xdestroy_fn_t, is prohibited.");
+        return nullptr;
+    }
+
+    /**
+     *  Obtains a proxy 'xDestroy' function pointer [of type void(*)(void*)]
+     *  for a deleter in a type-safe way.
+     *  
+     *  The deleter can be one of:
+     *         - integral function constant
+     *         - state-less (empty) deleter
+     *         - non-capturing lambda
+     *  
+     *  Type-safety is garanteed by checking whether the deleter or yielded function pointer
+     *  is invocable with the non-q-qualified pointer value.
+     */
+    template<typename D, typename P>
+    constexpr xdestroy_fn_t obtain_xdestroy_for(D, P*) noexcept requires(internal::needs_xdestroy_proxy<D, P>) {
+        return internal::xdestroy_proxy<D, P>;
+    }
+
+    /**
+     *  Directly obtains a 'xDestroy' function pointer [of type void(*)(void*)]
+     *  from a deleter in a type-safe way.
+     *  
+     *  The deleter can be one of:
+     *         - function pointer of type xdestroy_fn_t
+     *         - structure holding a function pointer
+     *         - integral function constant
+     *         - non-capturing lambda
+     *  ... and yield a function pointer of type xdestroy_fn_t.
+     *  
+     *  Type-safety is garanteed by checking whether the deleter or yielded function pointer
+     *  is invocable with the non-q-qualified pointer value.
+     */
+    template<typename D, typename P>
+    constexpr xdestroy_fn_t obtain_xdestroy_for(D d, P*) noexcept requires(internal::can_yield_xdestroy<D>) {
+        return d;
+    }
+#else
+    template<typename D, typename P>
+    constexpr std::enable_if_t<internal::is_unusable_for_xdestroy_v<D>, xdestroy_fn_t> obtain_xdestroy_for(D, P*) {
+        static_assert(std::is_same<D, void>::value,
+                      "A function pointer, which is not of type xdestroy_fn_t, is prohibited.");
+        return nullptr;
+    }
+
+    template<typename D, typename P>
+    constexpr std::enable_if_t<internal::needs_xdestroy_proxy_v<D, P>, xdestroy_fn_t> obtain_xdestroy_for(D,
+                                                                                                          P*) noexcept {
+        return internal::xdestroy_proxy<D, P>;
+    }
+
+    template<typename D, typename P>
+    constexpr std::enable_if_t<internal::can_yield_xdestroy_v<D>, xdestroy_fn_t> obtain_xdestroy_for(D d, P*) noexcept {
+        return d;
+    }
+#endif
+}
+#pragma once
+
+#include <string>  //  std::string
+#include <memory>  //  std::shared_ptr, std::unique_ptr
+#include <vector>  //  std::vector
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+#include <optional>  // std::optional
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+namespace sqlite_orm {
+
+    /**
+     *  This class accepts c++ type and transfers it to sqlite name (int -> INTEGER, std::string -> TEXT)
+     */
+    template<class T, typename Enable = void>
+    struct type_printer;
+
+    struct integer_printer {
+        inline const std::string& print() {
+            static const std::string res = "INTEGER";
+            return res;
+        }
+    };
+
+    struct text_printer {
+        inline const std::string& print() {
+            static const std::string res = "TEXT";
+            return res;
+        }
+    };
+
+    struct real_printer {
+        inline const std::string& print() {
+            static const std::string res = "REAL";
+            return res;
+        }
+    };
+
+    struct blob_printer {
+        inline const std::string& print() {
+            static const std::string res = "BLOB";
+            return res;
+        }
+    };
+
+    // Note unsigned/signed char and simple char used for storing integer values, not char values.
+    template<>
+    struct type_printer<unsigned char, void> : public integer_printer {};
+
+    template<>
+    struct type_printer<signed char, void> : public integer_printer {};
+
+    template<>
+    struct type_printer<char, void> : public integer_printer {};
+
+    template<>
+    struct type_printer<unsigned short int, void> : public integer_printer {};
+
+    template<>
+    struct type_printer<short, void> : public integer_printer {};
+
+    template<>
+    struct type_printer<unsigned int, void> : public integer_printer {};
+
+    template<>
+    struct type_printer<int, void> : public integer_printer {};
+
+    template<>
+    struct type_printer<unsigned long, void> : public integer_printer {};
+
+    template<>
+    struct type_printer<long, void> : public integer_printer {};
+
+    template<>
+    struct type_printer<unsigned long long, void> : public integer_printer {};
+
+    template<>
+    struct type_printer<long long, void> : public integer_printer {};
+
+    template<>
+    struct type_printer<bool, void> : public integer_printer {};
+
+    template<>
+    struct type_printer<std::string, void> : public text_printer {};
+
+    template<>
+    struct type_printer<std::wstring, void> : public text_printer {};
+
+    template<>
+    struct type_printer<const char*, void> : public text_printer {};
+
+    template<>
+    struct type_printer<float, void> : public real_printer {};
+
+    template<>
+    struct type_printer<double, void> : public real_printer {};
+
+    template<class T>
+    struct type_printer<std::shared_ptr<T>, void> : public type_printer<T> {};
+
+    template<class T>
+    struct type_printer<std::unique_ptr<T>, void> : public type_printer<T> {};
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+    template<class T>
+    struct type_printer<std::optional<T>, void> : public type_printer<T> {};
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+    template<>
+    struct type_printer<std::vector<char>, void> : public blob_printer {};
+}
+#pragma once
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        enum class collate_argument {
+            binary,
+            nocase,
+            rtrim,
+        };
+    }
+
+}
+#pragma once
+
+#include <string>  //  std::string
+#include <tuple>  //  std::tuple, std::make_tuple
+#include <sstream>  //  std::stringstream
+#include <type_traits>  //  std::is_base_of, std::false_type, std::true_type
+#include <ostream>  //  std::ostream
+
+// #include "table_type.h"
+
+#include <type_traits>  //  std::enable_if, std::is_member_pointer, std::is_member_function_pointer
+
+// #include "member_traits/getter_traits.h"
+
+// #include "getters.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class O, class T>
+        using getter_by_value_const = T (O::*)() const;
+
+        template<class O, class T>
+        using getter_by_value = T (O::*)();
+
+        template<class O, class T>
+        using getter_by_ref_const = T& (O::*)() const;
+
+        template<class O, class T>
+        using getter_by_ref = T& (O::*)();
+
+        template<class O, class T>
+        using getter_by_const_ref_const = const T& (O::*)() const;
+
+        template<class O, class T>
+        using getter_by_const_ref = const T& (O::*)();
+#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
+        template<class O, class T>
+        using getter_by_value_const_noexcept = T (O::*)() const noexcept;
+
+        template<class O, class T>
+        using getter_by_value_noexcept = T (O::*)() noexcept;
+
+        template<class O, class T>
+        using getter_by_ref_const_noexcept = T& (O::*)() const noexcept;
+
+        template<class O, class T>
+        using getter_by_ref_noexcept = T& (O::*)() noexcept;
+
+        template<class O, class T>
+        using getter_by_const_ref_const_noexcept = const T& (O::*)() const noexcept;
+
+        template<class O, class T>
+        using getter_by_const_ref_noexcept = const T& (O::*)() noexcept;
+#endif
+    }
+}
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T>
+        struct getter_traits;
+
+        template<class O, class T>
+        struct getter_traits<getter_by_value_const<O, T>> {
+            using object_type = O;
+            using field_type = T;
+
+            static constexpr const bool returns_lvalue = false;
+        };
+
+        template<class O, class T>
+        struct getter_traits<getter_by_value<O, T>> {
+            using object_type = O;
+            using field_type = T;
+
+            static constexpr const bool returns_lvalue = false;
+        };
+
+        template<class O, class T>
+        struct getter_traits<getter_by_ref_const<O, T>> {
+            using object_type = O;
+            using field_type = T;
+
+            static constexpr const bool returns_lvalue = true;
+        };
+
+        template<class O, class T>
+        struct getter_traits<getter_by_ref<O, T>> {
+            using object_type = O;
+            using field_type = T;
+
+            static constexpr const bool returns_lvalue = true;
+        };
+
+        template<class O, class T>
+        struct getter_traits<getter_by_const_ref_const<O, T>> {
+            using object_type = O;
+            using field_type = T;
+
+            static constexpr const bool returns_lvalue = true;
+        };
+
+        template<class O, class T>
+        struct getter_traits<getter_by_const_ref<O, T>> {
+            using object_type = O;
+            using field_type = T;
+
+            static constexpr const bool returns_lvalue = true;
+        };
+#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
+        template<class O, class T>
+        struct getter_traits<getter_by_value_const_noexcept<O, T>> {
+            using object_type = O;
+            using field_type = T;
+
+            static constexpr const bool returns_lvalue = false;
+        };
+
+        template<class O, class T>
+        struct getter_traits<getter_by_value_noexcept<O, T>> {
+            using object_type = O;
+            using field_type = T;
+
+            static constexpr const bool returns_lvalue = false;
+        };
+
+        template<class O, class T>
+        struct getter_traits<getter_by_ref_const_noexcept<O, T>> {
+            using object_type = O;
+            using field_type = T;
+
+            static constexpr const bool returns_lvalue = true;
+        };
+
+        template<class O, class T>
+        struct getter_traits<getter_by_ref_noexcept<O, T>> {
+            using object_type = O;
+            using field_type = T;
+
+            static constexpr const bool returns_lvalue = true;
+        };
+
+        template<class O, class T>
+        struct getter_traits<getter_by_const_ref_const_noexcept<O, T>> {
+            using object_type = O;
+            using field_type = T;
+
+            static constexpr const bool returns_lvalue = true;
+        };
+
+        template<class O, class T>
+        struct getter_traits<getter_by_const_ref_noexcept<O, T>> {
+            using object_type = O;
+            using field_type = T;
+
+            static constexpr const bool returns_lvalue = true;
+        };
+#endif
+    }
+}
+
+// #include "member_traits/setter_traits.h"
+
+// #include "setters.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class O, class T>
+        using setter_by_value = void (O::*)(T);
+
+        template<class O, class T>
+        using setter_by_ref = void (O::*)(T&);
+
+        template<class O, class T>
+        using setter_by_const_ref = void (O::*)(const T&);
+#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
+        template<class O, class T>
+        using setter_by_value_noexcept = void (O::*)(T) noexcept;
+
+        template<class O, class T>
+        using setter_by_ref_noexcept = void (O::*)(T&) noexcept;
+
+        template<class O, class T>
+        using setter_by_const_ref_noexcept = void (O::*)(const T&) noexcept;
+#endif
+    }
+}
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T>
+        struct setter_traits;
+
+        template<class O, class T>
+        struct setter_traits<setter_by_value<O, T>> {
+            using object_type = O;
+            using field_type = T;
+        };
+
+        template<class O, class T>
+        struct setter_traits<setter_by_ref<O, T>> {
+            using object_type = O;
+            using field_type = T;
+        };
+
+        template<class O, class T>
+        struct setter_traits<setter_by_const_ref<O, T>> {
+            using object_type = O;
+            using field_type = T;
+        };
+#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
+        template<class O, class T>
+        struct setter_traits<setter_by_value_noexcept<O, T>> {
+            using object_type = O;
+            using field_type = T;
+        };
+
+        template<class O, class T>
+        struct setter_traits<setter_by_ref_noexcept<O, T>> {
+            using object_type = O;
+            using field_type = T;
+        };
+
+        template<class O, class T>
+        struct setter_traits<setter_by_const_ref_noexcept<O, T>> {
+            using object_type = O;
+            using field_type = T;
+        };
+#endif
+    }
+}
+
+// #include "member_traits/is_getter.h"
+
+#include <type_traits>  //  std::false_type, std::true_type
+
+// #include "getters.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T>
+        struct is_getter : std::false_type {};
+
+        template<class O, class T>
+        struct is_getter<getter_by_value_const<O, T>> : std::true_type {};
+
+        template<class O, class T>
+        struct is_getter<getter_by_value<O, T>> : std::true_type {};
+
+        template<class O, class T>
+        struct is_getter<getter_by_ref_const<O, T>> : std::true_type {};
+
+        template<class O, class T>
+        struct is_getter<getter_by_ref<O, T>> : std::true_type {};
+
+        template<class O, class T>
+        struct is_getter<getter_by_const_ref_const<O, T>> : std::true_type {};
+
+        template<class O, class T>
+        struct is_getter<getter_by_const_ref<O, T>> : std::true_type {};
+#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
+        template<class O, class T>
+        struct is_getter<getter_by_value_const_noexcept<O, T>> : std::true_type {};
+
+        template<class O, class T>
+        struct is_getter<getter_by_value_noexcept<O, T>> : std::true_type {};
+
+        template<class O, class T>
+        struct is_getter<getter_by_ref_const_noexcept<O, T>> : std::true_type {};
+
+        template<class O, class T>
+        struct is_getter<getter_by_ref_noexcept<O, T>> : std::true_type {};
+
+        template<class O, class T>
+        struct is_getter<getter_by_const_ref_const_noexcept<O, T>> : std::true_type {};
+
+        template<class O, class T>
+        struct is_getter<getter_by_const_ref_noexcept<O, T>> : std::true_type {};
+#endif
+    }
+}
+
+// #include "member_traits/is_setter.h"
+
+// #include "setters.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T>
+        struct is_setter : std::false_type {};
+
+        template<class O, class T>
+        struct is_setter<setter_by_value<O, T>> : std::true_type {};
+
+        template<class O, class T>
+        struct is_setter<setter_by_ref<O, T>> : std::true_type {};
+
+        template<class O, class T>
+        struct is_setter<setter_by_const_ref<O, T>> : std::true_type {};
+#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
+        template<class O, class T>
+        struct is_setter<setter_by_value_noexcept<O, T>> : std::true_type {};
+
+        template<class O, class T>
+        struct is_setter<setter_by_ref_noexcept<O, T>> : std::true_type {};
+
+        template<class O, class T>
+        struct is_setter<setter_by_const_ref_noexcept<O, T>> : std::true_type {};
+#endif
+    }
+}
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        template<class T, class F>
+        struct column_pointer;
+
+        /**
+         *  Trait class used to define table mapped type by setter/getter/member
+         *  T - member pointer
+         *  `type` is a type which is mapped.
+         *  E.g.
+         *  -   `table_type<decltype(&User::id)>::type` is `User`
+         *  -   `table_type<decltype(&User::getName)>::type` is `User`
+         *  -   `table_type<decltype(&User::setName)>::type` is `User`
+         */
+        template<class T, class SFINAE = void>
+        struct table_type;
+
+        template<class O, class F>
+        struct table_type<F O::*,
+                          typename std::enable_if<std::is_member_pointer<F O::*>::value &&
+                                                  !std::is_member_function_pointer<F O::*>::value>::type> {
+            using type = O;
+        };
+
+        template<class T>
+        struct table_type<T, typename std::enable_if<is_getter<T>::value>::type> {
+            using type = typename getter_traits<T>::object_type;
+        };
+
+        template<class T>
+        struct table_type<T, typename std::enable_if<is_setter<T>::value>::type> {
+            using type = typename setter_traits<T>::object_type;
+        };
+
+        template<class T, class F>
+        struct table_type<column_pointer<T, F>, void> {
+            using type = T;
+        };
+    }
+}
+
+// #include "tuple_helper/tuple_helper.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  AUTOINCREMENT constraint class.
+         */
+        struct autoincrement_t {};
+
+        struct primary_key_base {
+            enum class order_by {
+                unspecified,
+                ascending,
+                descending,
+            };
+
+            order_by asc_option = order_by::unspecified;
+
+            operator std::string() const {
+                std::string res = "PRIMARY KEY";
+                switch(this->asc_option) {
+                    case order_by::ascending:
+                        res += " ASC";
+                        break;
+                    case order_by::descending:
+                        res += " DESC";
+                        break;
+                    default:
+                        break;
+                }
+                return res;
+            }
+        };
+
+        /**
+         *  PRIMARY KEY constraint class.
+         *  Cs is parameter pack which contains columns (member pointers and/or function pointers). Can be empty when
+         *  used withen `make_column` function.
+         */
+        template<class... Cs>
+        struct primary_key_t : primary_key_base {
+            using order_by = primary_key_base::order_by;
+            using columns_tuple = std::tuple<Cs...>;
+
+            columns_tuple columns;
+
+            primary_key_t(decltype(columns) c) : columns(move(c)) {}
+
+            primary_key_t<Cs...> asc() const {
+                auto res = *this;
+                res.asc_option = order_by::ascending;
+                return res;
+            }
+
+            primary_key_t<Cs...> desc() const {
+                auto res = *this;
+                res.asc_option = order_by::descending;
+                return res;
+            }
+        };
+
+        struct unique_base {
+            operator std::string() const {
+                return "UNIQUE";
+            }
+        };
+
+        /**
+         *  UNIQUE constraint class.
+         */
+        template<class... Args>
+        struct unique_t : unique_base {
+            using columns_tuple = std::tuple<Args...>;
+
+            columns_tuple columns;
+
+            unique_t(columns_tuple columns_) : columns(move(columns_)) {}
+        };
+
+        /**
+         *  DEFAULT constraint class.
+         *  T is a value type.
+         */
+        template<class T>
+        struct default_t {
+            using value_type = T;
+
+            value_type value;
+
+            operator std::string() const {
+                return "DEFAULT";
+            }
+        };
+
+#if SQLITE_VERSION_NUMBER >= 3006019
+
+        /**
+         *  FOREIGN KEY constraint class.
+         *  Cs are columns which has foreign key
+         *  Rs are column which C references to
+         *  Available in SQLite 3.6.19 or higher
+         */
+
+        template<class A, class B>
+        struct foreign_key_t;
+
+        enum class foreign_key_action {
+            none,  //  not specified
+            no_action,
+            restrict_,
+            set_null,
+            set_default,
+            cascade,
+        };
+
+        inline std::ostream& operator<<(std::ostream& os, foreign_key_action action) {
+            switch(action) {
+                case decltype(action)::no_action:
+                    os << "NO ACTION";
+                    break;
+                case decltype(action)::restrict_:
+                    os << "RESTRICT";
+                    break;
+                case decltype(action)::set_null:
+                    os << "SET NULL";
+                    break;
+                case decltype(action)::set_default:
+                    os << "SET DEFAULT";
+                    break;
+                case decltype(action)::cascade:
+                    os << "CASCADE";
+                    break;
+                case decltype(action)::none:
+                    break;
+            }
+            return os;
+        }
+
+        struct on_update_delete_base {
+            const bool update;  //  true if update and false if delete
+
+            operator std::string() const {
+                if(this->update) {
+                    return "ON UPDATE";
+                } else {
+                    return "ON DELETE";
+                }
+            }
+        };
+
+        /**
+         *  F - foreign key class
+         */
+        template<class F>
+        struct on_update_delete_t : on_update_delete_base {
+            using foreign_key_type = F;
+
+            const foreign_key_type& fk;
+
+            on_update_delete_t(decltype(fk) fk_, decltype(update) update_, foreign_key_action action_) :
+                on_update_delete_base{update_}, fk(fk_), _action(action_) {}
+
+            foreign_key_action _action = foreign_key_action::none;
+
+            foreign_key_type no_action() const {
+                auto res = this->fk;
+                if(update) {
+                    res.on_update._action = foreign_key_action::no_action;
+                } else {
+                    res.on_delete._action = foreign_key_action::no_action;
+                }
+                return res;
+            }
+
+            foreign_key_type restrict_() const {
+                auto res = this->fk;
+                if(update) {
+                    res.on_update._action = foreign_key_action::restrict_;
+                } else {
+                    res.on_delete._action = foreign_key_action::restrict_;
+                }
+                return res;
+            }
+
+            foreign_key_type set_null() const {
+                auto res = this->fk;
+                if(update) {
+                    res.on_update._action = foreign_key_action::set_null;
+                } else {
+                    res.on_delete._action = foreign_key_action::set_null;
+                }
+                return res;
+            }
+
+            foreign_key_type set_default() const {
+                auto res = this->fk;
+                if(update) {
+                    res.on_update._action = foreign_key_action::set_default;
+                } else {
+                    res.on_delete._action = foreign_key_action::set_default;
+                }
+                return res;
+            }
+
+            foreign_key_type cascade() const {
+                auto res = this->fk;
+                if(update) {
+                    res.on_update._action = foreign_key_action::cascade;
+                } else {
+                    res.on_delete._action = foreign_key_action::cascade;
+                }
+                return res;
+            }
+
+            operator bool() const {
+                return this->_action != decltype(this->_action)::none;
+            }
+        };
+
+        template<class F>
+        bool operator==(const on_update_delete_t<F>& lhs, const on_update_delete_t<F>& rhs) {
+            return lhs._action == rhs._action;
+        }
+
+        template<class... Cs, class... Rs>
+        struct foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>> {
+            using columns_type = std::tuple<Cs...>;
+            using references_type = std::tuple<Rs...>;
+            using self = foreign_key_t<columns_type, references_type>;
+
+            /**
+             * Holds obect type of all referenced columns.
+             */
+            using target_type = typename same_or_void<typename table_type<Rs>::type...>::type;
+
+            /**
+             * Holds obect type of all source columns.
+             */
+            using source_type = typename same_or_void<typename table_type<Cs>::type...>::type;
+
+            columns_type columns;
+            references_type references;
+
+            on_update_delete_t<self> on_update;
+            on_update_delete_t<self> on_delete;
+
+            static_assert(std::tuple_size<columns_type>::value == std::tuple_size<references_type>::value,
+                          "Columns size must be equal to references tuple");
+            static_assert(!std::is_same<target_type, void>::value, "All references must have the same type");
+
+            foreign_key_t(columns_type columns_, references_type references_) :
+                columns(move(columns_)), references(move(references_)),
+                on_update(*this, true, foreign_key_action::none), on_delete(*this, false, foreign_key_action::none) {}
+
+            foreign_key_t(const self& other) :
+                columns(other.columns), references(other.references), on_update(*this, true, other.on_update._action),
+                on_delete(*this, false, other.on_delete._action) {}
+
+            self& operator=(const self& other) {
+                this->columns = other.columns;
+                this->references = other.references;
+                this->on_update = {*this, true, other.on_update._action};
+                this->on_delete = {*this, false, other.on_delete._action};
+                return *this;
+            }
+
+            template<class L>
+            void for_each_column(const L&) {}
+
+            template<class... Opts>
+            constexpr bool has_every() const {
+                return false;
+            }
+        };
+
+        template<class A, class B>
+        bool operator==(const foreign_key_t<A, B>& lhs, const foreign_key_t<A, B>& rhs) {
+            return lhs.columns == rhs.columns && lhs.references == rhs.references && lhs.on_update == rhs.on_update &&
+                   lhs.on_delete == rhs.on_delete;
+        }
+
+        /**
+         *  Cs can be a class member pointer, a getter function member pointer or setter
+         *  func member pointer
+         *  Available in SQLite 3.6.19 or higher
+         */
+        template<class... Cs>
+        struct foreign_key_intermediate_t {
+            using tuple_type = std::tuple<Cs...>;
+
+            tuple_type columns;
+
+            foreign_key_intermediate_t(tuple_type columns_) : columns(std::move(columns_)) {}
+
+            template<class... Rs>
+            foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>> references(Rs... refs) {
+                return {std::move(this->columns), std::make_tuple(std::forward<Rs>(refs)...)};
+            }
+        };
+#endif
+
+        struct collate_constraint_t {
+            internal::collate_argument argument = internal::collate_argument::binary;
+
+            collate_constraint_t(internal::collate_argument argument_) : argument(argument_) {}
+
+            operator std::string() const {
+                std::string res = "COLLATE " + this->string_from_collate_argument(this->argument);
+                return res;
+            }
+
+            static std::string string_from_collate_argument(internal::collate_argument argument) {
+                switch(argument) {
+                    case decltype(argument)::binary:
+                        return "BINARY";
+                    case decltype(argument)::nocase:
+                        return "NOCASE";
+                    case decltype(argument)::rtrim:
+                        return "RTRIM";
+                }
+                throw std::system_error(std::make_error_code(orm_error_code::invalid_collate_argument_enum));
+            }
+        };
+
+        struct check_string {
+            operator std::string() const {
+                return "CHECK";
+            }
+        };
+
+        template<class T>
+        struct check_t : check_string {
+            using expression_type = T;
+
+            expression_type expression;
+
+            check_t(expression_type expression_) : expression(std::move(expression_)) {}
+        };
+        struct basic_generated_always {
+            enum class storage_type {
+                not_specified,
+                virtual_,
+                stored,
+            };
+
+            bool full = true;
+            storage_type storage = storage_type::not_specified;
+        };
+
+        template<class T>
+        struct generated_always_t : basic_generated_always {
+            using expression_type = T;
+
+            expression_type expression;
+
+            generated_always_t(expression_type expression_, bool full, storage_type storage) :
+                basic_generated_always{full, storage}, expression(std::move(expression_)) {}
+
+            generated_always_t<T> virtual_() {
+                return {std::move(this->expression), this->full, storage_type::virtual_};
+            }
+
+            generated_always_t<T> stored() {
+                return {std::move(this->expression), this->full, storage_type::stored};
+            }
+        };
+
+        template<class T>
+        struct is_generated_always : std::false_type {};
+
+        template<class T>
+        struct is_generated_always<generated_always_t<T>> : std::true_type {};
+
+        template<class T>
+        struct is_constraint : std::false_type {};
+
+        template<>
+        struct is_constraint<autoincrement_t> : std::true_type {};
+
+        template<class... Cs>
+        struct is_constraint<primary_key_t<Cs...>> : std::true_type {};
+
+        template<class... Args>
+        struct is_constraint<unique_t<Args...>> : std::true_type {};
+
+        template<class T>
+        struct is_constraint<default_t<T>> : std::true_type {};
+
+        template<class C, class R>
+        struct is_constraint<foreign_key_t<C, R>> : std::true_type {};
+
+        template<>
+        struct is_constraint<collate_constraint_t> : std::true_type {};
+
+        template<class T>
+        struct is_constraint<check_t<T>> : std::true_type {};
+#if SQLITE_VERSION_NUMBER >= 3031000
+        template<class T>
+        struct is_constraint<generated_always_t<T>> : std::true_type {};
+#endif
+        template<class... Args>
+        struct constraints_size;
+
+        template<>
+        struct constraints_size<> {
+            static constexpr const int value = 0;
+        };
+
+        template<class H, class... Args>
+        struct constraints_size<H, Args...> {
+            static constexpr const int value = is_constraint<H>::value + constraints_size<Args...>::value;
+        };
+    }
+#if SQLITE_VERSION_NUMBER >= 3031000
+    template<class T>
+    internal::generated_always_t<T> generated_always_as(T expression) {
+        return {std::move(expression), true, internal::basic_generated_always::storage_type::not_specified};
+    }
+
+    template<class T>
+    internal::generated_always_t<T> as(T expression) {
+        return {std::move(expression), false, internal::basic_generated_always::storage_type::not_specified};
+    }
+#endif
+#if SQLITE_VERSION_NUMBER >= 3006019
+
+    /**
+     *  FOREIGN KEY constraint construction function that takes member pointer as argument
+     *  Available in SQLite 3.6.19 or higher
+     */
+    template<class... Cs>
+    internal::foreign_key_intermediate_t<Cs...> foreign_key(Cs... columns) {
+        return {std::make_tuple(std::forward<Cs>(columns)...)};
+    }
+#endif
+
+    /**
+     *  UNIQUE constraint builder function.
+     */
+    template<class... Args>
+    internal::unique_t<Args...> unique(Args... args) {
+        return {std::make_tuple(std::forward<Args>(args)...)};
+    }
+
+    inline internal::unique_t<> unique() {
+        return {{}};
+    }
+
+    inline internal::autoincrement_t autoincrement() {
+        return {};
+    }
+
+    template<class... Cs>
+    internal::primary_key_t<Cs...> primary_key(Cs... cs) {
+        return {std::make_tuple(std::forward<Cs>(cs)...)};
+    }
+
+    inline internal::primary_key_t<> primary_key() {
+        return {{}};
+    }
+
+    template<class T>
+    internal::default_t<T> default_value(T t) {
+        return {std::move(t)};
+    }
+
+    inline internal::collate_constraint_t collate_nocase() {
+        return {internal::collate_argument::nocase};
+    }
+
+    inline internal::collate_constraint_t collate_binary() {
+        return {internal::collate_argument::binary};
+    }
+
+    inline internal::collate_constraint_t collate_rtrim() {
+        return {internal::collate_argument::rtrim};
+    }
+
+    template<class T>
+    internal::check_t<T> check(T t) {
+        return {std::move(t)};
+    }
+
+    namespace internal {
+
+        /**
+         *  FOREIGN KEY traits. Common case
+         */
+        template<class T>
+        struct is_foreign_key : std::false_type {};
+
+        /**
+         *  FOREIGN KEY traits. Specialized case
+         */
+        template<class C, class R>
+        struct is_foreign_key<internal::foreign_key_t<C, R>> : std::true_type {};
+
+        /**
+         *  PRIMARY KEY traits. Common case
+         */
+        template<class T>
+        struct is_primary_key : public std::false_type {};
+
+        /**
+         *  PRIMARY KEY traits. Specialized case
+         */
+        template<class... Cs>
+        struct is_primary_key<internal::primary_key_t<Cs...>> : public std::true_type {};
+
+        /**
+         * PRIMARY KEY INSERTABLE traits.
+         */
+        template<typename T>
+        struct is_primary_key_insertable {
+            using field_type = typename T::field_type;
+            using constraints_type = typename T::constraints_type;
+
+            static_assert((tuple_helper::tuple_contains_type<primary_key_t<>, constraints_type>::value),
+                          "an unexpected type was passed");
+
+            static constexpr bool value =
+                (tuple_helper::tuple_contains_some_type<default_t, constraints_type>::value ||
+                 tuple_helper::tuple_contains_type<autoincrement_t, constraints_type>::value ||
+                 std::is_base_of<integer_printer, type_printer<field_type>>::value);
+        };
+    }
+
+}
+#pragma once
+
+#include <type_traits>  //  std::false_type, std::true_type
+#include <memory>  //  std::shared_ptr, std::unique_ptr
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+#include <optional>  // std::optional
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+namespace sqlite_orm {
+
+    /**
+     *  This is class that tells `sqlite_orm` that type is nullable. Nullable types
+     *  are mapped to sqlite database as `NULL` and not-nullable are mapped as `NOT NULL`.
+     *  Default nullability status for all types is `NOT NULL`. So if you want to map
+     *  custom type as `NULL` (for example: boost::optional) you have to create a specialiation
+     *  of type_is_nullable for your type and derive from `std::true_type`.
+     */
+    template<class T>
+    struct type_is_nullable : public std::false_type {
+        bool operator()(const T&) const {
+            return true;
+        }
+    };
+
+    /**
+     *  This is a specialization for std::shared_ptr. std::shared_ptr is nullable in sqlite_orm.
+     */
+    template<class T>
+    struct type_is_nullable<std::shared_ptr<T>> : public std::true_type {
+        bool operator()(const std::shared_ptr<T>& t) const {
+            return static_cast<bool>(t);
+        }
+    };
+
+    /**
+     *  This is a specialization for std::unique_ptr. std::unique_ptr is nullable too.
+     */
+    template<class T>
+    struct type_is_nullable<std::unique_ptr<T>> : public std::true_type {
+        bool operator()(const std::unique_ptr<T>& t) const {
+            return static_cast<bool>(t);
+        }
+    };
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+    /**
+     *  This is a specialization for std::optional. std::optional is nullable.
+     */
+    template<class T>
+    struct type_is_nullable<std::optional<T>> : public std::true_type {
+        bool operator()(const std::optional<T>& t) const {
+            return t.has_value();
+        }
+    };
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+}
+#pragma once
+
+#include <memory>  //  std::unique_ptr
+#include <string>  //  std::string
+#include <sstream>  //  std::stringstream
+
+// #include "constraints.h"
+
+// #include "serializator_context.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        struct serializator_context_base {
+            bool replace_bindable_with_question = false;
+            bool skip_table_name = true;
+            bool use_parentheses = true;
+        };
+
+        template<class I>
+        struct serializator_context : serializator_context_base {
+            using impl_type = I;
+
+            const impl_type& impl;
+
+            serializator_context(const impl_type& impl_) : impl(impl_) {}
+        };
+
+        template<class S>
+        struct serializator_context_builder {
+            using storage_type = S;
+            using impl_type = typename storage_type::impl_type;
+
+            serializator_context_builder(const storage_type& storage_) : storage(storage_) {}
+
+            serializator_context<impl_type> operator()() const {
+                return {obtain_const_impl(this->storage)};
+            }
+
+            const storage_type& storage;
+        };
+
+    }
+
+}
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  This class is used in tuple interation to know whether tuple constains `default_value_t`
+         *  constraint class and what it's value if it is
+         */
+        struct default_value_extractor {
+
+            template<class A>
+            std::unique_ptr<std::string> operator()(const A&) {
+                return {};
+            }
+
+            template<class T>
+            std::unique_ptr<std::string> operator()(const default_t<T>& t) {
+                serializator_context_base context;
+                return std::make_unique<std::string>(serialize(t.value, context));
+            }
+        };
+
+    }
+
+}
+#pragma once
+
+#include <type_traits>  //  std::false_type, std::true_type
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+#include <optional>  //  std::nullopt
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+// #include "tags.h"
+
+namespace sqlite_orm {
+    namespace internal {
+        struct negatable_t {};
+
+        /**
+         *  Inherit from this class if target class can be chained with other conditions with '&&' and '||' operators
+         */
+        struct condition_t {};
+    }
+}
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  Inherit this class to support arithmetic types overloading
+         */
+        struct arithmetic_t {};
+
+        template<class L, class R, class... Ds>
+        struct binary_operator : Ds... {
+            using left_type = L;
+            using right_type = R;
+
+            left_type lhs;
+            right_type rhs;
+
+            binary_operator(left_type lhs_, right_type rhs_) : lhs(std::move(lhs_)), rhs(std::move(rhs_)) {}
+        };
+
+        struct conc_string {
+            operator std::string() const {
+                return "||";
+            }
+        };
+
+        /**
+         *  Result of concatenation || operator
+         */
+        template<class L, class R>
+        using conc_t = binary_operator<L, R, conc_string>;
+
+        struct add_string {
+            operator std::string() const {
+                return "+";
+            }
+        };
+
+        /**
+         *  Result of addition + operator
+         */
+        template<class L, class R>
+        using add_t = binary_operator<L, R, add_string, arithmetic_t, negatable_t>;
+
+        struct sub_string {
+            operator std::string() const {
+                return "-";
+            }
+        };
+
+        /**
+         *  Result of substitute - operator
+         */
+        template<class L, class R>
+        using sub_t = binary_operator<L, R, sub_string, arithmetic_t, negatable_t>;
+
+        struct mul_string {
+            operator std::string() const {
+                return "*";
+            }
+        };
+
+        /**
+         *  Result of multiply * operator
+         */
+        template<class L, class R>
+        using mul_t = binary_operator<L, R, mul_string, arithmetic_t, negatable_t>;
+
+        struct div_string {
+            operator std::string() const {
+                return "/";
+            }
+        };
+
+        /**
+         *  Result of divide / operator
+         */
+        template<class L, class R>
+        using div_t = binary_operator<L, R, div_string, arithmetic_t, negatable_t>;
+
+        struct mod_operator_string {
+            operator std::string() const {
+                return "%";
+            }
+        };
+
+        /**
+         *  Result of mod % operator
+         */
+        template<class L, class R>
+        using mod_t = binary_operator<L, R, mod_operator_string, arithmetic_t, negatable_t>;
+
+        struct bitwise_shift_left_string {
+            operator std::string() const {
+                return "<<";
+            }
+        };
+
+        /**
+         * Result of bitwise shift left << operator
+         */
+        template<class L, class R>
+        using bitwise_shift_left_t = binary_operator<L, R, bitwise_shift_left_string, arithmetic_t, negatable_t>;
+
+        struct bitwise_shift_right_string {
+            operator std::string() const {
+                return ">>";
+            }
+        };
+
+        /**
+         * Result of bitwise shift right >> operator
+         */
+        template<class L, class R>
+        using bitwise_shift_right_t = binary_operator<L, R, bitwise_shift_right_string, arithmetic_t, negatable_t>;
+
+        struct bitwise_and_string {
+            operator std::string() const {
+                return "&";
+            }
+        };
+
+        /**
+         * Result of bitwise and & operator
+         */
+        template<class L, class R>
+        using bitwise_and_t = binary_operator<L, R, bitwise_and_string, arithmetic_t, negatable_t>;
+
+        struct bitwise_or_string {
+            operator std::string() const {
+                return "|";
+            }
+        };
+
+        /**
+         * Result of bitwise or | operator
+         */
+        template<class L, class R>
+        using bitwise_or_t = binary_operator<L, R, bitwise_or_string, arithmetic_t, negatable_t>;
+
+        struct bitwise_not_string {
+            operator std::string() const {
+                return "~";
+            }
+        };
+
+        /**
+         * Result of bitwise not ~ operator
+         */
+        template<class T>
+        struct bitwise_not_t : bitwise_not_string, arithmetic_t, negatable_t {
+            using argument_type = T;
+
+            argument_type argument;
+
+            bitwise_not_t(argument_type argument_) : argument(std::move(argument_)) {}
+        };
+
+        struct assign_string {
+            operator std::string() const {
+                return "=";
+            }
+        };
+
+        /**
+         *  Result of assign = operator
+         */
+        template<class L, class R>
+        using assign_t = binary_operator<L, R, assign_string>;
+
+        /**
+         *  Assign operator traits. Common case
+         */
+        template<class T>
+        struct is_assign_t : public std::false_type {};
+
+        /**
+         *  Assign operator traits. Specialized case
+         */
+        template<class L, class R>
+        struct is_assign_t<assign_t<L, R>> : public std::true_type {};
+
+        template<class L, class... Args>
+        struct in_t;
+
+    }
+
+    /**
+     *  Public interface for || concatenation operator. Example: `select(conc(&User::name, "@gmail.com"));` => SELECT
+     * name || '@gmail.com' FROM users
+     */
+    template<class L, class R>
+    internal::conc_t<L, R> conc(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    /**
+     *  Public interface for + operator. Example: `select(add(&User::age, 100));` => SELECT age + 100 FROM users
+     */
+    template<class L, class R>
+    internal::add_t<L, R> add(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    /**
+     *  Public interface for - operator. Example: `select(sub(&User::age, 1));` => SELECT age - 1 FROM users
+     */
+    template<class L, class R>
+    internal::sub_t<L, R> sub(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    /**
+     *  Public interface for * operator. Example: `select(mul(&User::salary, 2));` => SELECT salary * 2 FROM users
+     */
+    template<class L, class R>
+    internal::mul_t<L, R> mul(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    /**
+     *  Public interface for / operator. Example: `select(div(&User::salary, 3));` => SELECT salary / 3 FROM users
+     *  @note Please notice that ::div function already exists in pure C standard library inside <cstdlib> header.
+     *  If you use `using namespace sqlite_orm` directive you an specify which `div` you call explicitly using  `::div` or `sqlite_orm::div` statements.
+     */
+    template<class L, class R>
+    internal::div_t<L, R> div(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    /**
+     *  Public interface for % operator. Example: `select(mod(&User::age, 5));` => SELECT age % 5 FROM users
+     */
+    template<class L, class R>
+    internal::mod_t<L, R> mod(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::bitwise_shift_left_t<L, R> bitwise_shift_left(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::bitwise_shift_right_t<L, R> bitwise_shift_right(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::bitwise_and_t<L, R> bitwise_and(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::bitwise_or_t<L, R> bitwise_or(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class T>
+    internal::bitwise_not_t<T> bitwise_not(T t) {
+        return {std::move(t)};
+    }
+
+    template<class L, class R>
+    internal::assign_t<L, R> assign(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+}
+#pragma once
+
+#include <tuple>  //  std::tuple
+#include <string>  //  std::string
+#include <memory>  //  std::unique_ptr
+#include <type_traits>  //  std::true_type, std::false_type, std::is_same, std::enable_if, std::is_member_pointer, std::is_member_function_pointer
+
+// #include "cxx_polyfill.h"
+
+// #include "type_traits.h"
+
+#include <type_traits>
+#include <tuple>
+
+// #include "cxx_polyfill.h"
+
+namespace sqlite_orm {
+    // C++ generic traits used throughout the library
+    namespace internal {
+        // enable_if for types
+        template<template<typename...> class Op, class... Args>
+        using match_if = std::enable_if_t<Op<Args...>::value>;
+
+        // enable_if for types
+        template<template<typename...> class Op, class... Args>
+        using match_if_not = std::enable_if_t<std::negation<Op<Args...>>::value>;
+
+        // enable_if for types
+        template<class T, template<typename...> class Primary>
+        using match_specialization_of = std::enable_if_t<polyfill::is_specialization_of_v<T, Primary>>;
+
+        // enable_if for functions
+        template<template<typename...> class Op, class... Args>
+        using satisfies = std::enable_if_t<Op<Args...>::value, bool>;
+
+        // enable_if for functions
+        template<template<typename...> class Op, class... Args>
+        using satisfies_not = std::enable_if_t<std::negation<Op<Args...>>::value, bool>;
+
+        // enable_if for functions
+        template<class T, template<typename...> class Primary>
+        using satisfies_is_specialization_of = std::enable_if_t<polyfill::is_specialization_of_v<T, Primary>, bool>;
+    }
+
+    // type traits not quite polyfill, however used throughout the program
+    namespace internal {
+        template<typename T>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_integral_constant_v = false;
+
+        template<typename T, T N>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_integral_constant_v<std::integral_constant<T, N>> = true;
+
+        template<typename T>
+        struct is_integral_constant : polyfill::bool_constant<is_integral_constant_v<T>> {};
+    }
+
+    // type name template aliases for syntactic sugar
+    namespace internal {
+        template<typename T>
+        using type_t = typename T::type;
+
+        template<typename T>
+        using value_type_t = typename T::value_type;
+
+        template<typename T>
+        using field_type_t = typename T::field_type;
+
+        template<typename T>
+        using object_type_t = typename T::object_type;
+
+        template<typename T>
+        using cte_label_type_t = typename T::cte_label_type;
+
+        template<typename T>
+        using cte_object_type_t = typename T::cte_object_type;
+
+        template<typename T>
+        using table_type_t = typename T::table_type;
+
+        template<typename S>
+        using storage_object_type_t = typename S::table_type::object_type;
+
+        template<typename S>
+        using storage_cte_mapper_type_t = typename S::table_type::cte_mapper_type;
+
+        template<typename S>
+        using storage_cte_label_type_t = typename S::table_type::cte_label_type;
+
+        template<typename T>
+        using expression_type_t = typename T::expression_type;
+    }
+
+    namespace internal {
+        template<unsigned int N>
+        using nth_constant = std::integral_constant<unsigned int, N>;
+
+        template<typename... Fs>
+        using fields_t = std::tuple<Fs...>;
+
+#if __cplusplus >= 201703L  // use of C++17 or higher
+        template<auto c>
+        using ice_t = std::integral_constant<decltype(c), c>;
+
+        // cudos to OznOg https://stackoverflow.com/a/64606884/279251
+        template<class X, class Tuple>
+        struct tuple_index_of;
+
+        template<class X, class... T>
+        struct tuple_index_of<X, std::tuple<T...>> {
+            template<size_t... idx>
+            static constexpr ptrdiff_t find_idx(std::index_sequence<idx...>) {
+                return std::max({static_cast<ptrdiff_t>(std::is_same<X, T>::value ? idx : -1)...});
+            }
+
+            static constexpr ptrdiff_t value = find_idx(std::index_sequence_for<T...>{});
+        };
+        template<class X, class Tuple>
+        inline constexpr ptrdiff_t tuple_index_of_v = tuple_index_of<X, Tuple>::value;
+#endif
+
+        template<typename T>
+        struct tuplify {
+            using type = T;
+        };
+        template<typename... Ts>
+        struct tuplify<std::tuple<Ts...>> {
+            using type = std::tuple<Ts...>;
+        };
+
+        template<typename T>
+        using tuplify_t = typename tuplify<T>::type;
+    }
+
+#if __cplusplus >= 201703L  // use of C++17 or higher
+    /**
+     *  Capture a compile-time value as an integral constant.
+     */
+    template<auto c>
+    inline constexpr internal::ice_t<c> c_v{};
+#endif
+}
+
+// #include "type_is_nullable.h"
+
+// #include "tuple_helper/tuple_helper.h"
+
+// #include "default_value_extractor.h"
+
+// #include "constraints.h"
+
+// #include "member_traits/member_traits.h"
+
+#include <type_traits>  //  std::enable_if
+
+// #include "is_field_member_pointer.h"
+
+#include <type_traits>  //  std::false_type, std::true_type, std::is_member_pointer, std::is_member_function_pointer
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T, class SFINAE = void>
+        struct is_field_member_pointer : std::false_type {};
+
+        template<class T>
+        struct is_field_member_pointer<T,
+                                       typename std::enable_if<std::is_member_pointer<T>::value &&
+                                                               !std::is_member_function_pointer<T>::value>::type>
+            : std::true_type {};
+    }
+}
+
+// #include "is_getter.h"
+
+// #include "field_member_traits.h"
+
+#include <type_traits>  //  std::enable_if
+
+// #include "is_field_member_pointer.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T, class SFINAE = void>
+        struct field_member_traits;
+
+        template<class O, class F>
+        struct field_member_traits<F O::*, typename std::enable_if<is_field_member_pointer<F O::*>::value>::type> {
+            using object_type = O;
+            using field_type = F;
+        };
+    }
+}
+
+// #include "is_setter.h"
+
+// #include "getter_traits.h"
+
+// #include "setter_traits.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T, class SFINAE = void>
+        struct member_traits;
+
+        template<class T>
+        struct member_traits<T, typename std::enable_if<is_field_member_pointer<T>::value>::type> {
+            using object_type = typename field_member_traits<T>::object_type;
+            using field_type = typename field_member_traits<T>::field_type;
+        };
+
+        template<class T>
+        struct member_traits<T, typename std::enable_if<is_getter<T>::value>::type> {
+            using object_type = typename getter_traits<T>::object_type;
+            using field_type = typename getter_traits<T>::field_type;
+        };
+
+        template<class T>
+        struct member_traits<T, typename std::enable_if<is_setter<T>::value>::type> {
+            using object_type = typename setter_traits<T>::object_type;
+            using field_type = typename setter_traits<T>::field_type;
+        };
+    }
+}
+
+// #include "member_traits/field_member_traits.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  typename T::value_type if is_integral_constant_v<T>
+         */
+        template<typename T>
+        using ice_value_type_t = std::enable_if_t<is_integral_constant_v<T>, value_type_t<T>>;
+
+        struct basic_column {
+
+            /**
+             *  Column name. Specified during construction in `make_column`.
+             */
+            const std::string name;
+        };
+
+        /**
+         *  This class stores single column info. column_t is a pair of [column_name:member_pointer] mapped to a storage
+         *  O is a mapped class, e.g. User
+         *  T is a mapped class'es field type, e.g. &User::name
+         *  Op... is a constraints pack, e.g. primary_key_t, autoincrement_t etc
+         */
+        template<class O, class T, class G /* = const T& (O::*)() const*/, class S /* = void (O::*)(T)*/, class... Op>
+        struct column_t : basic_column {
+            using object_type = O;
+            // the passed in type is either `integral_constant<F O::*member>` or the return type
+            using _ice_or_field_type = T;
+            // `F O::*` from `integral_constant<F O::*member>` or `T`
+            using _member_pointer_or_field_type = polyfill::detected_or_t<T, ice_value_type_t, T>;
+            // `F` from `F O::*` or `T`
+            using field_type = polyfill::detected_or_t<_member_pointer_or_field_type,
+                                                       field_type_t,
+                                                       field_member_traits<_member_pointer_or_field_type>>;
+            using constraints_type = std::tuple<Op...>;
+            using member_pointer_t = field_type object_type::*;
+            using getter_type = G;
+            using setter_type = S;
+
+            /**
+             *  Member pointer used to read/write member
+             */
+            member_pointer_t member_pointer /* = nullptr*/;
+
+            /**
+             *  Getter member function pointer to get a value. If member_pointer is null than
+             *  `getter` and `setter` must be not null
+             */
+            getter_type getter /* = nullptr*/;
+
+            /**
+             *  Setter member function
+             */
+            setter_type setter /* = nullptr*/;
+
+            /**
+             *  Constraints tuple
+             */
+            constraints_type constraints;
+
+            column_t(std::string name_,
+                     member_pointer_t member_pointer_,
+                     getter_type getter_,
+                     setter_type setter_,
+                     constraints_type constraints_) :
+                basic_column{move(name_)},
+                member_pointer(member_pointer_), getter(getter_), setter(setter_), constraints(move(constraints_)) {}
+
+            /**
+             *  Simplified interface for `NOT NULL` constraint
+             */
+            bool not_null() const {
+                return !type_is_nullable<field_type>::value;
+            }
+
+            template<class Opt>
+            constexpr bool has() const {
+                return tuple_helper::tuple_contains_type<Opt, constraints_type>::value;
+            }
+
+            template<class O1, class O2, class... Opts>
+            constexpr bool has_every() const {
+                if(has<O1>() && has<O2>()) {
+                    return true;
+                } else {
+                    return has_every<Opts...>();
+                }
+            }
+
+            template<class O1>
+            constexpr bool has_every() const {
+                return has<O1>();
+            }
+
+            /**
+             *  Simplified interface for `DEFAULT` constraint
+             *  @return string representation of default value if it exists otherwise nullptr
+             */
+            std::unique_ptr<std::string> default_value() const {
+                std::unique_ptr<std::string> res;
+                iterate_tuple(this->constraints, [&res](auto& v) {
+                    auto dft = internal::default_value_extractor()(v);
+                    if(dft) {
+                        res = std::move(dft);
+                    }
+                });
+                return res;
+            }
+
+            bool is_generated() const {
+#if SQLITE_VERSION_NUMBER >= 3031000
+                auto res = false;
+                iterate_tuple(this->constraints, [&res](auto& constraint) {
+                    using constraint_type = typename std::decay<decltype(constraint)>::type;
+                    if(!res) {
+                        res = is_generated_always<constraint_type>::value;
+                    }
+                });
+                return res;
+#else
+                return false;
+#endif
+            }
+        };
+
+        // we are compelled to wrap all sfinae-implemented traits to prevent "error: type/value mismatch at argument 2 in template parameter list"
+        namespace sfinae {
+            /**
+             *  Column with insertable primary key traits. Common case.
+             */
+            template<class T, class SFINAE = void>
+            struct is_column_with_insertable_primary_key : public std::false_type {};
+
+            /**
+             *  Column with insertable primary key traits. Specialized case case.
+             */
+            template<class O, class T, class... Op>
+            struct is_column_with_insertable_primary_key<
+                column_t<O, T, Op...>,
+                typename std::enable_if<(tuple_helper::tuple_contains_type<
+                                         primary_key_t<>,
+                                         typename column_t<O, T, Op...>::constraints_type>::value)>::type> {
+                using column_type = column_t<O, T, Op...>;
+                static constexpr bool value = is_primary_key_insertable<column_type>::value;
+            };
+
+            /**
+             *  Column with noninsertable primary key traits. Common case.
+             */
+            template<class T, class SFINAE = void>
+            struct is_column_with_noninsertable_primary_key : public std::false_type {};
+
+            /**
+             *  Column with noninsertable primary key traits. Specialized case case.
+             */
+            template<class O, class T, class... Op>
+            struct is_column_with_noninsertable_primary_key<
+                column_t<O, T, Op...>,
+                typename std::enable_if<(tuple_helper::tuple_contains_type<
+                                         primary_key_t<>,
+                                         typename column_t<O, T, Op...>::constraints_type>::value)>::type> {
+                using column_type = column_t<O, T, Op...>;
+                static constexpr bool value = !is_primary_key_insertable<column_type>::value;
+            };
+
+        }
+
+        /**
+         *  Column traits. Common case.
+         */
+        template<class T>
+        struct is_column : public std::false_type {};
+
+        /**
+         *  Column traits. Specialized case case.
+         */
+        template<class O, class T, class... Op>
+        struct is_column<column_t<O, T, Op...>> : public std::true_type {};
+
+        /**
+         *  Column with insertable primary key traits.
+         */
+        template<class T>
+        struct is_column_with_insertable_primary_key : public sfinae::is_column_with_insertable_primary_key<T> {};
+
+        /**
+         *  Column with noninsertable primary key traits.
+         */
+        template<class T>
+        struct is_column_with_noninsertable_primary_key : public sfinae::is_column_with_noninsertable_primary_key<T> {};
+
+        template<class T>
+        struct column_field_type {
+            using type = void;
+        };
+
+        template<class O, class T, class... Op>
+        struct column_field_type<column_t<O, T, Op...>> {
+            using type = typename column_t<O, T, Op...>::field_type;
+        };
+
+        template<class T, class SFINAE = void>
+        struct column_field_expression {
+            using type = void;
+        };
+
+        template<class O, class T, class... Op>
+        struct column_field_expression<column_t<O, T, Op...>, match_if_not<is_integral_constant, T>> {
+            using type = typename column_t<O, T, Op...>::member_pointer_t;
+        };
+
+        // match `F O::*member`
+        template<class O, class F, F O::*m, class... Op>
+        struct column_field_expression<column_t<O, ice_t<m>, Op...>, void> : ice_t<m> {};
+
+        template<class T>
+        struct column_constraints_type {
+            using type = std::tuple<>;
+        };
+
+        template<class O, class T, class... Op>
+        struct column_constraints_type<column_t<O, T, Op...>> {
+            using type = typename column_t<O, T, Op...>::constraints_type;
+        };
+
+    }
+
+    /**
+     *  Column builder function. You should use it to create columns instead of constructor
+     */
+    template<class O,
+             class T,
+             typename = typename std::enable_if<!std::is_member_function_pointer<T O::*>::value>::type,
+             class... Op>
+    internal::column_t<O, T, const T& (O::*)() const, void (O::*)(T), Op...>
+    make_column(const std::string& name, T O::*m, Op... constraints) {
+        static_assert(internal::template constraints_size<Op...>::value == std::tuple_size<std::tuple<Op...>>::value,
+                      "Incorrect constraints pack");
+        static_assert(internal::is_field_member_pointer<T O::*>::value,
+                      "second argument expected as a member field pointer, not member function pointer");
+        return {name, m, nullptr, nullptr, std::make_tuple(constraints...)};
+    }
+
+    /**
+     *  Column builder function. You should use it to create columns instead of constructor
+     */
+    template<class T,
+             T m,
+             class O = typename internal::field_member_traits<T>::object_type,
+             class F = typename internal::field_member_traits<T>::field_type,
+             class... Op>
+    internal::column_t<O, std::integral_constant<T, m>, const F& (O::*)() const, void (O::*)(F), Op...>
+    make_column(const std::string& name, std::integral_constant<T, m>, Op... constraints) {
+        static_assert(internal::template constraints_size<Op...>::value == std::tuple_size<std::tuple<Op...>>::value,
+                      "Incorrect constraints pack");
+        static_assert(internal::is_field_member_pointer<T>::value,
+                      "second argument expected as a member field pointer, not member function pointer");
+        return {name, m, nullptr, nullptr, std::make_tuple(constraints...)};
+    }
+
+    /**
+     *  Column builder function with setter and getter. You should use it to create columns instead of constructor
+     */
+    template<class G,
+             class S,
+             typename = typename std::enable_if<internal::is_getter<G>::value>::type,
+             typename = typename std::enable_if<internal::is_setter<S>::value>::type,
+             class... Op>
+    internal::column_t<typename internal::setter_traits<S>::object_type,
+                       typename internal::setter_traits<S>::field_type,
+                       G,
+                       S,
+                       Op...>
+    make_column(const std::string& name, S setter, G getter, Op... constraints) {
+        static_assert(std::is_same<typename internal::setter_traits<S>::field_type,
+                                   typename internal::getter_traits<G>::field_type>::value,
+                      "Getter and setter must get and set same data type");
+        static_assert(internal::template constraints_size<Op...>::value == std::tuple_size<std::tuple<Op...>>::value,
+                      "Incorrect constraints pack");
+        return {name, nullptr, getter, setter, std::make_tuple(constraints...)};
+    }
+
+    /**
+     *  Column builder function with getter and setter (reverse order). You should use it to create columns instead of
+     * constructor
+     */
+    template<class G,
+             class S,
+             typename = typename std::enable_if<internal::is_getter<G>::value>::type,
+             typename = typename std::enable_if<internal::is_setter<S>::value>::type,
+             class... Op>
+    internal::column_t<typename internal::setter_traits<S>::object_type,
+                       typename internal::setter_traits<S>::field_type,
+                       G,
+                       S,
+                       Op...>
+    make_column(const std::string& name, G getter, S setter, Op... constraints) {
+        static_assert(std::is_same<typename internal::setter_traits<S>::field_type,
+                                   typename internal::getter_traits<G>::field_type>::value,
+                      "Getter and setter must get and set same data type");
+        static_assert(internal::template constraints_size<Op...>::value == std::tuple_size<std::tuple<Op...>>::value,
+                      "Incorrect constraints pack");
+        return {name, nullptr, getter, setter, std::make_tuple(constraints...)};
+    }
+
+}
+#pragma once
+
+#include <string>  //  std::string
+#include <sstream>  //  std::stringstream
+#include <vector>  //  std::vector
+#include <cstddef>  //  std::nullptr_t
+#include <memory>  //  std::shared_ptr, std::unique_ptr
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+#include <optional>  // std::optional
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+#ifndef SQLITE_ORM_OMITS_CODECVT
+#include <codecvt>  //  std::codecvt_utf8_utf16
+#endif  //  SQLITE_ORM_OMITS_CODECVT
+
+namespace sqlite_orm {
+
+    /**
+     *  Is used to print members mapped to objects in storage_t::dump member function.
+     *  Other developers can create own specialization to map custom types
+     */
+    template<class T, typename Enable = void>
+    struct field_printer {
+        std::string operator()(const T& t) const {
+            std::stringstream stream;
+            stream << t;
+            return stream.str();
+        }
+    };
+
+    /**
+     *  Upgrade to integer is required when using unsigned char(uint8_t)
+     */
+    template<>
+    struct field_printer<unsigned char, void> {
+        std::string operator()(const unsigned char& t) const {
+            std::stringstream stream;
+            stream << +t;
+            return stream.str();
+        }
+    };
+
+    /**
+     *  Upgrade to integer is required when using signed char(int8_t)
+     */
+    template<>
+    struct field_printer<signed char, void> {
+        std::string operator()(const signed char& t) const {
+            std::stringstream stream;
+            stream << +t;
+            return stream.str();
+        }
+    };
+
+    /**
+     *  char is neigher signer char nor unsigned char so it has its own specialization
+     */
+    template<>
+    struct field_printer<char, void> {
+        std::string operator()(const char& t) const {
+            std::stringstream stream;
+            stream << +t;
+            return stream.str();
+        }
+    };
+
+    template<>
+    struct field_printer<std::string, void> {
+        std::string operator()(const std::string& string) const {
+            return string;
+        }
+    };
+
+    template<>
+    struct field_printer<std::vector<char>, void> {
+        std::string operator()(const std::vector<char>& t) const {
+            std::stringstream ss;
+            ss << std::hex;
+            for(auto c: t) {
+                ss << c;
+            }
+            return ss.str();
+        }
+    };
+#ifndef SQLITE_ORM_OMITS_CODECVT
+    template<>
+    struct field_printer<std::wstring, void> {
+        std::string operator()(const std::wstring& wideString) const {
+            std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
+            return converter.to_bytes(wideString);
+        }
+    };
+#endif  //  SQLITE_ORM_OMITS_CODECVT
+    template<>
+    struct field_printer<std::nullptr_t, void> {
+        std::string operator()(const std::nullptr_t&) const {
+            return "null";
+        }
+    };
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+    template<>
+    struct field_printer<std::nullopt_t, void> {
+        std::string operator()(const std::nullopt_t&) const {
+            return "null";
+        }
+    };
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+    template<class T>
+    struct field_printer<std::shared_ptr<T>, void> {
+        std::string operator()(const std::shared_ptr<T>& t) const {
+            if(t) {
+                return field_printer<T>()(*t);
+            } else {
+                return field_printer<std::nullptr_t>()(nullptr);
+            }
+        }
+    };
+
+    template<class T>
+    struct field_printer<std::unique_ptr<T>, void> {
+        std::string operator()(const std::unique_ptr<T>& t) const {
+            if(t) {
+                return field_printer<T>()(*t);
+            } else {
+                return field_printer<std::nullptr_t>()(nullptr);
+            }
+        }
+    };
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+    template<class T>
+    struct field_printer<std::optional<T>, void> {
+        std::string operator()(const std::optional<T>& t) const {
+            if(t.has_value()) {
+                return field_printer<T>()(*t);
+            } else {
+                return field_printer<std::nullptr_t>()(nullptr);
+            }
+        }
+    };
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+    template<typename P, typename T, typename D>
+    class pointer_binding;
+
+    template<class P, class T, class D>
+    struct field_printer<pointer_binding<P, T, D>, void> {
+        std::string operator()(const pointer_binding<P, T, D>&) const {
+            return field_printer<std::nullptr_t>()(nullptr);
+        }
+    };
+}
+#pragma once
+
+#include <string>  //  std::string
+#include <type_traits>  //  std::enable_if, std::is_same
+#include <vector>  //  std::vector
+#include <tuple>  //  std::tuple, std::tuple_size
+#include <sstream>  //  std::stringstream
+
+// #include "type_traits.h"
+
+// #include "collate_argument.h"
+
+// #include "constraints.h"
+
+// #include "optional_container.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  This is a cute class which allows storing something or nothing
+         *  depending on template argument. Useful for optional class members
+         */
+        template<class T>
+        struct optional_container {
+            using type = T;
+
+            type field;
+
+            template<class L>
+            void apply(const L& l) const {
+                l(this->field);
+            }
+        };
+
+        template<>
+        struct optional_container<void> {
+            using type = void;
+
+            template<class L>
+            void apply(const L&) const {
+                //..
+            }
+        };
+    }
+}
+
+// #include "tags.h"
+
+// #include "expression.h"
+
+#include <utility>
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+#include <optional>
+#endif
+
+// #include "operators.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        template<class L, class R>
+        struct and_condition_t;
+
+        template<class L, class R>
+        struct or_condition_t;
+
+        /**
+         *  Is not an operator but a result of c(...) function. Has operator= overloaded which returns assign_t
+         */
+        template<class T>
+        struct expression_t : condition_t {
+            T value;
+
+            expression_t(T value_) : value(std::move(value_)) {}
+
+            template<class R>
+            assign_t<T, R> operator=(R r) const {
+                return {this->value, std::move(r)};
+            }
+
+            assign_t<T, std::nullptr_t> operator=(std::nullptr_t) const {
+                return {this->value, nullptr};
+            }
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+            assign_t<T, std::nullopt_t> operator=(std::nullopt_t) const {
+                return {this->value, std::nullopt};
+            }
+#endif
+            template<class... Args>
+            in_t<T, Args...> in(Args... args) const {
+                return {this->value, std::make_tuple(std::forward<Args>(args)...), false};
+            }
+
+            template<class... Args>
+            in_t<T, Args...> not_in(Args... args) const {
+                return {this->value, std::make_tuple(std::forward<Args>(args)...), true};
+            }
+
+            template<class R>
+            and_condition_t<T, R> and_(R right) const {
+                return {this->value, std::move(right)};
+            }
+
+            template<class R>
+            or_condition_t<T, R> or_(R right) const {
+                return {this->value, std::move(right)};
+            }
+        };
+
+        template<class T>
+        T get_from_expression(T value) {
+            return std::move(value);
+        }
+
+        template<class T>
+        T get_from_expression(expression_t<T> expression) {
+            return std::move(expression.value);
+        }
+    }
+
+    /**
+     *  Public interface for syntax sugar for columns. Example: `where(c(&User::id) == 5)` or
+     * `storage.update(set(c(&User::name) = "Dua Lipa"));
+     */
+    template<class T>
+    internal::expression_t<T> c(T value) {
+        return {std::move(value)};
+    }
+}
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        struct limit_string {
+            operator std::string() const {
+                return "LIMIT";
+            }
+        };
+
+        /**
+         *  Stores LIMIT/OFFSET info
+         */
+        template<class T, bool has_offset, bool offset_is_implicit, class O>
+        struct limit_t : limit_string {
+            T lim;
+            optional_container<O> off;
+
+            limit_t() = default;
+
+            limit_t(decltype(lim) lim_) : lim(std::move(lim_)) {}
+
+            limit_t(decltype(lim) lim_, decltype(off) off_) : lim(std::move(lim_)), off(std::move(off_)) {}
+        };
+
+        template<class T>
+        struct is_limit : std::false_type {};
+
+        template<class T, bool has_offset, bool offset_is_implicit, class O>
+        struct is_limit<limit_t<T, has_offset, offset_is_implicit, O>> : std::true_type {};
+
+        /**
+         *  Stores OFFSET only info
+         */
+        template<class T>
+        struct offset_t {
+            T off;
+        };
+
+        template<class T>
+        struct is_offset : std::false_type {};
+
+        template<class T>
+        struct is_offset<offset_t<T>> : std::true_type {};
+
+        /**
+         *  Collated something
+         */
+        template<class T>
+        struct collate_t : public condition_t {
+            T expr;
+            collate_argument argument;
+
+            collate_t(T expr_, collate_argument argument_) : expr(std::move(expr_)), argument(argument_) {}
+
+            operator std::string() const {
+                return collate_constraint_t{this->argument};
+            }
+        };
+
+        struct named_collate_base {
+            std::string name;
+
+            operator std::string() const {
+                return "COLLATE " + this->name;
+            }
+        };
+
+        /**
+         *  Collated something with custom collate function
+         */
+        template<class T>
+        struct named_collate : named_collate_base {
+            T expr;
+
+            named_collate(T expr_, std::string name_) : named_collate_base{std::move(name_)}, expr(std::move(expr_)) {}
+        };
+
+        struct negated_condition_string {
+            operator std::string() const {
+                return "NOT";
+            }
+        };
+
+        /**
+         *  Result of not operator
+         */
+        template<class C>
+        struct negated_condition_t : condition_t, negated_condition_string {
+            C c;
+
+            negated_condition_t(C c_) : c(std::move(c_)) {}
+        };
+
+        /**
+         *  Base class for binary conditions
+         *  L is left argument type
+         *  R is right argument type
+         *  S is 'string' class (a class which has cast to `std::string` operator)
+         *  Res is result type
+         */
+        template<class L, class R, class S, class Res>
+        struct binary_condition : condition_t, S {
+            using left_type = L;
+            using right_type = R;
+            using result_type = Res;
+
+            left_type l;
+            right_type r;
+
+            binary_condition() = default;
+
+            binary_condition(left_type l_, right_type r_) : l(std::move(l_)), r(std::move(r_)) {}
+        };
+
+        struct and_condition_string {
+            operator std::string() const {
+                return "AND";
+            }
+        };
+
+        /**
+         *  Result of and operator
+         */
+        template<class L, class R>
+        struct and_condition_t : binary_condition<L, R, and_condition_string, bool> {
+            using super = binary_condition<L, R, and_condition_string, bool>;
+
+            using super::super;
+        };
+
+        template<class L, class R>
+        and_condition_t<L, R> make_and_condition(L left, R right) {
+            return {std::move(left), std::move(right)};
+        }
+
+        struct or_condition_string {
+            operator std::string() const {
+                return "OR";
+            }
+        };
+
+        /**
+         *  Result of or operator
+         */
+        template<class L, class R>
+        struct or_condition_t : binary_condition<L, R, or_condition_string, bool> {
+            using super = binary_condition<L, R, or_condition_string, bool>;
+
+            using super::super;
+        };
+
+        template<class L, class R>
+        or_condition_t<L, R> make_or_condition(L left, R right) {
+            return {std::move(left), std::move(right)};
+        }
+
+        struct is_equal_string {
+            operator std::string() const {
+                return "=";
+            }
+        };
+
+        /**
+         *  = and == operators object
+         */
+        template<class L, class R>
+        struct is_equal_t : binary_condition<L, R, is_equal_string, bool>, negatable_t {
+            using self = is_equal_t<L, R>;
+
+            using binary_condition<L, R, is_equal_string, bool>::binary_condition;
+
+            collate_t<self> collate_binary() const {
+                return {*this, collate_argument::binary};
+            }
+
+            collate_t<self> collate_nocase() const {
+                return {*this, collate_argument::nocase};
+            }
+
+            collate_t<self> collate_rtrim() const {
+                return {*this, collate_argument::rtrim};
+            }
+
+            named_collate<self> collate(std::string name) const {
+                return {*this, std::move(name)};
+            }
+
+            template<class C>
+            named_collate<self> collate() const {
+                std::stringstream ss;
+                ss << C::name();
+                auto name = ss.str();
+                ss.flush();
+                return {*this, std::move(name)};
+            }
+        };
+
+        struct is_not_equal_string {
+            operator std::string() const {
+                return "!=";
+            }
+        };
+
+        /**
+         *  != operator object
+         */
+        template<class L, class R>
+        struct is_not_equal_t : binary_condition<L, R, is_not_equal_string, bool>, negatable_t {
+            using self = is_not_equal_t<L, R>;
+
+            using binary_condition<L, R, is_not_equal_string, bool>::binary_condition;
+
+            collate_t<self> collate_binary() const {
+                return {*this, collate_argument::binary};
+            }
+
+            collate_t<self> collate_nocase() const {
+                return {*this, collate_argument::nocase};
+            }
+
+            collate_t<self> collate_rtrim() const {
+                return {*this, collate_argument::rtrim};
+            }
+        };
+
+        struct greater_than_string {
+            operator std::string() const {
+                return ">";
+            }
+        };
+
+        /**
+         *  > operator object.
+         */
+        template<class L, class R>
+        struct greater_than_t : binary_condition<L, R, greater_than_string, bool>, negatable_t {
+            using self = greater_than_t<L, R>;
+
+            using binary_condition<L, R, greater_than_string, bool>::binary_condition;
+
+            collate_t<self> collate_binary() const {
+                return {*this, collate_argument::binary};
+            }
+
+            collate_t<self> collate_nocase() const {
+                return {*this, collate_argument::nocase};
+            }
+
+            collate_t<self> collate_rtrim() const {
+                return {*this, collate_argument::rtrim};
+            }
+        };
+
+        struct greater_or_equal_string {
+            operator std::string() const {
+                return ">=";
+            }
+        };
+
+        /**
+         *  >= operator object.
+         */
+        template<class L, class R>
+        struct greater_or_equal_t : binary_condition<L, R, greater_or_equal_string, bool>, negatable_t {
+            using self = greater_or_equal_t<L, R>;
+
+            using binary_condition<L, R, greater_or_equal_string, bool>::binary_condition;
+
+            collate_t<self> collate_binary() const {
+                return {*this, collate_argument::binary};
+            }
+
+            collate_t<self> collate_nocase() const {
+                return {*this, collate_argument::nocase};
+            }
+
+            collate_t<self> collate_rtrim() const {
+                return {*this, collate_argument::rtrim};
+            }
+        };
+
+        struct lesser_than_string {
+            operator std::string() const {
+                return "<";
+            }
+        };
+
+        /**
+         *  < operator object.
+         */
+        template<class L, class R>
+        struct lesser_than_t : binary_condition<L, R, lesser_than_string, bool>, negatable_t {
+            using self = lesser_than_t<L, R>;
+
+            using binary_condition<L, R, lesser_than_string, bool>::binary_condition;
+
+            collate_t<self> collate_binary() const {
+                return {*this, collate_argument::binary};
+            }
+
+            collate_t<self> collate_nocase() const {
+                return {*this, collate_argument::nocase};
+            }
+
+            collate_t<self> collate_rtrim() const {
+                return {*this, collate_argument::rtrim};
+            }
+        };
+
+        struct lesser_or_equal_string {
+            operator std::string() const {
+                return "<=";
+            }
+        };
+
+        /**
+         *  <= operator object.
+         */
+        template<class L, class R>
+        struct lesser_or_equal_t : binary_condition<L, R, lesser_or_equal_string, bool>, negatable_t {
+            using self = lesser_or_equal_t<L, R>;
+
+            using binary_condition<L, R, lesser_or_equal_string, bool>::binary_condition;
+
+            collate_t<self> collate_binary() const {
+                return {*this, collate_argument::binary};
+            }
+
+            collate_t<self> collate_nocase() const {
+                return {*this, collate_argument::nocase};
+            }
+
+            collate_t<self> collate_rtrim() const {
+                return {*this, collate_argument::rtrim};
+            }
+        };
+
+        struct in_base {
+            bool negative = false;  //  used in not_in
+
+            operator std::string() const {
+                if(!this->negative) {
+                    return "IN";
+                } else {
+                    return "NOT IN";
+                }
+            }
+        };
+
+        /**
+         *  IN operator object.
+         */
+        template<class L, class A>
+        struct dynamic_in_t : condition_t, in_base, negatable_t {
+            using self = dynamic_in_t<L, A>;
+
+            L left;  //  left expression
+            A argument;  //  in arg
+
+            dynamic_in_t(L left_, A argument_, bool negative_) :
+                in_base{negative_}, left(std::move(left_)), argument(std::move(argument_)) {}
+        };
+
+        template<class L, class... Args>
+        struct in_t : condition_t, in_base, negatable_t {
+            L left;
+            std::tuple<Args...> argument;
+
+            in_t(L left_, decltype(argument) argument_, bool negative_) :
+                in_base{negative_}, left(std::move(left_)), argument(std::move(argument_)) {}
+        };
+
+        struct is_null_string {
+            operator std::string() const {
+                return "IS NULL";
+            }
+        };
+
+        /**
+         *  IS NULL operator object.
+         */
+        template<class T>
+        struct is_null_t : is_null_string, negatable_t {
+            using self = is_null_t<T>;
+
+            T t;
+
+            is_null_t(T t_) : t(std::move(t_)) {}
+        };
+
+        struct is_not_null_string {
+            operator std::string() const {
+                return "IS NOT NULL";
+            }
+        };
+
+        /**
+         *  IS NOT NULL operator object.
+         */
+        template<class T>
+        struct is_not_null_t : is_not_null_string, negatable_t {
+            using self = is_not_null_t<T>;
+
+            T t;
+
+            is_not_null_t(T t_) : t(std::move(t_)) {}
+        };
+
+        struct order_by_base {
+            int asc_desc = 0;  //  1: asc, -1: desc
+            std::string _collate_argument;
+
+            order_by_base() = default;
+
+            order_by_base(decltype(asc_desc) asc_desc_, decltype(_collate_argument) _collate_argument_) :
+                asc_desc(asc_desc_), _collate_argument(move(_collate_argument_)) {}
+        };
+
+        struct order_by_string {
+            operator std::string() const {
+                return "ORDER BY";
+            }
+        };
+
+        /**
+         *  ORDER BY argument holder.
+         */
+        template<class O>
+        struct order_by_t : order_by_base, order_by_string {
+            using expression_type = O;
+            using self = order_by_t<expression_type>;
+
+            expression_type expression;
+
+            order_by_t(expression_type expression_) : order_by_base(), expression(std::move(expression_)) {}
+
+            self asc() {
+                auto res = *this;
+                res.asc_desc = 1;
+                return res;
+            }
+
+            self desc() {
+                auto res = *this;
+                res.asc_desc = -1;
+                return res;
+            }
+
+            self collate_binary() const {
+                auto res = *this;
+                res._collate_argument =
+                    collate_constraint_t::string_from_collate_argument(sqlite_orm::internal::collate_argument::binary);
+                return res;
+            }
+
+            self collate_nocase() const {
+                auto res = *this;
+                res._collate_argument =
+                    collate_constraint_t::string_from_collate_argument(sqlite_orm::internal::collate_argument::nocase);
+                return res;
+            }
+
+            self collate_rtrim() const {
+                auto res = *this;
+                res._collate_argument =
+                    collate_constraint_t::string_from_collate_argument(sqlite_orm::internal::collate_argument::rtrim);
+                return res;
+            }
+
+            self collate(std::string name) const {
+                auto res = *this;
+                res._collate_argument = std::move(name);
+                return res;
+            }
+
+            template<class C>
+            self collate() const {
+                std::stringstream ss;
+                ss << C::name();
+                auto name = ss.str();
+                ss.flush();
+                return this->collate(move(name));
+            }
+        };
+
+        /**
+         *  ORDER BY pack holder.
+         */
+        template<class... Args>
+        struct multi_order_by_t : order_by_string {
+            using args_type = std::tuple<Args...>;
+
+            args_type args;
+
+            multi_order_by_t(args_type&& args_) : args(std::move(args_)) {}
+        };
+
+        struct dynamic_order_by_entry_t : order_by_base {
+            std::string name;
+
+            dynamic_order_by_entry_t(decltype(name) name_, int asc_desc_, std::string collate_argument_) :
+                order_by_base{asc_desc_, move(collate_argument_)}, name(move(name_)) {}
+        };
+
+        /**
+         *  C - serializator context class
+         */
+        template<class C>
+        struct dynamic_order_by_t : order_by_string {
+            using context_t = C;
+            using entry_t = dynamic_order_by_entry_t;
+            using const_iterator = typename std::vector<entry_t>::const_iterator;
+
+            dynamic_order_by_t(const context_t& context_) : context(context_) {}
+
+            template<class O>
+            void push_back(order_by_t<O> order_by) {
+                auto newContext = this->context;
+                newContext.skip_table_name = true;
+                auto columnName = serialize(order_by.expression, newContext);
+                entries.emplace_back(move(columnName), order_by.asc_desc, move(order_by._collate_argument));
+            }
+
+            const_iterator begin() const {
+                return this->entries.begin();
+            }
+
+            const_iterator end() const {
+                return this->entries.end();
+            }
+
+            void clear() {
+                this->entries.clear();
+            }
+
+          protected:
+            std::vector<entry_t> entries;
+            context_t context;
+        };
+
+        template<class T>
+        struct is_order_by : std::false_type {};
+
+        template<class O>
+        struct is_order_by<order_by_t<O>> : std::true_type {};
+
+        template<class... Args>
+        struct is_order_by<multi_order_by_t<Args...>> : std::true_type {};
+
+        template<class C>
+        struct is_order_by<dynamic_order_by_t<C>> : std::true_type {};
+
+        struct between_string {
+            operator std::string() const {
+                return "BETWEEN";
+            }
+        };
+
+        /**
+         *  BETWEEN operator object.
+         */
+        template<class A, class T>
+        struct between_t : condition_t, between_string {
+            using expression_type = A;
+            using lower_type = T;
+            using upper_type = T;
+
+            expression_type expr;
+            lower_type b1;
+            upper_type b2;
+
+            between_t(expression_type expr_, lower_type b1_, upper_type b2_) :
+                expr(std::move(expr_)), b1(std::move(b1_)), b2(std::move(b2_)) {}
+        };
+
+        struct like_string {
+            operator std::string() const {
+                return "LIKE";
+            }
+        };
+
+        /**
+         *  LIKE operator object.
+         */
+        template<class A, class T, class E>
+        struct like_t : condition_t, like_string, negatable_t {
+            using self = like_t<A, T, E>;
+            using arg_t = A;
+            using pattern_t = T;
+            using escape_t = E;
+
+            arg_t arg;
+            pattern_t pattern;
+            optional_container<escape_t> arg3;  //  not escape cause escape exists as a function here
+
+            like_t(arg_t arg_, pattern_t pattern_, optional_container<escape_t> escape_) :
+                arg(std::move(arg_)), pattern(std::move(pattern_)), arg3(std::move(escape_)) {}
+
+            template<class C>
+            like_t<A, T, C> escape(C c) const {
+                optional_container<C> newArg3{std::move(c)};
+                return {std::move(this->arg), std::move(this->pattern), std::move(newArg3)};
+            }
+        };
+
+        struct glob_string {
+            operator std::string() const {
+                return "GLOB";
+            }
+        };
+
+        template<class A, class T>
+        struct glob_t : condition_t, glob_string, internal::negatable_t {
+            using self = glob_t<A, T>;
+            using arg_t = A;
+            using pattern_t = T;
+
+            arg_t arg;
+            pattern_t pattern;
+
+            glob_t(arg_t arg_, pattern_t pattern_) : arg(std::move(arg_)), pattern(std::move(pattern_)) {}
+        };
+
+        struct cross_join_string {
+            operator std::string() const {
+                return "CROSS JOIN";
+            }
+        };
+
+        /**
+         *  CROSS JOIN holder.
+         *  T is joined type which represents any mapped table.
+         */
+        template<class T>
+        struct cross_join_t : cross_join_string {
+            using type = T;
+        };
+
+        struct natural_join_string {
+            operator std::string() const {
+                return "NATURAL JOIN";
+            }
+        };
+
+        /**
+         *  NATURAL JOIN holder.
+         *  T is joined type which represents any mapped table.
+         */
+        template<class T>
+        struct natural_join_t : natural_join_string {
+            using type = T;
+        };
+
+        struct left_join_string {
+            operator std::string() const {
+                return "LEFT JOIN";
+            }
+        };
+
+        /**
+         *  LEFT JOIN holder.
+         *  T is joined type which represents any mapped table.
+         *  O is on(...) argument type.
+         */
+        template<class T, class O>
+        struct left_join_t : left_join_string {
+            using type = T;
+            using on_type = O;
+
+            on_type constraint;
+
+            left_join_t(on_type constraint_) : constraint(std::move(constraint_)) {}
+        };
+
+        struct join_string {
+            operator std::string() const {
+                return "JOIN";
+            }
+        };
+
+        /**
+         *  Simple JOIN holder.
+         *  T is joined type which represents any mapped table.
+         *  O is on(...) argument type.
+         */
+        template<class T, class O>
+        struct join_t : join_string {
+            using type = T;
+            using on_type = O;
+
+            on_type constraint;
+
+            join_t(on_type constraint_) : constraint(std::move(constraint_)) {}
+        };
+
+        struct left_outer_join_string {
+            operator std::string() const {
+                return "LEFT OUTER JOIN";
+            }
+        };
+
+        /**
+         *  LEFT OUTER JOIN holder.
+         *  T is joined type which represents any mapped table.
+         *  O is on(...) argument type.
+         */
+        template<class T, class O>
+        struct left_outer_join_t : left_outer_join_string {
+            using type = T;
+            using on_type = O;
+
+            on_type constraint;
+
+            left_outer_join_t(on_type constraint_) : constraint(std::move(constraint_)) {}
+        };
+
+        struct on_string {
+            operator std::string() const {
+                return "ON";
+            }
+        };
+
+        /**
+         *  on(...) argument holder used for JOIN, LEFT JOIN, LEFT OUTER JOIN and INNER JOIN
+         *  T is on type argument.
+         */
+        template<class T>
+        struct on_t : on_string {
+            using arg_type = T;
+
+            arg_type arg;
+
+            on_t(arg_type arg_) : arg(std::move(arg_)) {}
+        };
+
+        /**
+         *  USING argument holder.
+         */
+        template<class F, class O>
+        struct using_t {
+            column_pointer<O, F> column;
+
+            operator std::string() const {
+                return "USING";
+            }
+        };
+
+        struct inner_join_string {
+            operator std::string() const {
+                return "INNER JOIN";
+            }
+        };
+
+        /**
+         *  INNER JOIN holder.
+         *  T is joined type which represents any mapped table.
+         *  O is on(...) argument type.
+         */
+        template<class T, class O>
+        struct inner_join_t : inner_join_string {
+            using type = T;
+            using on_type = O;
+
+            on_type constraint;
+
+            inner_join_t(on_type constraint_) : constraint(std::move(constraint_)) {}
+        };
+
+        struct exists_string {
+            operator std::string() const {
+                return "EXISTS";
+            }
+        };
+
+        template<class T>
+        struct exists_t : condition_t, exists_string, internal::negatable_t {
+            using type = T;
+            using self = exists_t<type>;
+
+            type t;
+
+            exists_t(T t_) : t(std::move(t_)) {}
+        };
+
+        struct cast_string {
+            operator std::string() const {
+                return "CAST";
+            }
+        };
+
+        /**
+         *  CAST holder.
+         *  T is a type to cast to
+         *  E is an expression type
+         *  Example: cast<std::string>(&User::id)
+         */
+        template<class T, class E>
+        struct cast_t : cast_string {
+            using to_type = T;
+            using expression_type = E;
+
+            expression_type expression;
+
+            cast_t(expression_type expression_) : expression(std::move(expression_)) {}
+        };
+
+        template<class... Args>
+        struct from_t {
+            using tuple_type = std::tuple<Args...>;
+        };
+
+        template<class T>
+        struct is_from : std::false_type {};
+
+        template<class... Args>
+        struct is_from<from_t<Args...>> : std::true_type {};
+    }
+
+    /**
+     *  Explicit FROM function. Usage:
+     *  `storage.select(&User::id, from<User>());`
+     */
+    template<class... Args>
+    internal::from_t<Args...> from() {
+        static_assert(std::tuple_size<std::tuple<Args...>>::value > 0, "");
+        return {};
+    }
+
+    template<class T, typename = typename std::enable_if<std::is_base_of<internal::negatable_t, T>::value>::type>
+    internal::negated_condition_t<T> operator!(T arg) {
+        return {std::move(arg)};
+    }
+
+    /**
+     *  Cute operators for columns
+     */
+    template<class T, class R>
+    internal::lesser_than_t<T, R> operator<(internal::expression_t<T> expr, R r) {
+        return {std::move(expr.value), std::move(r)};
+    }
+
+    template<class L, class T>
+    internal::lesser_than_t<L, T> operator<(L l, internal::expression_t<T> expr) {
+        return {std::move(l), std::move(expr.value)};
+    }
+
+    template<class T, class R>
+    internal::lesser_or_equal_t<T, R> operator<=(internal::expression_t<T> expr, R r) {
+        return {std::move(expr.value), std::move(r)};
+    }
+
+    template<class L, class T>
+    internal::lesser_or_equal_t<L, T> operator<=(L l, internal::expression_t<T> expr) {
+        return {std::move(l), std::move(expr.value)};
+    }
+
+    template<class T, class R>
+    internal::greater_than_t<T, R> operator>(internal::expression_t<T> expr, R r) {
+        return {std::move(expr.value), std::move(r)};
+    }
+
+    template<class L, class T>
+    internal::greater_than_t<L, T> operator>(L l, internal::expression_t<T> expr) {
+        return {std::move(l), std::move(expr.value)};
+    }
+
+    template<class T, class R>
+    internal::greater_or_equal_t<T, R> operator>=(internal::expression_t<T> expr, R r) {
+        return {std::move(expr.value), std::move(r)};
+    }
+
+    template<class L, class T>
+    internal::greater_or_equal_t<L, T> operator>=(L l, internal::expression_t<T> expr) {
+        return {std::move(l), std::move(expr.value)};
+    }
+
+    template<class T, class R>
+    internal::is_equal_t<T, R> operator==(internal::expression_t<T> expr, R r) {
+        return {std::move(expr.value), std::move(r)};
+    }
+
+    template<class L, class T>
+    internal::is_equal_t<L, T> operator==(L l, internal::expression_t<T> expr) {
+        return {std::move(l), std::move(expr.value)};
+    }
+
+    template<class T, class R>
+    internal::is_not_equal_t<T, R> operator!=(internal::expression_t<T> expr, R r) {
+        return {std::move(expr.value), std::move(r)};
+    }
+
+    template<class L, class T>
+    internal::is_not_equal_t<L, T> operator!=(L l, internal::expression_t<T> expr) {
+        return {std::move(l), std::move(expr.value)};
+    }
+
+    template<class T, class R>
+    internal::conc_t<T, R> operator||(internal::expression_t<T> expr, R r) {
+        return {std::move(expr.value), std::move(r)};
+    }
+
+    template<class L, class T>
+    internal::conc_t<L, T> operator||(L l, internal::expression_t<T> expr) {
+        return {std::move(l), std::move(expr.value)};
+    }
+
+    template<class L, class R>
+    internal::conc_t<L, R> operator||(internal::expression_t<L> l, internal::expression_t<R> r) {
+        return {std::move(l.value), std::move(r.value)};
+    }
+
+    template<class T, class R>
+    internal::add_t<T, R> operator+(internal::expression_t<T> expr, R r) {
+        return {std::move(expr.value), std::move(r)};
+    }
+
+    template<class L, class T>
+    internal::add_t<L, T> operator+(L l, internal::expression_t<T> expr) {
+        return {std::move(l), std::move(expr.value)};
+    }
+
+    template<class L, class R>
+    internal::add_t<L, R> operator+(internal::expression_t<L> l, internal::expression_t<R> r) {
+        return {std::move(l.value), std::move(r.value)};
+    }
+
+    template<class T, class R>
+    internal::sub_t<T, R> operator-(internal::expression_t<T> expr, R r) {
+        return {std::move(expr.value), std::move(r)};
+    }
+
+    template<class L, class T>
+    internal::sub_t<L, T> operator-(L l, internal::expression_t<T> expr) {
+        return {std::move(l), std::move(expr.value)};
+    }
+
+    template<class L, class R>
+    internal::sub_t<L, R> operator-(internal::expression_t<L> l, internal::expression_t<R> r) {
+        return {std::move(l.value), std::move(r.value)};
+    }
+
+    template<class T, class R>
+    internal::mul_t<T, R> operator*(internal::expression_t<T> expr, R r) {
+        return {std::move(expr.value), std::move(r)};
+    }
+
+    template<class L, class T>
+    internal::mul_t<L, T> operator*(L l, internal::expression_t<T> expr) {
+        return {std::move(l), std::move(expr.value)};
+    }
+
+    template<class L, class R>
+    internal::mul_t<L, R> operator*(internal::expression_t<L> l, internal::expression_t<R> r) {
+        return {std::move(l.value), std::move(r.value)};
+    }
+
+    template<class T, class R>
+    internal::div_t<T, R> operator/(internal::expression_t<T> expr, R r) {
+        return {std::move(expr.value), std::move(r)};
+    }
+
+    template<class L, class T>
+    internal::div_t<L, T> operator/(L l, internal::expression_t<T> expr) {
+        return {std::move(l), std::move(expr.value)};
+    }
+
+    template<class L, class R>
+    internal::div_t<L, R> operator/(internal::expression_t<L> l, internal::expression_t<R> r) {
+        return {std::move(l.value), std::move(r.value)};
+    }
+
+    template<class T, class R>
+    internal::mod_t<T, R> operator%(internal::expression_t<T> expr, R r) {
+        return {std::move(expr.value), std::move(r)};
+    }
+
+    template<class L, class T>
+    internal::mod_t<L, T> operator%(L l, internal::expression_t<T> expr) {
+        return {std::move(l), std::move(expr.value)};
+    }
+
+    template<class L, class R>
+    internal::mod_t<L, R> operator%(internal::expression_t<L> l, internal::expression_t<R> r) {
+        return {std::move(l.value), std::move(r.value)};
+    }
+
+    template<class F, class O>
+    internal::using_t<F O::*, O> using_(F O::*p) {
+        return {std::move(p)};
+    }
+    template<class F, class O>
+    internal::using_t<F, O> using_(internal::column_pointer<O, F> cp) {
+        return {std::move(cp)};
+    }
+
+    template<class T>
+    internal::on_t<T> on(T t) {
+        return {std::move(t)};
+    }
+
+    template<class T>
+    internal::cross_join_t<T> cross_join() {
+        return {};
+    }
+
+    template<class T>
+    internal::natural_join_t<T> natural_join() {
+        return {};
+    }
+
+    template<class T, class O>
+    internal::left_join_t<T, O> left_join(O o) {
+        return {std::move(o)};
+    }
+
+    template<class T, class O>
+    internal::join_t<T, O> join(O o) {
+        return {std::move(o)};
+    }
+
+    template<class T, class O>
+    internal::left_outer_join_t<T, O> left_outer_join(O o) {
+        return {std::move(o)};
+    }
+
+    template<class T, class O>
+    internal::inner_join_t<T, O> inner_join(O o) {
+        return {std::move(o)};
+    }
+
+    template<class T>
+    internal::offset_t<T> offset(T off) {
+        return {std::move(off)};
+    }
+
+    template<class T>
+    internal::limit_t<T, false, false, void> limit(T lim) {
+        return {std::move(lim)};
+    }
+
+    template<class T, class O>
+    typename std::enable_if<!internal::is_offset<T>::value, internal::limit_t<T, true, true, O>>::type limit(O off,
+                                                                                                             T lim) {
+        return {std::move(lim), {std::move(off)}};
+    }
+
+    template<class T, class O>
+    internal::limit_t<T, true, false, O> limit(T lim, internal::offset_t<O> offt) {
+        return {std::move(lim), {std::move(offt.off)}};
+    }
+
+    template<class L,
+             class R,
+             typename = typename std::enable_if<std::is_base_of<internal::condition_t, L>::value ||
+                                                std::is_base_of<internal::condition_t, R>::value>::type>
+    auto operator&&(L l, R r) {
+        using internal::get_from_expression;
+        return internal::make_and_condition(std::move(get_from_expression(l)), std::move(get_from_expression(r)));
+    }
+
+    template<class L, class R>
+    auto and_(L l, R r) {
+        using internal::get_from_expression;
+        return internal::make_and_condition(std::move(get_from_expression(l)), std::move(get_from_expression(r)));
+    }
+
+    template<class L,
+             class R,
+             typename = typename std::enable_if<std::is_base_of<internal::condition_t, L>::value ||
+                                                std::is_base_of<internal::condition_t, R>::value>::type>
+    auto operator||(L l, R r) {
+        using internal::get_from_expression;
+        return internal::make_or_condition(std::move(get_from_expression(l)), std::move(get_from_expression(r)));
+    }
+
+    template<class L, class R>
+    auto or_(L l, R r) {
+        using internal::get_from_expression;
+        return internal::make_or_condition(std::move(get_from_expression(l)), std::move(get_from_expression(r)));
+    }
+
+    template<class T>
+    internal::is_not_null_t<T> is_not_null(T t) {
+        return {std::move(t)};
+    }
+
+    template<class T>
+    internal::is_null_t<T> is_null(T t) {
+        return {std::move(t)};
+    }
+
+    template<class L, class E>
+    internal::dynamic_in_t<L, std::vector<E>> in(L l, std::vector<E> values) {
+        return {std::move(l), std::move(values), false};
+    }
+
+    template<class L, class E>
+    internal::dynamic_in_t<L, std::vector<E>> in(L l, std::initializer_list<E> values) {
+        return {std::move(l), std::move(values), false};
+    }
+
+    template<class L, class A>
+    internal::dynamic_in_t<L, A> in(L l, A arg) {
+        return {std::move(l), std::move(arg), false};
+    }
+
+    template<class L, class E>
+    internal::dynamic_in_t<L, std::vector<E>> not_in(L l, std::vector<E> values) {
+        return {std::move(l), std::move(values), true};
+    }
+
+    template<class L, class E>
+    internal::dynamic_in_t<L, std::vector<E>> not_in(L l, std::initializer_list<E> values) {
+        return {std::move(l), std::move(values), true};
+    }
+
+    template<class L, class A>
+    internal::dynamic_in_t<L, A> not_in(L l, A arg) {
+        return {std::move(l), std::move(arg), true};
+    }
+
+    template<class L, class R>
+    internal::is_equal_t<L, R> is_equal(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::is_equal_t<L, R> eq(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::is_not_equal_t<L, R> is_not_equal(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::is_not_equal_t<L, R> ne(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::greater_than_t<L, R> greater_than(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::greater_than_t<L, R> gt(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::greater_or_equal_t<L, R> greater_or_equal(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::greater_or_equal_t<L, R> ge(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::lesser_than_t<L, R> lesser_than(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::lesser_than_t<L, R> lt(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::lesser_or_equal_t<L, R> lesser_or_equal(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L, class R>
+    internal::lesser_or_equal_t<L, R> le(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    /**
+     * ORDER BY column
+     * Example: storage.select(&User::name, order_by(&User::id))
+     * 
+     * Note: choosing a column by a numeric literal isn't supported, i.e. order_by(2),
+     * use order_by(2_nth_col) instead
+     */
+    template<class O, internal::satisfies_not<std::is_arithmetic, O> = true>
+    internal::order_by_t<O> order_by(O o) {
+        return {std::move(o)};
+    }
+
+    /**
+     * Note: index_constant<> is used for 0-based indexing,
+     * use order_by(2_nth_col) instead
+     */
+    template<size_t I>
+    internal::order_by_t<polyfill::index_constant<I>> order_by(polyfill::index_constant<I> n) {
+        static_assert(polyfill::always_false_v<polyfill::index_constant<I>>,
+                      "Please use 1_nth_col, 2_nth_col, ... instead");
+        return {n};
+    }
+
+    /**
+     * ORDER BY column1, column2
+     * Example: storage.get_all<Singer>(multi_order_by(order_by(&Singer::name).asc(), order_by(&Singer::gender).desc())
+     */
+    template<class... Args>
+    internal::multi_order_by_t<Args...> multi_order_by(Args&&... args) {
+        return {std::make_tuple(std::forward<Args>(args)...)};
+    }
+
+    /**
+     * ORDER BY column1, column2
+     * Difference from `multi_order_by` is that `dynamic_order_by` can be changed at runtime using `push_back` member
+     * function Example:
+     *  auto orderBy = dynamic_order_by(storage);
+     *  if(someCondition) {
+     *      orderBy.push_back(&User::id);
+     *  } else {
+     *      orderBy.push_back(&User::name);
+     *      orderBy.push_back(&User::birthDate);
+     *  }
+     */
+    template<class S>
+    internal::dynamic_order_by_t<internal::serializator_context<typename S::impl_type>>
+    dynamic_order_by(const S& storage) {
+        internal::serializator_context_builder<S> builder(storage);
+        return builder();
+    }
+
+    /**
+     *  X BETWEEN Y AND Z
+     *  Example: storage.select(between(&User::id, 10, 20))
+     */
+    template<class A, class T>
+    internal::between_t<A, T> between(A expr, T b1, T b2) {
+        return {std::move(expr), std::move(b1), std::move(b2)};
+    }
+
+    /**
+     *  X LIKE Y
+     *  Example: storage.select(like(&User::name, "T%"))
+     */
+    template<class A, class T>
+    internal::like_t<A, T, void> like(A a, T t) {
+        return {std::move(a), std::move(t), {}};
+    }
+
+    /**
+     *  X GLOB Y
+     *  Example: storage.select(glob(&User::name, "*S"))
+     */
+    template<class A, class T>
+    internal::glob_t<A, T> glob(A a, T t) {
+        return {std::move(a), std::move(t)};
+    }
+
+    /**
+     *  X LIKE Y ESCAPE Z
+     *  Example: storage.select(like(&User::name, "T%", "%"))
+     */
+    template<class A, class T, class E>
+    internal::like_t<A, T, E> like(A a, T t, E e) {
+        return {std::move(a), std::move(t), {std::move(e)}};
+    }
+
+    /**
+     *  EXISTS(condition).
+     *  Example: storage.select(columns(&Agent::code, &Agent::name, &Agent::workingArea, &Agent::comission),
+         where(exists(select(asterisk<Customer>(),
+         where(is_equal(&Customer::grade, 3) and
+         is_equal(&Agent::code, &Customer::agentCode))))),
+         order_by(&Agent::comission));
+     */
+    template<class T>
+    internal::exists_t<T> exists(T t) {
+        return {std::move(t)};
+    }
+
+    /**
+     *  CAST(X AS type).
+     *  Example: cast<std::string>(&User::id)
+     */
+    template<class T, class E>
+    internal::cast_t<T, E> cast(E e) {
+        return {std::move(e)};
+    }
+}
+#pragma once
+
+#include <type_traits>  //  std::enable_if, std::is_base_of, std::is_member_pointer
+#include <sstream>  //  std::stringstream
+#include <string>  //  std::string
+
+namespace sqlite_orm {
+
+    /**
+     *  This is base class for every class which is used as a custom table alias.
+     *  For more information please look through self_join.cpp example
+     */
+    struct alias_tag {};
+
+    namespace internal {
+
+        /**
+         *  This is a common built-in class used for custom single character table aliases.
+         *  Also you can use language aliases `alias_a`, `alias_b` etc. instead
+         */
+        template<class T, char A>
+        struct table_alias : alias_tag {
+            using type = T;
+
+            constexpr static char get() {
+                return A;
+            }
+        };
+
+        /**
+         *  Column expression with table alias attached like 'C.ID'. This is not a column alias
+         */
+        template<class T, class C>
+        struct alias_column_t {
+            using alias_type = T;
+            using column_type = C;
+
+            column_type column;
+
+            alias_column_t(){};
+
+            alias_column_t(column_type column_) : column(std::move(column_)) {}
+        };
+
+        template<class T, class SFINAE = void>
+        struct alias_extractor;
+
+        template<class A>
+        struct alias_extractor<A, typename std::enable_if<std::is_base_of<alias_tag, A>::value>::type> {
+            using object_type = typename A::type;
+
+            static std::string get() {
+                std::stringstream ss;
+                ss << A::get();
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct alias_extractor<T, typename std::enable_if<!std::is_base_of<alias_tag, T>::value>::type> {
+            using object_type = T;
+
+            static std::string get() {
+                return {};
+            }
+        };
+
+        /**
+         * Used to store alias for expression
+         */
+        template<class T, class E>
+        struct as_t {
+            using alias_type = T;
+            using expression_type = E;
+
+            expression_type expression;
+        };
+
+        template<class T>
+        struct alias_holder {
+            using type = T;
+        };
+    }
+
+    /**
+     *  @return column with table alias attached. Place it instead of a column statement in case you need to specify a
+     *  column with table alias prefix like 'a.column'. For more information please look through self_join.cpp example
+     */
+    template<class T, class C>
+    internal::alias_column_t<T, C> alias_column(C c) {
+        static_assert(std::is_member_pointer<C>::value,
+                      "alias_column argument must be a member pointer mapped to a storage");
+        return {c};
+    }
+
+    template<class T, class E>
+    internal::as_t<T, E> as(E expression) {
+        return {std::move(expression)};
+    }
+
+    template<class T>
+    internal::alias_holder<T> get() {
+        return {};
+    }
+
+    template<class T>
+    using alias_a = internal::table_alias<T, 'a'>;
+    template<class T>
+    using alias_b = internal::table_alias<T, 'b'>;
+    template<class T>
+    using alias_c = internal::table_alias<T, 'c'>;
+    template<class T>
+    using alias_d = internal::table_alias<T, 'd'>;
+    template<class T>
+    using alias_e = internal::table_alias<T, 'e'>;
+    template<class T>
+    using alias_f = internal::table_alias<T, 'f'>;
+    template<class T>
+    using alias_g = internal::table_alias<T, 'g'>;
+    template<class T>
+    using alias_h = internal::table_alias<T, 'h'>;
+    template<class T>
+    using alias_i = internal::table_alias<T, 'i'>;
+    template<class T>
+    using alias_j = internal::table_alias<T, 'j'>;
+    template<class T>
+    using alias_k = internal::table_alias<T, 'k'>;
+    template<class T>
+    using alias_l = internal::table_alias<T, 'l'>;
+    template<class T>
+    using alias_m = internal::table_alias<T, 'm'>;
+    template<class T>
+    using alias_n = internal::table_alias<T, 'n'>;
+    template<class T>
+    using alias_o = internal::table_alias<T, 'o'>;
+    template<class T>
+    using alias_p = internal::table_alias<T, 'p'>;
+    template<class T>
+    using alias_q = internal::table_alias<T, 'q'>;
+    template<class T>
+    using alias_r = internal::table_alias<T, 'r'>;
+    template<class T>
+    using alias_s = internal::table_alias<T, 's'>;
+    template<class T>
+    using alias_t = internal::table_alias<T, 't'>;
+    template<class T>
+    using alias_u = internal::table_alias<T, 'u'>;
+    template<class T>
+    using alias_v = internal::table_alias<T, 'v'>;
+    template<class T>
+    using alias_w = internal::table_alias<T, 'w'>;
+    template<class T>
+    using alias_x = internal::table_alias<T, 'x'>;
+    template<class T>
+    using alias_y = internal::table_alias<T, 'y'>;
+    template<class T>
+    using alias_z = internal::table_alias<T, 'z'>;
+}
+#pragma once
+
+// #include "conditions.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        template<class... Args>
+        struct join_iterator;
+
+        template<>
+        struct join_iterator<> {
+
+            template<class L>
+            void operator()(const L&) const {
+                //..
+            }
+        };
+
+        template<class H, class... Tail>
+        struct join_iterator<H, Tail...> : public join_iterator<Tail...> {
+            using super = join_iterator<Tail...>;
+
+            template<class L>
+            void operator()(const L& l) const {
+                this->super::operator()(l);
+            }
+        };
+
+        template<class T, class... Tail>
+        struct join_iterator<cross_join_t<T>, Tail...> : public join_iterator<Tail...> {
+            using super = join_iterator<Tail...>;
+            using join_type = cross_join_t<T>;
+
+            template<class L>
+            void operator()(const L& l) const {
+                l(*this);
+                this->super::operator()(l);
+            }
+        };
+
+        template<class T, class... Tail>
+        struct join_iterator<natural_join_t<T>, Tail...> : public join_iterator<Tail...> {
+            using super = join_iterator<Tail...>;
+            using join_type = natural_join_t<T>;
+
+            template<class L>
+            void operator()(const L& l) const {
+                l(*this);
+                this->super::operator()(l);
+            }
+        };
+
+        template<class T, class O, class... Tail>
+        struct join_iterator<left_join_t<T, O>, Tail...> : public join_iterator<Tail...> {
+            using super = join_iterator<Tail...>;
+            using join_type = left_join_t<T, O>;
+
+            template<class L>
+            void operator()(const L& l) const {
+                l(*this);
+                this->super::operator()(l);
+            }
+        };
+
+        template<class T, class O, class... Tail>
+        struct join_iterator<join_t<T, O>, Tail...> : public join_iterator<Tail...> {
+            using super = join_iterator<Tail...>;
+            using join_type = join_t<T, O>;
+
+            template<class L>
+            void operator()(const L& l) const {
+                l(*this);
+                this->super::operator()(l);
+            }
+        };
+
+        template<class T, class O, class... Tail>
+        struct join_iterator<left_outer_join_t<T, O>, Tail...> : public join_iterator<Tail...> {
+            using super = join_iterator<Tail...>;
+            using join_type = left_outer_join_t<T, O>;
+
+            template<class L>
+            void operator()(const L& l) const {
+                l(*this);
+                this->super::operator()(l);
+            }
+        };
+
+        template<class T, class O, class... Tail>
+        struct join_iterator<inner_join_t<T, O>, Tail...> : public join_iterator<Tail...> {
+            using super = join_iterator<Tail...>;
+            using join_type = inner_join_t<T, O>;
+
+            template<class L>
+            void operator()(const L& l) const {
+                l(*this);
+                this->super::operator()(l);
+            }
+        };
+    }
+}
+#pragma once
+
+#include <string>  //  std::string
+#include <tuple>  //  std::make_tuple, std::tuple_size
+#include <type_traits>  //  std::forward, std::is_base_of, std::enable_if
+#include <memory>  //  std::unique_ptr
+#include <vector>  //  std::vector
+
+// #include "conditions.h"
+
+// #include "operators.h"
+
+// #include "is_base_of_template.h"
+
+#include <type_traits>  //  std::true_type, std::false_type, std::declval
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /*
+         * This is because of bug in MSVC, for more information, please visit
+         * https://stackoverflow.com/questions/34672441/stdis-base-of-for-template-classes/34672753#34672753
+         */
+#if defined(_MSC_VER) && (_MSC_VER < 1920)
+        template<template<typename...> class Base, typename Derived>
+        struct is_base_of_template_impl {
+            template<typename... Ts>
+            static constexpr std::true_type test(const Base<Ts...>*);
+
+            static constexpr std::false_type test(...);
+
+            using type = decltype(test(std::declval<Derived*>()));
+        };
+
+        template<typename Derived, template<typename...> class Base>
+        using is_base_of_template = typename is_base_of_template_impl<Base, Derived>::type;
+
+#else
+        template<template<typename...> class C, typename... Ts>
+        std::true_type is_base_of_template_impl(const C<Ts...>*);
+
+        template<template<typename...> class C>
+        std::false_type is_base_of_template_impl(...);
+
+        template<typename T, template<typename...> class C>
+        using is_base_of_template = decltype(is_base_of_template_impl<C>(std::declval<T*>()));
+#endif
+    }
+}
+
+// #include "serialize_result_type.h"
+
+#ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
+#include <string_view>  //  string_view
+#else
+#include <string>  //  std::string
+#endif
+
+namespace sqlite_orm {
+    namespace internal {
+#ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
+        using serialize_result_type = std::string_view;
+#else
+        using serialize_result_type = std::string;
+#endif
+    }
+}
+
+namespace sqlite_orm {
+
+    using int64 = sqlite_int64;
+    using uint64 = sqlite_uint64;
+
+    namespace internal {
+
+        template<class T>
+        struct is_into;
+
+        template<class T>
+        struct unique_ptr_result_of {};
+
+        /**
+         *  Base class for operator overloading
+         *  R - return type
+         *  S - class with operator std::string
+         *  Args - function arguments types
+         */
+        template<class R, class S, class... Args>
+        struct built_in_function_t : S, arithmetic_t {
+            using return_type = R;
+            using string_type = S;
+            using args_type = std::tuple<Args...>;
+
+            static constexpr const size_t args_size = std::tuple_size<args_type>::value;
+
+            args_type args;
+
+            built_in_function_t(args_type&& args_) : args(std::move(args_)) {}
+        };
+
+        struct typeof_string {
+            serialize_result_type serialize() const {
+                return "TYPEOF";
+            }
+        };
+
+        struct unicode_string {
+            serialize_result_type serialize() const {
+                return "UNICODE";
+            }
+        };
+
+        struct length_string {
+            serialize_result_type serialize() const {
+                return "LENGTH";
+            }
+        };
+
+        struct abs_string {
+            serialize_result_type serialize() const {
+                return "ABS";
+            }
+        };
+
+        struct lower_string {
+            serialize_result_type serialize() const {
+                return "LOWER";
+            }
+        };
+
+        struct upper_string {
+            serialize_result_type serialize() const {
+                return "UPPER";
+            }
+        };
+
+        struct last_insert_rowid_string {
+            serialize_result_type serialize() const {
+                return "LAST_INSERT_ROWID";
+            }
+        };
+
+        struct total_changes_string {
+            serialize_result_type serialize() const {
+                return "TOTAL_CHANGES";
+            }
+        };
+
+        struct changes_string {
+            serialize_result_type serialize() const {
+                return "CHANGES";
+            }
+        };
+
+        struct trim_string {
+            serialize_result_type serialize() const {
+                return "TRIM";
+            }
+        };
+
+        struct ltrim_string {
+            serialize_result_type serialize() const {
+                return "LTRIM";
+            }
+        };
+
+        struct rtrim_string {
+            serialize_result_type serialize() const {
+                return "RTRIM";
+            }
+        };
+
+        struct hex_string {
+            serialize_result_type serialize() const {
+                return "HEX";
+            }
+        };
+
+        struct quote_string {
+            serialize_result_type serialize() const {
+                return "QUOTE";
+            }
+        };
+
+        struct randomblob_string {
+            serialize_result_type serialize() const {
+                return "RANDOMBLOB";
+            }
+        };
+
+        struct instr_string {
+            serialize_result_type serialize() const {
+                return "INSTR";
+            }
+        };
+
+        struct replace_string {
+            serialize_result_type serialize() const {
+                return "REPLACE";
+            }
+        };
+
+        struct round_string {
+            serialize_result_type serialize() const {
+                return "ROUND";
+            }
+        };
+
+#if SQLITE_VERSION_NUMBER >= 3007016
+
+        struct char_string {
+            serialize_result_type serialize() const {
+                return "CHAR";
+            }
+        };
+
+        struct random_string {
+            serialize_result_type serialize() const {
+                return "RANDOM";
+            }
+        };
+
+#endif
+
+        struct coalesce_string {
+            serialize_result_type serialize() const {
+                return "COALESCE";
+            }
+        };
+
+        struct ifnull_string {
+            serialize_result_type serialize() const {
+                return "IFNULL";
+            }
+        };
+
+        struct date_string {
+            serialize_result_type serialize() const {
+                return "DATE";
+            }
+        };
+
+        struct time_string {
+            serialize_result_type serialize() const {
+                return "TIME";
+            }
+        };
+
+        struct datetime_string {
+            serialize_result_type serialize() const {
+                return "DATETIME";
+            }
+        };
+
+        struct julianday_string {
+            serialize_result_type serialize() const {
+                return "JULIANDAY";
+            }
+        };
+
+        struct strftime_string {
+            serialize_result_type serialize() const {
+                return "STRFTIME";
+            }
+        };
+
+        struct zeroblob_string {
+            serialize_result_type serialize() const {
+                return "ZEROBLOB";
+            }
+        };
+
+        struct substr_string {
+            serialize_result_type serialize() const {
+                return "SUBSTR";
+            }
+        };
+#ifdef SQLITE_SOUNDEX
+        struct soundex_string {
+            serialize_result_type serialize() const {
+                return "SOUNDEX";
+            }
+        };
+#endif
+        struct total_string {
+            serialize_result_type serialize() const {
+                return "TOTAL";
+            }
+        };
+
+        struct sum_string {
+            serialize_result_type serialize() const {
+                return "SUM";
+            }
+        };
+
+        struct count_string {
+            serialize_result_type serialize() const {
+                return "COUNT";
+            }
+        };
+
+        /**
+         *  T is use to specify type explicitly for queries like
+         *  SELECT COUNT(*) FROM table_name;
+         *  T can be omitted with void.
+         */
+        template<class T>
+        struct count_asterisk_t : count_string {
+            using type = T;
+        };
+
+        /**
+         *  The same thing as count<T>() but without T arg.
+         *  Is used in cases like this:
+         *    SELECT cust_code, cust_name, cust_city, grade
+         *    FROM customer
+         *    WHERE grade=2 AND EXISTS
+         *        (SELECT COUNT(*)
+         *        FROM customer
+         *        WHERE grade=2
+         *        GROUP BY grade
+         *        HAVING COUNT(*)>2);
+         *  `c++`
+         *  auto rows =
+         *      storage.select(columns(&Customer::code, &Customer::name, &Customer::city, &Customer::grade),
+         *          where(is_equal(&Customer::grade, 2)
+         *              and exists(select(count<Customer>(),
+         *                  where(is_equal(&Customer::grade, 2)),
+         *          group_by(&Customer::grade),
+         *          having(greater_than(count(), 2))))));
+         */
+        struct count_asterisk_without_type : count_string {};
+
+        struct avg_string {
+            serialize_result_type serialize() const {
+                return "AVG";
+            }
+        };
+
+        struct max_string {
+            serialize_result_type serialize() const {
+                return "MAX";
+            }
+        };
+
+        struct min_string {
+            serialize_result_type serialize() const {
+                return "MIN";
+            }
+        };
+
+        struct group_concat_string {
+            serialize_result_type serialize() const {
+                return "GROUP_CONCAT";
+            }
+        };
+#ifdef SQLITE_ENABLE_MATH_FUNCTIONS
+        struct acos_string {
+            serialize_result_type serialize() const {
+                return "ACOS";
+            }
+        };
+
+        struct acosh_string {
+            serialize_result_type serialize() const {
+                return "ACOSH";
+            }
+        };
+
+        struct asin_string {
+            serialize_result_type serialize() const {
+                return "ASIN";
+            }
+        };
+
+        struct asinh_string {
+            serialize_result_type serialize() const {
+                return "ASINH";
+            }
+        };
+
+        struct atan_string {
+            serialize_result_type serialize() const {
+                return "ATAN";
+            }
+        };
+
+        struct atan2_string {
+            serialize_result_type serialize() const {
+                return "ATAN2";
+            }
+        };
+
+        struct atanh_string {
+            serialize_result_type serialize() const {
+                return "ATANH";
+            }
+        };
+
+        struct ceil_string {
+            serialize_result_type serialize() const {
+                return "CEIL";
+            }
+        };
+
+        struct ceiling_string {
+            serialize_result_type serialize() const {
+                return "CEILING";
+            }
+        };
+
+        struct cos_string {
+            serialize_result_type serialize() const {
+                return "COS";
+            }
+        };
+
+        struct cosh_string {
+            serialize_result_type serialize() const {
+                return "COSH";
+            }
+        };
+
+        struct degrees_string {
+            serialize_result_type serialize() const {
+                return "DEGREES";
+            }
+        };
+
+        struct exp_string {
+            serialize_result_type serialize() const {
+                return "EXP";
+            }
+        };
+
+        struct floor_string {
+            serialize_result_type serialize() const {
+                return "FLOOR";
+            }
+        };
+
+        struct ln_string {
+            serialize_result_type serialize() const {
+                return "LN";
+            }
+        };
+
+        struct log_string {
+            serialize_result_type serialize() const {
+                return "LOG";
+            }
+        };
+
+        struct log10_string {
+            serialize_result_type serialize() const {
+                return "LOG10";
+            }
+        };
+
+        struct log2_string {
+            serialize_result_type serialize() const {
+                return "LOG2";
+            }
+        };
+
+        struct mod_string {
+            serialize_result_type serialize() const {
+                return "MOD";
+            }
+        };
+
+        struct pi_string {
+            serialize_result_type serialize() const {
+                return "PI";
+            }
+        };
+
+        struct pow_string {
+            serialize_result_type serialize() const {
+                return "POW";
+            }
+        };
+
+        struct power_string {
+            serialize_result_type serialize() const {
+                return "POWER";
+            }
+        };
+
+        struct radians_string {
+            serialize_result_type serialize() const {
+                return "RADIANS";
+            }
+        };
+
+        struct sin_string {
+            serialize_result_type serialize() const {
+                return "SIN";
+            }
+        };
+
+        struct sinh_string {
+            serialize_result_type serialize() const {
+                return "SINH";
+            }
+        };
+
+        struct sqrt_string {
+            serialize_result_type serialize() const {
+                return "SQRT";
+            }
+        };
+
+        struct tan_string {
+            serialize_result_type serialize() const {
+                return "TAN";
+            }
+        };
+
+        struct tanh_string {
+            serialize_result_type serialize() const {
+                return "TANH";
+            }
+        };
+
+        struct trunc_string {
+            serialize_result_type serialize() const {
+                return "TRUNC";
+            }
+        };
+
+#endif  //  SQLITE_ENABLE_MATH_FUNCTIONS
+#ifdef SQLITE_ENABLE_JSON1
+        struct json_string {
+            serialize_result_type serialize() const {
+                return "JSON";
+            }
+        };
+
+        struct json_array_string {
+            serialize_result_type serialize() const {
+                return "JSON_ARRAY";
+            }
+        };
+
+        struct json_array_length_string {
+            serialize_result_type serialize() const {
+                return "JSON_ARRAY_LENGTH";
+            }
+        };
+
+        struct json_extract_string {
+            serialize_result_type serialize() const {
+                return "JSON_EXTRACT";
+            }
+        };
+
+        struct json_insert_string {
+            serialize_result_type serialize() const {
+                return "JSON_INSERT";
+            }
+        };
+
+        struct json_replace_string {
+            serialize_result_type serialize() const {
+                return "JSON_REPLACE";
+            }
+        };
+
+        struct json_set_string {
+            serialize_result_type serialize() const {
+                return "JSON_SET";
+            }
+        };
+
+        struct json_object_string {
+            serialize_result_type serialize() const {
+                return "JSON_OBJECT";
+            }
+        };
+
+        struct json_patch_string {
+            serialize_result_type serialize() const {
+                return "JSON_PATCH";
+            }
+        };
+
+        struct json_remove_string {
+            serialize_result_type serialize() const {
+                return "JSON_REMOVE";
+            }
+        };
+
+        struct json_type_string {
+            serialize_result_type serialize() const {
+                return "JSON_TYPE";
+            }
+        };
+
+        struct json_valid_string {
+            serialize_result_type serialize() const {
+                return "JSON_VALID";
+            }
+        };
+
+        struct json_quote_string {
+            serialize_result_type serialize() const {
+                return "JSON_QUOTE";
+            }
+        };
+
+        struct json_group_array_string {
+            serialize_result_type serialize() const {
+                return "JSON_GROUP_ARRAY";
+            }
+        };
+
+        struct json_group_object_string {
+            serialize_result_type serialize() const {
+                return "JSON_GROUP_OBJECT";
+            }
+        };
+#endif  //  SQLITE_ENABLE_JSON1
+    }
+
+    /**
+     *  Cute operators for core functions
+     */
+    template<class F,
+             class R,
+             typename =
+                 typename std::enable_if<internal::is_base_of_template<F, internal::built_in_function_t>::value>::type>
+    internal::lesser_than_t<F, R> operator<(F f, R r) {
+        return {std::move(f), std::move(r)};
+    }
+
+    template<class F,
+             class R,
+             typename =
+                 typename std::enable_if<internal::is_base_of_template<F, internal::built_in_function_t>::value>::type>
+    internal::lesser_or_equal_t<F, R> operator<=(F f, R r) {
+        return {std::move(f), std::move(r)};
+    }
+
+    template<class F,
+             class R,
+             typename =
+                 typename std::enable_if<internal::is_base_of_template<F, internal::built_in_function_t>::value>::type>
+    internal::greater_than_t<F, R> operator>(F f, R r) {
+        return {std::move(f), std::move(r)};
+    }
+
+    template<class F,
+             class R,
+             typename =
+                 typename std::enable_if<internal::is_base_of_template<F, internal::built_in_function_t>::value>::type>
+    internal::greater_or_equal_t<F, R> operator>=(F f, R r) {
+        return {std::move(f), std::move(r)};
+    }
+
+    template<class F,
+             class R,
+             typename =
+                 typename std::enable_if<internal::is_base_of_template<F, internal::built_in_function_t>::value>::type>
+    internal::is_equal_t<F, R> operator==(F f, R r) {
+        return {std::move(f), std::move(r)};
+    }
+
+    template<class F,
+             class R,
+             typename =
+                 typename std::enable_if<internal::is_base_of_template<F, internal::built_in_function_t>::value>::type>
+    internal::is_not_equal_t<F, R> operator!=(F f, R r) {
+        return {std::move(f), std::move(r)};
+    }
+#ifdef SQLITE_ENABLE_MATH_FUNCTIONS
+
+    /**
+     *  ACOS(X) function https://www.sqlite.org/lang_mathfunc.html#acos
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::acos(&Triangle::cornerA));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::acos_string, X> acos(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  ACOS(X) function https://www.sqlite.org/lang_mathfunc.html#acos
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::acos<std::optional<double>>(&Triangle::cornerA));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::acos_string, X> acos(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  ACOSH(X) function https://www.sqlite.org/lang_mathfunc.html#acosh
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::acosh(&Triangle::cornerA));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::acosh_string, X> acosh(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  ACOSH(X) function https://www.sqlite.org/lang_mathfunc.html#acosh
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::acosh<std::optional<double>>(&Triangle::cornerA));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::acosh_string, X> acosh(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  ASIN(X) function https://www.sqlite.org/lang_mathfunc.html#asin
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::asin(&Triangle::cornerA));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::asin_string, X> asin(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  ASIN(X) function https://www.sqlite.org/lang_mathfunc.html#asin
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::asin<std::optional<double>>(&Triangle::cornerA));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::asin_string, X> asin(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  ASINH(X) function https://www.sqlite.org/lang_mathfunc.html#asinh
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::asinh(&Triangle::cornerA));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::asinh_string, X> asinh(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  ASINH(X) function https://www.sqlite.org/lang_mathfunc.html#asinh
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::asinh<std::optional<double>>(&Triangle::cornerA));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::asinh_string, X> asinh(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  ATAN(X) function https://www.sqlite.org/lang_mathfunc.html#atan
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::atan(1));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::atan_string, X> atan(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  ATAN(X) function https://www.sqlite.org/lang_mathfunc.html#atan
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::atan<std::optional<double>>(1));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::atan_string, X> atan(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  ATAN2(X, Y) function https://www.sqlite.org/lang_mathfunc.html#atan2
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::atan2(1, 3));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X, class Y>
+    internal::built_in_function_t<double, internal::atan2_string, X, Y> atan2(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    /**
+     *  ATAN2(X, Y) function https://www.sqlite.org/lang_mathfunc.html#atan2
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::atan2<std::optional<double>>(1, 3));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X, class Y>
+    internal::built_in_function_t<R, internal::atan2_string, X, Y> atan2(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    /**
+     *  ATANH(X) function https://www.sqlite.org/lang_mathfunc.html#atanh
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::atanh(1));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::atanh_string, X> atanh(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  ATANH(X) function https://www.sqlite.org/lang_mathfunc.html#atanh
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::atanh<std::optional<double>>(1));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::atanh_string, X> atanh(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  CEIL(X) function https://www.sqlite.org/lang_mathfunc.html#ceil
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::ceil(&User::rating));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::ceil_string, X> ceil(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  CEIL(X) function https://www.sqlite.org/lang_mathfunc.html#ceil
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::ceil<std::optional<double>>(&User::rating));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::ceil_string, X> ceil(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  CEILING(X) function https://www.sqlite.org/lang_mathfunc.html#ceil
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::ceiling(&User::rating));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::ceiling_string, X> ceiling(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  CEILING(X) function https://www.sqlite.org/lang_mathfunc.html#ceil
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::ceiling<std::optional<double>>(&User::rating));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::ceiling_string, X> ceiling(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  COS(X) function https://www.sqlite.org/lang_mathfunc.html#cos
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::cos(&Triangle::cornerB));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::cos_string, X> cos(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  COS(X) function https://www.sqlite.org/lang_mathfunc.html#cos
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::cos<std::optional<double>>(&User::rating));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::cos_string, X> cos(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  COSH(X) function https://www.sqlite.org/lang_mathfunc.html#cosh
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::cosh(&Triangle::cornerB));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::cosh_string, X> cosh(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  COSH(X)  function https://www.sqlite.org/lang_mathfunc.html#cosh
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::cosh<std::optional<double>>(&User::rating));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::cosh_string, X> cosh(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  DEGREES(X) function https://www.sqlite.org/lang_mathfunc.html#degrees
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::degrees(&Triangle::cornerB));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::degrees_string, X> degrees(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  DEGREES(X) function https://www.sqlite.org/lang_mathfunc.html#degrees
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::degrees<std::optional<double>>(&User::rating));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::degrees_string, X> degrees(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  EXP(X) function https://www.sqlite.org/lang_mathfunc.html#exp
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::exp(&Triangle::cornerB));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::exp_string, X> exp(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  EXP(X) function https://www.sqlite.org/lang_mathfunc.html#exp
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::exp<std::optional<double>>(&User::rating));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::exp_string, X> exp(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  FLOOR(X) function https://www.sqlite.org/lang_mathfunc.html#floor
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::floor(&User::rating));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::floor_string, X> floor(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  FLOOR(X) function https://www.sqlite.org/lang_mathfunc.html#floor
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::floor<std::optional<double>>(&User::rating));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::floor_string, X> floor(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  LN(X) function https://www.sqlite.org/lang_mathfunc.html#ln
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::ln(200));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::ln_string, X> ln(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  LN(X) function https://www.sqlite.org/lang_mathfunc.html#ln
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::ln<std::optional<double>>(200));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::ln_string, X> ln(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  LOG(X) function https://www.sqlite.org/lang_mathfunc.html#log
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::log(100));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::log_string, X> log(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  LOG(X) function https://www.sqlite.org/lang_mathfunc.html#log
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::log<std::optional<double>>(100));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::log_string, X> log(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  LOG10(X) function https://www.sqlite.org/lang_mathfunc.html#log
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::log10(100));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::log10_string, X> log10(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  LOG10(X) function https://www.sqlite.org/lang_mathfunc.html#log
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::log10<std::optional<double>>(100));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::log10_string, X> log10(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  LOG(B, X) function https://www.sqlite.org/lang_mathfunc.html#log
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::log(10, 100));   //  decltype(rows) is std::vector<double>
+     */
+    template<class B, class X>
+    internal::built_in_function_t<double, internal::log_string, B, X> log(B b, X x) {
+        return {std::tuple<B, X>{std::forward<B>(b), std::forward<X>(x)}};
+    }
+
+    /**
+     *  LOG(B, X) function https://www.sqlite.org/lang_mathfunc.html#log
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::log<std::optional<double>>(10, 100));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class B, class X>
+    internal::built_in_function_t<R, internal::log_string, B, X> log(B b, X x) {
+        return {std::tuple<B, X>{std::forward<B>(b), std::forward<X>(x)}};
+    }
+
+    /**
+     *  LOG2(X) function https://www.sqlite.org/lang_mathfunc.html#log2
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::log2(64));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::log2_string, X> log2(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  LOG2(X) function https://www.sqlite.org/lang_mathfunc.html#log2
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::log2<std::optional<double>>(64));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::log2_string, X> log2(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  MOD(X, Y) function https://www.sqlite.org/lang_mathfunc.html#mod
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::mod_f(6, 5));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X, class Y>
+    internal::built_in_function_t<double, internal::mod_string, X, Y> mod_f(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    /**
+     *  MOD(X, Y) function https://www.sqlite.org/lang_mathfunc.html#mod
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::mod_f<std::optional<double>>(6, 5));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X, class Y>
+    internal::built_in_function_t<R, internal::mod_string, X, Y> mod_f(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    /**
+     *  PI() function https://www.sqlite.org/lang_mathfunc.html#pi
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::pi());   //  decltype(rows) is std::vector<double>
+     */
+    inline internal::built_in_function_t<double, internal::pi_string> pi() {
+        return {{}};
+    }
+
+    /**
+     *  PI() function https://www.sqlite.org/lang_mathfunc.html#pi
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, etc.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::pi<float>());   //  decltype(rows) is std::vector<float>
+     */
+    template<class R>
+    internal::built_in_function_t<R, internal::pi_string> pi() {
+        return {{}};
+    }
+
+    /**
+     *  POW(X, Y) function https://www.sqlite.org/lang_mathfunc.html#pow
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::pow(2, 5));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X, class Y>
+    internal::built_in_function_t<double, internal::pow_string, X, Y> pow(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    /**
+     *  POW(X, Y) function https://www.sqlite.org/lang_mathfunc.html#pow
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::pow<std::optional<double>>(2, 5));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X, class Y>
+    internal::built_in_function_t<R, internal::pow_string, X, Y> pow(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    /**
+     *  POWER(X, Y) function https://www.sqlite.org/lang_mathfunc.html#pow
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::power(2, 5));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X, class Y>
+    internal::built_in_function_t<double, internal::power_string, X, Y> power(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    /**
+     *  POWER(X, Y) function https://www.sqlite.org/lang_mathfunc.html#pow
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::power<std::optional<double>>(2, 5));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X, class Y>
+    internal::built_in_function_t<R, internal::power_string, X, Y> power(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    /**
+     *  RADIANS(X) function https://www.sqlite.org/lang_mathfunc.html#radians
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::radians(&Triangle::cornerAInDegrees));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::radians_string, X> radians(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  RADIANS(X) function https://www.sqlite.org/lang_mathfunc.html#radians
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::radians<std::optional<double>>(&Triangle::cornerAInDegrees));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::radians_string, X> radians(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  SIN(X) function https://www.sqlite.org/lang_mathfunc.html#sin
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::sin(&Triangle::cornerA));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::sin_string, X> sin(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  SIN(X) function https://www.sqlite.org/lang_mathfunc.html#sin
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::sin<std::optional<double>>(&Triangle::cornerA));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::sin_string, X> sin(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  SINH(X) function https://www.sqlite.org/lang_mathfunc.html#sinh
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::sinh(&Triangle::cornerA));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::sinh_string, X> sinh(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  SINH(X) function https://www.sqlite.org/lang_mathfunc.html#sinh
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::sinh<std::optional<double>>(&Triangle::cornerA));   //  decltype(rows) is std::vector<std::optional<double>>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::sinh_string, X> sinh(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  SQRT(X) function https://www.sqlite.org/lang_mathfunc.html#sqrt
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::sqrt(25));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::sqrt_string, X> sqrt(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  SQRT(X) function https://www.sqlite.org/lang_mathfunc.html#sqrt
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::sqrt<int>(25));   //  decltype(rows) is std::vector<int>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::sqrt_string, X> sqrt(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  TAN(X) function https://www.sqlite.org/lang_mathfunc.html#tan
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::tan(&Triangle::cornerC));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::tan_string, X> tan(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  TAN(X) function https://www.sqlite.org/lang_mathfunc.html#tan
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::tan<float>(&Triangle::cornerC));   //  decltype(rows) is std::vector<float>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::tan_string, X> tan(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  TANH(X) function https://www.sqlite.org/lang_mathfunc.html#tanh
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::tanh(&Triangle::cornerC));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::tanh_string, X> tanh(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  TANH(X) function https://www.sqlite.org/lang_mathfunc.html#tanh
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::tanh<float>(&Triangle::cornerC));   //  decltype(rows) is std::vector<float>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::tanh_string, X> tanh(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  TRUNC(X) function https://www.sqlite.org/lang_mathfunc.html#trunc
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::trunc(5.5));   //  decltype(rows) is std::vector<double>
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::trunc_string, X> trunc(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  TRUNC(X) function https://www.sqlite.org/lang_mathfunc.html#trunc
+     *
+     *  Difference with the previous function is that previous override has `double` as return type but this
+     *  override accepts return type from you as a template argument. You can use any bindable type:
+     *  `float`, `int`, `std::optional<double>` etc. This override is handy when you expect `null` as result.
+     *
+     *  Example:
+     *
+     *  auto rows = storage.select(sqlite_orm::trunc<float>(5.5));   //  decltype(rows) is std::vector<float>
+     */
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::trunc_string, X> trunc(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+#endif  //  SQLITE_ENABLE_MATH_FUNCTIONS
+    /**
+     *  TYPEOF(x) function https://sqlite.org/lang_corefunc.html#typeof
+     */
+    template<class T>
+    internal::built_in_function_t<std::string, internal::typeof_string, T> typeof_(T t) {
+        return {std::tuple<T>{std::forward<T>(t)}};
+    }
+
+    /**
+     *  UNICODE(x) function https://sqlite.org/lang_corefunc.html#unicode
+     */
+    template<class T>
+    internal::built_in_function_t<int, internal::unicode_string, T> unicode(T t) {
+        return {std::tuple<T>{std::forward<T>(t)}};
+    }
+
+    /**
+     *  LENGTH(x) function https://sqlite.org/lang_corefunc.html#length
+     */
+    template<class T>
+    internal::built_in_function_t<int, internal::length_string, T> length(T t) {
+        return {std::tuple<T>{std::forward<T>(t)}};
+    }
+
+    /**
+     *  ABS(x) function https://sqlite.org/lang_corefunc.html#abs
+     */
+    template<class T>
+    internal::built_in_function_t<std::unique_ptr<double>, internal::abs_string, T> abs(T t) {
+        return {std::tuple<T>{std::forward<T>(t)}};
+    }
+
+    /**
+     *  LOWER(x) function https://sqlite.org/lang_corefunc.html#lower
+     */
+    template<class T>
+    internal::built_in_function_t<std::string, internal::lower_string, T> lower(T t) {
+        return {std::tuple<T>{std::forward<T>(t)}};
+    }
+
+    /**
+     *  UPPER(x) function https://sqlite.org/lang_corefunc.html#upper
+     */
+    template<class T>
+    internal::built_in_function_t<std::string, internal::upper_string, T> upper(T t) {
+        return {std::tuple<T>{std::forward<T>(t)}};
+    }
+
+    /**
+     *  LAST_INSERT_ROWID(x) function https://www.sqlite.org/lang_corefunc.html#last_insert_rowid
+     */
+    inline internal::built_in_function_t<int64, internal::last_insert_rowid_string> last_insert_rowid() {
+        return {{}};
+    }
+
+    /**
+     *  TOTAL_CHANGES() function https://sqlite.org/lang_corefunc.html#total_changes
+     */
+    inline internal::built_in_function_t<int, internal::total_changes_string> total_changes() {
+        return {{}};
+    }
+
+    /**
+     *  CHANGES() function https://sqlite.org/lang_corefunc.html#changes
+     */
+    inline internal::built_in_function_t<int, internal::changes_string> changes() {
+        return {{}};
+    }
+
+    /**
+     *  TRIM(X) function https://sqlite.org/lang_corefunc.html#trim
+     */
+    template<class T>
+    internal::built_in_function_t<std::string, internal::trim_string, T> trim(T t) {
+        return {std::tuple<T>{std::forward<T>(t)}};
+    }
+
+    /**
+     *  TRIM(X,Y) function https://sqlite.org/lang_corefunc.html#trim
+     */
+    template<class X, class Y>
+    internal::built_in_function_t<std::string, internal::trim_string, X, Y> trim(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    /**
+     *  LTRIM(X) function https://sqlite.org/lang_corefunc.html#ltrim
+     */
+    template<class X>
+    internal::built_in_function_t<std::string, internal::ltrim_string, X> ltrim(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  LTRIM(X,Y) function https://sqlite.org/lang_corefunc.html#ltrim
+     */
+    template<class X, class Y>
+    internal::built_in_function_t<std::string, internal::ltrim_string, X, Y> ltrim(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    /**
+     *  RTRIM(X) function https://sqlite.org/lang_corefunc.html#rtrim
+     */
+    template<class X>
+    internal::built_in_function_t<std::string, internal::rtrim_string, X> rtrim(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  RTRIM(X,Y) function https://sqlite.org/lang_corefunc.html#rtrim
+     */
+    template<class X, class Y>
+    internal::built_in_function_t<std::string, internal::rtrim_string, X, Y> rtrim(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    /**
+     *  HEX(X) function https://sqlite.org/lang_corefunc.html#hex
+     */
+    template<class X>
+    internal::built_in_function_t<std::string, internal::hex_string, X> hex(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  QUOTE(X) function https://sqlite.org/lang_corefunc.html#quote
+     */
+    template<class X>
+    internal::built_in_function_t<std::string, internal::quote_string, X> quote(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  RANDOMBLOB(X) function https://sqlite.org/lang_corefunc.html#randomblob
+     */
+    template<class X>
+    internal::built_in_function_t<std::vector<char>, internal::randomblob_string, X> randomblob(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  INSTR(X) function https://sqlite.org/lang_corefunc.html#instr
+     */
+    template<class X, class Y>
+    internal::built_in_function_t<int, internal::instr_string, X, Y> instr(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    /**
+     *  REPLACE(X) function https://sqlite.org/lang_corefunc.html#replace
+     */
+    template<class X, class Y, class Z>
+    typename std::enable_if<internal::count_tuple<std::tuple<X, Y, Z>, internal::is_into>::value == 0,
+                            internal::built_in_function_t<std::string, internal::replace_string, X, Y, Z>>::type
+    replace(X x, Y y, Z z) {
+        return {std::tuple<X, Y, Z>{std::forward<X>(x), std::forward<Y>(y), std::forward<Z>(z)}};
+    }
+
+    /**
+     *  ROUND(X) function https://sqlite.org/lang_corefunc.html#round
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::round_string, X> round(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  ROUND(X, Y) function https://sqlite.org/lang_corefunc.html#round
+     */
+    template<class X, class Y>
+    internal::built_in_function_t<double, internal::round_string, X, Y> round(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+#if SQLITE_VERSION_NUMBER >= 3007016
+
+    /**
+     *  CHAR(X1,X2,...,XN) function https://sqlite.org/lang_corefunc.html#char
+     */
+    template<class... Args>
+    internal::built_in_function_t<std::string, internal::char_string, Args...> char_(Args... args) {
+        return {std::make_tuple(std::forward<Args>(args)...)};
+    }
+
+    /**
+     *  RANDOM() function https://www.sqlite.org/lang_corefunc.html#random
+     */
+    inline internal::built_in_function_t<int, internal::random_string> random() {
+        return {{}};
+    }
+
+#endif
+
+    /**
+     *  COALESCE(X,Y,...) function https://www.sqlite.org/lang_corefunc.html#coalesce
+     */
+    template<class R, class... Args>
+    internal::built_in_function_t<R, internal::coalesce_string, Args...> coalesce(Args... args) {
+        return {std::make_tuple(std::forward<Args>(args)...)};
+    }
+
+    /**
+     *  IFNULL(X,Y) function https://www.sqlite.org/lang_corefunc.html#ifnull
+     */
+    template<class R, class X, class Y>
+    internal::built_in_function_t<R, internal::ifnull_string, X, Y> ifnull(X x, Y y) {
+        return {std::make_tuple(std::move(x), std::move(y))};
+    }
+
+    /**
+     *  DATE(timestring, modifier, modifier, ...) function https://www.sqlite.org/lang_datefunc.html
+     */
+    template<class... Args>
+    internal::built_in_function_t<std::string, internal::date_string, Args...> date(Args... args) {
+        return {std::tuple<Args...>{std::forward<Args>(args)...}};
+    }
+
+    /**
+     *  TIME(timestring, modifier, modifier, ...) function https://www.sqlite.org/lang_datefunc.html
+     */
+    template<class... Args>
+    internal::built_in_function_t<std::string, internal::time_string, Args...> time(Args... args) {
+        return {std::tuple<Args...>{std::forward<Args>(args)...}};
+    }
+
+    /**
+     *  DATETIME(timestring, modifier, modifier, ...) function https://www.sqlite.org/lang_datefunc.html
+     */
+    template<class... Args>
+    internal::built_in_function_t<std::string, internal::datetime_string, Args...> datetime(Args... args) {
+        return {std::tuple<Args...>{std::forward<Args>(args)...}};
+    }
+
+    /**
+     *  JULIANDAY(timestring, modifier, modifier, ...) function https://www.sqlite.org/lang_datefunc.html
+     */
+    template<class... Args>
+    internal::built_in_function_t<double, internal::julianday_string, Args...> julianday(Args... args) {
+        return {std::tuple<Args...>{std::forward<Args>(args)...}};
+    }
+
+    /**
+     *  STRFTIME(timestring, modifier, modifier, ...) function https://www.sqlite.org/lang_datefunc.html
+     */
+    template<class... Args>
+    internal::built_in_function_t<std::string, internal::strftime_string, Args...> strftime(Args... args) {
+        return {std::tuple<Args...>{std::forward<Args>(args)...}};
+    }
+
+    /**
+     *  ZEROBLOB(N) function https://www.sqlite.org/lang_corefunc.html#zeroblob
+     */
+    template<class N>
+    internal::built_in_function_t<std::vector<char>, internal::zeroblob_string, N> zeroblob(N n) {
+        return {std::tuple<N>{std::forward<N>(n)}};
+    }
+
+    /**
+     *  SUBSTR(X,Y) function https://www.sqlite.org/lang_corefunc.html#substr
+     */
+    template<class X, class Y>
+    internal::built_in_function_t<std::string, internal::substr_string, X, Y> substr(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    /**
+     *  SUBSTR(X,Y,Z) function https://www.sqlite.org/lang_corefunc.html#substr
+     */
+    template<class X, class Y, class Z>
+    internal::built_in_function_t<std::string, internal::substr_string, X, Y, Z> substr(X x, Y y, Z z) {
+        return {std::tuple<X, Y, Z>{std::forward<X>(x), std::forward<Y>(y), std::forward<Z>(z)}};
+    }
+
+#ifdef SQLITE_SOUNDEX
+    /**
+     *  SOUNDEX(X) function https://www.sqlite.org/lang_corefunc.html#soundex
+     */
+    template<class X>
+    internal::core_function_t<std::string, internal::soundex_string, X> soundex(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+#endif
+
+    /**
+     *  TOTAL(X) aggregate function.
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::total_string, X> total(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  SUM(X) aggregate function.
+     */
+    template<class X>
+    internal::built_in_function_t<std::unique_ptr<double>, internal::sum_string, X> sum(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  COUNT(X) aggregate function.
+     */
+    template<class X>
+    internal::built_in_function_t<int, internal::count_string, X> count(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  COUNT(*) without FROM function.
+     */
+    inline internal::count_asterisk_without_type count() {
+        return {};
+    }
+
+    /**
+     *  COUNT(*) with FROM function. Specified type T will be serializeed as
+     *  a from argument.
+     */
+    template<class T>
+    internal::count_asterisk_t<T> count() {
+        return {};
+    }
+
+    /**
+     *  AVG(X) aggregate function.
+     */
+    template<class X>
+    internal::built_in_function_t<double, internal::avg_string, X> avg(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  MAX(X, ...) aggregate or simple multi-argument function.
+     *  The return type is deduced from the first argument.
+     */
+    template<class X, class... Rest>
+    internal::built_in_function_t<internal::unique_ptr_result_of<X>, internal::max_string, X, Rest...>
+    max(X x, Rest... rest) {
+        return {std::tuple<X, Rest...>{std::move(x), std::move(rest)...}};
+    }
+
+    /**
+     *  MIN(X, ...) aggregate or simple multi-argument function.
+     *  The return type is deduced from the first argument.
+     */
+    template<class X, class... Rest>
+    internal::built_in_function_t<internal::unique_ptr_result_of<X>, internal::min_string, X, Rest...>
+    min(X x, Rest... rest) {
+        return {std::tuple<X, Rest...>{std::move(x), std::move(rest)...}};
+    }
+
+    /**
+     *  GROUP_CONCAT(X) aggregate function.
+     */
+    template<class X>
+    internal::built_in_function_t<std::string, internal::group_concat_string, X> group_concat(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    /**
+     *  GROUP_CONCAT(X, Y) aggregate function.
+     */
+    template<class X, class Y>
+    internal::built_in_function_t<std::string, internal::group_concat_string, X, Y> group_concat(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+#ifdef SQLITE_ENABLE_JSON1
+    template<class X>
+    internal::built_in_function_t<std::string, internal::json_string, X> json(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    template<class... Args>
+    internal::built_in_function_t<std::string, internal::json_array_string, Args...> json_array(Args... args) {
+        return {std::tuple<Args...>{std::forward<Args>(args)...}};
+    }
+
+    template<class X>
+    internal::built_in_function_t<int, internal::json_array_length_string, X> json_array_length(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::json_array_length_string, X> json_array_length(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    template<class X, class Y>
+    internal::built_in_function_t<int, internal::json_array_length_string, X, Y> json_array_length(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    template<class R, class X, class Y>
+    internal::built_in_function_t<R, internal::json_array_length_string, X, Y> json_array_length(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    template<class R, class X, class... Args>
+    internal::built_in_function_t<R, internal::json_extract_string, X, Args...> json_extract(X x, Args... args) {
+        return {std::tuple<X, Args...>{std::forward<X>(x), std::forward<Args>(args)...}};
+    }
+
+    template<class X, class... Args>
+    internal::built_in_function_t<std::string, internal::json_insert_string, X, Args...> json_insert(X x,
+                                                                                                     Args... args) {
+        static_assert(std::tuple_size<std::tuple<Args...>>::value % 2 == 0,
+                      "number of arguments in json_insert must be odd");
+        return {std::tuple<X, Args...>{std::forward<X>(x), std::forward<Args>(args)...}};
+    }
+
+    template<class X, class... Args>
+    internal::built_in_function_t<std::string, internal::json_replace_string, X, Args...> json_replace(X x,
+                                                                                                       Args... args) {
+        static_assert(std::tuple_size<std::tuple<Args...>>::value % 2 == 0,
+                      "number of arguments in json_replace must be odd");
+        return {std::tuple<X, Args...>{std::forward<X>(x), std::forward<Args>(args)...}};
+    }
+
+    template<class X, class... Args>
+    internal::built_in_function_t<std::string, internal::json_set_string, X, Args...> json_set(X x, Args... args) {
+        static_assert(std::tuple_size<std::tuple<Args...>>::value % 2 == 0,
+                      "number of arguments in json_set must be odd");
+        return {std::tuple<X, Args...>{std::forward<X>(x), std::forward<Args>(args)...}};
+    }
+
+    template<class... Args>
+    internal::built_in_function_t<std::string, internal::json_object_string, Args...> json_object(Args... args) {
+        static_assert(std::tuple_size<std::tuple<Args...>>::value % 2 == 0,
+                      "number of arguments in json_object must be even");
+        return {std::tuple<Args...>{std::forward<Args>(args)...}};
+    }
+
+    template<class X, class Y>
+    internal::built_in_function_t<std::string, internal::json_patch_string, X, Y> json_patch(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    template<class X, class... Args>
+    internal::built_in_function_t<std::string, internal::json_remove_string, X, Args...> json_remove(X x,
+                                                                                                     Args... args) {
+        return {std::tuple<X, Args...>{std::forward<X>(x), std::forward<Args>(args)...}};
+    }
+
+    template<class R, class X, class... Args>
+    internal::built_in_function_t<R, internal::json_remove_string, X, Args...> json_remove(X x, Args... args) {
+        return {std::tuple<X, Args...>{std::forward<X>(x), std::forward<Args>(args)...}};
+    }
+
+    template<class X>
+    internal::built_in_function_t<std::string, internal::json_type_string, X> json_type(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::json_type_string, X> json_type(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    template<class X, class Y>
+    internal::built_in_function_t<std::string, internal::json_type_string, X, Y> json_type(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    template<class R, class X, class Y>
+    internal::built_in_function_t<R, internal::json_type_string, X, Y> json_type(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+    template<class X>
+    internal::built_in_function_t<bool, internal::json_valid_string, X> json_valid(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    template<class R, class X>
+    internal::built_in_function_t<R, internal::json_quote_string, X> json_quote(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    template<class X>
+    internal::built_in_function_t<std::string, internal::json_group_array_string, X> json_group_array(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
+    }
+
+    template<class X, class Y>
+    internal::built_in_function_t<std::string, internal::json_group_object_string, X, Y> json_group_object(X x, Y y) {
+        return {std::tuple<X, Y>{std::forward<X>(x), std::forward<Y>(y)}};
+    }
+
+#endif  //  SQLITE_ENABLE_JSON1
+    template<class L,
+             class R,
+             typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value +
+                                                     std::is_base_of<internal::arithmetic_t, R>::value >
+                                                 0)>::type>
+    internal::add_t<L, R> operator+(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L,
+             class R,
+             typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value +
+                                                     std::is_base_of<internal::arithmetic_t, R>::value >
+                                                 0)>::type>
+    internal::sub_t<L, R> operator-(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L,
+             class R,
+             typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value +
+                                                     std::is_base_of<internal::arithmetic_t, R>::value >
+                                                 0)>::type>
+    internal::mul_t<L, R> operator*(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L,
+             class R,
+             typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value +
+                                                     std::is_base_of<internal::arithmetic_t, R>::value >
+                                                 0)>::type>
+    internal::div_t<L, R> operator/(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+
+    template<class L,
+             class R,
+             typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value +
+                                                     std::is_base_of<internal::arithmetic_t, R>::value >
+                                                 0)>::type>
+    internal::mod_t<L, R> operator%(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+}
+#pragma once
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  Cute class used to compare setters/getters and member pointers with each other.
+         */
+        template<class L, class R>
+        struct typed_comparator {
+            bool operator()(const L&, const R&) const {
+                return false;
+            }
+        };
+
+        template<class O>
+        struct typed_comparator<O, O> {
+            bool operator()(const O& lhs, const O& rhs) const {
+                return lhs == rhs;
+            }
+        };
+
+        template<class L, class R>
+        bool compare_any(const L& lhs, const R& rhs) {
+            return typed_comparator<L, R>()(lhs, rhs);
+        }
+    }
+}
+#pragma once
+
+#include <string>  //  std::string
+#include <utility>  //  std::declval
+#include <tuple>  //  std::tuple, std::get, std::tuple_size
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+#include <optional>  // std::optional
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+// #include "cxx_polyfill.h"
+
+// #include "type_traits.h"
+
+// #include "is_base_of_template.h"
+
+// #include "tuple_helper/tuple_helper.h"
+
+// #include "optional_container.h"
+
+// #include "ast/where.h"
+
+// #include "../serialize_result_type.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+        struct where_string {
+            serialize_result_type serialize() const {
+                return "WHERE";
+            }
+        };
+
+        /**
+         *  WHERE argument holder.
+         *  C is expression type. Can be any expression like: is_equal_t, is_null_t, exists_t etc
+         *  Don't construct it manually. Call `where(...)` function instead.
+         */
+        template<class C>
+        struct where_t : where_string {
+            using expression_type = C;
+
+            expression_type expression;
+
+            where_t(expression_type expression_) : expression(std::move(expression_)) {}
+        };
+
+        template<class T>
+        struct is_where : std::false_type {};
+
+        template<class T>
+        struct is_where<where_t<T>> : std::true_type {};
+    }
+
+    /**
+     *  WHERE clause. Use it to add WHERE conditions wherever you like.
+     *  C is expression type. Can be any expression like: is_equal_t, is_null_t, exists_t etc
+     *  @example
+     *  //  SELECT name
+     *  //  FROM letters
+     *  //  WHERE id > 3
+     *  auto rows = storage.select(&Letter::name, where(greater_than(&Letter::id, 3)));
+     */
+    template<class C>
+    internal::where_t<C> where(C expression) {
+        return {std::move(expression)};
+    }
+}
+
+// #include "ast/group_by.h"
+
+#include <tuple>  //  std::tuple, std::make_tuple
+#include <type_traits>  //  std::true_type, std::false_type, std::forward
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T, class... Args>
+        struct group_by_with_having {
+            using args_type = std::tuple<Args...>;
+            using expression_type = T;
+
+            args_type args;
+            expression_type expression;
+        };
+
+        /**
+         *  GROUP BY pack holder.
+         */
+        template<class... Args>
+        struct group_by_t {
+            using args_type = std::tuple<Args...>;
+
+            args_type args;
+
+            template<class T>
+            group_by_with_having<T, Args...> having(T expression) {
+                return {move(this->args), std::move(expression)};
+            }
+        };
+
+        template<class T>
+        struct is_group_by : std::false_type {};
+
+        template<class... Args>
+        struct is_group_by<group_by_t<Args...>> : std::true_type {};
+
+        template<class T, class... Args>
+        struct is_group_by<group_by_with_having<T, Args...>> : std::true_type {};
+
+        /**
+         *  HAVING holder.
+         *  T is having argument type.
+         */
+        template<class T>
+        struct having_t {
+            using expression_type = T;
+
+            expression_type expression;
+        };
+
+        template<class T>
+        struct is_having : std::false_type {};
+
+        template<class T>
+        struct is_having<having_t<T>> : std::true_type {};
+    }
+
+    /**
+     *  GROUP BY column.
+     *  Example: storage.get_all<Employee>(group_by(&Employee::name))
+     */
+    template<class... Args>
+    internal::group_by_t<Args...> group_by(Args&&... args) {
+        return {std::make_tuple(std::forward<Args>(args)...)};
+    }
+
+    /**
+     *  [Deprecation notice]: this function is deprecated and will be removed in v1.9. Please use `group_by(...).having(...)` instead.
+     *
+     *  HAVING(expression).
+     *  Example: storage.get_all<Employee>(group_by(&Employee::name), having(greater_than(count(&Employee::name), 2)));
+     */
+    template<class T>
+    internal::having_t<T> having(T expression) {
+        return {std::move(expression)};
+    }
+}
+
+namespace sqlite_orm {
+
+    namespace internal {
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class T>
+        struct as_optional_t {
+            using value_type = T;
+
+            value_type value;
+        };
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+
+        struct distinct_string {
+            operator std::string() const {
+                return "DISTINCT";
+            }
+        };
+
+        /**
+         *  DISCTINCT generic container.
+         */
+        template<class T>
+        struct distinct_t : distinct_string {
+            using value_type = T;
+
+            value_type value;
+
+            distinct_t(value_type value_) : value(std::move(value_)) {}
+        };
+
+        struct all_string {
+            operator std::string() const {
+                return "ALL";
+            }
+        };
+
+        /**
+         *  ALL generic container.
+         */
+        template<class T>
+        struct all_t : all_string {
+            T value;
+
+            all_t(T value_) : value(std::move(value_)) {}
+        };
+
+        template<class... Args>
+        struct columns_t {
+            using columns_type = std::tuple<Args...>;
+
+            columns_type columns;
+            bool distinct = false;
+
+            static constexpr const int count = std::tuple_size<columns_type>::value;
+        };
+
+        template<class T>
+        struct is_columns : std::false_type {};
+
+        template<class... Args>
+        struct is_columns<columns_t<Args...>> : std::true_type {};
+
+        struct set_string {
+            operator std::string() const {
+                return "SET";
+            }
+        };
+
+        template<class... Args>
+        struct set_t : set_string {
+            using assigns_type = std::tuple<Args...>;
+
+            assigns_type assigns;
+
+            set_t(assigns_type assigns_) : assigns(move(assigns_)) {}
+        };
+
+        /**
+         *  This class is used to store explicit mapped type T and its column descriptor (member pointer/getter/setter).
+         *  Is useful when mapped type is derived from other type and base class has members mapped to a storage.
+         */
+        template<class T, class F>
+        struct column_pointer {
+            using self = column_pointer<T, F>;
+            using type = T;
+            using field_type = F;
+
+            field_type field;
+
+            template<class R>
+            internal::is_equal_t<self, R> operator==(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            internal::is_not_equal_t<self, R> operator!=(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            internal::lesser_than_t<self, R> operator<(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            internal::lesser_or_equal_t<self, R> operator<=(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            internal::greater_than_t<self, R> operator>(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            internal::greater_or_equal_t<self, R> operator>=(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+        };
+
+        /**
+         *  Subselect object type.
+         */
+        template<class T, class... Args>
+        struct select_t {
+            using return_type = T;
+            using conditions_type = std::tuple<Args...>;
+
+            return_type col;
+            conditions_type conditions;
+            bool highest_level = false;
+        };
+
+        template<class T>
+        struct is_select : std::false_type {};
+
+        template<class T, class... Args>
+        struct is_select<select_t<T, Args...>> : std::true_type {};
+
+        /**
+         *  Base for UNION, UNION ALL, EXCEPT and INTERSECT
+         */
+        template<class L, class R>
+        struct compound_operator {
+            using left_type = L;
+            using right_type = R;
+
+            left_type left;
+            right_type right;
+
+            compound_operator(left_type l, right_type r) : left(std::move(l)), right(std::move(r)) {
+                this->left.highest_level = true;
+                this->right.highest_level = true;
+            }
+        };
+
+        struct union_base {
+            bool all = false;
+
+            operator std::string() const {
+                if(!this->all) {
+                    return "UNION";
+                } else {
+                    return "UNION ALL";
+                }
+            }
+        };
+
+        /**
+         *  UNION object type.
+         */
+        template<class L, class R>
+        struct union_t : public compound_operator<L, R>, union_base {
+            using left_type = typename compound_operator<L, R>::left_type;
+            using right_type = typename compound_operator<L, R>::right_type;
+
+            union_t(left_type l, right_type r, decltype(all) all_) :
+                compound_operator<L, R>(std::move(l), std::move(r)), union_base{all_} {}
+
+            union_t(left_type l, right_type r) : union_t(std::move(l), std::move(r), false) {}
+        };
+
+        struct except_string {
+            operator std::string() const {
+                return "EXCEPT";
+            }
+        };
+
+        /**
+         *  EXCEPT object type.
+         */
+        template<class L, class R>
+        struct except_t : compound_operator<L, R>, except_string {
+            using super = compound_operator<L, R>;
+            using left_type = typename super::left_type;
+            using right_type = typename super::right_type;
+
+            using super::super;
+        };
+
+        struct intersect_string {
+            operator std::string() const {
+                return "INTERSECT";
+            }
+        };
+        /**
+         *  INTERSECT object type.
+         */
+        template<class L, class R>
+        struct intersect_t : compound_operator<L, R>, intersect_string {
+            using super = compound_operator<L, R>;
+            using left_type = typename super::left_type;
+            using right_type = typename super::right_type;
+
+            using super::super;
+        };
+
+        struct with_string {
+            explicit operator std::string() const {
+                return "WITH";
+            }
+        };
+
+        /**
+         *  Labeled (aliased) CTE expression.
+         */
+        template<class Label, class Select, class nExplicitCols>
+        struct common_table_expression : public Label {
+            using cte_label_type = Label;
+            using expression_type = Select;
+            static constexpr size_t explicit_column_count = nExplicitCols::value;
+
+            std::vector<std::string> explicitColumnNames;
+            expression_type subselect;
+
+            common_table_expression(std::vector<std::string> explicitColumnNames, expression_type subselect) :
+                explicitColumnNames{move(explicitColumnNames)}, subselect{std::move(subselect)} {
+                this->subselect.highest_level = true;
+            }
+        };
+        template<class... CTEs>
+        using common_table_expressions = std::tuple<CTEs...>;
+
+        template<typename Label, class nExplicitCols>
+        struct cte_builder {
+            std::vector<std::string> explicitColumnNames;
+
+            template<class T, class... Args>
+            common_table_expression<Label, select_t<T, Args...>, nExplicitCols>
+            operator()(select_t<T, Args...> sel) && {
+                return {move(this->explicitColumnNames), std::move(sel)};
+            }
+
+            template<class Compound,
+                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            common_table_expression<Label, select_t<Compound>, nExplicitCols> operator()(Compound sel) && {
+                return {move(this->explicitColumnNames), {std::move(sel)}};
+            }
+
+            template<class T, class... Args>
+            common_table_expression<Label, select_t<T, Args...>, nExplicitCols> as(select_t<T, Args...> sel) && {
+                return {move(this->explicitColumnNames), std::move(sel)};
+            }
+
+            template<class Compound,
+                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            common_table_expression<Label, select_t<Compound>, nExplicitCols> as(Compound sel) && {
+                return {move(this->explicitColumnNames), {std::move(sel)}};
+            }
+
+            template<class T, class... Args>
+            common_table_expression<Label, select_t<T, Args...>, nExplicitCols>
+            materialized(select_t<T, Args...> sel) && {
+                static_assert(polyfill::always_false_v<T>, "`WITH ... AS MATERIALIZED` is unimplemented");
+                return {move(this->explicitColumnNames), std::move(sel)};
+            }
+
+            template<class Compound,
+                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            common_table_expression<Label, select_t<Compound>, nExplicitCols> materialized(Compound sel) && {
+                static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS MATERIALIZED` is unimplemented");
+                return {move(this->explicitColumnNames), {std::move(sel)}};
+            }
+
+            template<class T, class... Args>
+            common_table_expression<Label, select_t<T, Args...>, nExplicitCols>
+            not_materialized(select_t<T, Args...> sel) && {
+                static_assert(polyfill::always_false_v<T>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
+                return {move(this->explicitColumnNames), std::move(sel)};
+            }
+
+            template<class Compound,
+                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            common_table_expression<Label, select_t<Compound>, nExplicitCols> not_materialized(Compound sel) && {
+                static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
+                return {move(this->explicitColumnNames), {std::move(sel)}};
+            }
+        };
+
+        /**
+         *  WITH object type - expression with prepended CTEs.
+         */
+        template<class E, class... CTEs>
+        struct with_t : with_string {
+            using cte_type = common_table_expressions<CTEs...>;
+            using expression_type = E;
+
+            cte_type cte;
+            expression_type expression;
+
+            with_t(cte_type cte, expression_type expression) : cte{move(cte)}, expression{std::move(expression)} {
+                this->expression.highest_level = true;
+            }
+        };
+
+        /**
+         *  Generic way to get DISTINCT value from any type.
+         */
+        template<class T>
+        bool get_distinct(const T&) {
+            return false;
+        }
+
+        template<class... Args>
+        bool get_distinct(const columns_t<Args...>& cols) {
+            return cols.distinct;
+        }
+
+        template<class T>
+        struct asterisk_t {
+            using type = T;
+        };
+
+        template<class T>
+        struct object_t {
+            using type = T;
+        };
+
+        template<class T>
+        struct then_t {
+            using expression_type = T;
+
+            expression_type expression;
+        };
+
+        template<class R, class T, class E, class... Args>
+        struct simple_case_t {
+            using return_type = R;
+            using case_expression_type = T;
+            using args_type = std::tuple<Args...>;
+            using else_expression_type = E;
+
+            optional_container<case_expression_type> case_expression;
+            args_type args;
+            optional_container<else_expression_type> else_expression;
+        };
+
+        /**
+         *  T is a case expression type
+         *  E is else type (void is ELSE is omitted)
+         *  Args... is a pack of WHEN expressions
+         */
+        template<class R, class T, class E, class... Args>
+        struct simple_case_builder {
+            using return_type = R;
+            using case_expression_type = T;
+            using args_type = std::tuple<Args...>;
+            using else_expression_type = E;
+
+            optional_container<case_expression_type> case_expression;
+            args_type args;
+            optional_container<else_expression_type> else_expression;
+
+            template<class W, class Th>
+            simple_case_builder<R, T, E, Args..., std::pair<W, Th>> when(W w, then_t<Th> t) {
+                using result_args_type = std::tuple<Args..., std::pair<W, Th>>;
+                std::pair<W, Th> newPair{std::move(w), std::move(t.expression)};
+                result_args_type result_args =
+                    std::tuple_cat(std::move(this->args), std::move(std::make_tuple(newPair)));
+                std::get<std::tuple_size<result_args_type>::value - 1>(result_args) = std::move(newPair);
+                return {std::move(this->case_expression), std::move(result_args), std::move(this->else_expression)};
+            }
+
+            simple_case_t<R, T, E, Args...> end() {
+                return {std::move(this->case_expression), std::move(args), std::move(this->else_expression)};
+            }
+
+            template<class El>
+            simple_case_builder<R, T, El, Args...> else_(El el) {
+                return {{std::move(this->case_expression)}, std::move(args), {std::move(el)}};
+            }
+        };
+
+        template<class T>
+        void validate_conditions() {
+            static_assert(count_tuple<T, is_where>::value <= 1, "a single query cannot contain > 1 WHERE blocks");
+            static_assert(count_tuple<T, is_group_by>::value <= 1, "a single query cannot contain > 1 GROUP BY blocks");
+            static_assert(count_tuple<T, is_order_by>::value <= 1, "a single query cannot contain > 1 ORDER BY blocks");
+            static_assert(count_tuple<T, is_limit>::value <= 1, "a single query cannot contain > 1 LIMIT blocks");
+            static_assert(count_tuple<T, is_from>::value <= 1, "a single query cannot contain > 1 FROM blocks");
+        }
+    }
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+    template<class T>
+    internal::as_optional_t<T> as_optional(T value) {
+        return {std::move(value)};
+    }
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+    template<class T>
+    internal::then_t<T> then(T t) {
+        return {std::move(t)};
+    }
+
+    template<class R, class T>
+    internal::simple_case_builder<R, T, void> case_(T t) {
+        return {{std::move(t)}};
+    }
+
+    template<class R>
+    internal::simple_case_builder<R, void, void> case_() {
+        return {};
+    }
+
+    template<class T>
+    internal::distinct_t<T> distinct(T t) {
+        return {std::move(t)};
+    }
+
+    template<class T>
+    internal::all_t<T> all(T t) {
+        return {std::move(t)};
+    }
+
+    template<class... Args>
+    internal::columns_t<Args...> distinct(internal::columns_t<Args...> cols) {
+        cols.distinct = true;
+        return cols;
+    }
+
+    /**
+     *  SET keyword used in UPDATE ... SET queries.
+     *  Args must have `assign_t` type. E.g. set(assign(&User::id, 5)) or set(c(&User::id) = 5)
+     */
+    template<class... Args>
+    internal::set_t<Args...> set(Args... args) {
+        using arg_tuple = std::tuple<Args...>;
+        static_assert(std::tuple_size<arg_tuple>::value ==
+                          internal::count_tuple<arg_tuple, internal::is_assign_t>::value,
+                      "set function accepts assign operators only");
+        return {std::make_tuple(std::forward<Args>(args)...)};
+    }
+
+    template<class... Args>
+    internal::columns_t<Args...> columns(Args... args) {
+        return {std::make_tuple<Args...>(std::forward<Args>(args)...)};
+    }
+
+    /**
+     *  Explicitly refer to a column, used in contexts
+     *  where the automatic object mapping deduction needs to be overridden,
+     *  or when you need to refer to a column in a CTE.
+     *  
+     *  Use it like this:
+     *  struct MyType : BaseType { ... };
+     *  storage.select(column<MyType>(&BaseType::id));
+     *  // ... or
+     *  struct Object { ... };
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(c_v<&Object::id>)));
+     */
+    template<class O, class F>
+    internal::column_pointer<O, F> column(F f) {
+        return {std::move(f)};
+    }
+
+    /**
+     *  Turn 1_nth_col -> 0_col
+     */
+    template<class O, unsigned int I>
+    auto column(internal::nth_constant<I>) {
+        return column<O>(polyfill::index_constant<I - 1>{});
+    }
+
+    /**
+     *  Public function for subselect query. Is useful in UNION queries.
+     */
+    template<class T, class... Args>
+    internal::select_t<T, Args...> select(T t, Args... args) {
+        using args_tuple = std::tuple<Args...>;
+        internal::validate_conditions<args_tuple>();
+        return {std::move(t), std::make_tuple(std::forward<Args>(args)...)};
+    }
+
+    /**
+     *  Public function for UNION operator.
+     *  lhs and rhs are subselect objects.
+     *  Look through example in examples/union.cpp
+     */
+    template<class L, class R>
+    internal::union_t<L, R> union_(L lhs, R rhs) {
+        return {std::move(lhs), std::move(rhs)};
+    }
+
+    /**
+     *  Public function for EXCEPT operator.
+     *  lhs and rhs are subselect objects.
+     *  Look through example in examples/except.cpp
+     */
+    template<class L, class R>
+    internal::except_t<L, R> except(L lhs, R rhs) {
+        return {std::move(lhs), std::move(rhs)};
+    }
+
+    template<class L, class R>
+    internal::intersect_t<L, R> intersect(L lhs, R rhs) {
+        return {std::move(lhs), std::move(rhs)};
+    }
+
+    /**
+     *  Example : cte<cte_1>()(select(&Object::id));
+     *  The list of column names is optional;
+     *  if provided the number of columns must match the number of columns of the subselect.
+     *  The column names will be merged with the subselect:
+     *  1. column names of subselect
+     *  2. explicit columns
+     *  3. fill in empty column names with stringified column index
+     */
+    template<class Label,
+             class... ColumnNames,
+             std::enable_if_t<polyfill::conjunction_v<std::is_convertible<ColumnNames, std::string>...>, bool> = true>
+    internal::cte_builder<Label, polyfill::index_constant<sizeof...(ColumnNames)>>
+    cte(ColumnNames... explicitColumnNames) {
+        return {{std::move(explicitColumnNames)...}};
+    }
+
+    // tuple of CTEs
+    template<class E, class... Labels, class... Selects, class... nExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Labels, Selects, nExplicitCols>...>
+    with(std::tuple<internal::common_table_expression<Labels, Selects, nExplicitCols>...> cte, E expression) {
+        return {move(cte), std::move(expression)};
+    }
+
+    /** A single CTE.
+     *  Example : with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
+     */
+    template<class E, class Label, class Select, class nExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Label, Select, nExplicitCols>>
+    with(internal::common_table_expression<Label, Select, nExplicitCols> cte, E expression) {
+        return {std::make_tuple(move(cte)), std::move(expression)};
+    }
+
+    /**
+     *  Public function for UNION ALL operator.
+     *  lhs and rhs are subselect objects.
+     *  Look through example in examples/union.cpp
+     */
+    template<class L, class R>
+    internal::union_t<L, R> union_all(L lhs, R rhs) {
+        return {std::move(lhs), std::move(rhs), true};
+    }
+
+    /**
+     * SELECT * FROM T function.
+     * T is typed mapped to a storage.
+     * Example: auto rows = storage.select(asterisk<User>());
+     * // decltype(rows) is std::vector<std::tuple<...all column typed in declared in make_table order...>>
+     * If you need to fetch result as objects not tuple please use `object<T>` instead.
+     */
+    template<class T>
+    internal::asterisk_t<T> asterisk() {
+        return {};
+    }
+
+    /**
+     * SELECT * FROM T function.
+     * T is typed mapped to a storage.
+     * Example: auto rows = storage.select(object<User>());
+     * // decltype(rows) is std::vector<User>
+     * If you need to fetch result as tuples not objects please use `asterisk<T>` instead.
+     */
+    template<class T>
+    internal::object_t<T> object() {
+        return {};
+    }
+}
+#pragma once
+
+#include <string>  //  std::string
+
+namespace sqlite_orm {
+
+    struct table_info {
+        int cid = 0;
+        std::string name;
+        std::string type;
+        bool notnull = false;
+        std::string dflt_value;
+        int pk = 0;
+
+        table_info(decltype(cid) cid_,
+                   decltype(name) name_,
+                   decltype(type) type_,
+                   decltype(notnull) notnull_,
+                   decltype(dflt_value) dflt_value_,
+                   decltype(pk) pk_) :
+            cid(cid_),
+            name(move(name_)), type(move(type_)), notnull(notnull_), dflt_value(move(dflt_value_)), pk(pk_) {}
+    };
+
+}
+#pragma once
+
+#include <memory>  // std::unique_ptr
+#include <sqlite3.h>
+#include <type_traits>  // std::integral_constant
+
+namespace sqlite_orm {
+
+    /**
+     *  Guard class which finalizes `sqlite3_stmt` in dtor
+     */
+    using statement_finalizer =
+        std::unique_ptr<sqlite3_stmt, std::integral_constant<decltype(&sqlite3_finalize), sqlite3_finalize>>;
+}
+#pragma once
+#include <type_traits>
+
+namespace sqlite_orm {
+
+    /**
+     *  Helper classes used by statement_binder and row_extractor.
+     */
+    struct int_or_smaller_tag {};
+    struct bigint_tag {};
+    struct real_tag {};
+
+    template<class V>
+    struct arithmetic_tag {
+        using type = std::conditional_t<std::is_integral<V>::value,
+                                        // Integer class
+                                        std::conditional_t<sizeof(V) <= sizeof(int), int_or_smaller_tag, bigint_tag>,
+                                        // Floating-point class
+                                        real_tag>;
+    };
+
+    template<class V>
+    using arithmetic_tag_t = typename arithmetic_tag<V>::type;
+}
+#pragma once
+
+#include <type_traits>
+#include <memory>
+#include <utility>
+
+// #include "start_macros.h"
+
+// #include "xdestroy_handling.h"
+
+namespace sqlite_orm {
+
+    /**
+     *  Wraps a pointer and tags it with a pointer type,
+     *  used for accepting function parameters,
+     *  facilitating the 'pointer-passing interface'.
+     * 
+     *  Template parameters:
+     *    - P: The value type, possibly const-qualified.
+     *    - T: An integral constant string denoting the pointer type, e.g. carray_pvt_name.
+     *
+     */
+    template<typename P, typename T>
+    struct pointer_arg {
+
+        static_assert(std::is_convertible<typename T::value_type, const char*>::value,
+                      "`std::integral_constant<>` must be convertible to `const char*`");
+
+        using tag = T;
+        P* p_;
+
+        P* ptr() const noexcept {
+            return p_;
+        }
+
+        operator P*() const noexcept {
+            return p_;
+        }
+    };
+
+    /**
+     *  Pointer value with associated deleter function,
+     *  used for returning or binding pointer values
+     *  as part of facilitating the 'pointer-passing interface'.
+     * 
+     *  Template parameters:
+     *    - D: The deleter for the pointer value;
+     *         can be one of:
+     *         - function pointer
+     *         - integral function pointer constant
+     *         - state-less (empty) deleter
+     *         - non-capturing lambda
+     *         - structure implicitly yielding a function pointer
+     *
+     *  @note Use one of the factory functions to create a pointer binding,
+     *  e.g. bindable_carray_pointer or statically_bindable_carray_pointer().
+     *  
+     *  @example
+     *  ```
+     *  int64 rememberedId;
+     *  storage.select(func<remember_fn>(&Object::id, statically_bindable_carray_pointer(&rememberedId)));
+     *  ```
+     */
+    template<typename P, typename T, typename D>
+    class pointer_binding {
+
+        P* p_;
+        SQLITE_ORM_NOUNIQUEADDRESS
+        D d_;
+
+      protected:
+        // Constructing pointer bindings must go through bindable_pointer()
+        template<class T2, class P2, class D2>
+        friend auto bindable_pointer(P2*, D2) noexcept -> pointer_binding<P2, T2, D2>;
+        template<class B>
+        friend B bindable_pointer(typename B::qualified_type*, typename B::deleter_type) noexcept;
+
+        // Construct from pointer and deleter.
+        // Transfers ownership of the passed in object.
+        pointer_binding(P* p, D d = {}) noexcept : p_{p}, d_{std::move(d)} {}
+
+      public:
+        using qualified_type = P;
+        using tag = T;
+        using deleter_type = D;
+
+        pointer_binding(const pointer_binding&) = delete;
+        pointer_binding& operator=(const pointer_binding&) = delete;
+        pointer_binding& operator=(pointer_binding&&) = delete;
+
+        pointer_binding(pointer_binding&& other) noexcept :
+            p_{std::exchange(other.p_, nullptr)}, d_{std::move(other.d_)} {}
+
+        ~pointer_binding() {
+            if(p_) {
+                if(auto xDestroy = get_xdestroy()) {
+                    // note: C-casting `P* -> void*` like statement_binder<pointer_binding<P, T, D>
+                    xDestroy((void*)p_);
+                }
+            }
+        }
+
+        P* ptr() const noexcept {
+            return p_;
+        }
+
+        P* take_ptr() noexcept {
+            return std::exchange(p_, nullptr);
+        }
+
+        xdestroy_fn_t get_xdestroy() const noexcept {
+            return obtain_xdestroy_for(d_, p_);
+        }
+    };
+
+    /**
+     *  Template alias for a static pointer value binding.
+     *  'Static' means that ownership won't be transferred to sqlite,
+     *  sqlite doesn't delete it, and sqlite assumes the object
+     *  pointed to is valid throughout the lifetime of a statement.
+     */
+    template<typename P, typename T>
+    using static_pointer_binding = pointer_binding<P, T, null_xdestroy_t>;
+}
+
+namespace sqlite_orm {
+
+    /**
+     *  Wrap a pointer, its type and its deleter function for binding it to a statement.
+     *  
+     *  Unless the deleter yields a nullptr 'xDestroy' function the ownership of the pointed-to-object
+     *  is transferred to the pointer binding, which will delete it through
+     *  the deleter when the statement finishes.
+     */
+    template<class T, class P, class D>
+    auto bindable_pointer(P* p, D d) noexcept -> pointer_binding<P, T, D> {
+        return {p, std::move(d)};
+    }
+
+    template<class T, class P, class D>
+    auto bindable_pointer(std::unique_ptr<P, D> p) noexcept -> pointer_binding<P, T, D> {
+        return bindable_pointer<T>(p.release(), p.get_deleter());
+    }
+
+    template<typename B>
+    B bindable_pointer(typename B::qualified_type* p, typename B::deleter_type d = {}) noexcept {
+        return B{p, std::move(d)};
+    }
+
+    /**
+     *  Wrap a pointer and its type for binding it to a statement.
+     *  
+     *  Note: 'Static' means that ownership of the pointed-to-object won't be transferred
+     *  and sqlite assumes the object pointed to is valid throughout the lifetime of a statement.
+     */
+    template<class T, class P>
+    auto statically_bindable_pointer(P* p) noexcept -> static_pointer_binding<P, T> {
+        return bindable_pointer<T>(p, null_xdestroy_f);
+    }
+
+    template<typename B>
+    B statically_bindable_pointer(typename B::qualified_type* p,
+                                  typename B::deleter_type* /*exposition*/ = nullptr) noexcept {
+        return bindable_pointer<B>(p);
+    }
+
+    /**
+     *  Forward a pointer value from an argument.
+     */
+    template<class P, class T>
+    auto rebind_statically(const pointer_arg<P, T>& pv) noexcept -> static_pointer_binding<P, T> {
+        return statically_bindable_pointer<T>(pv.ptr());
+    }
+}
+#pragma once
+
+#include <sqlite3.h>
+#include <type_traits>  //  std::enable_if_t, std::is_arithmetic, std::is_same, std::true_type, std::false_type
+#include <memory>  //  std::default_delete
+#include <string>  //  std::string, std::wstring
+#ifndef SQLITE_ORM_OMITS_CODECVT
+#include <codecvt>  //  std::codecvt_utf8_utf16
+#endif  //  SQLITE_ORM_OMITS_CODECVT
+#include <vector>  //  std::vector
+#include <cstddef>  //  std::nullptr_t
+#include <utility>  //  std::declval
+#include <locale>  //  std::wstring_convert
+#include <cstring>  //  ::strncpy, ::strlen
+
+// #include "is_std_ptr.h"
+
+namespace sqlite_orm {
+
+    /**
+     *  Specialization for optional type (std::shared_ptr / std::unique_ptr).
+     */
+    template<typename T>
+    struct is_std_ptr : std::false_type {};
+
+    template<typename T>
+    struct is_std_ptr<std::shared_ptr<T>> : std::true_type {
+        using element_type = T;
+
+        static std::shared_ptr<T> make(const T& v) {
+            return std::make_shared<T>(v);
+        }
+    };
+
+    template<typename T>
+    struct is_std_ptr<std::unique_ptr<T>> : std::true_type {
+        using element_type = T;
+
+        static std::unique_ptr<T> make(const T& v) {
+            return std::make_unique<T>(v);
+        }
+    };
+}
+
+// #include "arithmetic_tag.h"
+
+// #include "xdestroy_handling.h"
+
+// #include "pointer_value.h"
+
+namespace sqlite_orm {
+
+    /**
+     *  Helper class used for binding fields to sqlite3 statements.
+     */
+    template<class V, typename Enable = void>
+    struct statement_binder : std::false_type {};
+
+    /**
+     *  Specialization for 'pointer-passing interface'.
+     */
+    template<class P, class T, class D>
+    struct statement_binder<pointer_binding<P, T, D>, void> {
+        using V = pointer_binding<P, T, D>;
+
+        // ownership of pointed-to-object is left untouched and remains at prepared statement's AST expression
+        int bind(sqlite3_stmt* stmt, int index, const V& value) const {
+            // note: C-casting `P* -> void*`, internal::xdestroy_proxy() does the inverse
+            return sqlite3_bind_pointer(stmt, index, (void*)value.ptr(), T::value, null_xdestroy_f);
+        }
+
+        // ownership of pointed-to-object is transferred to sqlite
+        void result(sqlite3_context* context, V& value) const {
+            // note: C-casting `P* -> void*`,
+            // row_extractor<pointer_arg<P, T>>::extract() and internal::xdestroy_proxy() do the inverse
+            sqlite3_result_pointer(context, (void*)value.take_ptr(), T::value, value.get_xdestroy());
+        }
+    };
+
+    /**
+     *  Specialization for arithmetic types.
+     */
+    template<class V>
+    struct statement_binder<V, std::enable_if_t<std::is_arithmetic<V>::value>> {
+
+        int bind(sqlite3_stmt* stmt, int index, const V& value) const {
+            return this->bind(stmt, index, value, tag());
+        }
+
+        void result(sqlite3_context* context, const V& value) const {
+            this->result(context, value, tag());
+        }
+
+      private:
+        using tag = arithmetic_tag_t<V>;
+
+        int bind(sqlite3_stmt* stmt, int index, const V& value, const int_or_smaller_tag&) const {
+            return sqlite3_bind_int(stmt, index, static_cast<int>(value));
+        }
+
+        void result(sqlite3_context* context, const V& value, const int_or_smaller_tag&) const {
+            sqlite3_result_int(context, static_cast<int>(value));
+        }
+
+        int bind(sqlite3_stmt* stmt, int index, const V& value, const bigint_tag&) const {
+            return sqlite3_bind_int64(stmt, index, static_cast<sqlite3_int64>(value));
+        }
+
+        void result(sqlite3_context* context, const V& value, const bigint_tag&) const {
+            sqlite3_result_int64(context, static_cast<sqlite3_int64>(value));
+        }
+
+        int bind(sqlite3_stmt* stmt, int index, const V& value, const real_tag&) const {
+            return sqlite3_bind_double(stmt, index, static_cast<double>(value));
+        }
+
+        void result(sqlite3_context* context, const V& value, const real_tag&) const {
+            sqlite3_result_double(context, static_cast<double>(value));
+        }
+    };
+
+    /**
+     *  Specialization for std::string and C-string.
+     */
+    template<class V>
+    struct statement_binder<V,
+                            std::enable_if_t<std::is_same<V, std::string>::value || std::is_same<V, const char*>::value
+#ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
+                                             || std::is_same<V, std::string_view>::value
+#endif
+                                             >> {
+
+        int bind(sqlite3_stmt* stmt, int index, const V& value) const {
+            auto stringData = this->string_data(value);
+            return sqlite3_bind_text(stmt, index, std::get<0>(stringData), std::get<1>(stringData), SQLITE_TRANSIENT);
+        }
+
+        void result(sqlite3_context* context, const V& value) const {
+            auto stringData = this->string_data(value);
+            auto stringDataLength = std::get<1>(stringData);
+            auto dataCopy = new char[stringDataLength + 1];
+            constexpr auto deleter = std::default_delete<char[]>{};
+            auto stringChars = std::get<0>(stringData);
+            ::strncpy(dataCopy, stringChars, stringDataLength + 1);
+            sqlite3_result_text(context, dataCopy, stringDataLength, obtain_xdestroy_for(deleter, dataCopy));
+        }
+
+      private:
+        std::tuple<const char*, int> string_data(const std::string& s) const {
+            return {s.c_str(), int(s.size())};
+        }
+
+        std::tuple<const char*, int> string_data(const char* s) const {
+            auto length = int(::strlen(s));
+            return {s, length};
+        }
+
+#ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
+        std::tuple<const char*, int> string_data(const std::string_view& s) const {
+            return {s.data(), int(s.size())};
+        }
+#endif
+    };
+
+#ifndef SQLITE_ORM_OMITS_CODECVT
+    /**
+     *  Specialization for std::wstring and C-wstring.
+     */
+    template<class V>
+    struct statement_binder<
+        V,
+        std::enable_if_t<std::is_same<V, std::wstring>::value || std::is_same<V, const wchar_t*>::value>> {
+
+        int bind(sqlite3_stmt* stmt, int index, const V& value) const {
+            std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
+            std::string utf8Str = converter.to_bytes(value);
+            return statement_binder<decltype(utf8Str)>().bind(stmt, index, utf8Str);
+        }
+
+        void result(sqlite3_context* context, const V& value) const {
+            sqlite3_result_text16(context, (const void*)value.data(), int(value.length()), nullptr);
+        }
+    };
+#endif  //  SQLITE_ORM_OMITS_CODECVT
+
+    /**
+     *  Specialization for std::nullptr_t.
+     */
+    template<>
+    struct statement_binder<std::nullptr_t, void> {
+        int bind(sqlite3_stmt* stmt, int index, const std::nullptr_t&) const {
+            return sqlite3_bind_null(stmt, index);
+        }
+
+        void result(sqlite3_context* context, const std::nullptr_t&) const {
+            sqlite3_result_null(context);
+        }
+    };
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+    /**
+     *  Specialization for std::nullopt_t.
+     */
+    template<>
+    struct statement_binder<std::nullopt_t, void> {
+        int bind(sqlite3_stmt* stmt, int index, const std::nullopt_t&) const {
+            return sqlite3_bind_null(stmt, index);
+        }
+
+        void result(sqlite3_context* context, const std::nullopt_t&) const {
+            sqlite3_result_null(context);
+        }
+    };
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+
+    template<class V>
+    struct statement_binder<V, std::enable_if_t<is_std_ptr<V>::value>> {
+        using value_type = typename is_std_ptr<V>::element_type;
+
+        int bind(sqlite3_stmt* stmt, int index, const V& value) const {
+            if(value) {
+                return statement_binder<value_type>().bind(stmt, index, *value);
+            } else {
+                return statement_binder<std::nullptr_t>().bind(stmt, index, nullptr);
+            }
+        }
+
+        void result(sqlite3_context* context, const V& value) const {
+            if(value) {
+                statement_binder<value_type>().result(context, value);
+            } else {
+                statement_binder<std::nullptr_t>().result(context, nullptr);
+            }
+        }
+    };
+
+    /**
+     *  Specialization for optional type (std::vector<char>).
+     */
+    template<>
+    struct statement_binder<std::vector<char>, void> {
+        int bind(sqlite3_stmt* stmt, int index, const std::vector<char>& value) const {
+            if(value.size()) {
+                return sqlite3_bind_blob(stmt, index, (const void*)&value.front(), int(value.size()), SQLITE_TRANSIENT);
+            } else {
+                return sqlite3_bind_blob(stmt, index, "", 0, SQLITE_TRANSIENT);
+            }
+        }
+
+        void result(sqlite3_context* context, const std::vector<char>& value) const {
+            if(value.size()) {
+                sqlite3_result_blob(context, (const void*)&value.front(), int(value.size()), nullptr);
+            } else {
+                sqlite3_result_blob(context, "", 0, nullptr);
+            }
+        }
+    };
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+    template<class T>
+    struct statement_binder<std::optional<T>, void> {
+        using value_type = T;
+
+        int bind(sqlite3_stmt* stmt, int index, const std::optional<T>& value) const {
+            if(value) {
+                return statement_binder<value_type>().bind(stmt, index, *value);
+            } else {
+                return statement_binder<std::nullopt_t>().bind(stmt, index, std::nullopt);
+            }
+        }
+
+        void result(sqlite3_context* context, const std::optional<T>& value) const {
+            if(value) {
+                statement_binder<value_type>().result(context, value);
+            } else {
+                statement_binder<std::nullopt_t>().result(context, std::nullopt);
+            }
+        }
+    };
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+
+    namespace internal {
+
+        template<class T>
+        using is_bindable = std::integral_constant<bool, !std::is_base_of<std::false_type, statement_binder<T>>::value>;
+
+        struct conditional_binder_base {
+            sqlite3_stmt* stmt = nullptr;
+            int& index;
+
+            conditional_binder_base(decltype(stmt) stmt_, decltype(index) index_) : stmt(stmt_), index(index_) {}
+        };
+
+        template<class T, class C>
+        struct conditional_binder;
+
+        template<class T>
+        struct conditional_binder<T, std::true_type> : conditional_binder_base {
+
+            using conditional_binder_base::conditional_binder_base;
+
+            int operator()(const T& t) const {
+                return statement_binder<T>().bind(this->stmt, this->index++, t);
+            }
+        };
+
+        template<class T>
+        struct conditional_binder<T, std::false_type> : conditional_binder_base {
+            using conditional_binder_base::conditional_binder_base;
+
+            int operator()(const T&) const {
+                return SQLITE_OK;
+            }
+        };
+
+        template<class T, template<class C> class F, class SFINAE = void>
+        struct tuple_filter_single;
+
+        template<class T, template<class C> class F>
+        struct tuple_filter_single<T, F, typename std::enable_if<F<T>::value>::type> {
+            using type = std::tuple<T>;
+        };
+
+        template<class T, template<class C> class F>
+        struct tuple_filter_single<T, F, typename std::enable_if<!F<T>::value>::type> {
+            using type = std::tuple<>;
+        };
+
+        template<class T, template<class C> class F>
+        struct tuple_filter;
+
+        template<class... Args, template<class C> class F>
+        struct tuple_filter<std::tuple<Args...>, F> {
+            using type = typename conc_tuple<typename tuple_filter_single<Args, F>::type...>::type;
+        };
+
+        template<class T>
+        struct bindable_filter_single : tuple_filter_single<T, is_bindable> {};
+
+        template<class T>
+        struct bindable_filter;
+
+        template<class... Args>
+        struct bindable_filter<std::tuple<Args...>> {
+            using type = typename conc_tuple<typename bindable_filter_single<Args>::type...>::type;
+        };
+    }
+}
+#pragma once
+
+#include <sqlite3.h>
+#include <type_traits>  //  std::enable_if_t, std::is_arithmetic, std::is_same, std::enable_if
+#include <stdlib.h>  //  atof, atoi, atoll
+#include <string>  //  std::string, std::wstring
+#ifndef SQLITE_ORM_OMITS_CODECVT
+#include <codecvt>  //  std::wstring_convert, std::codecvt_utf8_utf16
+#endif  //  SQLITE_ORM_OMITS_CODECVT
+#include <vector>  //  std::vector
+#include <cstring>  //  strlen
+#include <algorithm>  //  std::copy
+#include <iterator>  //  std::back_inserter
+#include <tuple>  //  std::tuple, std::tuple_size, std::tuple_element
+
+// #include "arithmetic_tag.h"
+
+// #include "pointer_value.h"
+
+// #include "journal_mode.h"
+
+#include <string>  //  std::string
+#include <memory>  //  std::unique_ptr
+#include <array>  //  std::array
+#include <algorithm>  //  std::transform
+#include <cctype>  // std::toupper
+
+namespace sqlite_orm {
+
+/**
+ *  Caps case cause of 1) delete keyword; 2) https://www.sqlite.org/pragma.html#pragma_journal_mode original spelling
+ */
+#ifdef DELETE
+#undef DELETE
+#endif
+    enum class journal_mode : signed char {
+        DELETE = 0,
+        TRUNCATE = 1,
+        PERSIST = 2,
+        MEMORY = 3,
+        WAL = 4,
+        OFF = 5,
+    };
+
+    namespace internal {
+
+        inline const std::string& to_string(journal_mode j) {
+            static std::string res[] = {
+                "DELETE",
+                "TRUNCATE",
+                "PERSIST",
+                "MEMORY",
+                "WAL",
+                "OFF",
+            };
+            return res[static_cast<int>(j)];
+        }
+
+        inline std::unique_ptr<journal_mode> journal_mode_from_string(const std::string& str) {
+            std::string upper_str;
+            std::transform(str.begin(), str.end(), std::back_inserter(upper_str), [](char c) {
+                return static_cast<char>(std::toupper(static_cast<int>(c)));
+            });
+            static std::array<journal_mode, 6> all = {{
+                journal_mode::DELETE,
+                journal_mode::TRUNCATE,
+                journal_mode::PERSIST,
+                journal_mode::MEMORY,
+                journal_mode::WAL,
+                journal_mode::OFF,
+            }};
+            for(auto j: all) {
+                if(to_string(j) == upper_str) {
+                    return std::make_unique<journal_mode>(j);
+                }
+            }
+            return {};
+        }
+    }
+}
+
+// #include "error_code.h"
+
+namespace sqlite_orm {
+
+    /**
+     *  Helper class used to cast values from argv to V class
+     *  which depends from column type.
+     *
+     */
+    template<class V, typename Enable = void>
+    struct row_extractor {
+        //  used in sqlite3_exec (select)
+        V extract(const char* row_value) const;
+
+        //  used in sqlite_column (iteration, get_all)
+        V extract(sqlite3_stmt* stmt, int columnIndex) const;
+
+        //  used in user defined functions
+        V extract(sqlite3_value* value) const;
+    };
+
+    /**
+     *  Specialization for the 'pointer-passing interface'.
+     * 
+     *  @note The 'pointer-passing' interface doesn't support (and in fact prohibits)
+     *  extracting pointers from columns.
+     */
+    template<class P, class T>
+    struct row_extractor<pointer_arg<P, T>, void> {
+        using V = pointer_arg<P, T>;
+
+        V extract(sqlite3_value* value) const {
+            return {(P*)sqlite3_value_pointer(value, T::value)};
+        }
+    };
+
+    /**
+     * Undefine using pointer_binding<> for querying values
+     */
+    template<class P, class T, class D>
+    struct row_extractor<pointer_binding<P, T, D>, void>;
+
+    /**
+     *  Specialization for arithmetic types.
+     */
+    template<class V>
+    struct row_extractor<V, std::enable_if_t<std::is_arithmetic<V>::value>> {
+        V extract(const char* row_value) const {
+            return this->extract(row_value, tag());
+        }
+
+        V extract(sqlite3_stmt* stmt, int columnIndex) const {
+            return this->extract(stmt, columnIndex, tag());
+        }
+
+        V extract(sqlite3_value* value) const {
+            return this->extract(value, tag());
+        }
+
+      private:
+        using tag = arithmetic_tag_t<V>;
+
+        V extract(const char* row_value, const int_or_smaller_tag&) const {
+            return static_cast<V>(atoi(row_value));
+        }
+
+        V extract(sqlite3_stmt* stmt, int columnIndex, const int_or_smaller_tag&) const {
+            return static_cast<V>(sqlite3_column_int(stmt, columnIndex));
+        }
+
+        V extract(sqlite3_value* value, const int_or_smaller_tag&) const {
+            return static_cast<V>(sqlite3_value_int(value));
+        }
+
+        V extract(const char* row_value, const bigint_tag&) const {
+            return static_cast<V>(atoll(row_value));
+        }
+
+        V extract(sqlite3_stmt* stmt, int columnIndex, const bigint_tag&) const {
+            return static_cast<V>(sqlite3_column_int64(stmt, columnIndex));
+        }
+
+        V extract(sqlite3_value* value, const bigint_tag&) const {
+            return static_cast<V>(sqlite3_value_int64(value));
+        }
+
+        V extract(const char* row_value, const real_tag&) const {
+            return static_cast<V>(atof(row_value));
+        }
+
+        V extract(sqlite3_stmt* stmt, int columnIndex, const real_tag&) const {
+            return static_cast<V>(sqlite3_column_double(stmt, columnIndex));
+        }
+
+        V extract(sqlite3_value* value, const real_tag&) const {
+            return static_cast<V>(sqlite3_value_double(value));
+        }
+    };
+
+    /**
+     *  Specialization for std::string.
+     */
+    template<>
+    struct row_extractor<std::string, void> {
+        std::string extract(const char* row_value) const {
+            if(row_value) {
+                return row_value;
+            } else {
+                return {};
+            }
+        }
+
+        std::string extract(sqlite3_stmt* stmt, int columnIndex) const {
+            if(auto cStr = (const char*)sqlite3_column_text(stmt, columnIndex)) {
+                return cStr;
+            } else {
+                return {};
+            }
+        }
+
+        std::string extract(sqlite3_value* value) const {
+            if(auto cStr = (const char*)sqlite3_value_text(value)) {
+                return cStr;
+            } else {
+                return {};
+            }
+        }
+    };
+#ifndef SQLITE_ORM_OMITS_CODECVT
+    /**
+     *  Specialization for std::wstring.
+     */
+    template<>
+    struct row_extractor<std::wstring, void> {
+        std::wstring extract(const char* row_value) const {
+            if(row_value) {
+                std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
+                return converter.from_bytes(row_value);
+            } else {
+                return {};
+            }
+        }
+
+        std::wstring extract(sqlite3_stmt* stmt, int columnIndex) const {
+            auto cStr = (const char*)sqlite3_column_text(stmt, columnIndex);
+            if(cStr) {
+                std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
+                return converter.from_bytes(cStr);
+            } else {
+                return {};
+            }
+        }
+
+        std::wstring extract(sqlite3_value* value) const {
+            if(auto cStr = (const wchar_t*)sqlite3_value_text16(value)) {
+                return cStr;
+            } else {
+                return {};
+            }
+        }
+    };
+#endif  //  SQLITE_ORM_OMITS_CODECVT
+
+    template<class V>
+    struct row_extractor<V, std::enable_if_t<is_std_ptr<V>::value>> {
+        using value_type = typename is_std_ptr<V>::element_type;
+
+        V extract(const char* row_value) const {
+            if(row_value) {
+                return is_std_ptr<V>::make(row_extractor<value_type>().extract(row_value));
+            } else {
+                return {};
+            }
+        }
+
+        V extract(sqlite3_stmt* stmt, int columnIndex) const {
+            auto type = sqlite3_column_type(stmt, columnIndex);
+            if(type != SQLITE_NULL) {
+                return is_std_ptr<V>::make(row_extractor<value_type>().extract(stmt, columnIndex));
+            } else {
+                return {};
+            }
+        }
+
+        V extract(sqlite3_value* value) const {
+            auto type = sqlite3_value_type(value);
+            if(type != SQLITE_NULL) {
+                return is_std_ptr<V>::make(row_extractor<value_type>().extract(value));
+            } else {
+                return {};
+            }
+        }
+    };
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+    template<class T>
+    struct row_extractor<std::optional<T>, void> {
+        using value_type = T;
+
+        std::optional<T> extract(const char* row_value) const {
+            if(row_value) {
+                return std::make_optional(row_extractor<value_type>().extract(row_value));
+            } else {
+                return std::nullopt;
+            }
+        }
+
+        std::optional<T> extract(sqlite3_stmt* stmt, int columnIndex) const {
+            auto type = sqlite3_column_type(stmt, columnIndex);
+            if(type != SQLITE_NULL) {
+                return std::make_optional(row_extractor<value_type>().extract(stmt, columnIndex));
+            } else {
+                return std::nullopt;
+            }
+        }
+
+        std::optional<T> extract(sqlite3_value* value) const {
+            auto type = sqlite3_value_type(value);
+            if(type != SQLITE_NULL) {
+                return std::make_optional(row_extractor<value_type>().extract(value));
+            } else {
+                return std::nullopt;
+            }
+        }
+    };
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+    /**
+     *  Specialization for std::vector<char>.
+     */
+    template<>
+    struct row_extractor<std::vector<char>> {
+        std::vector<char> extract(const char* row_value) const {
+            if(row_value) {
+                auto len = ::strlen(row_value);
+                return this->go(row_value, len);
+            } else {
+                return {};
+            }
+        }
+
+        std::vector<char> extract(sqlite3_stmt* stmt, int columnIndex) const {
+            auto bytes = static_cast<const char*>(sqlite3_column_blob(stmt, columnIndex));
+            auto len = static_cast<size_t>(sqlite3_column_bytes(stmt, columnIndex));
+            return this->go(bytes, len);
+        }
+
+        std::vector<char> extract(sqlite3_value* value) const {
+            auto bytes = static_cast<const char*>(sqlite3_value_blob(value));
+            auto len = static_cast<size_t>(sqlite3_value_bytes(value));
+            return this->go(bytes, len);
+        }
+
+      protected:
+        std::vector<char> go(const char* bytes, size_t len) const {
+            if(len) {
+                std::vector<char> res;
+                res.reserve(len);
+                std::copy(bytes, bytes + len, std::back_inserter(res));
+                return res;
+            } else {
+                return {};
+            }
+        }
+    };
+
+    template<class... Args>
+    struct row_extractor<std::tuple<Args...>> {
+
+        std::tuple<Args...> extract(char** argv) const {
+            std::tuple<Args...> res;
+            this->extract<std::tuple_size<decltype(res)>::value>(res, argv);
+            return res;
+        }
+
+        std::tuple<Args...> extract(sqlite3_stmt* stmt, int /*columnIndex*/) const {
+            std::tuple<Args...> res;
+            this->extract<std::tuple_size<decltype(res)>::value>(res, stmt);
+            return res;
+        }
+
+      protected:
+        template<size_t I, typename std::enable_if<I != 0>::type* = nullptr>
+        void extract(std::tuple<Args...>& t, sqlite3_stmt* stmt) const {
+            using tuple_type = typename std::tuple_element<I - 1, typename std::tuple<Args...>>::type;
+            std::get<I - 1>(t) = row_extractor<tuple_type>().extract(stmt, I - 1);
+            this->extract<I - 1>(t, stmt);
+        }
+
+        template<size_t I, typename std::enable_if<I == 0>::type* = nullptr>
+        void extract(std::tuple<Args...>&, sqlite3_stmt*) const {
+            //..
+        }
+
+        template<size_t I, typename std::enable_if<I != 0>::type* = nullptr>
+        void extract(std::tuple<Args...>& t, char** argv) const {
+            using tuple_type = typename std::tuple_element<I - 1, typename std::tuple<Args...>>::type;
+            std::get<I - 1>(t) = row_extractor<tuple_type>().extract(argv[I - 1]);
+            this->extract<I - 1>(t, argv);
+        }
+
+        template<size_t I, typename std::enable_if<I == 0>::type* = nullptr>
+        void extract(std::tuple<Args...>&, char**) const {
+            //..
+        }
+    };
+
+    /**
+     *  Specialization for journal_mode.
+     */
+    template<>
+    struct row_extractor<journal_mode, void> {
+        journal_mode extract(const char* row_value) const {
+            if(row_value) {
+                if(auto res = internal::journal_mode_from_string(row_value)) {
+                    return std::move(*res);
+                } else {
+                    throw std::system_error(std::make_error_code(orm_error_code::incorrect_journal_mode_string));
+                }
+            } else {
+                throw std::system_error(std::make_error_code(orm_error_code::incorrect_journal_mode_string));
+            }
+        }
+
+        journal_mode extract(sqlite3_stmt* stmt, int columnIndex) const {
+            auto cStr = (const char*)sqlite3_column_text(stmt, columnIndex);
+            return this->extract(cStr);
+        }
+    };
+}
+#pragma once
+
+#include <sqlite3.h>
+#include <string>  //  std::string
+#include <system_error>  //  std::system_error, std::error_code
+
+namespace sqlite_orm {
+
+    namespace internal {
+        inline void perform_step(sqlite3* db, sqlite3_stmt* stmt) {
+            auto rc = sqlite3_step(stmt);
+            if(rc == SQLITE_DONE) {
+                //  done..
+            } else {
+                throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                        sqlite3_errmsg(db));
+            }
+        }
+
+        static void perform_void_exec(sqlite3* db, const std::string& query) {
+            int rc = sqlite3_exec(db, query.c_str(), nullptr, nullptr, nullptr);
+            if(rc != SQLITE_OK) {
+                throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                        sqlite3_errmsg(db));
+            }
+        }
+
+        template<class T>
+        inline auto call_insert_impl_and_catch_constraint_failed(const T& insert_impl) {
+            try {
+                return insert_impl();
+            } catch(const std::system_error& e) {
+                if(e.code() == std::error_code(SQLITE_CONSTRAINT, get_sqlite_error_category())) {
+                    std::stringstream ss;
+                    ss << "Attempting to execute 'insert' request resulted in an error like \"" << e.what()
+                       << "\". Perhaps ordinary 'insert' is not acceptable for this table and you should try "
+                          "'replace' or 'insert' with explicit column listing?";
+                    throw std::system_error(e.code(), ss.str());
+                }
+                throw;
+            }
+        }
+    }
+}
+#pragma once
+
+#include <ostream>
+
+namespace sqlite_orm {
+
+    enum class sync_schema_result {
+
+        /**
+         *  created new table, table with the same tablename did not exist
+         */
+        new_table_created,
+
+        /**
+         *  table schema is the same as storage, nothing to be done
+         */
+        already_in_sync,
+
+        /**
+         *  removed excess columns in table (than storage) without dropping a table
+         */
+        old_columns_removed,
+
+        /**
+         *  lacking columns in table (than storage) added without dropping a table
+         */
+        new_columns_added,
+
+        /**
+         *  both old_columns_removed and new_columns_added
+         */
+        new_columns_added_and_old_columns_removed,
+
+        /**
+         *  old table is dropped and new is recreated. Reasons :
+         *      1. delete excess columns in the table than storage if preseve = false
+         *      2. Lacking columns in the table cannot be added due to NULL and DEFAULT constraint
+         *      3. Reasons 1 and 2 both together
+         *      4. data_type mismatch between table and storage.
+         */
+        dropped_and_recreated,
+    };
+
+    inline std::ostream& operator<<(std::ostream& os, sync_schema_result value) {
+        switch(value) {
+            case sync_schema_result::new_table_created:
+                return os << "new table created";
+            case sync_schema_result::already_in_sync:
+                return os << "table and storage is already in sync.";
+            case sync_schema_result::old_columns_removed:
+                return os << "old excess columns removed";
+            case sync_schema_result::new_columns_added:
+                return os << "new columns added";
+            case sync_schema_result::new_columns_added_and_old_columns_removed:
+                return os << "old excess columns removed and new columns added";
+            case sync_schema_result::dropped_and_recreated:
+                return os << "old table dropped and recreated";
+        }
+        return os;
+    }
+}
+#pragma once
+
+#include <tuple>  //  std::tuple, std::make_tuple
+#include <string>  //  std::string
+#include <utility>  //  std::forward
+
+// #include "indexed_column.h"
+
+#include <string>  //  std::string
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        template<class C>
+        struct indexed_column_t {
+            using column_type = C;
+
+            indexed_column_t(column_type _column_or_expression) :
+                column_or_expression(std::move(_column_or_expression)) {}
+
+            column_type column_or_expression;
+            std::string _collation_name;
+            int _order = 0;  //  -1 = desc, 1 = asc, 0 = not specified
+
+            indexed_column_t<column_type> collate(std::string name) {
+                auto res = std::move(*this);
+                res._collation_name = move(name);
+                return res;
+            }
+
+            indexed_column_t<column_type> asc() {
+                auto res = std::move(*this);
+                res._order = 1;
+                return res;
+            }
+
+            indexed_column_t<column_type> desc() {
+                auto res = std::move(*this);
+                res._order = -1;
+                return res;
+            }
+        };
+
+        template<class C>
+        struct indexed_column_maker {
+            using type = indexed_column_t<C>;
+
+            indexed_column_t<C> operator()(C col) const {
+                return {std::move(col)};
+            }
+        };
+
+        template<class C>
+        struct indexed_column_maker<indexed_column_t<C>> {
+            using type = indexed_column_t<C>;
+
+            indexed_column_t<C> operator()(indexed_column_t<C> col) const {
+                return std::move(col);
+            }
+        };
+
+        template<class C>
+        auto make_indexed_column(C col) {
+            indexed_column_maker<C> maker;
+            return maker(std::move(col));
+        }
+
+    }
+
+    /**
+     * Use this function to specify indexed column inside `make_index` function call.
+     * Example: make_index("index_name", indexed_column(&User::id).asc())
+     */
+    template<class C>
+    internal::indexed_column_t<C> indexed_column(C column_or_expression) {
+        return {std::move(column_or_expression)};
+    }
+
+}
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        struct index_base {
+            std::string name;
+            bool unique = false;
+        };
+
+        template<class... Els>
+        struct index_t : index_base {
+            using elements_type = std::tuple<Els...>;
+            using object_type = void;
+
+            index_t(std::string name_, bool unique_, elements_type elements_) :
+                index_base{move(name_), unique_}, elements(move(elements_)) {}
+
+            elements_type elements;
+        };
+    }
+
+    template<class... Cols>
+    internal::index_t<typename internal::indexed_column_maker<Cols>::type...> make_index(const std::string& name,
+                                                                                         Cols... cols) {
+        return {name, false, std::make_tuple(internal::make_indexed_column(cols)...)};
+    }
+
+    template<class... Cols>
+    internal::index_t<typename internal::indexed_column_maker<Cols>::type...> make_unique_index(const std::string& name,
+                                                                                                Cols... cols) {
+        return {name, true, std::make_tuple(internal::make_indexed_column(cols)...)};
+    }
+}
+#pragma once
+
+// #include "alias.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  If T is alias then mapped_type_proxy<T>::type is alias::type
+         *  otherwise T is T.
+         */
+        template<class T, class SFINAE = void>
+        struct mapped_type_proxy {
+            using type = T;
+        };
+
+        template<class T>
+        struct mapped_type_proxy<T, typename std::enable_if<std::is_base_of<alias_tag, T>::value>::type> {
+            using type = typename T::type;
+        };
+    }
+}
+#pragma once
+
+#include <string>  //  std::string
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        struct rowid_t {
+            operator std::string() const {
+                return "rowid";
+            }
+        };
+
+        struct oid_t {
+            operator std::string() const {
+                return "oid";
+            }
+        };
+
+        struct _rowid_t {
+            operator std::string() const {
+                return "_rowid_";
+            }
+        };
+
+        template<class T>
+        struct table_rowid_t : public rowid_t {
+            using type = T;
+        };
+
+        template<class T>
+        struct table_oid_t : public oid_t {
+            using type = T;
+        };
+        template<class T>
+        struct table__rowid_t : public _rowid_t {
+            using type = T;
+        };
+
+    }
+
+    inline internal::rowid_t rowid() {
+        return {};
+    }
+
+    inline internal::oid_t oid() {
+        return {};
+    }
+
+    inline internal::_rowid_t _rowid_() {
+        return {};
+    }
+
+    template<class T>
+    internal::table_rowid_t<T> rowid() {
+        return {};
+    }
+
+    template<class T>
+    internal::table_oid_t<T> oid() {
+        return {};
+    }
+
+    template<class T>
+    internal::table__rowid_t<T> _rowid_() {
+        return {};
+    }
+}
+#pragma once
+
+#include <type_traits>  //  std::enable_if, std::is_same, std::decay, std::is_arithmetic
+#include <tuple>  //  std::tuple
+#include <functional>  //  std::reference_wrapper
+
+// #include "cxx_polyfill.h"
+
+// #include "type_traits.h"
+
+// #include "core_functions.h"
+
+// #include "select_constraints.h"
+
+// #include "operators.h"
+
+// #include "rowid.h"
+
+// #include "alias.h"
+
+// #include "cte_types.h"
+
+#include <type_traits>
+#include <tuple>
+
+// #include "cxx_polyfill.h"
+
+// #include "start_macros.h"
+
+// #include "type_traits.h"
+
+namespace sqlite_orm {
+
+    /**
+     *  Classification of a label as a 'CTE' label.
+     */
+    struct cte_label_tag {};
+
+    namespace internal {
+
+        /**
+         *  Tuple data structure for CTEs
+         */
+        template<typename Label, typename... Fs>
+        class column_results : fields_t<Fs...> {
+          public:
+            using fields_type = fields_t<Fs...>;
+            // this type name is used to detect the mapping from label to mapper
+            using cte_label_type = Label;
+
+            template<size_t I>
+            decltype(auto) cget() const noexcept {
+                return std::get<I>(polyfill::as_template_base<std::tuple>(*this));
+            }
+            template<size_t I>
+            void set(std::tuple_element_t<I, fields_type> v) noexcept {
+                std::get<I>(polyfill::as_template_base<std::tuple>(*this)) = std::move(v);
+            }
+        };
+
+        /**
+         *  This class maps an expression of a subselect (basically select_t<>::return_type) to
+         *  a tuple of fields (a column_results<Label, Fields>)
+         */
+        template<typename Label, typename Expression, typename... Fs>
+        class subselect_mapper {
+          public:
+            using index_sequence = std::index_sequence_for<Fs...>;
+            // this type name is used to detect the mapping from label to object
+            using cte_label_type = Label;
+            using cte_object_type = column_results<Label, Fs...>;
+            using expressions_type = tuplify_t<Expression>;
+        };
+
+        template<class O, size_t I>
+        SQLITE_ORM_INLINE_VAR auto cte_getter_v = &(O::template cget<I>);
+        template<class O, size_t I>
+        SQLITE_ORM_INLINE_VAR auto cte_setter_v = &(O::template set<I>);
+
+        template<class O, size_t I>
+        using cte_getter_t = decltype(cte_getter_v<O, I>);
+        template<class O, size_t I>
+        using cte_setter_t = decltype(cte_setter_v<O, I>);
+    }
+}
+
+// #include "storage_traits.h"
+
+#include <type_traits>  //  std::is_same, std::enable_if, std::true_type, std::false_type, std::integral_constant
+#include <tuple>  //  std::tuple
+
+// #include "type_traits.h"
+
+// #include "storage_lookup.h"
+
+#include <type_traits>
+
+// #include "cxx_polyfill.h"
+
+// #include "type_traits.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class... Ts>
+        struct storage_t;
+
+        template<class... Ts>
+        struct storage_impl;
+
+        template<class T>
+        struct is_storage : std::false_type {};
+
+        template<class... Ts>
+        struct is_storage<storage_t<Ts...>> : std::true_type {};
+        template<class... Ts>
+        struct is_storage<const storage_t<Ts...>> : std::true_type {};
+
+        template<class T>
+        struct is_storage_impl : std::false_type {};
+
+        template<class... Ts>
+        struct is_storage_impl<storage_impl<Ts...>> : std::true_type {};
+        template<class... Ts>
+        struct is_storage_impl<const storage_impl<Ts...>> : std::true_type {};
+
+        /**
+         *  A data type's CTE alias, otherwise T itself is used as a CTE alias.
+         */
+        template<typename T>
+        using detected_cte_label_t = polyfill::detected_or_t<T, cte_label_type_t, T>;
+
+        /**
+         *  std::true_type if given object is mapped, std::false_type otherwise
+         */
+        template<typename S, typename O>
+        using object_type_matches = typename polyfill::conjunction<std::is_void<storage_cte_label_type_t<S>>,
+                                                                   std::is_same<O, storage_object_type_t<S>>>::type;
+
+        /**
+         *  std::true_type if object is mapped via given (CTE) label, std::false_type otherwise
+         */
+        template<typename S, typename Label>
+        using cte_label_type_matches = typename polyfill::conjunction<
+            std::negation<std::is_void<storage_cte_label_type_t<S>>>,
+            std::is_same<detected_cte_label_t<Label>, storage_cte_label_type_t<S>>>::type;
+
+        template<typename S, typename Lookup>
+        using lookup_type_matches =
+            typename polyfill::disjunction<object_type_matches<S, Lookup>, cte_label_type_matches<S, Lookup>>::type;
+    }
+
+    // pick/lookup metafunctions
+    namespace internal {
+
+        /**
+         *  S - storage_impl type
+         *  O - mapped data type or CTE label
+         */
+        template<class S, class O, class SFINAE = void>
+        struct storage_pick_impl_type;
+
+        template<class S, class O>
+        struct storage_pick_impl_type<S, O, match_if<lookup_type_matches, S, O>> {
+            using type = S;
+        };
+
+        template<class S, class O>
+        struct storage_pick_impl_type<S, O, match_if_not<lookup_type_matches, S, O>>
+            : storage_pick_impl_type<typename S::super, O> {};
+
+        /**
+         *  Final specialisation
+         */
+        template<class O>
+        struct storage_pick_impl_type<storage_impl<>, O, void> {};
+
+        /**
+         *  storage_t specialization
+         */
+        template<class... Ts, class O>
+        struct storage_pick_impl_type<storage_t<Ts...>, O, void>
+            : storage_pick_impl_type<typename storage_t<Ts...>::impl_type, O> {};
+
+        /**
+         *  S - storage_impl type
+         *  O - mapped data type or CTE label
+         */
+        template<class S, class O, class SFINAE = void>
+        struct storage_find_impl_type;
+
+        template<class S, class O>
+        struct storage_find_impl_type<S, O, match_if<lookup_type_matches, S, O>> {
+            using type = S;
+        };
+
+        template<class S, class O>
+        struct storage_find_impl_type<S, O, match_if_not<lookup_type_matches, S, O>>
+            : storage_find_impl_type<typename S::super, O> {};
+
+        /**
+         *  Final specialisation
+         */
+        template<class O>
+        struct storage_find_impl_type<storage_impl<>, O, void> {
+            using type = storage_impl<>;
+        };
+
+        /**
+         *  storage_t specialization
+         */
+        template<class... Ts, class O>
+        struct storage_find_impl_type<storage_t<Ts...>, O, void>
+            : storage_find_impl_type<typename storage_t<Ts...>::impl_type, O> {};
+    }
+
+    namespace internal {
+
+        /**
+         *  S - storage_t or storage_impl type
+         *  Lookup - mapped data type or CTE label
+         */
+        template<class S, class Lookup>
+        using storage_pick_impl_t =
+            std::conditional_t<std::is_const<S>::value,
+                               const typename storage_pick_impl_type<std::remove_const_t<S>, Lookup>::type,
+                               // note: need to remove const on this branch, too, due to SFINAE
+                               typename storage_pick_impl_type<std::remove_const_t<S>, Lookup>::type>;
+
+        /**
+         *  S - storage_t or storage_impl type
+         *  Lookup - mapped data type or CTE label
+         */
+        template<class S, class Lookup>
+        using storage_find_impl_t =
+            std::conditional_t<std::is_const<S>::value,
+                               const typename storage_find_impl_type<std::remove_const_t<S>, Lookup>::type,
+                               // note: need to remove const on this branch, too, due to SFINAE
+                               typename storage_find_impl_type<std::remove_const_t<S>, Lookup>::type>;
+    }
+}
+
+// runtime lookup functions
+namespace sqlite_orm {
+    namespace internal {
+        template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
+        storage_pick_impl_t<S, Lookup>& pick_impl(S& impl) {
+            return impl;
+        }
+
+        template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
+        storage_find_impl_t<S, Lookup>& find_impl(S& impl) {
+            return impl;
+        }
+
+        template<class Lookup, class S, satisfies<is_storage, S> = true>
+        storage_pick_impl_t<const S, Lookup>& pick_const_impl(S& storage) {
+            return obtain_const_impl(storage);
+        }
+    }
+}
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class O, bool WithoutRowId, class... Cs>
+        struct table_t;
+
+        template<class A, class B>
+        struct foreign_key_t;
+
+        namespace storage_traits {
+
+            template<class S>
+            struct type_is_mapped_impl : std::true_type {};
+
+            template<>
+            struct type_is_mapped_impl<storage_impl<>> : std::false_type {};
+
+            /**
+             *  S - storage
+             *  O - mapped or not mapped data type
+             */
+            template<class S, class O>
+            struct type_is_mapped : type_is_mapped_impl<storage_find_impl_t<S, O>> {};
+
+            template<class S>
+            struct storage_columns_count_impl : std::integral_constant<int, S::table_type::elements_count> {};
+
+            template<>
+            struct storage_columns_count_impl<storage_impl<>> : std::integral_constant<int, 0> {};
+
+            /**
+             *  S - storage
+             *  O - mapped or not mapped data type
+             */
+            template<class S, class O>
+            struct storage_columns_count : storage_columns_count_impl<storage_find_impl_t<S, O>> {};
+
+            /**
+             *  T - table type.
+             */
+            template<class T, template<class> class TranfsormOp>
+            struct table_types;
+
+            /**
+             *  type is std::tuple of field types of mapped colums.
+             */
+            template<class O, bool WithoutRowId, class... Args, template<class> class TransformOp>
+            struct table_types<table_t<O, WithoutRowId, Args...>, TransformOp> {
+                using args_tuple = std::tuple<Args...>;
+                using columns_tuple = typename tuple_filter<args_tuple, is_column>::type;
+
+                using type = typename tuple_transformer<columns_tuple, TransformOp>::type;
+            };
+
+            /**
+             *  S - storage_impl type
+             *  O - mapped or not mapped data type
+             */
+            template<class S>
+            struct storage_mapped_columns_impl {
+                using table_type = typename S::table_type;
+                using type = typename table_types<table_type, column_field_type>::type;
+            };
+
+            template<>
+            struct storage_mapped_columns_impl<storage_impl<>> {
+                using type = std::tuple<>;
+            };
+
+            /**
+             *  S - storage
+             *  O - mapped or not mapped data type
+             */
+            template<class S, class O>
+            struct storage_mapped_columns : storage_mapped_columns_impl<storage_find_impl_t<S, O>> {};
+
+            /**
+             *  S - storage_impl type for specific mapped type
+             *  O - mapped data type
+             */
+            template<class S>
+            struct storage_mapped_column_expressions_impl : table_types<table_type_t<S>, column_field_expression> {};
+
+            template<>
+            struct storage_mapped_column_expressions_impl<storage_impl<>> {
+                using type = std::tuple<>;
+            };
+
+            /**
+             *  S - storage
+             *  O - mapped data type
+             */
+            template<class S, class O>
+            struct storage_mapped_column_expressions
+                : storage_mapped_column_expressions_impl<storage_find_impl_t<S, O>> {};
+
+            /**
+             *  C is any column type: column_t or constraint type
+             *  O - object type references in FOREIGN KEY
+             */
+            template<class C, class O>
+            struct column_foreign_keys_count : std::integral_constant<int, 0> {};
+
+            template<class A, class B, class O>
+            struct column_foreign_keys_count<foreign_key_t<A, B>, O> {
+                using target_type = typename foreign_key_t<A, B>::target_type;
+
+                static constexpr const int value = std::is_same<O, target_type>::value ? 1 : 0;
+            };
+
+            /**
+             * O - object type references in FOREIGN KEY
+             * Cs - column types which are stored in table_t::columns_type
+             */
+            template<class O, class... Cs>
+            struct table_foreign_keys_count_impl;
+
+            template<class O>
+            struct table_foreign_keys_count_impl<O> {
+                static constexpr const int value = 0;
+            };
+
+            template<class O, class H, class... Tail>
+            struct table_foreign_keys_count_impl<O, H, Tail...> {
+                static constexpr const int value =
+                    column_foreign_keys_count<H, O>::value + table_foreign_keys_count_impl<O, Tail...>::value;
+            };
+
+            /**
+             *  T is table_t type
+             *  O is object type which is the reference target (e.g. foreign_key(&Visit::userId).references(&User::id) has O = User)
+             */
+            template<class T, class O>
+            struct table_foreign_keys_count;
+
+            template<class O, class... Cs, class P>
+            struct table_foreign_keys_count<table_t<O, false, Cs...>, P> {
+                using table_type = table_t<O, false, Cs...>;
+
+                static constexpr const int value = table_foreign_keys_count_impl<P, Cs...>::value;
+            };
+
+            /**
+             *  S - storage class
+             *  O - type mapped to S
+             */
+            template<class S, class O>
+            struct storage_foreign_keys_count_impl;
+
+            template<class O>
+            struct storage_foreign_keys_count_impl<storage_impl<>, O> : std::integral_constant<int, 0> {};
+
+            template<class H, class... Ts, class O>
+            struct storage_foreign_keys_count_impl<storage_impl<H, Ts...>, O> {
+                static constexpr const int value = table_foreign_keys_count<H, O>::value +
+                                                   storage_foreign_keys_count_impl<storage_impl<Ts...>, O>::value;
+            };
+
+            /**
+             * S - storage class
+             * O - type mapped to S
+             * This class tells how many types mapped to S have foreign keys to O
+             */
+            template<class S, class O>
+            struct storage_foreign_keys_count {
+                using impl_type = typename S::impl_type;
+
+                static constexpr const int value = storage_foreign_keys_count_impl<impl_type, O>::value;
+            };
+
+            /**
+             * C is any table element type: column_t or constraint type
+             * O - object type references in FOREIGN KEY
+             */
+            template<class C, class O, class SFINAE = void>
+            struct column_fk_references {
+                using type = std::tuple<>;
+            };
+
+            template<class C, class O, class SFINAE = void>
+            struct column_foreign_keys {
+                using type = std::tuple<>;
+            };
+
+            template<class A, class B, class O>
+            struct column_foreign_keys<
+                foreign_key_t<A, B>,
+                O,
+                typename std::enable_if<std::is_same<O, typename foreign_key_t<A, B>::target_type>::value>::type> {
+                using type = std::tuple<foreign_key_t<A, B>>;
+            };
+
+            template<class A, class B, class O>
+            struct column_foreign_keys<
+                foreign_key_t<A, B>,
+                O,
+                typename std::enable_if<!std::is_same<O, typename foreign_key_t<A, B>::target_type>::value>::type> {
+                using type = std::tuple<>;
+            };
+
+            template<class A, class B, class O>
+            struct column_fk_references<
+                foreign_key_t<A, B>,
+                O,
+                typename std::enable_if<std::is_same<O, typename foreign_key_t<A, B>::target_type>::value>::type> {
+                using target_type = typename foreign_key_t<A, B>::source_type;
+
+                using type = std::tuple<target_type>;
+            };
+
+            template<class A, class B, class O>
+            struct column_fk_references<
+                foreign_key_t<A, B>,
+                O,
+                typename std::enable_if<!std::is_same<O, typename foreign_key_t<A, B>::target_type>::value>::type> {
+                using type = std::tuple<>;
+            };
+
+            /**
+             * O - object type references in FOREIGN KEY
+             * Cs - column types which are stored in table_t::columns_type
+             */
+            template<class O, class... Cs>
+            struct table_fk_references_impl;
+
+            template<class O, class... Cs>
+            struct table_foreign_keys_impl;
+
+            template<class O>
+            struct table_fk_references_impl<O> {
+                using type = std::tuple<>;
+            };
+
+            template<class O>
+            struct table_foreign_keys_impl<O> {
+                using type = std::tuple<>;
+            };
+
+            template<class O, class H, class... Tail>
+            struct table_fk_references_impl<O, H, Tail...> {
+                using head_tuple = typename column_fk_references<H, O>::type;
+                using tail_tuple = typename table_fk_references_impl<O, Tail...>::type;
+                using type = typename conc_tuple<head_tuple, tail_tuple>::type;
+            };
+
+            template<class O, class H, class... Tail>
+            struct table_foreign_keys_impl<O, H, Tail...> {
+                using head_tuple = typename column_foreign_keys<H, O>::type;
+                using tail_tuple = typename table_foreign_keys_impl<O, Tail...>::type;
+                using type = typename conc_tuple<head_tuple, tail_tuple>::type;
+            };
+
+            /**
+             *  T is table_t type
+             *  O is object type which is the reference target (e.g. foreign_key(&Visit::userId).references(&User::id) has O = User)
+             */
+            template<class T, class O>
+            struct table_fk_references;
+
+            template<class T, class O>
+            struct table_foreign_keys;
+
+            template<class O, bool WithoutRowId, class... Cs, class P>
+            struct table_fk_references<table_t<O, WithoutRowId, Cs...>, P> {
+                using table_type = table_t<O, WithoutRowId, Cs...>;
+
+                using type = typename table_fk_references_impl<P, Cs...>::type;
+            };
+
+            template<class O, bool WithoutRowId, class... Cs, class P>
+            struct table_foreign_keys<table_t<O, WithoutRowId, Cs...>, P> {
+                using table_type = table_t<O, WithoutRowId, Cs...>;
+
+                using type = typename table_foreign_keys_impl<P, Cs...>::type;
+            };
+
+            /**
+             *  S - storage class
+             *  O - type mapped to S
+             */
+            template<class S, class O>
+            struct storage_fk_references_impl;
+
+            template<class S, class O>
+            struct storage_foreign_keys_impl;
+
+            template<class O>
+            struct storage_fk_references_impl<storage_impl<>, O> {
+                using type = std::tuple<>;
+            };
+
+            template<class O>
+            struct storage_foreign_keys_impl<storage_impl<>, O> {
+                using type = std::tuple<>;
+            };
+
+            template<class H, class... Ts, class O>
+            struct storage_fk_references_impl<storage_impl<H, Ts...>, O> {
+                using head_tuple = typename table_fk_references<H, O>::type;
+                using tail_tuple = typename storage_fk_references_impl<storage_impl<Ts...>, O>::type;
+                using type = typename conc_tuple<head_tuple, tail_tuple>::type;
+            };
+
+            template<class H, class... Ts, class O>
+            struct storage_foreign_keys_impl<storage_impl<H, Ts...>, O> {
+                using head_tuple = typename table_foreign_keys<H, O>::type;
+                using tail_tuple = typename storage_foreign_keys_impl<storage_impl<Ts...>, O>::type;
+                using type = typename conc_tuple<head_tuple, tail_tuple>::type;
+            };
+
+            /**
+             *  S - storage class
+             *  O - type mapped to S
+             *  type holds `std::tuple` with types that has references to O as  foreign keys
+             */
+            template<class S, class O>
+            struct storage_fk_references {
+                using impl_type = typename S::impl_type;
+
+                using type = typename storage_fk_references_impl<impl_type, O>::type;
+            };
+
+            template<class S, class O>
+            struct storage_foreign_keys {
+                using impl_type = typename S::impl_type;
+
+                using type = typename storage_foreign_keys_impl<impl_type, O>::type;
+            };
+
+        }
+    }
+}
+
+// #include "function.h"
+
+#include <string>  //  std::string
+#include <sqlite3.h>
+#include <tuple>  //  std::tuple
+#include <functional>  //  std::function
+#include <algorithm>  //  std::min
+
+// #include "cxx_polyfill.h"
+
+namespace sqlite_orm {
+
+    struct arg_values;
+
+    template<class T, class P>
+    struct pointer_arg;
+    template<class T, class P, class D>
+    class pointer_binding;
+
+    namespace internal {
+
+        struct function_base {
+            using func_call = std::function<
+                void(sqlite3_context* context, void* functionPointer, int argsCount, sqlite3_value** values)>;
+            using final_call = std::function<void(sqlite3_context* context, void* functionPointer)>;
+
+            std::string name;
+            int argumentsCount = 0;
+            std::function<int*()> create;
+            void (*destroy)(int*) = nullptr;
+
+            function_base(decltype(name) name_,
+                          decltype(argumentsCount) argumentsCount_,
+                          decltype(create) create_,
+                          decltype(destroy) destroy_) :
+                name(move(name_)),
+                argumentsCount(argumentsCount_), create(move(create_)), destroy(destroy_) {}
+        };
+
+        struct scalar_function_t : function_base {
+            func_call run;
+
+            scalar_function_t(decltype(name) name_,
+                              int argumentsCount_,
+                              decltype(create) create_,
+                              decltype(run) run_,
+                              decltype(destroy) destroy_) :
+                function_base{move(name_), argumentsCount_, move(create_), destroy_},
+                run(move(run_)) {}
+        };
+
+        struct aggregate_function_t : function_base {
+            func_call step;
+            final_call finalCall;
+
+            aggregate_function_t(decltype(name) name_,
+                                 int argumentsCount_,
+                                 decltype(create) create_,
+                                 decltype(step) step_,
+                                 decltype(finalCall) finalCall_,
+                                 decltype(destroy) destroy_) :
+                function_base{move(name_), argumentsCount_, move(create_), destroy_},
+                step(move(step_)), finalCall(move(finalCall_)) {}
+        };
+
+        //  got it from here https://stackoverflow.com/questions/87372/check-if-a-class-has-a-member-function-of-a-given-signature
+        template<class F>
+        struct is_scalar_function_impl {
+
+            template<class U, class T>
+            struct SFINAE;
+
+            template<class U, class R>
+            struct SFINAE<U, R (U::*)() const> {};
+
+            template<class U>
+            static char test(SFINAE<U, decltype(&U::operator())>*);
+
+            template<class U>
+            static int test(...);
+
+            static constexpr bool has = sizeof(test<F>(0)) == sizeof(char);
+        };
+
+        template<class F>
+        struct is_aggregate_function_impl {
+
+            template<class U, class T>
+            struct SFINAE;
+
+            template<class U, class R>
+            struct SFINAE<U, R (U::*)() const> {};
+
+            template<class U>
+            static char test(SFINAE<U, decltype(&U::step)>*);
+
+            template<class U>
+            static int test(...);
+
+            template<class U>
+            static char test2(SFINAE<U, decltype(&U::fin)>*);
+
+            template<class U>
+            static int test2(...);
+
+            static constexpr bool has = sizeof(test<F>(0)) == sizeof(char);
+            static constexpr bool has2 = sizeof(test2<F>(0)) == sizeof(char);
+            static constexpr bool has_both = has && has2;
+        };
+
+        template<class F>
+        struct is_scalar_function : std::integral_constant<bool, is_scalar_function_impl<F>::has> {};
+
+        template<class F>
+        struct is_aggregate_function : std::integral_constant<bool, is_aggregate_function_impl<F>::has_both> {};
+
+        template<class F>
+        struct scalar_run_member_pointer {
+            using type = decltype(&F::operator());
+        };
+
+        template<class F>
+        struct aggregate_run_member_pointer {
+            using step_type = decltype(&F::step);
+            using fin_type = decltype(&F::fin);
+        };
+
+        template<class T>
+        struct member_function_arguments;
+
+        template<class O, class R, class... Args>
+        struct member_function_arguments<R (O::*)(Args...) const> {
+            using member_function_type = R (O::*)(Args...) const;
+            using tuple_type = std::tuple<typename std::decay<Args>::type...>;
+            using return_type = R;
+        };
+
+        template<class O, class R, class... Args>
+        struct member_function_arguments<R (O::*)(Args...)> {
+            using member_function_type = R (O::*)(Args...);
+            using tuple_type = std::tuple<typename std::decay<Args>::type...>;
+            using return_type = R;
+        };
+
+        template<class F, bool IsScalar>
+        struct callable_arguments_impl;
+
+        template<class F>
+        struct callable_arguments_impl<F, true> {
+            using function_member_pointer = typename scalar_run_member_pointer<F>::type;
+            using args_tuple = typename member_function_arguments<function_member_pointer>::tuple_type;
+            using return_type = typename member_function_arguments<function_member_pointer>::return_type;
+        };
+
+        template<class F>
+        struct callable_arguments_impl<F, false> {
+            using step_function_member_pointer = typename aggregate_run_member_pointer<F>::step_type;
+            using fin_function_member_pointer = typename aggregate_run_member_pointer<F>::fin_type;
+            using args_tuple = typename member_function_arguments<step_function_member_pointer>::tuple_type;
+            using return_type = typename member_function_arguments<fin_function_member_pointer>::return_type;
+        };
+
+        template<class F>
+        struct callable_arguments : callable_arguments_impl<F, is_scalar_function<F>::value> {};
+
+        template<class F, class... Args>
+        struct function_call {
+            using function_type = F;
+            using args_tuple = std::tuple<Args...>;
+
+            args_tuple args;
+        };
+
+        template<class T>
+        struct unpacked_arg {
+            using type = T;
+        };
+        template<class F, class... Args>
+        struct unpacked_arg<function_call<F, Args...>> {
+            using type = typename callable_arguments<F>::return_type;
+        };
+        template<class T>
+        using unpacked_arg_t = typename unpacked_arg<T>::type;
+
+        template<size_t I, class FnArg, class CallArg>
+        SQLITE_ORM_CONSTEVAL bool expected_pointer_value() {
+            static_assert(polyfill::always_false_v<FnArg, CallArg>, "Expected a pointer value for I-th argument");
+            return false;
+        }
+
+        template<size_t I, class FnArg, class CallArg, class EnableIfTag = void>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_same_pvt_v = expected_pointer_value<I, FnArg, CallArg>();
+
+#if __cplusplus >= 201703L  // using C++17 or higher
+        template<size_t I, const char* PointerArg, const char* Binding>
+        SQLITE_ORM_CONSTEVAL bool assert_same_pointer_type() {
+            constexpr bool valid = Binding == PointerArg;
+            static_assert(valid, "Pointer value types of I-th argument do not match");
+            return valid;
+        }
+
+        template<size_t I, class PointerArg, class Binding>
+        SQLITE_ORM_INLINE_VAR constexpr bool
+            is_same_pvt_v<I, PointerArg, Binding, polyfill::void_t<typename PointerArg::tag, typename Binding::tag>> =
+                assert_same_pointer_type<I, PointerArg::tag::value, Binding::tag::value>();
+#else
+        template<size_t I, class PointerArg, class Binding>
+        SQLITE_ORM_CONSTEVAL bool assert_same_pointer_type() {
+            constexpr bool valid = Binding::value == PointerArg::value;
+            static_assert(valid, "Pointer value types of I-th argument do not match");
+            return valid;
+        }
+
+        template<size_t I, class PointerArg, class Binding>
+        SQLITE_ORM_INLINE_VAR constexpr bool
+            is_same_pvt_v<I, PointerArg, Binding, polyfill::void_t<typename PointerArg::tag, typename Binding::tag>> =
+                assert_same_pointer_type<I, typename PointerArg::tag, typename Binding::tag>();
+#endif
+
+        template<size_t I, class FnArg, class CallArg>
+        SQLITE_ORM_CONSTEVAL bool validate_pointer_value_type(std::false_type) {
+            return true;
+        }
+
+        template<size_t I, class FnArg, class CallArg>
+        SQLITE_ORM_CONSTEVAL bool validate_pointer_value_type(std::true_type) {
+            return is_same_pvt_v<I, FnArg, CallArg>;
+        }
+
+        template<class FnArgs, class CallArgs>
+        SQLITE_ORM_CONSTEVAL bool validate_pointer_value_types(polyfill::index_constant<size_t(-1)>) {
+            return true;
+        }
+        template<class FnArgs, class CallArgs, size_t I>
+        SQLITE_ORM_CONSTEVAL bool validate_pointer_value_types(polyfill::index_constant<I>) {
+            using func_arg_t = std::tuple_element_t<I, FnArgs>;
+            using passed_arg_t = unpacked_arg_t<std::tuple_element_t<I, CallArgs>>;
+
+            constexpr bool valid = validate_pointer_value_type<I,
+                                                               std::tuple_element_t<I, FnArgs>,
+                                                               unpacked_arg_t<std::tuple_element_t<I, CallArgs>>>(
+                polyfill::bool_constant < (polyfill::is_specialization_of_v<func_arg_t, pointer_arg>) ||
+                (polyfill::is_specialization_of_v<passed_arg_t, pointer_binding>) > {});
+
+            return validate_pointer_value_types<FnArgs, CallArgs>(polyfill::index_constant<I - 1>{}) && valid;
+        }
+    }
+
+    /**
+     *  Used to call user defined function: `func<MyFunc>(...);`
+     */
+    template<class F, class... Args>
+    internal::function_call<F, Args...> func(Args... args) {
+        using args_tuple = std::tuple<Args...>;
+        using function_args_tuple = typename internal::callable_arguments<F>::args_tuple;
+        constexpr auto argsCount = std::tuple_size<args_tuple>::value;
+        constexpr auto functionArgsCount = std::tuple_size<function_args_tuple>::value;
+        static_assert((argsCount == functionArgsCount &&
+                       !std::is_same<function_args_tuple, std::tuple<arg_values>>::value &&
+                       internal::validate_pointer_value_types<function_args_tuple, args_tuple>(
+                           internal::polyfill::index_constant<std::min<>(functionArgsCount, argsCount) - 1>{})) ||
+                          std::is_same<function_args_tuple, std::tuple<arg_values>>::value,
+                      "Number of arguments does not match");
+        return {std::make_tuple(std::forward<Args>(args)...)};
+    }
+
+}
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  Obains the result type of expressions that form the columns of a select statement.
+         *  
+         *  This is a proxy class used to define what type must have result type depending on select
+         *  arguments (member pointer, aggregate functions, etc). Below you can see specializations
+         *  for different types. E.g. specialization for internal::length_t has `type` int cause
+         *  LENGTH returns INTEGER in sqlite. Every column_result_t must have `type` type that equals
+         *  c++ SELECT return type for T
+         *  T - C++ type
+         *  SFINAE - sfinae argument
+         * 
+         *  Note (implementation): could be possibly implemented by utilizing column_expression_of_t
+         */
+        template<class St, class T, class SFINAE = void>
+        struct column_result_t;
+
+        template<class St, class T>
+        using column_result_of_t = typename column_result_t<St, T>::type;
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class St, class T>
+        struct column_result_t<St, as_optional_t<T>, void> {
+            using type = std::optional<typename column_result_t<St, T>::type>;
+        };
+
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+
+        template<class St, class O, class F>
+        struct column_result_t<St,
+                               F O::*,
+                               std::enable_if_t<std::is_member_pointer<F O::*>::value &&
+                                                !std::is_member_function_pointer<F O::*>::value>> {
+            using type = F;
+        };
+
+        template<class St, class O, class F, F O::*m>
+        struct column_result_t<St, ice_t<m>, void> {
+            using type = F;
+        };
+
+        template<class St, class L, class A>
+        struct column_result_t<St, dynamic_in_t<L, A>, void> {
+            using type = bool;
+        };
+
+        template<class St, class L, class... Args>
+        struct column_result_t<St, in_t<L, Args...>, void> {
+            using type = bool;
+        };
+
+        /**
+         *  Common case for all getter types. Getter types are defined in column.h file
+         */
+        template<class St, class T>
+        struct column_result_t<St, T, match_if<is_getter, T>> {
+            using type = typename getter_traits<T>::field_type;
+        };
+
+        /**
+         *  Common case for all setter types. Setter types are defined in column.h file
+         */
+        template<class St, class T>
+        struct column_result_t<St, T, match_if<is_setter, T>> {
+            using type = typename setter_traits<T>::field_type;
+        };
+
+        template<class St, class R, class S, class... Args>
+        struct column_result_t<St, built_in_function_t<R, S, Args...>, void> {
+            using type = R;
+        };
+
+        template<class St, class F, class... Args>
+        struct column_result_t<St, function_call<F, Args...>, void> {
+            using type = typename callable_arguments<F>::return_type;
+        };
+
+        template<class St, class X, class S>
+        struct column_result_t<St, built_in_function_t<unique_ptr_result_of<X>, S, X>, void> {
+            using type = std::unique_ptr<typename column_result_t<St, X>::type>;
+        };
+
+        template<class St, class T>
+        struct column_result_t<St, count_asterisk_t<T>, void> {
+            using type = int;
+        };
+
+        template<class St>
+        struct column_result_t<St, count_asterisk_without_type, void> {
+            using type = int;
+        };
+
+        template<class St, class T>
+        struct column_result_t<St, distinct_t<T>, void> {
+            using type = typename column_result_t<St, T>::type;
+        };
+
+        template<class St, class T>
+        struct column_result_t<St, all_t<T>, void> {
+            using type = typename column_result_t<St, T>::type;
+        };
+
+        template<class St, class L, class R>
+        struct column_result_t<St, conc_t<L, R>, void> {
+            using type = std::string;
+        };
+
+        template<class St, class L, class R>
+        struct column_result_t<St, add_t<L, R>, void> {
+            using type = double;
+        };
+
+        template<class St, class L, class R>
+        struct column_result_t<St, sub_t<L, R>, void> {
+            using type = double;
+        };
+
+        template<class St, class L, class R>
+        struct column_result_t<St, mul_t<L, R>, void> {
+            using type = double;
+        };
+
+        template<class St, class L, class R>
+        struct column_result_t<St, div_t<L, R>, void> {
+            using type = double;
+        };
+
+        template<class St, class L, class R>
+        struct column_result_t<St, mod_t<L, R>, void> {
+            using type = double;
+        };
+
+        template<class St, class L, class R>
+        struct column_result_t<St, bitwise_shift_left_t<L, R>, void> {
+            using type = int;
+        };
+
+        template<class St, class L, class R>
+        struct column_result_t<St, bitwise_shift_right_t<L, R>, void> {
+            using type = int;
+        };
+
+        template<class St, class L, class R>
+        struct column_result_t<St, bitwise_and_t<L, R>, void> {
+            using type = int;
+        };
+
+        template<class St, class L, class R>
+        struct column_result_t<St, bitwise_or_t<L, R>, void> {
+            using type = int;
+        };
+
+        template<class St, class T>
+        struct column_result_t<St, bitwise_not_t<T>, void> {
+            using type = int;
+        };
+
+        template<class St>
+        struct column_result_t<St, rowid_t, void> {
+            using type = int64;
+        };
+
+        template<class St>
+        struct column_result_t<St, oid_t, void> {
+            using type = int64;
+        };
+
+        template<class St>
+        struct column_result_t<St, _rowid_t, void> {
+            using type = int64;
+        };
+
+        template<class St, class T>
+        struct column_result_t<St, table_rowid_t<T>, void> {
+            using type = int64;
+        };
+
+        template<class St, class T>
+        struct column_result_t<St, table_oid_t<T>, void> {
+            using type = int64;
+        };
+
+        template<class St, class T>
+        struct column_result_t<St, table__rowid_t<T>, void> {
+            using type = int64;
+        };
+
+        template<class St, class T, class C>
+        struct column_result_t<St, alias_column_t<T, C>, void> : column_result_t<St, C> {};
+
+        template<class St, class T, class F>
+        struct column_result_t<St, column_pointer<T, F>, void> : column_result_t<St, F> {};
+
+        template<class St, class Label, size_t I>
+        struct column_result_t<St, column_pointer<Label, polyfill::index_constant<I>>, void>
+            : column_result_t<St, cte_getter_t<storage_object_type_t<storage_pick_impl_t<St, Label>>, I>> {};
+
+        template<class St, class Label, class O, class F, F O::*m>
+        struct column_result_t<St, column_pointer<Label, ice_t<m>>, void> {
+            using type = F;
+        };
+
+        template<class St, class... Args>
+        struct column_result_t<St, columns_t<Args...>, void> {
+            using type = fields_t<column_result_of_t<St, std::decay_t<Args>>...>;
+        };
+
+        template<class St, class T, class... Args>
+        struct column_result_t<St, select_t<T, Args...>> : column_result_t<St, T> {};
+
+        template<class St, class T>
+        struct column_result_t<St, T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
+            using left_type = typename T::left_type;
+            using right_type = typename T::right_type;
+            using left_result = column_result_of_t<St, left_type>;
+            using right_result = column_result_of_t<St, right_type>;
+            static_assert(std::is_same<left_result, right_result>::value,
+                          "Compound subselect queries must return same types");
+            using type = left_result;
+        };
+
+        template<class St, class T>
+        struct column_result_t<St, T, typename std::enable_if<is_base_of_template<T, binary_condition>::value>::type> {
+            using type = typename T::result_type;
+        };
+
+        /**
+         *  Result for the most simple queries like `SELECT 1`
+         */
+        template<class St, class T>
+        struct column_result_t<St, T, match_if<std::is_arithmetic, T>> {
+            using type = T;
+        };
+
+        /**
+         *  Result for the most simple queries like `SELECT 'ototo'`
+         */
+        template<class St>
+        struct column_result_t<St, const char*, void> {
+            using type = std::string;
+        };
+
+        template<class St>
+        struct column_result_t<St, std::string, void> {
+            using type = std::string;
+        };
+
+        template<class St, class T, class E>
+        struct column_result_t<St, as_t<T, E>, void> : column_result_t<St, typename std::decay<E>::type> {};
+
+        template<class St, class T>
+        struct column_result_t<St, asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>> {
+            using type = typename storage_traits::storage_mapped_columns<St, T>::type;
+        };
+
+        template<class St, class A>
+        struct column_result_t<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>> {
+            using type = typename storage_traits::storage_mapped_columns<St, type_t<A>>::type;
+        };
+
+        template<class St, class T>
+        struct column_result_t<St, object_t<T>, void> {
+            using type = T;
+        };
+
+        template<class St, class T, class E>
+        struct column_result_t<St, cast_t<T, E>, void> {
+            using type = T;
+        };
+
+        template<class St, class R, class T, class E, class... Args>
+        struct column_result_t<St, simple_case_t<R, T, E, Args...>, void> {
+            using type = R;
+        };
+
+        template<class St, class A, class T, class E>
+        struct column_result_t<St, like_t<A, T, E>, void> {
+            using type = bool;
+        };
+
+        template<class St, class A, class T>
+        struct column_result_t<St, glob_t<A, T>, void> {
+            using type = bool;
+        };
+
+        template<class St, class C>
+        struct column_result_t<St, negated_condition_t<C>, void> {
+            using type = bool;
+        };
+
+        template<class St, class T>
+        struct column_result_t<St, std::reference_wrapper<T>, void> : column_result_t<St, T> {};
+    }
+}
+#pragma once
+
+#include <string>  //  std::string
+#include <type_traits>  //  std::remove_reference, std::is_same, std::is_base_of
+#include <vector>  //  std::vector
+#include <tuple>  //  std::tuple_size, std::tuple_element
+#include <algorithm>  //  std::reverse, std::find_if
+
+// #include "cxx_polyfill.h"
+
+// #include "type_traits.h"
+
+// #include "column_result.h"
+
+// #include "static_magic.h"
+
+// #include "typed_comparator.h"
+
+// #include "constraints.h"
+
+// #include "tuple_helper/tuple_helper.h"
+
+// #include "table_info.h"
+
+// #include "type_printer.h"
+
+// #include "column.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  A data type's label type, void otherwise.
+         */
+        template<typename O>
+        using label_of_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
+
+        template<typename O>
+        using mapped_object_type_of_t = polyfill::detected_or_t<O, cte_object_type_t, O>;
+
+        struct basic_table {
+
+            /**
+             *  Table name.
+             */
+            std::string name;
+        };
+
+        /**
+         *  Table descriptor.
+         * 
+         *  Can be either for a table mapped to storage or for a common table expression (CTE).
+         * 
+         *  The template parameter O is either a regular data structure object (i.e. direct mapping from storage to data)
+         *  or an abstract 'mapper' object with a label attached.
+         *  The driving force behind this 'mapper' abstraction is the presence of a T::cte_label_type.
+         */
+        template<class O, bool WithoutRowId, class... Cs>
+        struct table_t : basic_table {
+            using super = basic_table;
+            using cte_mapper_type = O;
+            using cte_label_type = label_of_t<O>;
+            using object_type = mapped_object_type_of_t<O>;
+            using elements_type = std::tuple<Cs...>;
+
+            static constexpr const int elements_count = static_cast<int>(std::tuple_size<elements_type>::value);
+            static constexpr const bool is_without_rowid = WithoutRowId;
+
+            elements_type elements;
+
+            table_t(std::string name_, elements_type elements_) : super{move(name_)}, elements{move(elements_)} {}
+
+            table_t<O, true, Cs...> without_rowid() const {
+                return {this->name, this->elements};
+            }
+
+            /**
+             *  Function used to get field value from object by mapped member pointer/setter/getter
+             */
+            template<class F, class C>
+            const F* get_object_field_pointer(const object_type& obj, C c) const {
+                const F* res = nullptr;
+                this->for_each_column_with_field_type<F>([&res, &c, &obj](auto& col) {
+                    using column_type = typename std::remove_reference<decltype(col)>::type;
+                    using member_pointer_t = typename column_type::member_pointer_t;
+                    using getter_type = typename column_type::getter_type;
+                    using setter_type = typename column_type::setter_type;
+                    // Make static_if have at least one input as a workaround for GCC bug:
+                    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64095
+                    if(!res) {
+                        static_if<std::is_same<C, member_pointer_t>{}>([&res, &obj, &col](const C& c_) {
+                            if(compare_any(col.member_pointer, c_)) {
+                                res = &(obj.*col.member_pointer);
+                            }
+                        })(c);
+                    }
+                    if(!res) {
+                        static_if<std::is_same<C, getter_type>{}>([&res, &obj, &col](const C& c_) {
+                            if(compare_any(col.getter, c_)) {
+                                res = &((obj).*(col.getter))();
+                            }
+                        })(c);
+                    }
+                    if(!res) {
+                        static_if<std::is_same<C, setter_type>{}>([&res, &obj, &col](const C& c_) {
+                            if(compare_any(col.setter, c_)) {
+                                res = &((obj).*(col.getter))();
+                            }
+                        })(c);
+                    }
+                });
+                return res;
+            }
+
+            template<class C>
+            bool exists_in_composite_primary_key(const C& column) const {
+                auto res = false;
+                this->for_each_primary_key([&column, &res](auto& primaryKey) {
+                    iterate_tuple(primaryKey.columns, [&res, &column](auto& value) {
+                        if(!res) {
+                            if(column.member_pointer) {
+                                res = compare_any(value, column.member_pointer);
+                            } else {
+                                res = compare_any(value, column.getter) || compare_any(value, column.setter);
+                            }
+                        }
+                    });
+                });
+                return res;
+            }
+
+            /**
+             *  Calls **l** with every primary key dedicated constraint
+             */
+            template<class L>
+            void for_each_primary_key(const L& lambda) const {
+                iterate_tuple(this->elements, [&lambda](auto& element) {
+                    using element_type = typename std::decay<decltype(element)>::type;
+                    static_if<is_primary_key<element_type>{}>(lambda)(element);
+                });
+            }
+
+            std::vector<std::string> composite_key_columns_names() const {
+                std::vector<std::string> res;
+                this->for_each_primary_key([this, &res](auto& c) {
+                    res = this->composite_key_columns_names(c);
+                });
+                return res;
+            }
+
+            std::vector<std::string> primary_key_column_names() const {
+                std::vector<std::string> res;
+                this->for_each_column_with<primary_key_t<>>([&res](auto& c) {
+                    res.push_back(c.name);
+                });
+                if(!res.size()) {
+                    res = this->composite_key_columns_names();
+                }
+                return res;
+            }
+
+            template<class... Args>
+            std::vector<std::string> composite_key_columns_names(const primary_key_t<Args...>& pk) const {
+                std::vector<std::string> res;
+                using pk_columns_tuple = decltype(pk.columns);
+                res.reserve(std::tuple_size<pk_columns_tuple>::value);
+                iterate_tuple(pk.columns, [this, &res](auto& v) {
+                    if(auto columnName = this->find_column_name(v)) {
+                        res.push_back(*columnName);
+                    } else {
+                        res.push_back({});
+                    }
+                });
+                return res;
+            }
+
+            /**
+             *  Searches column name by class member pointer passed as the first argument.
+             *  @return column name or empty string if nothing found.
+             */
+            template<class F,
+                     class O,
+                     typename = typename std::enable_if<std::is_member_pointer<F O::*>::value &&
+                                                        !std::is_member_function_pointer<F O::*>::value>::type>
+            const std::string* find_column_name(F O::*m) const {
+                const std::string* res = nullptr;
+                this->template for_each_column_with_field_type<F>([&res, m](auto& c) {
+                    if(c.member_pointer == m) {
+                        res = &c.name;
+                    }
+                });
+                return res;
+            }
+
+            /**
+             *  Searches column name by class getter function member pointer passed as first argument.
+             *  @return column name or empty string if nothing found.
+             */
+            template<class G>
+            const std::string* find_column_name(G getter,
+                                                typename std::enable_if<is_getter<G>::value>::type* = nullptr) const {
+                const std::string* res = nullptr;
+                using field_type = typename getter_traits<G>::field_type;
+                this->template for_each_column_with_field_type<field_type>([&res, getter](auto& c) {
+                    if(compare_any(c.getter, getter)) {
+                        res = &c.name;
+                    }
+                });
+                return res;
+            }
+
+            /**
+             *  Searches column name by class setter function member pointer passed as first argument.
+             *  @return column name or empty string if nothing found.
+             */
+            template<class S>
+            const std::string* find_column_name(S setter,
+                                                typename std::enable_if<is_setter<S>::value>::type* = nullptr) const {
+                const std::string* res = nullptr;
+                using field_type = typename setter_traits<S>::field_type;
+                this->template for_each_column_with_field_type<field_type>([&res, setter](auto& c) {
+                    if(compare_any(c.setter, setter)) {
+                        res = &c.name;
+                    }
+                });
+                return res;
+            }
+
+            /**
+             *  Counts and returns amount of columns without GENERATED ALWAYS constraints. Skips table constraints.
+             */
+            int non_generated_columns_count() const {
+                auto res = 0;
+                this->for_each_column([&res](auto& column) {
+                    if(!column.is_generated()) {
+                        ++res;
+                    }
+                });
+                return res;
+            }
+
+            /**
+             *  Counts and returns amount of columns. Skips constraints.
+             */
+            int count_columns_amount() const {
+                auto res = 0;
+                this->for_each_column([&res](auto&) {
+                    ++res;
+                });
+                return res;
+            }
+
+            /**
+             *  Iterates all columns and fires passed lambda. Lambda must have one and only templated argument. Otherwise
+             *  code will not compile. Excludes table constraints (e.g. foreign_key_t) at the end of the columns list. To
+             *  iterate columns with table constraints use iterate_tuple(columns, ...) instead. L is lambda type. Do
+             *  not specify it explicitly.
+             *  @param lambda Lambda to be called per column itself. Must have signature like this [] (auto col) -> void {}
+             */
+            template<class L>
+            void for_each_column(const L& lambda) const {
+                iterate_tuple(this->elements, [&lambda](auto& element) {
+                    using element_type = typename std::decay<decltype(element)>::type;
+                    static_if<is_column<element_type>{}>(lambda)(element);
+                });
+            }
+
+            template<class L>
+            void for_each_foreign_key(const L& lambda) const {
+                iterate_tuple(this->elements, [&lambda](auto& element) {
+                    using element_type = typename std::decay<decltype(element)>::type;
+                    static_if<is_foreign_key<element_type>{}>(lambda)(element);
+                });
+            }
+
+            template<class F, class L>
+            void for_each_column_with_field_type(const L& lambda) const {
+                this->for_each_column([&lambda](auto& column) {
+                    using column_type = typename std::decay<decltype(column)>::type;
+                    using field_type = typename column_field_type<column_type>::type;
+                    static_if<std::is_same<F, field_type>{}>(lambda)(column);
+                });
+            }
+
+            /**
+             *  Iterates all columns that have specified constraints and fires passed lambda.
+             *  Lambda must have one and only templated argument Otherwise code will not compile.
+             *  L is lambda type. Do not specify it explicitly.
+             *  @param lambda Lambda to be called per column itself. Must have signature like this [] (auto col) -> void {}
+             */
+            template<class Op, class L>
+            void for_each_column_with(const L& lambda) const {
+                this->for_each_column([&lambda](auto& column) {
+                    using tuple_helper::tuple_contains_type;
+                    using column_type = typename std::decay<decltype(column)>::type;
+                    using constraints_type = typename column_constraints_type<column_type>::type;
+                    static_if<tuple_contains_type<Op, constraints_type>{}>(lambda)(column);
+                });
+            }
+
+            std::vector<table_info> get_table_info() const {
+                std::vector<table_info> res;
+                res.reserve(size_t(this->elements_count));
+                this->for_each_column([&res](auto& col) {
+                    std::string dft;
+                    using field_type = typename std::decay<decltype(col)>::type::field_type;
+                    if(auto d = col.default_value()) {
+                        dft = *d;
+                    }
+                    table_info i{
+                        -1,
+                        col.name,
+                        type_printer<field_type>().print(),
+                        col.not_null(),
+                        dft,
+                        col.template has<primary_key_t<>>(),
+                    };
+                    res.emplace_back(i);
+                });
+                auto compositeKeyColumnNames = this->composite_key_columns_names();
+                for(size_t i = 0; i < compositeKeyColumnNames.size(); ++i) {
+                    auto& columnName = compositeKeyColumnNames[i];
+                    auto it = std::find_if(res.begin(), res.end(), [&columnName](const table_info& ti) {
+                        return ti.name == columnName;
+                    });
+                    if(it != res.end()) {
+                        it->pk = static_cast<int>(i + 1);
+                    }
+                }
+                return res;
+            }
+        };
+    }
+
+    /**
+     *  Function used for table creation. Do not use table constructor - use this function
+     *  cause table class is templated and its constructing too (just like std::make_unique or std::make_pair).
+     */
+    template<class... Cs, class O = typename std::tuple_element<0, std::tuple<Cs...>>::type::object_type>
+    internal::table_t<O, false, Cs...> make_table(const std::string& name, Cs... args) {
+        return {name, std::make_tuple<Cs...>(std::forward<Cs>(args)...)};
+    }
+
+    template<class O, class... Cs>
+    internal::table_t<O, false, Cs...> make_table(const std::string& name, Cs... args) {
+        return {name, std::make_tuple<Cs...>(std::forward<Cs>(args)...)};
+    }
+}
+#pragma once
+
+#include <string>  //  std::string
+#include <sqlite3.h>
+#include <cstddef>  //  std::nullptr_t
+#include <system_error>  //  std::system_error, std::error_code
+#include <sstream>  //  std::stringstream
+#include <stdlib.h>  //  std::atoi
+#include <type_traits>  //  std::forward, std::enable_if, std::is_same, std::remove_reference, std::false_type, std::true_type
+#include <utility>  //  std::pair, std::make_pair
+#include <vector>  //  std::vector
+#include <algorithm>  //  std::find_if
+#include <typeindex>  //  std::type_index
+
+// #include "type_traits.h"
+
+// #include "error_code.h"
+
+// #include "statement_finalizer.h"
+
+// #include "row_extractor.h"
+
+// #include "util.h"
+
+// #include "constraints.h"
+
+// #include "select_constraints.h"
+
+// #include "field_printer.h"
+
+// #include "table_info.h"
+
+// #include "sync_schema_result.h"
+
+// #include "field_value_holder.h"
+
+#include <type_traits>  //  std::enable_if
+
+// #include "column.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T, class SFINAE = void>
+        struct field_value_holder;
+
+        template<class T>
+        struct field_value_holder<T, typename std::enable_if<getter_traits<T>::returns_lvalue>::type> {
+            using type = typename getter_traits<T>::field_type;
+
+            const type& value;
+        };
+
+        template<class T>
+        struct field_value_holder<T, typename std::enable_if<!getter_traits<T>::returns_lvalue>::type> {
+            using type = typename getter_traits<T>::field_type;
+
+            type value;
+        };
+    }
+}
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        struct storage_impl_base {
+
+            bool table_exists(const std::string& tableName, sqlite3* db) const {
+                auto result = false;
+                std::stringstream ss;
+                ss << "SELECT COUNT(*) FROM sqlite_master WHERE type = '"
+                   << "table"
+                   << "' AND name = '" << tableName << "'";
+                auto query = ss.str();
+                auto rc = sqlite3_exec(
+                    db,
+                    query.c_str(),
+                    [](void* data, int argc, char** argv, char** /*azColName*/) -> int {
+                        auto& res = *(bool*)data;
+                        if(argc) {
+                            res = !!std::atoi(argv[0]);
+                        }
+                        return 0;
+                    },
+                    &result,
+                    nullptr);
+                if(rc != SQLITE_OK) {
+                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                            sqlite3_errmsg(db));
+                }
+                return result;
+            }
+
+            void rename_table(sqlite3* db, const std::string& oldName, const std::string& newName) const {
+                std::stringstream ss;
+                ss << "ALTER TABLE " << oldName << " RENAME TO " << newName;
+                perform_void_exec(db, ss.str());
+            }
+
+            static bool calculate_remove_add_columns(std::vector<table_info*>& columnsToAdd,
+                                                     std::vector<table_info>& storageTableInfo,
+                                                     std::vector<table_info>& dbTableInfo) {
+                bool notEqual = false;
+
+                //  iterate through storage columns
+                for(size_t storageColumnInfoIndex = 0; storageColumnInfoIndex < storageTableInfo.size();
+                    ++storageColumnInfoIndex) {
+
+                    //  get storage's column info
+                    auto& storageColumnInfo = storageTableInfo[storageColumnInfoIndex];
+                    auto& columnName = storageColumnInfo.name;
+
+                    //  search for a column in db eith the same name
+                    auto dbColumnInfoIt = std::find_if(dbTableInfo.begin(), dbTableInfo.end(), [&columnName](auto& ti) {
+                        return ti.name == columnName;
+                    });
+                    if(dbColumnInfoIt != dbTableInfo.end()) {
+                        auto& dbColumnInfo = *dbColumnInfoIt;
+                        auto columnsAreEqual =
+                            dbColumnInfo.name == storageColumnInfo.name &&
+                            dbColumnInfo.notnull == storageColumnInfo.notnull &&
+                            (dbColumnInfo.dflt_value.length() > 0) == (storageColumnInfo.dflt_value.length() > 0) &&
+                            dbColumnInfo.pk == storageColumnInfo.pk;
+                        if(!columnsAreEqual) {
+                            notEqual = true;
+                            break;
+                        }
+                        dbTableInfo.erase(dbColumnInfoIt);
+                        storageTableInfo.erase(storageTableInfo.begin() +
+                                               static_cast<ptrdiff_t>(storageColumnInfoIndex));
+                        --storageColumnInfoIndex;
+                    } else {
+                        columnsToAdd.push_back(&storageColumnInfo);
+                    }
+                }
+                return notEqual;
+            }
+
+            std::vector<table_info> get_table_info(const std::string& tableName, sqlite3* db) const {
+                std::vector<table_info> result;
+                auto query = "PRAGMA table_info('" + tableName + "')";
+                auto rc = sqlite3_exec(
+                    db,
+                    query.c_str(),
+                    [](void* data, int argc, char** argv, char**) -> int {
+                        auto& res = *(std::vector<table_info>*)data;
+                        if(argc) {
+                            auto index = 0;
+                            auto cid = std::atoi(argv[index++]);
+                            std::string name = argv[index++];
+                            std::string type = argv[index++];
+                            bool notnull = !!std::atoi(argv[index++]);
+                            std::string dflt_value = argv[index] ? argv[index] : "";
+                            index++;
+                            auto pk = std::atoi(argv[index++]);
+                            res.push_back(table_info(cid, name, type, notnull, dflt_value, pk));
+                        }
+                        return 0;
+                    },
+                    &result,
+                    nullptr);
+                if(rc != SQLITE_OK) {
+                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                            sqlite3_errmsg(db));
+                }
+                return result;
+            }
+        };
+
+        /**
+         *  This is a generic implementation. Used as a tail in storage_impl inheritance chain
+         */
+        template<class... Ts>
+        struct storage_impl;
+
+        template<class H, class... Ts>
+        struct storage_impl<H, Ts...> : public storage_impl<Ts...> {
+            using super = storage_impl<Ts...>;
+            using self = storage_impl<H, Ts...>;
+            using table_type = H;
+
+            storage_impl(H h, Ts... ts) : super(std::forward<Ts>(ts)...), table(std::move(h)) {}
+
+            table_type table;
+
+            template<class L>
+            void for_each(const L& l) {
+                this->super::for_each(l);
+                l(*this);
+            }
+
+#if SQLITE_VERSION_NUMBER >= 3006019
+
+            /**
+             *  Returns foreign keys count in table definition
+             */
+            int foreign_keys_count() const {
+                auto res = 0;
+                iterate_tuple(this->table.elements, [&res](auto& c) {
+                    if(is_foreign_key<typename std::decay<decltype(c)>::type>::value) {
+                        ++res;
+                    }
+                });
+                return res;
+            }
+
+#endif
+
+            template<class Lookup>
+            storage_pick_impl_t<self, Lookup>& get_impl() {
+                return *this;
+            }
+            template<class Lookup>
+            storage_pick_impl_t<const self, Lookup>& get_impl() const {
+                return *this;
+            }
+
+            std::string find_table_name(std::type_index ti) const {
+                std::type_index thisTypeIndex{typeid(std::conditional_t<std::is_void<cte_label_type_t<H>>::value,
+                                                                        object_type_t<H>,
+                                                                        cte_label_type_t<H>>)};
+                if(thisTypeIndex == ti) {
+                    return this->table.name;
+                } else {
+                    return this->super::find_table_name(ti);
+                }
+            }
+
+            /**
+             *  Copies current table to another table with a given **name**.
+             *  Performs CREATE TABLE %name% AS SELECT %this->table.columns_names()% FROM &this->table.name%;
+             */
+            void
+            copy_table(sqlite3* db, const std::string& name, const std::vector<table_info*>& columnsToIgnore) const {
+                std::stringstream ss;
+                std::vector<std::string> columnNames;
+                this->table.for_each_column([&columnNames, &columnsToIgnore](auto& c) {
+                    auto& columnName = c.name;
+                    auto columnToIgnoreIt = std::find_if(columnsToIgnore.begin(),
+                                                         columnsToIgnore.end(),
+                                                         [&columnName](auto tableInfoPointer) {
+                                                             return columnName == tableInfoPointer->name;
+                                                         });
+                    if(columnToIgnoreIt == columnsToIgnore.end()) {
+                        columnNames.emplace_back(columnName);
+                    }
+                });
+                auto columnNamesCount = columnNames.size();
+                ss << "INSERT INTO " << name << " (";
+                for(size_t i = 0; i < columnNamesCount; ++i) {
+                    ss << columnNames[i];
+                    if(i < columnNamesCount - 1) {
+                        ss << ",";
+                    }
+                    ss << " ";
+                }
+                ss << ") ";
+                ss << "SELECT ";
+                for(size_t i = 0; i < columnNamesCount; ++i) {
+                    ss << columnNames[i];
+                    if(i < columnNamesCount - 1) {
+                        ss << ", ";
+                    }
+                }
+                ss << " FROM '" << this->table.name << "'";
+                perform_void_exec(db, ss.str());
+            }
+
+            sync_schema_result schema_status(sqlite3* db, bool preserve) const {
+
+                auto res = sync_schema_result::already_in_sync;
+
+                //  first let's see if table with such name exists..
+                auto gottaCreateTable = !this->table_exists(this->table.name, db);
+                if(!gottaCreateTable) {
+
+                    //  get table info provided in `make_table` call..
+                    auto storageTableInfo = this->table.get_table_info();
+
+                    //  now get current table info from db using `PRAGMA table_info` query..
+                    auto dbTableInfo = this->get_table_info(this->table.name, db);
+
+                    //  this vector will contain pointers to columns that gotta be added..
+                    std::vector<table_info*> columnsToAdd;
+
+                    if(this->calculate_remove_add_columns(columnsToAdd, storageTableInfo, dbTableInfo)) {
+                        gottaCreateTable = true;
+                    }
+
+                    if(!gottaCreateTable) {  //  if all storage columns are equal to actual db columns but there are
+                        //  excess columns at the db..
+                        if(dbTableInfo.size() > 0) {
+                            // extra table columns than storage columns
+                            if(!preserve) {
+#if SQLITE_VERSION_NUMBER >= 3035000  //  DROP COLUMN feature exists (v3.35.0)
+                                res = decltype(res)::old_columns_removed;
+#else
+                                gottaCreateTable = true;
+#endif
+                            } else {
+                                res = decltype(res)::old_columns_removed;
+                            }
+                        }
+                    }
+                    if(gottaCreateTable) {
+                        res = decltype(res)::dropped_and_recreated;
+                    } else {
+                        if(columnsToAdd.size()) {
+                            // extra storage columns than table columns
+                            for(auto columnPointer: columnsToAdd) {
+                                auto generatedStorageTypePointer =
+                                    this->find_column_generated_storage_type(columnPointer->name);
+                                if(generatedStorageTypePointer) {
+                                    if(*generatedStorageTypePointer == basic_generated_always::storage_type::stored) {
+                                        gottaCreateTable = true;
+                                        break;
+                                    }
+                                    //  fallback cause VIRTUAL can be added
+                                } else {
+                                    if(columnPointer->notnull && columnPointer->dflt_value.empty()) {
+                                        gottaCreateTable = true;
+                                        break;
+                                    }
+                                }
+                            }
+                            if(!gottaCreateTable) {
+                                if(res == decltype(res)::old_columns_removed) {
+                                    res = decltype(res)::new_columns_added_and_old_columns_removed;
+                                } else {
+                                    res = decltype(res)::new_columns_added;
+                                }
+                            } else {
+                                res = decltype(res)::dropped_and_recreated;
+                            }
+                        } else {
+                            if(res != decltype(res)::old_columns_removed) {
+                                res = decltype(res)::already_in_sync;
+                            }
+                        }
+                    }
+                } else {
+                    res = decltype(res)::new_table_created;
+                }
+                return res;
+            }
+
+          private:
+            const basic_generated_always::storage_type*
+            find_column_generated_storage_type(const std::string& name) const {
+                const basic_generated_always::storage_type* result = nullptr;
+#if SQLITE_VERSION_NUMBER >= 3031000
+                this->table.for_each_column([&result, &name](auto& column) {
+                    if(column.name != name) {
+                        return;
+                    }
+                    iterate_tuple(column.constraints, [&result](auto& constraint) {
+                        if(result) {
+                            return;
+                        }
+                        using constraint_type = typename std::decay<decltype(constraint)>::type;
+                        static_if<is_generated_always<constraint_type>{}>([&result](auto& generatedAlwaysConstraint) {
+                            result = &generatedAlwaysConstraint.storage;
+                        })(constraint);
+                    });
+                });
+#endif
+                return result;
+            }
+        };
+
+        template<>
+        struct storage_impl<> : storage_impl_base {
+
+            // Provided just to be on the safe side
+            template<class Lookup>
+            const storage_impl<>& get_impl() const {
+                static_assert(polyfill::always_false_v<Lookup>, "No such storage implementation");
+            }
+
+            std::string find_table_name(std::type_index) const {
+                return {};
+            }
+
+            template<class L>
+            void for_each(const L&) {}
+
+            int foreign_keys_count() const {
+                return 0;
+            }
+        };
+    }
+}
+
+// #include "storage_lookup.h"
+
+// interface functions
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
+        auto lookup_table(const S& strg) {
+            const auto& tImpl = find_impl<Lookup>(strg);
+            return static_if<std::is_same<decltype(tImpl), const storage_impl<>&>{}>(
+                [](const storage_impl<>&) {
+                    return nullptr;
+                },
+                [](const auto& tImpl) {
+                    return &tImpl.table;
+                })(tImpl);
+        }
+
+        template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
+        std::string lookup_table_name(const S& strg) {
+            const auto& tImpl = find_impl<Lookup>(strg);
+            return static_if<std::is_same<decltype(tImpl), const storage_impl<>&>{}>(
+                [](const storage_impl<>&) {
+                    return std::string{};
+                },
+                [](const auto& tImpl) {
+                    return tImpl.table.name;
+                })(tImpl);
+        }
+
+        template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
+        const std::string& get_table_name(const S& strg) {
+            return pick_impl<Lookup>(strg).table.name;
+        }
+
+        /**
+         *  Find column name by its type and member pointer.
+         */
+        template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
+        const std::string* find_column_name(const S& strg, F O::*field) {
+            return pick_impl<O>(strg).table.find_column_name(field);
+        }
+
+        template<class Label, class O, class F, class S, satisfies<is_storage_impl, S> = true>
+        constexpr decltype(auto) materialize_column_pointer(const S&, const column_pointer<O, F>& cp) {
+            return cp.field;
+        }
+
+        template<class Label, size_t I, class S, satisfies<is_storage_impl, S> = true>
+        constexpr decltype(auto) materialize_column_pointer(const S&,
+                                                            const column_pointer<Label, polyfill::index_constant<I>>&) {
+            using timpl_type = storage_pick_impl_t<S, Label>;
+            return cte_getter_v<storage_object_type_t<timpl_type>, I>;
+        }
+
+        template<class Label, class O, class F, F O::*m, class S, satisfies<is_storage_impl, S> = true>
+        constexpr decltype(auto) materialize_column_pointer(const S&, const column_pointer<Label, ice_t<m>>&) {
+            using timpl_type = storage_pick_impl_t<S, Label>;
+            using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
+            // lookup index in column_results object (aka fields tuple) by member pointer
+            constexpr auto I = tuple_index_of_v<ice_t<m>, typename cte_mapper_type::expressions_type>;
+            return cte_getter_v<cte_object_type_t<cte_mapper_type>, I>;
+        }
+
+        /**
+         *  Find column name by:
+         *  1. by explicit object type and member pointer.
+         *  2. by label type and index constant.
+         *  3. by label type and member pointer constant.
+         */
+        template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
+        const std::string* find_column_name(const S& strg, const column_pointer<O, F>& cp) {
+            auto field = materialize_column_pointer(strg, cp);
+            return pick_impl<O>(strg).table.find_column_name(field);
+        }
+    }
+}
+#pragma once
+
+#include <memory>  //  std::unique/shared_ptr, std::make_unique/shared
+#include <string>  //  std::string
+#include <sqlite3.h>
+#include <type_traits>  //  std::remove_reference, std::is_base_of, std::decay, std::false_type, std::true_type
+#include <cstddef>  //  std::ptrdiff_t
+#include <iterator>  //  std::input_iterator_tag, std::iterator_traits, std::distance
+#include <functional>  //  std::function
+#include <sstream>  //  std::stringstream
+#include <map>  //  std::map
+#include <vector>  //  std::vector
+#include <tuple>  //  std::tuple_size, std::tuple, std::make_tuple
+#include <utility>  //  std::forward, std::pair
+#include <algorithm>  //  std::find
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+#include <optional>  // std::optional
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+// #include "type_traits.h"
+
+// #include "alias.h"
+
+// #include "row_extractor_builder.h"
+
+// #include "row_extractor.h"
+
+// #include "mapped_row_extractor.h"
+
+#include <sqlite3.h>
+
+// #include "object_from_column_builder.h"
+
+#include <sqlite3.h>
+
+// #include "row_extractor.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        struct object_from_column_builder_base {
+            sqlite3_stmt* stmt = nullptr;
+            mutable int index = 0;
+        };
+
+        /**
+         * This is a cute lambda replacement which is used in several places.
+         */
+        template<class O>
+        struct object_from_column_builder : object_from_column_builder_base {
+            using object_type = O;
+
+            object_type& object;
+
+            object_from_column_builder(object_type& object_, sqlite3_stmt* stmt_) :
+                object_from_column_builder_base{stmt_}, object(object_) {}
+
+            template<class C>
+            void operator()(const C& c) const {
+                using field_type = typename C::field_type;
+                auto value = row_extractor<field_type>().extract(this->stmt, this->index++);
+                if(c.member_pointer) {
+                    this->object.*c.member_pointer = std::move(value);
+                } else {
+                    ((this->object).*(c.setter))(std::move(value));
+                }
+            }
+        };
+
+    }
+}
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         * This is a private row extractor class. It is used for extracting rows as objects instead of tuple.
+         * Main difference from regular `row_extractor` is that this class takes table info which is required
+         * for constructing objects by member pointers. To construct please use `row_extractor_builder` class
+         * Type arguments:
+         * V is value type just like regular `row_extractor` has
+         * T is table info class `table_t`
+         */
+        template<class V, class T>
+        struct mapped_row_extractor {
+            using table_info_t = T;
+
+            mapped_row_extractor(const table_info_t& tableInfo_) : tableInfo(tableInfo_) {}
+
+            V extract(sqlite3_stmt* stmt, int /*columnIndex*/) {
+                V res;
+                object_from_column_builder<V> builder{res, stmt};
+                this->tableInfo.for_each_column(builder);
+                return res;
+            }
+
+            const table_info_t& tableInfo;
+        };
+
+    }
+
+}
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         * This builder is used to construct different row extractors depending on type.
+         * It has two specializations: for mapped to storage types (e.g. User, Visit etc) and
+         * for non-mapped (e.g. std::string, QString, int etc). For non mapped its operator() returns
+         * generic `row_extractor`, for mapped it returns `mapped_row_extractor` instance.
+         */
+        template<class T, bool IsMapped, class I>
+        struct row_extractor_builder;
+
+        template<class T, class I>
+        struct row_extractor_builder<T, false, I> {
+
+            row_extractor<T> operator()(const I* /*tableInfo*/) const {
+                return {};
+            }
+        };
+
+        template<class T, class I>
+        struct row_extractor_builder<T, true, I> {
+
+            mapped_row_extractor<T, I> operator()(const I* tableInfo) const {
+                return {*tableInfo};
+            }
+        };
+
+        template<class T, bool IsMapped, class I>
+        auto make_row_extractor(const I* tableInfo) {
+            using builder_t = row_extractor_builder<T, IsMapped, I>;
+            return builder_t{}(tableInfo);
+        }
+
+    }
+
+}
+
+// #include "error_code.h"
+
+// #include "type_printer.h"
+
+// #include "tuple_helper/tuple_helper.h"
+
+// #include "constraints.h"
+
+// #include "type_is_nullable.h"
+
+// #include "field_printer.h"
+
+// #include "rowid.h"
+
+// #include "operators.h"
+
+// #include "select_constraints.h"
+
+// #include "core_functions.h"
+
+// #include "conditions.h"
+
+// #include "statement_binder.h"
+
+// #include "column_result.h"
+
+// #include "mapped_type_proxy.h"
+
+// #include "sync_schema_result.h"
+
+// #include "table_info.h"
+
+// #include "storage_impl.h"
+
+// #include "journal_mode.h"
+
+// #include "field_value_holder.h"
+
+// #include "view.h"
+
+#include <memory>  //  std::shared_ptr
+#include <string>  //  std::string
+#include <utility>  //  std::forward, std::move
+#include <sqlite3.h>
+#include <system_error>  //  std::system_error
+#include <tuple>  //  std::tuple, std::make_tuple
+
+// #include "row_extractor.h"
+
+// #include "statement_finalizer.h"
+
+// #include "error_code.h"
+
+// #include "iterator.h"
+
+#include <memory>  //  std::shared_ptr, std::unique_ptr, std::make_shared
+#include <sqlite3.h>
+#include <type_traits>  //  std::decay
+#include <utility>  //  std::move
+#include <cstddef>  //  std::ptrdiff_t
+#include <iterator>  //  std::input_iterator_tag
+#include <system_error>  //  std::system_error
+#include <ios>  //  std::make_error_code
+
+// #include "row_extractor.h"
+
+// #include "statement_finalizer.h"
+
+// #include "error_code.h"
+
+// #include "object_from_column_builder.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        template<class V>
+        struct iterator_t {
+            using view_type = V;
+            using value_type = typename view_type::mapped_type;
+
+          protected:
+            /**
+             *  The double-indirection is so that copies of the iterator
+             *  share the same sqlite3_stmt from a sqlite3_prepare_v2()
+             *  call. When one finishes iterating it the pointer
+             *  inside the shared_ptr is nulled out in all copies.
+             */
+            std::shared_ptr<statement_finalizer> stmt;
+
+            // only null for the default constructed iterator
+            view_type* view;
+
+            /**
+             *  shared_ptr is used over unique_ptr here
+             *  so that the iterator can be copyable.
+             */
+            std::shared_ptr<value_type> current;
+
+            void extract_value() {
+                auto& storage = this->view->storage;
+                auto& impl = pick_const_impl<value_type>(storage);
+                this->current = std::make_shared<value_type>();
+                object_from_column_builder<value_type> builder{*this->current, this->stmt->get()};
+                impl.table.for_each_column(builder);
+            }
+
+          public:
+            using difference_type = std::ptrdiff_t;
+            using pointer = value_type*;
+            using reference = value_type&;
+            using iterator_category = std::input_iterator_tag;
+
+            iterator_t() : view(nullptr){};
+
+            iterator_t(sqlite3_stmt* stmt_, view_type& view_) :
+                stmt(std::make_shared<statement_finalizer>(stmt_)), view(&view_) {
+                next();
+            }
+
+            const value_type& operator*() const {
+                if(!this->stmt || !this->current) {
+                    throw std::system_error(std::make_error_code(orm_error_code::trying_to_dereference_null_iterator));
+                }
+                return *this->current;
+            }
+
+            const value_type* operator->() const {
+                return &(this->operator*());
+            }
+
+          private:
+            void next() {
+                this->current.reset();
+                if(this->stmt) {
+                    auto statementPointer = this->stmt->get();
+                    auto ret = sqlite3_step(statementPointer);
+                    switch(ret) {
+                        case SQLITE_ROW:
+                            this->extract_value();
+                            break;
+                        case SQLITE_DONE:
+                            this->stmt.reset();
+                            break;
+                        default: {
+                            auto db = this->view->connection.get();
+                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                    sqlite3_errmsg(db));
+                        }
+                    }
+                }
+            }
+
+          public:
+            iterator_t<V>& operator++() {
+                next();
+                return *this;
+            }
+
+            void operator++(int) {
+                this->operator++();
+            }
+
+            bool operator==(const iterator_t& other) const {
+                return this->current == other.current;
+            }
+
+            bool operator!=(const iterator_t& other) const {
+                return !(*this == other);
+            }
+        };
+    }
+}
+
+// #include "ast_iterator.h"
+
+#include <vector>  //  std::vector
+#include <functional>  //  std::reference_wrapper
+
+// #include "conditions.h"
+
+// #include "select_constraints.h"
+
+// #include "operators.h"
+
+// #include "tuple_helper/tuple_helper.h"
+
+// #include "core_functions.h"
+
+// #include "prepared_statement.h"
+
+#include <sqlite3.h>
+#include <iterator>  //  std::iterator_traits
+#include <string>  //  std::string
+#include <type_traits>  //  std::true_type, std::false_type
+#include <utility>  //  std::pair
+
+// #include "connection_holder.h"
+
+#include <sqlite3.h>
+#include <string>  //  std::string
+#include <system_error>  //  std::system_error
+
+// #include "error_code.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        struct connection_holder {
+
+            connection_holder(std::string filename_) : filename(move(filename_)) {}
+
+            connection_holder(connection_holder* connection) :
+                filename{connection->filename}, db{connection->db}, _retain_count{++connection->_retain_count} {}
+
+            void retain() {
+                ++this->_retain_count;
+                if(1 == this->_retain_count) {
+                    auto rc = sqlite3_open(this->filename.c_str(), &this->db);
+                    if(rc != SQLITE_OK) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(this->db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(this->db));
+                    }
+                }
+            }
+
+            void release() {
+                --this->_retain_count;
+                if(0 == this->_retain_count) {
+                    auto rc = sqlite3_close(this->db);
+                    if(rc != SQLITE_OK) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(this->db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(this->db));
+                    }
+                }
+            }
+
+            sqlite3* get() const {
+                return this->db;
+            }
+
+            int retain_count() const {
+                return this->_retain_count;
+            }
+
+            const std::string filename;
+
+          protected:
+            sqlite3* db = nullptr;
+            int _retain_count = 0;
+        };
+
+        struct connection_ref {
+            connection_ref(connection_holder& holder_) : holder(holder_) {
+                this->holder.retain();
+            }
+
+            connection_ref(const connection_ref& other) : holder(other.holder) {
+                this->holder.retain();
+            }
+
+            connection_ref(connection_ref&& other) : holder(other.holder) {
+                this->holder.retain();
+            }
+
+            ~connection_ref() {
+                this->holder.release();
+            }
+
+            sqlite3* get() const {
+                return this->holder.get();
+            }
+
+          protected:
+            connection_holder& holder;
+        };
+    }
+}
+
+// #include "select_constraints.h"
+
+// #include "values.h"
+
+#include <vector>  //  std::vector
+#include <initializer_list>
+#include <tuple>  //  std::tuple
+#include <type_traits>  //  std::false_type, std::true_type
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        template<class... Args>
+        struct values_t {
+            using args_tuple = std::tuple<Args...>;
+
+            args_tuple tuple;
+        };
+
+        template<class T>
+        struct is_values : std::false_type {};
+
+        template<class... Args>
+        struct is_values<values_t<Args...>> : std::true_type {};
+
+        template<class T>
+        struct dynamic_values_t {
+            std::vector<T> vector;
+        };
+
+    }
+
+    template<class... Args>
+    internal::values_t<Args...> values(Args... args) {
+        return {{std::forward<Args>(args)...}};
+    }
+
+    template<class T>
+    internal::dynamic_values_t<T> values(std::vector<T> vector) {
+        return {{move(vector)}};
+    }
+
+}
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        struct prepared_statement_base {
+            sqlite3_stmt* stmt = nullptr;
+            connection_ref con;
+
+            ~prepared_statement_base() {
+                if(this->stmt) {
+                    sqlite3_finalize(this->stmt);
+                    this->stmt = nullptr;
+                }
+            }
+
+            std::string sql() const {
+                if(this->stmt) {
+                    if(auto res = sqlite3_sql(this->stmt)) {
+                        return res;
+                    } else {
+                        return {};
+                    }
+                } else {
+                    return {};
+                }
+            }
+
+#if SQLITE_VERSION_NUMBER >= 3014000
+            std::string expanded_sql() const {
+                if(this->stmt) {
+                    if(auto res = sqlite3_expanded_sql(this->stmt)) {
+                        std::string result = res;
+                        sqlite3_free(res);
+                        return result;
+                    } else {
+                        return {};
+                    }
+                } else {
+                    return {};
+                }
+            }
+#endif
+#if SQLITE_VERSION_NUMBER >= 3026000 and defined(SQLITE_ENABLE_NORMALIZE)
+            std::string normalized_sql() const {
+                if(this->stmt) {
+                    if(auto res = sqlite3_normalized_sql(this->stmt)) {
+                        return res;
+                    } else {
+                        return {};
+                    }
+                } else {
+                    return {};
+                }
+            }
+#endif
+        };
+
+        template<class T>
+        struct prepared_statement_t : prepared_statement_base {
+            using expression_type = T;
+
+            expression_type expression;
+
+            prepared_statement_t(T expression_, sqlite3_stmt* stmt_, connection_ref con_) :
+                prepared_statement_base{stmt_, std::move(con_)}, expression(std::move(expression_)) {}
+
+            prepared_statement_t(prepared_statement_t&& prepared_stmt) :
+                prepared_statement_base{prepared_stmt.stmt, std::move(prepared_stmt.con)},
+                expression(std::move(prepared_stmt.expression)) {
+                prepared_stmt.stmt = nullptr;
+            }
+        };
+
+        template<class T>
+        struct is_prepared_statement : std::false_type {};
+
+        template<class T>
+        struct is_prepared_statement<prepared_statement_t<T>> : std::true_type {};
+
+        /**
+         *  T - type of object to obtain from a database
+         */
+        template<class T, class R, class... Args>
+        struct get_all_t {
+            using type = T;
+            using return_type = R;
+
+            using conditions_type = std::tuple<Args...>;
+
+            conditions_type conditions;
+        };
+
+        template<class T, class R, class... Args>
+        struct get_all_pointer_t {
+            using type = T;
+            using return_type = R;
+
+            using conditions_type = std::tuple<Args...>;
+
+            conditions_type conditions;
+        };
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class T, class R, class... Args>
+        struct get_all_optional_t {
+            using type = T;
+            using return_type = R;
+
+            using conditions_type = std::tuple<Args...>;
+
+            conditions_type conditions;
+        };
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+        template<class T, class... Wargs>
+        struct update_all_t;
+
+        template<class... Args, class... Wargs>
+        struct update_all_t<set_t<Args...>, Wargs...> {
+            using set_type = set_t<Args...>;
+            using conditions_type = std::tuple<Wargs...>;
+
+            set_type set;
+            conditions_type conditions;
+        };
+
+        template<class T, class... Args>
+        struct remove_all_t {
+            using type = T;
+            using conditions_type = std::tuple<Args...>;
+
+            conditions_type conditions;
+        };
+
+        template<class T, class... Ids>
+        struct get_t {
+            using type = T;
+            using ids_type = std::tuple<Ids...>;
+
+            ids_type ids;
+        };
+
+        template<class T, class... Ids>
+        struct get_pointer_t {
+            using type = T;
+            using ids_type = std::tuple<Ids...>;
+
+            ids_type ids;
+        };
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class T, class... Ids>
+        struct get_optional_t {
+            using type = T;
+            using ids_type = std::tuple<Ids...>;
+
+            ids_type ids;
+        };
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+        template<class T>
+        struct update_t {
+            using type = T;
+
+            type object;
+        };
+
+        template<class T, class... Ids>
+        struct remove_t {
+            using type = T;
+            using ids_type = std::tuple<Ids...>;
+
+            ids_type ids;
+        };
+
+        template<class T>
+        struct insert_t {
+            using type = T;
+
+            type object;
+        };
+
+        template<class T>
+        struct is_insert : std::false_type {};
+
+        template<class T>
+        struct is_insert<insert_t<T>> : std::true_type {};
+
+        template<class T, class... Cols>
+        struct insert_explicit {
+            using type = T;
+            using columns_type = columns_t<Cols...>;
+
+            type obj;
+            columns_type columns;
+        };
+
+        template<class T>
+        struct replace_t {
+            using type = T;
+
+            type object;
+        };
+
+        template<class T>
+        struct is_replace : std::false_type {};
+
+        template<class T>
+        struct is_replace<replace_t<T>> : std::true_type {};
+
+        template<class It, class L, class O>
+        struct insert_range_t {
+            using iterator_type = It;
+            using container_object_type = typename std::iterator_traits<iterator_type>::value_type;
+            using transformer_type = L;
+            using object_type = O;
+
+            std::pair<iterator_type, iterator_type> range;
+            transformer_type transformer;
+        };
+
+        template<class T>
+        struct is_insert_range : std::false_type {};
+
+        template<class It, class L, class O>
+        struct is_insert_range<insert_range_t<It, L, O>> : std::true_type {};
+
+        template<class It, class L, class O>
+        struct replace_range_t {
+            using iterator_type = It;
+            using container_object_type = typename std::iterator_traits<iterator_type>::value_type;
+            using transformer_type = L;
+            using object_type = O;
+
+            std::pair<iterator_type, iterator_type> range;
+            transformer_type transformer;
+        };
+
+        template<class T>
+        struct is_replace_range : std::false_type {};
+
+        template<class It, class L, class O>
+        struct is_replace_range<replace_range_t<It, L, O>> : std::true_type {};
+
+        template<class... Args>
+        struct insert_raw_t {
+            using args_tuple = std::tuple<Args...>;
+
+            args_tuple args;
+        };
+
+        template<class T>
+        struct is_insert_raw : std::false_type {};
+
+        template<class... Args>
+        struct is_insert_raw<insert_raw_t<Args...>> : std::true_type {};
+
+        template<class... Args>
+        struct replace_raw_t {
+            using args_tuple = std::tuple<Args...>;
+
+            args_tuple args;
+        };
+
+        template<class T>
+        struct is_replace_raw : std::false_type {};
+
+        template<class... Args>
+        struct is_replace_raw<replace_raw_t<Args...>> : std::true_type {};
+
+        struct default_transformer {
+
+            template<class T>
+            const T& operator()(const T& object) const {
+                return object;
+            }
+        };
+
+        struct default_values_t {};
+
+        template<class T>
+        using is_default_values = std::is_same<default_values_t, T>;
+
+        enum class conflict_action {
+            abort,
+            fail,
+            ignore,
+            replace,
+            rollback,
+        };
+
+        struct insert_constraint {
+            conflict_action action = conflict_action::abort;
+        };
+
+        template<class T>
+        using is_insert_constraint = std::is_same<insert_constraint, T>;
+
+        template<class T>
+        struct is_upsert_clause;
+    }
+
+    inline internal::insert_constraint or_rollback() {
+        return internal::insert_constraint{internal::conflict_action::rollback};
+    }
+
+    inline internal::insert_constraint or_replace() {
+        return internal::insert_constraint{internal::conflict_action::replace};
+    }
+
+    inline internal::insert_constraint or_ignore() {
+        return internal::insert_constraint{internal::conflict_action::ignore};
+    }
+
+    inline internal::insert_constraint or_fail() {
+        return internal::insert_constraint{internal::conflict_action::fail};
+    }
+
+    inline internal::insert_constraint or_abort() {
+        return internal::insert_constraint{internal::conflict_action::abort};
+    }
+
+    /**
+     *  Use this function to add `DEFAULT VALUES` modifier to raw `INSERT`.
+     *
+     *  @example
+     *  ```
+     *  storage.insert(into<Singer>(), default_values());
+     *  ```
+     */
+    inline internal::default_values_t default_values() {
+        return {};
+    }
+
+    /**
+     *  Raw insert statement creation routine. Use this if `insert` with object does not fit you. This insert is designed to be able
+     *  to call any type of `INSERT` query with no limitations.
+     *  @example
+     *  ```sql
+     *  INSERT INTO users (id, name) VALUES(5, 'Little Mix')
+     *  ```
+     *  will be
+     *  ```c++
+     *  auto statement = storage.prepare(insert(into<User>, columns(&User::id, &User::name), values(std::make_tuple(5, "Little Mix"))));
+     *  storage.execute(statement));
+     *  ```
+     *  One more example:
+     *  ```sql
+     *  INSERT INTO singers (name) VALUES ('Sofia Reyes')('Kungs')
+     *  ```
+     *  will be
+     *  ```c++
+     *  auto statement = storage.prepare(insert(into<Singer>(), columns(&Singer::name), values(std::make_tuple("Sofia Reyes"), std::make_tuple("Kungs"))));
+     *  storage.execute(statement));
+     *  ```
+     *  One can use `default_values` to add `DEFAULT VALUES` modifier:
+     *  ```sql
+     *  INSERT INTO users DEFAULT VALUES
+     *  ```
+     *  will be
+     *  ```c++
+     *  auto statement = storage.prepare(insert(into<Singer>(), default_values()));
+     *  storage.execute(statement));
+     *  ```
+     *  Also one can use `INSERT OR ABORT`/`INSERT OR FAIL`/`INSERT OR IGNORE`/`INSERT OR REPLACE`/`INSERT ROLLBACK`:
+     *  ```c++
+     *  auto statement = storage.prepare(insert(or_ignore(), into<Singer>(), columns(&Singer::name), values(std::make_tuple("Sofia Reyes"), std::make_tuple("Kungs"))));
+     *  auto statement2 = storage.prepare(insert(or_rollback(), into<Singer>(), default_values()));
+     *  auto statement3 = storage.prepare(insert(or_abort(), into<User>, columns(&User::id, &User::name), values(std::make_tuple(5, "Little Mix"))));
+     *  ```
+     */
+    template<class... Args>
+    internal::insert_raw_t<Args...> insert(Args... args) {
+        using args_tuple = std::tuple<Args...>;
+        using internal::count_tuple;
+        using internal::is_columns;
+        using internal::is_insert_constraint;
+        using internal::is_into;
+        using internal::is_select;
+        using internal::is_upsert_clause;
+        using internal::is_values;
+
+        constexpr int orArgsCount = count_tuple<args_tuple, is_insert_constraint>::value;
+        static_assert(orArgsCount < 2, "Raw insert must have only one OR... argument");
+
+        constexpr int intoArgsCount = count_tuple<args_tuple, is_into>::value;
+        static_assert(intoArgsCount != 0, "Raw insert must have into<T> argument");
+        static_assert(intoArgsCount < 2, "Raw insert must have only one into<T> argument");
+
+        constexpr int columnsArgsCount = count_tuple<args_tuple, is_columns>::value;
+        static_assert(columnsArgsCount < 2, "Raw insert must have only one columns(...) argument");
+
+        constexpr int valuesArgsCount = count_tuple<args_tuple, is_values>::value;
+        static_assert(valuesArgsCount < 2, "Raw insert must have only one values(...) argument");
+
+        constexpr int defaultValuesCount = count_tuple<args_tuple, internal::is_default_values>::value;
+        static_assert(defaultValuesCount < 2, "Raw insert must have only one default_values() argument");
+
+        constexpr int selectsArgsCount = count_tuple<args_tuple, is_select>::value;
+        static_assert(selectsArgsCount < 2, "Raw insert must have only one select(...) argument");
+
+        constexpr int upsertClausesCount = count_tuple<args_tuple, is_upsert_clause>::value;
+        static_assert(upsertClausesCount <= 2, "Raw insert can contain 2 instances of upsert clause maximum");
+
+        constexpr int argsCount = int(std::tuple_size<args_tuple>::value);
+        static_assert(argsCount == intoArgsCount + columnsArgsCount + valuesArgsCount + defaultValuesCount +
+                                       selectsArgsCount + orArgsCount + upsertClausesCount,
+                      "Raw insert has invalid arguments");
+
+        return {{std::forward<Args>(args)...}};
+    }
+
+    /**
+     *  Raw replace statement creation routine. Use this if `replace` with object does not fit you. This replace is designed to be able
+     *  to call any type of `REPLACE` query with no limitations. Actually this is the same query as raw insert except `OR...` option existance.
+     *  @example
+     *  ```sql
+     *  REPLACE INTO users (id, name) VALUES(5, 'Little Mix')
+     *  ```
+     *  will be
+     *  ```c++
+     *  auto statement = storage.prepare(replace(into<User>, columns(&User::id, &User::name), values(std::make_tuple(5, "Little Mix"))));
+     *  storage.execute(statement));
+     *  ```
+     *  One more example:
+     *  ```sql
+     *  REPLACE INTO singers (name) VALUES ('Sofia Reyes')('Kungs')
+     *  ```
+     *  will be
+     *  ```c++
+     *  auto statement = storage.prepare(replace(into<Singer>(), columns(&Singer::name), values(std::make_tuple("Sofia Reyes"), std::make_tuple("Kungs"))));
+     *  storage.execute(statement));
+     *  ```
+     *  One can use `default_values` to add `DEFAULT VALUES` modifier:
+     *  ```sql
+     *  REPLACE INTO users DEFAULT VALUES
+     *  ```
+     *  will be
+     *  ```c++
+     *  auto statement = storage.prepare(replace(into<Singer>(), default_values()));
+     *  storage.execute(statement));
+     *  ```
+     */
+    template<class... Args>
+    internal::replace_raw_t<Args...> replace(Args... args) {
+        using args_tuple = std::tuple<Args...>;
+        using internal::count_tuple;
+        using internal::is_columns;
+        using internal::is_into;
+        using internal::is_values;
+
+        constexpr int intoArgsCount = count_tuple<args_tuple, is_into>::value;
+        static_assert(intoArgsCount != 0, "Raw replace must have into<T> argument");
+        static_assert(intoArgsCount < 2, "Raw replace must have only one into<T> argument");
+
+        constexpr int columnsArgsCount = count_tuple<args_tuple, is_columns>::value;
+        static_assert(columnsArgsCount < 2, "Raw replace must have only one columns(...) argument");
+
+        constexpr int valuesArgsCount = count_tuple<args_tuple, is_values>::value;
+        static_assert(valuesArgsCount < 2, "Raw replace must have only one values(...) argument");
+
+        constexpr int defaultValuesCount = count_tuple<args_tuple, internal::is_default_values>::value;
+        static_assert(defaultValuesCount < 2, "Raw replace must have only one default_values() argument");
+
+        constexpr int selectsArgsCount = count_tuple<args_tuple, internal::is_select>::value;
+        static_assert(selectsArgsCount < 2, "Raw replace must have only one select(...) argument");
+
+        constexpr int argsCount = int(std::tuple_size<args_tuple>::value);
+        static_assert(argsCount ==
+                          intoArgsCount + columnsArgsCount + valuesArgsCount + defaultValuesCount + selectsArgsCount,
+                      "Raw replace has invalid arguments");
+
+        return {{std::forward<Args>(args)...}};
+    }
+
+    /**
+     *  Create a replace range statement
+     *
+     *  @example
+     *  ```
+     *  std::vector<User> users;
+     *  users.push_back(User{1, "Leony"});
+     *  auto statement = storage.prepare(replace_range(users.begin(), users.end()));
+     *  storage.execute(statement);
+     *  ```
+     */
+    template<class It>
+    internal::replace_range_t<It, internal::default_transformer, typename std::iterator_traits<It>::value_type>
+    replace_range(It from, It to) {
+        return {{std::move(from), std::move(to)}};
+    }
+
+    /**
+     *  Create an replace range statement with explicit transformer. Transformer is used to apply containers with no strict objects with other kind of objects like pointers,
+     *  optionals or whatever.
+     *  @example
+     *  ```
+     *  std::vector<std::unique_ptr<User>> userPointers;
+     *  userPointers.push_back(std::make_unique<User>(1, "Eneli"));
+     *  auto statement = storage.prepare(replace_range<User>(userPointers.begin(), userPointers.end(), [](const std::unique_ptr<User> &userPointer) -> const User & {
+     *      return *userPointer;
+     *  }));
+     *  storage.execute(statement);
+     *  ```
+     */
+    template<class T, class It, class L>
+    internal::replace_range_t<It, L, T> replace_range(It from, It to, L transformer) {
+        return {{std::move(from), std::move(to)}, std::move(transformer)};
+    }
+
+    /**
+     *  Create an insert range statement
+     *  @example
+     *  ```
+     *  std::vector<User> users;
+     *  users.push_back(User{1, "Leony"});
+     *  auto statement = storage.prepare(insert_range(users.begin(), users.end()));
+     *  storage.execute(statement);
+     *  ```
+     */
+    template<class It>
+    internal::insert_range_t<It, internal::default_transformer, typename std::iterator_traits<It>::value_type>
+    insert_range(It from, It to) {
+        return {{std::move(from), std::move(to)}, internal::default_transformer{}};
+    }
+
+    /**
+     *  Create an insert range statement with explicit transformer. Transformer is used to apply containers with no strict objects with other kind of objects like pointers,
+     *  optionals or whatever.
+     *  @example
+     *  ```
+     *  std::vector<std::unique_ptr<User>> userPointers;
+     *  userPointers.push_back(std::make_unique<User>(1, "Eneli"));
+     *  auto statement = storage.prepare(insert_range<User>(userPointers.begin(), userPointers.end(), [](const std::unique_ptr<User> &userPointer) -> const User & {
+     *      return *userPointer;
+     *  }));
+     *  storage.execute(statement);
+     *  ```
+     */
+    template<class T, class It, class L>
+    internal::insert_range_t<It, L, T> insert_range(It from, It to, L transformer) {
+        return {{std::move(from), std::move(to)}, std::move(transformer)};
+    }
+    /**
+     *  Create a replace statement.
+     *  T is an object type mapped to a storage.
+     *  Usage: storage.replace(myUserInstance);
+     *  Parameter obj is accepted by value. If you want to accept it by ref
+     *  please use std::ref function: storage.replace(std::ref(myUserInstance));
+     */
+    template<class T>
+    internal::replace_t<T> replace(T obj) {
+        return {std::move(obj)};
+    }
+
+    /**
+     *  Create an insert statement.
+     *  T is an object type mapped to a storage.
+     *  Usage: storage.insert(myUserInstance);
+     *  Parameter obj is accepted by value. If you want to accept it by ref
+     *  please use std::ref function: storage.insert(std::ref(myUserInstance));
+     */
+    template<class T>
+    internal::insert_t<T> insert(T obj) {
+        return {std::move(obj)};
+    }
+
+    /**
+     *  Create an explicit insert statement.
+     *  T is an object type mapped to a storage.
+     *  Cols is columns types aparameter pack. Must contain member pointers
+     *  Usage: storage.insert(myUserInstance, columns(&User::id, &User::name));
+     *  Parameter obj is accepted by value. If you want to accept it by ref
+     *  please use std::ref function: storage.insert(std::ref(myUserInstance), columns(&User::id, &User::name));
+     */
+    template<class T, class... Cols>
+    internal::insert_explicit<T, Cols...> insert(T obj, internal::columns_t<Cols...> cols) {
+        return {std::move(obj), std::move(cols)};
+    }
+
+    /**
+     *  Create a remove statement
+     *  T is an object type mapped to a storage.
+     *  Usage: remove<User>(5);
+     */
+    template<class T, class... Ids>
+    internal::remove_t<T, Ids...> remove(Ids... ids) {
+        std::tuple<Ids...> idsTuple{std::forward<Ids>(ids)...};
+        return {move(idsTuple)};
+    }
+
+    /**
+     *  Create an update statement.
+     *  T is an object type mapped to a storage.
+     *  Usage: storage.update(myUserInstance);
+     *  Parameter obj is accepted by value. If you want to accept it by ref
+     *  please use std::ref function: storage.update(std::ref(myUserInstance));
+     */
+    template<class T>
+    internal::update_t<T> update(T obj) {
+        return {std::move(obj)};
+    }
+
+    /**
+     *  Create a get statement.
+     *  T is an object type mapped to a storage.
+     *  Usage: get<User>(5);
+     */
+    template<class T, class... Ids>
+    internal::get_t<T, Ids...> get(Ids... ids) {
+        std::tuple<Ids...> idsTuple{std::forward<Ids>(ids)...};
+        return {move(idsTuple)};
+    }
+
+    /**
+     *  Create a get pointer statement.
+     *  T is an object type mapped to a storage.
+     *  Usage: get_pointer<User>(5);
+     */
+    template<class T, class... Ids>
+    internal::get_pointer_t<T, Ids...> get_pointer(Ids... ids) {
+        std::tuple<Ids...> idsTuple{std::forward<Ids>(ids)...};
+        return {move(idsTuple)};
+    }
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+    /**
+     *  Create a get optional statement.
+     *  T is an object type mapped to a storage.
+     *  Usage: get_optional<User>(5);
+     */
+    template<class T, class... Ids>
+    internal::get_optional_t<T, Ids...> get_optional(Ids... ids) {
+        std::tuple<Ids...> idsTuple{std::forward<Ids>(ids)...};
+        return {move(idsTuple)};
+    }
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+    /**
+     *  Create a remove all statement.
+     *  T is an object type mapped to a storage.
+     *  Usage: storage.remove_all<User>(...);
+     */
+    template<class T, class... Args>
+    internal::remove_all_t<T, Args...> remove_all(Args... args) {
+        using args_tuple = std::tuple<Args...>;
+        internal::validate_conditions<args_tuple>();
+        args_tuple conditions{std::forward<Args>(args)...};
+        return {move(conditions)};
+    }
+
+    /**
+     *  Create a get all statement.
+     *  T is an object type mapped to a storage.
+     *  Usage: storage.get_all<User>(...);
+     */
+    template<class T, class... Args>
+    internal::get_all_t<T, std::vector<T>, Args...> get_all(Args... args) {
+        using args_tuple = std::tuple<Args...>;
+        internal::validate_conditions<args_tuple>();
+        args_tuple conditions{std::forward<Args>(args)...};
+        return {move(conditions)};
+    }
+
+    /**
+     *  Create a get all statement.
+     *  T is an object type mapped to a storage.
+     *  R is a container type. std::vector<T> is default
+     *  Usage: storage.get_all<User>(...);
+    */
+    template<class T, class R, class... Args>
+    internal::get_all_t<T, R, Args...> get_all(Args... args) {
+        using args_tuple = std::tuple<Args...>;
+        internal::validate_conditions<args_tuple>();
+        args_tuple conditions{std::forward<Args>(args)...};
+        return {move(conditions)};
+    }
+
+    /**
+     *  Create an update all statement.
+     *  Usage: storage.update_all(set(...), ...);
+     */
+    template<class... Args, class... Wargs>
+    internal::update_all_t<internal::set_t<Args...>, Wargs...> update_all(internal::set_t<Args...> set, Wargs... wh) {
+        using args_tuple = std::tuple<Wargs...>;
+        internal::validate_conditions<args_tuple>();
+        args_tuple conditions{std::forward<Wargs>(wh)...};
+        return {std::move(set), move(conditions)};
+    }
+
+    /**
+     *  Create a get all pointer statement.
+     *  T is an object type mapped to a storage.
+     *  Usage: storage.get_all_pointer<User>(...);
+     */
+    template<class T, class... Args>
+    internal::get_all_pointer_t<T, std::vector<std::unique_ptr<T>>, Args...> get_all_pointer(Args... args) {
+        using args_tuple = std::tuple<Args...>;
+        internal::validate_conditions<args_tuple>();
+        args_tuple conditions{std::forward<Args>(args)...};
+        return {move(conditions)};
+    }
+    /**
+     *  Create a get all pointer statement.
+     *  T is an object type mapped to a storage.
+     *  R is a container return type. std::vector<std::unique_ptr<T>> is default
+     *  Usage: storage.get_all_pointer<User>(...);
+    */
+    template<class T, class R, class... Args>
+    internal::get_all_pointer_t<T, R, Args...> get_all_pointer(Args... args) {
+        using args_tuple = std::tuple<Args...>;
+        internal::validate_conditions<args_tuple>();
+        args_tuple conditions{std::forward<Args>(args)...};
+        return {move(conditions)};
+    }
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+    /**
+     *  Create a get all optional statement.
+     *  T is an object type mapped to a storage.
+     *  Usage: storage.get_all_optional<User>(...);
+     */
+    template<class T, class... Args>
+    internal::get_all_optional_t<T, std::vector<std::optional<T>>, Args...> get_all_optional(Args... args) {
+        using args_tuple = std::tuple<Args...>;
+        internal::validate_conditions<args_tuple>();
+        args_tuple conditions{std::forward<Args>(args)...};
+        return {move(conditions)};
+    }
+
+    /**
+     *  Create a get all optional statement.
+     *  T is an object type mapped to a storage.
+     *  R is a container return type. std::vector<std::optional<T>> is default
+     *  Usage: storage.get_all_optional<User>(...);
+     */
+    template<class T, class R, class... Args>
+    internal::get_all_optional_t<T, R, Args...> get_all_optional(Args... args) {
+        using args_tuple = std::tuple<Args...>;
+        internal::validate_conditions<args_tuple>();
+        args_tuple conditions{std::forward<Args>(args)...};
+        return {move(conditions)};
+    }
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+}
+
+// #include "values.h"
+
+// #include "function.h"
+
+// #include "ast/excluded.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T>
+        struct excluded_t {
+            using expression_type = T;
+
+            expression_type expression;
+        };
+    }
+
+    template<class T>
+    internal::excluded_t<T> excluded(T expression) {
+        return {std::move(expression)};
+    }
+}
+
+// #include "ast/upsert_clause.h"
+
+#include <tuple>  //  std::tuple, std::make_tuple
+#include <type_traits>  //  std::false_type, std::true_type, std::forward
+
+namespace sqlite_orm {
+    namespace internal {
+#if SQLITE_VERSION_NUMBER >= 3024000
+        template<class T, class A>
+        struct upsert_clause;
+
+        template<class... Args>
+        struct conflict_target {
+            using args_tuple = std::tuple<Args...>;
+
+            args_tuple args;
+
+            upsert_clause<args_tuple, std::tuple<>> do_nothing() {
+                return {move(this->args), {}};
+            }
+
+            template<class... ActionsArgs>
+            upsert_clause<args_tuple, std::tuple<ActionsArgs...>> do_update(ActionsArgs... actions) {
+                return {move(this->args), {std::make_tuple(std::forward<ActionsArgs>(actions)...)}};
+            }
+        };
+
+        template<class... TargetArgs, class... ActionsArgs>
+        struct upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>> {
+            using target_args_tuple = std::tuple<TargetArgs...>;
+            using actions_tuple = std::tuple<ActionsArgs...>;
+
+            target_args_tuple target_args;
+
+            actions_tuple actions;
+        };
+
+        template<class T>
+        struct is_upsert_clause : std::false_type {};
+
+        template<class T, class A>
+        struct is_upsert_clause<upsert_clause<T, A>> : std::true_type {};
+    }
+
+    /**
+     *  ON CONFLICT upsert clause builder function.
+     *  @example
+     *  storage.insert(into<Employee>(),
+     *            columns(&Employee::id, &Employee::name, &Employee::age, &Employee::address, &Employee::salary),
+     *            values(std::make_tuple(3, "Sofia", 26, "Madrid", 15000.0),
+     *                 std::make_tuple(4, "Doja", 26, "LA", 25000.0)),
+     *            on_conflict(&Employee::id).do_update(set(c(&Employee::name) = excluded(&Employee::name),
+     *                                           c(&Employee::age) = excluded(&Employee::age),
+     *                                           c(&Employee::address) = excluded(&Employee::address),
+     *                                           c(&Employee::salary) = excluded(&Employee::salary))));
+     */
+    template<class... Args>
+    internal::conflict_target<Args...> on_conflict(Args... args) {
+        return {std::tuple<Args...>(std::forward<Args>(args)...)};
+    }
+#endif
+}
+
+// #include "ast/where.h"
+
+// #include "ast/into.h"
+
+#include <type_traits>  //  std::true_type, std::false_type
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T>
+        struct into_t {
+            using type = T;
+        };
+
+        template<class T>
+        struct is_into : std::false_type {};
+
+        template<class T>
+        struct is_into<into_t<T>> : std::true_type {};
+    }
+
+    template<class T>
+    internal::into_t<T> into() {
+        return {};
+    }
+}
+
+// #include "ast/group_by.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  ast_iterator accepts any expression and a callable object
+         *  which will be called for any node of provided expression.
+         *  E.g. if we pass `where(is_equal(5, max(&User::id, 10))` then
+         *  callable object will be called with 5, &User::id and 10.
+         *  ast_iterator is used mostly in finding literals to be bound to
+         *  a statement. To use it just call `iterate_ast(object, callable);`
+         *  T is an ast element. E.g. where_t
+         */
+        template<class T, class SFINAE = void>
+        struct ast_iterator {
+            using node_type = T;
+
+            /**
+             *  L is a callable type. Mostly is a templated lambda
+             */
+            template<class L>
+            void operator()(const T& t, const L& l) const {
+                l(t);
+            }
+        };
+
+        /**
+         *  Simplified API
+         */
+        template<class T, class L>
+        void iterate_ast(const T& t, const L& l) {
+            ast_iterator<T> iterator;
+            iterator(t, l);
+        }
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class T>
+        struct ast_iterator<as_optional_t<T>, void> {
+            using node_type = as_optional_t<T>;
+
+            template<class L>
+            void operator()(const node_type& node, const L& lambda) const {
+                iterate_ast(node.value, lambda);
+            }
+        };
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+
+        template<class T>
+        struct ast_iterator<std::reference_wrapper<T>, void> {
+            using node_type = std::reference_wrapper<T>;
+
+            template<class L>
+            void operator()(const node_type& expression, const L& lambda) const {
+                iterate_ast(expression.get(), lambda);
+            }
+        };
+
+        template<class... Args>
+        struct ast_iterator<group_by_t<Args...>, void> {
+            using node_type = group_by_t<Args...>;
+
+            template<class L>
+            void operator()(const node_type& expression, const L& lambda) const {
+                iterate_ast(expression.args, lambda);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<excluded_t<T>, void> {
+            using node_type = excluded_t<T>;
+
+            template<class L>
+            void operator()(const node_type& expression, const L& lambda) const {
+                iterate_ast(expression.expression, lambda);
+            }
+        };
+
+        template<class... TargetArgs, class... ActionsArgs>
+        struct ast_iterator<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void> {
+            using node_type = upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>;
+
+            template<class L>
+            void operator()(const node_type& expression, const L& lambda) const {
+                iterate_ast(expression.actions, lambda);
+            }
+        };
+
+        template<class C>
+        struct ast_iterator<where_t<C>, void> {
+            using node_type = where_t<C>;
+
+            template<class L>
+            void operator()(const node_type& expression, const L& lambda) const {
+                iterate_ast(expression.expression, lambda);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<T, typename std::enable_if<is_base_of_template<T, binary_condition>::value>::type> {
+            using node_type = T;
+
+            template<class L>
+            void operator()(const node_type& binaryCondition, const L& l) const {
+                iterate_ast(binaryCondition.l, l);
+                iterate_ast(binaryCondition.r, l);
+            }
+        };
+
+        template<class L, class R, class... Ds>
+        struct ast_iterator<binary_operator<L, R, Ds...>, void> {
+            using node_type = binary_operator<L, R, Ds...>;
+
+            template<class C>
+            void operator()(const node_type& binaryOperator, const C& l) const {
+                iterate_ast(binaryOperator.lhs, l);
+                iterate_ast(binaryOperator.rhs, l);
+            }
+        };
+
+        template<class... Args>
+        struct ast_iterator<columns_t<Args...>, void> {
+            using node_type = columns_t<Args...>;
+
+            template<class L>
+            void operator()(const node_type& cols, const L& l) const {
+                iterate_ast(cols.columns, l);
+            }
+        };
+
+        template<class L, class A>
+        struct ast_iterator<dynamic_in_t<L, A>, void> {
+            using node_type = dynamic_in_t<L, A>;
+
+            template<class C>
+            void operator()(const node_type& in, const C& l) const {
+                iterate_ast(in.left, l);
+                iterate_ast(in.argument, l);
+            }
+        };
+
+        template<class L, class... Args>
+        struct ast_iterator<in_t<L, Args...>, void> {
+            using node_type = in_t<L, Args...>;
+
+            template<class C>
+            void operator()(const node_type& in, const C& l) const {
+                iterate_ast(in.left, l);
+                iterate_ast(in.argument, l);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<std::vector<T>, void> {
+            using node_type = std::vector<T>;
+
+            template<class L>
+            void operator()(const node_type& vec, const L& l) const {
+                for(auto& i: vec) {
+                    iterate_ast(i, l);
+                }
+            }
+        };
+
+        template<>
+        struct ast_iterator<std::vector<char>, void> {
+            using node_type = std::vector<char>;
+
+            template<class L>
+            void operator()(const node_type& vec, const L& l) const {
+                l(vec);
+            }
+        };
+
+        template<class CTE>
+        struct ast_iterator<CTE, match_specialization_of<CTE, common_table_expression>> {
+            using node_type = CTE;
+
+            template<class L>
+            void operator()(const node_type& c, const L& l) const {
+                iterate_ast(c.subselect, l);
+            }
+        };
+
+        template<class With>
+        struct ast_iterator<With, std::enable_if_t<polyfill::is_specialization_of_v<With, with_t>>> {
+            using node_type = With;
+
+            template<class L>
+            void operator()(const node_type& c, const L& l) const {
+                iterate_ast(c.cte, l);
+                iterate_ast(c.expression, l);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
+            using node_type = T;
+
+            template<class L>
+            void operator()(const node_type& c, const L& l) const {
+                iterate_ast(c.left, l);
+                iterate_ast(c.right, l);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<into_t<T>, void> {
+            using node_type = into_t<T>;
+
+            template<class L>
+            void operator()(const node_type& node, const L& l) const {
+                //..
+            }
+        };
+
+        template<class... Args>
+        struct ast_iterator<insert_raw_t<Args...>, void> {
+            using node_type = insert_raw_t<Args...>;
+
+            template<class L>
+            void operator()(const node_type& node, const L& l) const {
+                iterate_ast(node.args, l);
+            }
+        };
+
+        template<class... Args>
+        struct ast_iterator<replace_raw_t<Args...>, void> {
+            using node_type = replace_raw_t<Args...>;
+
+            template<class L>
+            void operator()(const node_type& node, const L& l) const {
+                iterate_ast(node.args, l);
+            }
+        };
+
+        template<class T, class... Args>
+        struct ast_iterator<select_t<T, Args...>, void> {
+            using node_type = select_t<T, Args...>;
+
+            template<class L>
+            void operator()(const node_type& sel, const L& l) const {
+                iterate_ast(sel.col, l);
+                iterate_ast(sel.conditions, l);
+            }
+        };
+
+        template<class T, class R, class... Args>
+        struct ast_iterator<get_all_t<T, R, Args...>, void> {
+            using node_type = get_all_t<T, R, Args...>;
+
+            template<class L>
+            void operator()(const node_type& get, const L& l) const {
+                iterate_ast(get.conditions, l);
+            }
+        };
+
+        template<class T, class... Args>
+        struct ast_iterator<get_all_pointer_t<T, Args...>, void> {
+            using node_type = get_all_pointer_t<T, Args...>;
+
+            template<class L>
+            void operator()(const node_type& get, const L& l) const {
+                iterate_ast(get.conditions, l);
+            }
+        };
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class T, class... Args>
+        struct ast_iterator<get_all_optional_t<T, Args...>, void> {
+            using node_type = get_all_optional_t<T, Args...>;
+
+            template<class L>
+            void operator()(const node_type& get, const L& l) const {
+                iterate_ast(get.conditions, l);
+            }
+        };
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+        template<class... Args, class... Wargs>
+        struct ast_iterator<update_all_t<set_t<Args...>, Wargs...>, void> {
+            using node_type = update_all_t<set_t<Args...>, Wargs...>;
+
+            template<class L>
+            void operator()(const node_type& u, const L& l) const {
+                iterate_ast(u.set, l);
+                iterate_ast(u.conditions, l);
+            }
+        };
+
+        template<class T, class... Args>
+        struct ast_iterator<remove_all_t<T, Args...>, void> {
+            using node_type = remove_all_t<T, Args...>;
+
+            template<class L>
+            void operator()(const node_type& r, const L& l) const {
+                iterate_ast(r.conditions, l);
+            }
+        };
+
+        template<class... Args>
+        struct ast_iterator<set_t<Args...>, void> {
+            using node_type = set_t<Args...>;
+
+            template<class L>
+            void operator()(const node_type& s, const L& l) const {
+                iterate_ast(s.assigns, l);
+            }
+        };
+
+        template<class... Args>
+        struct ast_iterator<std::tuple<Args...>, void> {
+            using node_type = std::tuple<Args...>;
+
+            template<class L>
+            void operator()(const node_type& node, const L& l) const {
+                iterate_tuple(node, [&l](auto& v) {
+                    iterate_ast(v, l);
+                });
+            }
+        };
+
+        template<class T, class... Args>
+        struct ast_iterator<group_by_with_having<T, Args...>, void> {
+            using node_type = group_by_with_having<T, Args...>;
+
+            template<class L>
+            void operator()(const node_type& node, const L& lambda) const {
+                iterate_ast(node.args, lambda);
+                iterate_ast(node.expression, lambda);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<having_t<T>, void> {
+            using node_type = having_t<T>;
+
+            template<class L>
+            void operator()(const node_type& node, const L& lambda) const {
+                iterate_ast(node.expression, lambda);
+            }
+        };
+
+        template<class T, class E>
+        struct ast_iterator<cast_t<T, E>, void> {
+            using node_type = cast_t<T, E>;
+
+            template<class L>
+            void operator()(const node_type& c, const L& l) const {
+                iterate_ast(c.expression, l);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<exists_t<T>, void> {
+            using node_type = exists_t<T>;
+
+            template<class L>
+            void operator()(const node_type& e, const L& l) const {
+                iterate_ast(e.t, l);
+            }
+        };
+
+        template<class A, class T, class E>
+        struct ast_iterator<like_t<A, T, E>, void> {
+            using node_type = like_t<A, T, E>;
+
+            template<class L>
+            void operator()(const node_type& lk, const L& l) const {
+                iterate_ast(lk.arg, l);
+                iterate_ast(lk.pattern, l);
+                lk.arg3.apply([&l](auto& value) {
+                    iterate_ast(value, l);
+                });
+            }
+        };
+
+        template<class A, class T>
+        struct ast_iterator<glob_t<A, T>, void> {
+            using node_type = glob_t<A, T>;
+
+            template<class L>
+            void operator()(const node_type& lk, const L& l) const {
+                iterate_ast(lk.arg, l);
+                iterate_ast(lk.pattern, l);
+            }
+        };
+
+        template<class A, class T>
+        struct ast_iterator<between_t<A, T>, void> {
+            using node_type = between_t<A, T>;
+
+            template<class L>
+            void operator()(const node_type& b, const L& l) const {
+                iterate_ast(b.expr, l);
+                iterate_ast(b.b1, l);
+                iterate_ast(b.b2, l);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<named_collate<T>, void> {
+            using node_type = named_collate<T>;
+
+            template<class L>
+            void operator()(const node_type& col, const L& l) const {
+                iterate_ast(col.expr, l);
+            }
+        };
+
+        template<class C>
+        struct ast_iterator<negated_condition_t<C>, void> {
+            using node_type = negated_condition_t<C>;
+
+            template<class L>
+            void operator()(const node_type& neg, const L& l) const {
+                iterate_ast(neg.c, l);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<is_null_t<T>, void> {
+            using node_type = is_null_t<T>;
+
+            template<class L>
+            void operator()(const node_type& i, const L& l) const {
+                iterate_ast(i.t, l);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<is_not_null_t<T>, void> {
+            using node_type = is_not_null_t<T>;
+
+            template<class L>
+            void operator()(const node_type& i, const L& l) const {
+                iterate_ast(i.t, l);
+            }
+        };
+
+        template<class F, class... Args>
+        struct ast_iterator<function_call<F, Args...>, void> {
+            using node_type = function_call<F, Args...>;
+
+            template<class L>
+            void operator()(const node_type& f, const L& l) const {
+                iterate_ast(f.args, l);
+            }
+        };
+
+        template<class R, class S, class... Args>
+        struct ast_iterator<built_in_function_t<R, S, Args...>, void> {
+            using node_type = built_in_function_t<R, S, Args...>;
+
+            template<class L>
+            void operator()(const node_type& f, const L& l) const {
+                iterate_ast(f.args, l);
+            }
+        };
+
+        template<class T, class O>
+        struct ast_iterator<left_join_t<T, O>, void> {
+            using node_type = left_join_t<T, O>;
+
+            template<class L>
+            void operator()(const node_type& j, const L& l) const {
+                iterate_ast(j.constraint, l);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<on_t<T>, void> {
+            using node_type = on_t<T>;
+
+            template<class L>
+            void operator()(const node_type& o, const L& l) const {
+                iterate_ast(o.arg, l);
+            }
+        };
+
+        template<class T, class O>
+        struct ast_iterator<join_t<T, O>, void> {
+            using node_type = join_t<T, O>;
+
+            template<class L>
+            void operator()(const node_type& j, const L& l) const {
+                iterate_ast(j.constraint, l);
+            }
+        };
+
+        template<class T, class O>
+        struct ast_iterator<left_outer_join_t<T, O>, void> {
+            using node_type = left_outer_join_t<T, O>;
+
+            template<class L>
+            void operator()(const node_type& j, const L& l) const {
+                iterate_ast(j.constraint, l);
+            }
+        };
+
+        template<class T, class O>
+        struct ast_iterator<inner_join_t<T, O>, void> {
+            using node_type = inner_join_t<T, O>;
+
+            template<class L>
+            void operator()(const node_type& j, const L& l) const {
+                iterate_ast(j.constraint, l);
+            }
+        };
+
+        template<class R, class T, class E, class... Args>
+        struct ast_iterator<simple_case_t<R, T, E, Args...>, void> {
+            using node_type = simple_case_t<R, T, E, Args...>;
+
+            template<class L>
+            void operator()(const node_type& c, const L& l) const {
+                c.case_expression.apply([&l](auto& c_) {
+                    iterate_ast(c_, l);
+                });
+                iterate_tuple(c.args, [&l](auto& pair) {
+                    iterate_ast(pair.first, l);
+                    iterate_ast(pair.second, l);
+                });
+                c.else_expression.apply([&l](auto& el) {
+                    iterate_ast(el, l);
+                });
+            }
+        };
+
+        template<class T, class E>
+        struct ast_iterator<as_t<T, E>, void> {
+            using node_type = as_t<T, E>;
+
+            template<class L>
+            void operator()(const node_type& a, const L& l) const {
+                iterate_ast(a.expression, l);
+            }
+        };
+
+        template<class T, bool OI>
+        struct ast_iterator<limit_t<T, false, OI, void>, void> {
+            using node_type = limit_t<T, false, OI, void>;
+
+            template<class L>
+            void operator()(const node_type& a, const L& l) const {
+                iterate_ast(a.lim, l);
+            }
+        };
+
+        template<class T, class O>
+        struct ast_iterator<limit_t<T, true, false, O>, void> {
+            using node_type = limit_t<T, true, false, O>;
+
+            template<class L>
+            void operator()(const node_type& a, const L& l) const {
+                iterate_ast(a.lim, l);
+                a.off.apply([&l](auto& value) {
+                    iterate_ast(value, l);
+                });
+            }
+        };
+
+        template<class T, class O>
+        struct ast_iterator<limit_t<T, true, true, O>, void> {
+            using node_type = limit_t<T, true, true, O>;
+
+            template<class L>
+            void operator()(const node_type& a, const L& l) const {
+                a.off.apply([&l](auto& value) {
+                    iterate_ast(value, l);
+                });
+                iterate_ast(a.lim, l);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<distinct_t<T>, void> {
+            using node_type = distinct_t<T>;
+
+            template<class L>
+            void operator()(const node_type& a, const L& l) const {
+                iterate_ast(a.value, l);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<all_t<T>, void> {
+            using node_type = all_t<T>;
+
+            template<class L>
+            void operator()(const node_type& a, const L& l) const {
+                iterate_ast(a.value, l);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<bitwise_not_t<T>, void> {
+            using node_type = bitwise_not_t<T>;
+
+            template<class L>
+            void operator()(const node_type& a, const L& l) const {
+                iterate_ast(a.argument, l);
+            }
+        };
+
+        template<class... Args>
+        struct ast_iterator<values_t<Args...>, void> {
+            using node_type = values_t<Args...>;
+
+            template<class L>
+            void operator()(const node_type& node, const L& l) const {
+                iterate_ast(node.tuple, l);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<dynamic_values_t<T>, void> {
+            using node_type = dynamic_values_t<T>;
+
+            template<class L>
+            void operator()(const node_type& node, const L& l) const {
+                iterate_ast(node.vector, l);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<order_by_t<T>, void> {
+            using node_type = order_by_t<T>;
+
+            template<class L>
+            void operator()(const node_type& node, const L& l) const {
+                iterate_ast(node.expression, l);
+            }
+        };
+
+        template<class T>
+        struct ast_iterator<collate_t<T>, void> {
+            using node_type = collate_t<T>;
+
+            template<class L>
+            void operator()(const node_type& node, const L& l) const {
+                iterate_ast(node.expr, l);
+            }
+        };
+
+    }
+}
+
+// #include "prepared_statement.h"
+
+// #include "connection_holder.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         * This class does not related to SQL view. This is a container like class which is returned by
+         * by storage_t::iterate function. This class contains STL functions:
+         *  -   size_t size()
+         *  -   bool empty()
+         *  -   iterator end()
+         *  -   iterator begin()
+         *  All these functions are not right const cause all of them may open SQLite connections.
+         */
+        template<class T, class S, class... Args>
+        struct view_t {
+            using mapped_type = T;
+            using storage_type = S;
+            using self = view_t<T, S, Args...>;
+
+            storage_type& storage;
+            connection_ref connection;
+            get_all_t<T, std::vector<T>, Args...> args;
+
+            view_t(storage_type& stor, decltype(connection) conn, Args&&... args_) :
+                storage(stor), connection(std::move(conn)), args{std::make_tuple(std::forward<Args>(args_)...)} {}
+
+            size_t size() const {
+                return this->storage.template count<T>();
+            }
+
+            bool empty() const {
+                return !this->size();
+            }
+
+            iterator_t<self> begin() {
+                sqlite3_stmt* stmt = nullptr;
+                auto db = this->connection.get();
+                using context_t = serializator_context<typename storage_type::impl_type>;
+                context_t context{obtain_const_impl(this->storage)};
+                context.skip_table_name = false;
+                context.replace_bindable_with_question = true;
+                auto query = serialize(this->args, context);
+                auto ret = sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr);
+                if(ret == SQLITE_OK) {
+                    auto index = 1;
+                    iterate_ast(this->args.conditions, [&index, stmt, db](auto& node) {
+                        using node_type = typename std::decay<decltype(node)>::type;
+                        conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
+                        if(SQLITE_OK != binder(node)) {
+                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                    sqlite3_errmsg(db));
+                        }
+                    });
+                    return {stmt, *this};
+                } else {
+                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                            sqlite3_errmsg(db));
+                }
+            }
+
+            iterator_t<self> end() {
+                return {};
+            }
+        };
+    }
+}
+
+// #include "ast_iterator.h"
+
+// #include "storage_base.h"
+
+#include <functional>  //  std::function, std::bind
+#include <sqlite3.h>
+#include <string>  //  std::string
+#include <sstream>  //  std::stringstream
+#include <utility>  //  std::move
+#include <system_error>  //  std::system_error, std::error_code, std::make_error_code
+#include <vector>  //  std::vector
+#include <memory>  //  std::make_shared, std::shared_ptr
+#include <map>  //  std::map
+#include <type_traits>  //  std::decay, std::is_same
+#include <algorithm>  //  std::iter_swap
+
+// #include "pragma.h"
+
+#include <string>  //  std::string
+#include <sqlite3.h>
+#include <functional>  //  std::function
+#include <memory>  // std::shared_ptr
+#include <vector>  //  std::vector
+
+// #include "error_code.h"
+
+// #include "util.h"
+
+// #include "row_extractor.h"
+
+// #include "journal_mode.h"
+
+// #include "connection_holder.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+        struct storage_base;
+
+        template<class T>
+        int getPragmaCallback(void* data, int argc, char** argv, char**) {
+            auto& res = *(T*)data;
+            if(argc) {
+                res = row_extractor<T>().extract(argv[0]);
+            }
+            return 0;
+        }
+
+        template<>
+        inline int getPragmaCallback<std::vector<std::string>>(void* data, int argc, char** argv, char**) {
+            auto& res = *(std::vector<std::string>*)data;
+            res.reserve(argc);
+            for(decltype(argc) i = 0; i < argc; ++i) {
+                auto rowString = row_extractor<std::string>().extract(argv[i]);
+                res.push_back(move(rowString));
+            }
+            return 0;
+        }
+
+        struct pragma_t {
+            using get_connection_t = std::function<internal::connection_ref()>;
+
+            pragma_t(get_connection_t get_connection_) : get_connection(move(get_connection_)) {}
+
+            void busy_timeout(int value) {
+                this->set_pragma("busy_timeout", value);
+            }
+
+            int busy_timeout() {
+                return this->get_pragma<int>("busy_timeout");
+            }
+
+            sqlite_orm::journal_mode journal_mode() {
+                return this->get_pragma<sqlite_orm::journal_mode>("journal_mode");
+            }
+
+            void journal_mode(sqlite_orm::journal_mode value) {
+                this->_journal_mode = -1;
+                this->set_pragma("journal_mode", value);
+                this->_journal_mode = static_cast<decltype(this->_journal_mode)>(value);
+            }
+
+            /**
+             *  https://www.sqlite.org/pragma.html#pragma_application_id
+             */
+            int application_id() {
+                return this->get_pragma<int>("application_id");
+            }
+
+            /**
+             *  https://www.sqlite.org/pragma.html#pragma_application_id
+             */
+            void application_id(int value) {
+                this->set_pragma("application_id", value);
+            }
+
+            int synchronous() {
+                return this->get_pragma<int>("synchronous");
+            }
+
+            void synchronous(int value) {
+                this->_synchronous = -1;
+                this->set_pragma("synchronous", value);
+                this->_synchronous = value;
+            }
+
+            int user_version() {
+                return this->get_pragma<int>("user_version");
+            }
+
+            void user_version(int value) {
+                this->set_pragma("user_version", value);
+            }
+
+            int auto_vacuum() {
+                return this->get_pragma<int>("auto_vacuum");
+            }
+
+            void auto_vacuum(int value) {
+                this->set_pragma("auto_vacuum", value);
+            }
+
+            std::vector<std::string> integrity_check() {
+                return this->get_pragma<std::vector<std::string>>("integrity_check");
+            }
+
+            template<class T>
+            std::vector<std::string> integrity_check(T table_name) {
+                std::ostringstream oss;
+                oss << "integrity_check(" << table_name << ")";
+                return this->get_pragma<std::vector<std::string>>(oss.str());
+            }
+
+            std::vector<std::string> integrity_check(int n) {
+                std::ostringstream oss;
+                oss << "integrity_check(" << n << ")";
+                return this->get_pragma<std::vector<std::string>>(oss.str());
+            }
+
+          private:
+            friend struct storage_base;
+
+            int _synchronous = -1;
+            signed char _journal_mode = -1;  //  if != -1 stores static_cast<sqlite_orm::journal_mode>(journal_mode)
+            get_connection_t get_connection;
+
+            template<class T>
+            T get_pragma(const std::string& name) {
+                auto connection = this->get_connection();
+                auto query = "PRAGMA " + name;
+                T result;
+                auto db = connection.get();
+                auto rc = sqlite3_exec(db, query.c_str(), getPragmaCallback<T>, &result, nullptr);
+                if(rc == SQLITE_OK) {
+                    return result;
+                } else {
+                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                            sqlite3_errmsg(db));
+                }
+            }
+
+            /**
+             *  Yevgeniy Zakharov: I wanted to refactor this function with statements and value bindings
+             *  but it turns out that bindings in pragma statements are not supported.
+             */
+            template<class T>
+            void set_pragma(const std::string& name, const T& value, sqlite3* db = nullptr) {
+                auto con = this->get_connection();
+                if(!db) {
+                    db = con.get();
+                }
+                std::stringstream ss;
+                ss << "PRAGMA " << name << " = " << value;
+                internal::perform_void_exec(db, ss.str());
+            }
+
+            void set_pragma(const std::string& name, const sqlite_orm::journal_mode& value, sqlite3* db = nullptr) {
+                auto con = this->get_connection();
+                if(!db) {
+                    db = con.get();
+                }
+                std::stringstream ss;
+                ss << "PRAGMA " << name << " = " << internal::to_string(value);
+                internal::perform_void_exec(db, ss.str());
+            }
+        };
+    }
+}
+
+// #include "limit_accesor.h"
+
+#include <sqlite3.h>
+#include <map>  //  std::map
+#include <functional>  //  std::function
+#include <memory>  //  std::shared_ptr
+
+// #include "connection_holder.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        struct limit_accesor {
+            using get_connection_t = std::function<connection_ref()>;
+
+            limit_accesor(get_connection_t get_connection_) : get_connection(std::move(get_connection_)) {}
+
+            int length() {
+                return this->get(SQLITE_LIMIT_LENGTH);
+            }
+
+            void length(int newValue) {
+                this->set(SQLITE_LIMIT_LENGTH, newValue);
+            }
+
+            int sql_length() {
+                return this->get(SQLITE_LIMIT_SQL_LENGTH);
+            }
+
+            void sql_length(int newValue) {
+                this->set(SQLITE_LIMIT_SQL_LENGTH, newValue);
+            }
+
+            int column() {
+                return this->get(SQLITE_LIMIT_COLUMN);
+            }
+
+            void column(int newValue) {
+                this->set(SQLITE_LIMIT_COLUMN, newValue);
+            }
+
+            int expr_depth() {
+                return this->get(SQLITE_LIMIT_EXPR_DEPTH);
+            }
+
+            void expr_depth(int newValue) {
+                this->set(SQLITE_LIMIT_EXPR_DEPTH, newValue);
+            }
+
+            int compound_select() {
+                return this->get(SQLITE_LIMIT_COMPOUND_SELECT);
+            }
+
+            void compound_select(int newValue) {
+                this->set(SQLITE_LIMIT_COMPOUND_SELECT, newValue);
+            }
+
+            int vdbe_op() {
+                return this->get(SQLITE_LIMIT_VDBE_OP);
+            }
+
+            void vdbe_op(int newValue) {
+                this->set(SQLITE_LIMIT_VDBE_OP, newValue);
+            }
+
+            int function_arg() {
+                return this->get(SQLITE_LIMIT_FUNCTION_ARG);
+            }
+
+            void function_arg(int newValue) {
+                this->set(SQLITE_LIMIT_FUNCTION_ARG, newValue);
+            }
+
+            int attached() {
+                return this->get(SQLITE_LIMIT_ATTACHED);
+            }
+
+            void attached(int newValue) {
+                this->set(SQLITE_LIMIT_ATTACHED, newValue);
+            }
+
+            int like_pattern_length() {
+                return this->get(SQLITE_LIMIT_LIKE_PATTERN_LENGTH);
+            }
+
+            void like_pattern_length(int newValue) {
+                this->set(SQLITE_LIMIT_LIKE_PATTERN_LENGTH, newValue);
+            }
+
+            int variable_number() {
+                return this->get(SQLITE_LIMIT_VARIABLE_NUMBER);
+            }
+
+            void variable_number(int newValue) {
+                this->set(SQLITE_LIMIT_VARIABLE_NUMBER, newValue);
+            }
+
+            int trigger_depth() {
+                return this->get(SQLITE_LIMIT_TRIGGER_DEPTH);
+            }
+
+            void trigger_depth(int newValue) {
+                this->set(SQLITE_LIMIT_TRIGGER_DEPTH, newValue);
+            }
+
+#if SQLITE_VERSION_NUMBER >= 3008007
+            int worker_threads() {
+                return this->get(SQLITE_LIMIT_WORKER_THREADS);
+            }
+
+            void worker_threads(int newValue) {
+                this->set(SQLITE_LIMIT_WORKER_THREADS, newValue);
+            }
+#endif
+
+          protected:
+            get_connection_t get_connection;
+
+            friend struct storage_base;
+
+            /**
+             *  Stores limit set between connections.
+             */
+            std::map<int, int> limits;
+
+            int get(int id) {
+                auto connection = this->get_connection();
+                return sqlite3_limit(connection.get(), id, -1);
+            }
+
+            void set(int id, int newValue) {
+                this->limits[id] = newValue;
+                auto connection = this->get_connection();
+                sqlite3_limit(connection.get(), id, newValue);
+            }
+        };
+    }
+}
+
+// #include "transaction_guard.h"
+
+#include <functional>  //  std::function
+
+// #include "connection_holder.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  Class used as a guard for a transaction. Calls `ROLLBACK` in destructor.
+         *  Has explicit `commit()` and `rollback()` functions. After explicit function is fired
+         *  guard won't do anything in d-tor. Also you can set `commit_on_destroy` to true to
+         *  make it call `COMMIT` on destroy.
+         */
+        struct transaction_guard_t {
+            /**
+             *  This is a public lever to tell a guard what it must do in its destructor
+             *  if `gotta_fire` is true
+             */
+            bool commit_on_destroy = false;
+
+            transaction_guard_t(connection_ref connection_,
+                                std::function<void()> commit_func_,
+                                std::function<void()> rollback_func_) :
+                connection(std::move(connection_)),
+                commit_func(std::move(commit_func_)), rollback_func(std::move(rollback_func_)) {}
+
+            ~transaction_guard_t() {
+                if(this->gotta_fire) {
+                    if(!this->commit_on_destroy) {
+                        this->rollback_func();
+                    } else {
+                        this->commit_func();
+                    }
+                }
+            }
+
+            /**
+             *  Call `COMMIT` explicitly. After this call
+             *  guard will not call `COMMIT` or `ROLLBACK`
+             *  in its destructor.
+             */
+            void commit() {
+                this->commit_func();
+                this->gotta_fire = false;
+            }
+
+            /**
+             *  Call `ROLLBACK` explicitly. After this call
+             *  guard will not call `COMMIT` or `ROLLBACK`
+             *  in its destructor.
+             */
+            void rollback() {
+                this->rollback_func();
+                this->gotta_fire = false;
+            }
+
+          protected:
+            connection_ref connection;
+            std::function<void()> commit_func;
+            std::function<void()> rollback_func;
+            bool gotta_fire = true;
+        };
+    }
+}
+
+// #include "statement_finalizer.h"
+
+// #include "type_printer.h"
+
+// #include "tuple_helper/tuple_helper.h"
+
+// #include "row_extractor.h"
+
+// #include "util.h"
+
+// #include "connection_holder.h"
+
+// #include "backup.h"
+
+#include <sqlite3.h>
+#include <string>  //  std::string
+#include <memory>
+
+// #include "error_code.h"
+
+// #include "connection_holder.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  A backup class. Don't construct it as is, call storage.make_backup_from or storage.make_backup_to instead.
+         *  An instance of this class represents a wrapper around sqlite3_backup pointer. Use this class
+         *  to have maximum control on a backup operation. In case you need a single backup in one line you
+         *  can skip creating a backup_t instance and just call storage.backup_from or storage.backup_to function.
+         */
+        struct backup_t {
+            backup_t(connection_ref to_,
+                     const std::string& zDestName,
+                     connection_ref from_,
+                     const std::string& zSourceName,
+                     std::unique_ptr<connection_holder> holder_) :
+                handle(sqlite3_backup_init(to_.get(), zDestName.c_str(), from_.get(), zSourceName.c_str())),
+                holder(move(holder_)), to(to_), from(from_) {
+                if(!this->handle) {
+                    throw std::system_error(std::make_error_code(orm_error_code::failed_to_init_a_backup));
+                }
+            }
+
+            backup_t(backup_t&& other) :
+                handle(other.handle), holder(move(other.holder)), to(other.to), from(other.from) {
+                other.handle = nullptr;
+            }
+
+            ~backup_t() {
+                if(this->handle) {
+                    (void)sqlite3_backup_finish(this->handle);
+                    this->handle = nullptr;
+                }
+            }
+
+            /**
+             *  Calls sqlite3_backup_step with pages argument
+             */
+            int step(int pages) {
+                return sqlite3_backup_step(this->handle, pages);
+            }
+
+            /**
+             *  Returns sqlite3_backup_remaining result
+             */
+            int remaining() const {
+                return sqlite3_backup_remaining(this->handle);
+            }
+
+            /**
+             *  Returns sqlite3_backup_pagecount result
+             */
+            int pagecount() const {
+                return sqlite3_backup_pagecount(this->handle);
+            }
+
+          protected:
+            sqlite3_backup* handle = nullptr;
+            std::unique_ptr<connection_holder> holder;
+            connection_ref to;
+            connection_ref from;
+        };
+    }
+}
+
+// #include "function.h"
+
+// #include "values_to_tuple.h"
+
+#include <sqlite3.h>
+#include <tuple>  //  std::get, std::tuple_element
+
+// #include "row_extractor.h"
+
+// #include "arg_values.h"
+
+#include <sqlite3.h>
+
+// #include "row_extractor.h"
+
+namespace sqlite_orm {
+
+    struct arg_value {
+
+        arg_value() : arg_value(nullptr) {}
+
+        arg_value(sqlite3_value* value_) : value(value_) {}
+
+        template<class T>
+        T get() const {
+            return row_extractor<T>().extract(this->value);
+        }
+
+        bool is_null() const {
+            auto type = sqlite3_value_type(this->value);
+            return type == SQLITE_NULL;
+        }
+
+        bool is_text() const {
+            auto type = sqlite3_value_type(this->value);
+            return type == SQLITE_TEXT;
+        }
+
+        bool is_integer() const {
+            auto type = sqlite3_value_type(this->value);
+            return type == SQLITE_INTEGER;
+        }
+
+        bool is_float() const {
+            auto type = sqlite3_value_type(this->value);
+            return type == SQLITE_FLOAT;
+        }
+
+        bool is_blob() const {
+            auto type = sqlite3_value_type(this->value);
+            return type == SQLITE_BLOB;
+        }
+
+        bool empty() const {
+            return this->value == nullptr;
+        }
+
+      private:
+        sqlite3_value* value = nullptr;
+    };
+
+    struct arg_values {
+
+        struct iterator {
+
+            iterator(const arg_values& container_, int index_) :
+                container(container_), index(index_),
+                currentValue(index_ < int(container_.size()) ? container_[index_] : arg_value()) {}
+
+            iterator& operator++() {
+                ++this->index;
+                if(this->index < int(this->container.size())) {
+                    this->currentValue = this->container[this->index];
+                } else {
+                    this->currentValue = {};
+                }
+                return *this;
+            }
+
+            iterator operator++(int) {
+                auto res = *this;
+                ++this->index;
+                if(this->index < int(this->container.size())) {
+                    this->currentValue = this->container[this->index];
+                } else {
+                    this->currentValue = {};
+                }
+                return res;
+            }
+
+            arg_value operator*() const {
+                if(this->index < int(this->container.size()) && this->index >= 0) {
+                    return this->currentValue;
+                } else {
+                    throw std::system_error(std::make_error_code(orm_error_code::index_is_out_of_bounds));
+                }
+            }
+
+            arg_value* operator->() const {
+                return &this->currentValue;
+            }
+
+            bool operator==(const iterator& other) const {
+                return &other.container == &this->container && other.index == this->index;
+            }
+
+            bool operator!=(const iterator& other) const {
+                return !(*this == other);
+            }
+
+          private:
+            const arg_values& container;
+            int index = 0;
+            mutable arg_value currentValue;
+        };
+
+        arg_values() : arg_values(0, nullptr) {}
+
+        arg_values(int argsCount_, sqlite3_value** values_) : argsCount(argsCount_), values(values_) {}
+
+        size_t size() const {
+            return this->argsCount;
+        }
+
+        bool empty() const {
+            return 0 == this->argsCount;
+        }
+
+        arg_value operator[](int index) const {
+            if(index < this->argsCount && index >= 0) {
+                auto valuePointer = this->values[index];
+                return {valuePointer};
+            } else {
+                throw std::system_error(std::make_error_code(orm_error_code::index_is_out_of_bounds));
+            }
+        }
+
+        arg_value at(int index) const {
+            return this->operator[](index);
+        }
+
+        iterator begin() const {
+            return {*this, 0};
+        }
+
+        iterator end() const {
+            return {*this, this->argsCount};
+        }
+
+      private:
+        int argsCount = 0;
+        sqlite3_value** values = nullptr;
+    };
+}
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  T is a std::tuple type
+         *  I is index to extract value from values C array to tuple. I must me < std::tuple_size<T>::value
+         */
+        template<class T, size_t I>
+        struct values_to_tuple {
+
+            void extract(sqlite3_value** values, T& tuple, int argsCount) const {
+                using element_type = typename std::tuple_element<I, T>::type;
+                std::get<I>(tuple) = row_extractor<element_type>().extract(values[I]);
+
+                values_to_tuple<T, I - 1>().extract(values, tuple, argsCount);
+            }
+        };
+
+        template<class T>
+        struct values_to_tuple<T, size_t(-1)> {
+            void extract(sqlite3_value** values, T& tuple, int argsCount) const {
+                //..
+            }
+        };
+
+        template<>
+        struct values_to_tuple<std::tuple<arg_values>, 0> {
+            void extract(sqlite3_value** values, std::tuple<arg_values>& tuple, int argsCount) const {
+                std::get<0>(tuple) = arg_values(argsCount, values);
+            }
+        };
+    }
+}
+
+// #include "arg_values.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        struct storage_base {
+            using collating_function = std::function<int(int, const void*, int, const void*)>;
+
+            std::function<void(sqlite3*)> on_open;
+            pragma_t pragma;
+            limit_accesor limit;
+
+            transaction_guard_t transaction_guard() {
+                this->begin_transaction();
+                auto commitFunc = std::bind(static_cast<void (storage_base::*)()>(&storage_base::commit), this);
+                auto rollbackFunc = std::bind(static_cast<void (storage_base::*)()>(&storage_base::rollback), this);
+                return {this->get_connection(), move(commitFunc), move(rollbackFunc)};
+            }
+
+            void drop_index(const std::string& indexName) {
+                std::stringstream ss;
+                ss << "DROP INDEX '" << indexName + "'";
+                perform_void_exec(get_connection().get(), ss.str());
+            }
+
+            void vacuum() {
+                perform_void_exec(get_connection().get(), "VACUUM");
+            }
+
+            /**
+             *  Drops table with given name.
+             */
+            void drop_table(const std::string& tableName) {
+                auto con = this->get_connection();
+                this->drop_table_internal(tableName, con.get());
+            }
+
+            /**
+             * Rename table named `from` to `to`.
+             */
+            void rename_table(const std::string& from, const std::string& to) {
+                std::stringstream ss;
+                ss << "ALTER TABLE '" << from << "' RENAME TO '" << to << "'";
+                perform_void_exec(get_connection().get(), ss.str());
+            }
+
+            /**
+             *  sqlite3_changes function.
+             */
+            int changes() {
+                auto con = this->get_connection();
+                return sqlite3_changes(con.get());
+            }
+
+            /**
+             *  sqlite3_total_changes function.
+             */
+            int total_changes() {
+                auto con = this->get_connection();
+                return sqlite3_total_changes(con.get());
+            }
+
+            int64 last_insert_rowid() {
+                auto con = this->get_connection();
+                return sqlite3_last_insert_rowid(con.get());
+            }
+
+            int busy_timeout(int ms) {
+                auto con = this->get_connection();
+                return sqlite3_busy_timeout(con.get(), ms);
+            }
+
+            /**
+             *  Returns libsqltie3 lib version, not sqlite_orm
+             */
+            std::string libversion() {
+                return sqlite3_libversion();
+            }
+
+            bool transaction(const std::function<bool()>& f) {
+                auto guard = transaction_guard();
+                auto shouldCommit = f();
+                if(shouldCommit) {
+                    guard.commit();
+                } else {
+                    guard.rollback();
+                }
+                return shouldCommit;
+            }
+
+            std::string current_timestamp() {
+                auto con = this->get_connection();
+                return this->current_timestamp(con.get());
+            }
+
+#if SQLITE_VERSION_NUMBER >= 3007010
+            /**
+             * \fn db_release_memory
+             * \brief Releases freeable memory of database. It is function can/should be called periodically by
+             * application, if application has less memory usage constraint. \note sqlite3_db_release_memory added
+             * in 3.7.10 https://sqlite.org/changes.html
+             */
+            int db_release_memory() {
+                auto con = this->get_connection();
+                return sqlite3_db_release_memory(con.get());
+            }
+#endif
+
+            /**
+             *  Returns existing permanent table names in database. Doesn't check storage itself - works only with
+             * actual database.
+             *  @return Returns list of tables in database.
+             */
+            std::vector<std::string> table_names() {
+                auto con = this->get_connection();
+                std::vector<std::string> tableNames;
+                std::string sql = "SELECT name FROM sqlite_master WHERE type='table'";
+                using data_t = std::vector<std::string>;
+                auto db = con.get();
+                int res = sqlite3_exec(
+                    db,
+                    sql.c_str(),
+                    [](void* data, int argc, char** argv, char** /*columnName*/) -> int {
+                        auto& tableNames_ = *(data_t*)data;
+                        for(int i = 0; i < argc; i++) {
+                            if(argv[i]) {
+                                tableNames_.push_back(argv[i]);
+                            }
+                        }
+                        return 0;
+                    },
+                    &tableNames,
+                    nullptr);
+
+                if(res != SQLITE_OK) {
+                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                            sqlite3_errmsg(db));
+                }
+                return tableNames;
+            }
+
+            void open_forever() {
+                this->isOpenedForever = true;
+                this->connection->retain();
+                if(1 == this->connection->retain_count()) {
+                    this->on_open_internal(this->connection->get());
+                }
+            }
+
+            /**
+             * Call this to create user defined scalar function. Can be called at any time no matter connection is opened or no.
+             * T - function class. T must have operator() overload and static name function like this:
+             * ```
+             *  struct SqrtFunction {
+             *
+             *      double operator()(double arg) const {
+             *          return std::sqrt(arg);
+             *      }
+             *
+             *      static const char *name() {
+             *          return "SQRT";
+             *      }
+             *  };
+             * ```
+             */
+            template<class F>
+            void create_scalar_function() {
+                static_assert(is_scalar_function<F>::value, "F cannot be a scalar function");
+
+                std::stringstream ss;
+                ss << F::name();
+                auto name = ss.str();
+                using args_tuple = typename callable_arguments<F>::args_tuple;
+                using return_type = typename callable_arguments<F>::return_type;
+                auto argsCount = int(std::tuple_size<args_tuple>::value);
+                if(std::is_same<args_tuple, std::tuple<arg_values>>::value) {
+                    argsCount = -1;
+                }
+                this->scalarFunctions.emplace_back(new scalar_function_t{
+                    move(name),
+                    argsCount,
+                    []() -> int* {
+                        return (int*)(new F());
+                    },
+                    /* call = */
+                    [](sqlite3_context* context, void* functionVoidPointer, int argsCount, sqlite3_value** values) {
+                        auto& functionPointer = *static_cast<F*>(functionVoidPointer);
+                        args_tuple argsTuple;
+                        using tuple_size = std::tuple_size<args_tuple>;
+                        values_to_tuple<args_tuple, tuple_size::value - 1>().extract(values, argsTuple, argsCount);
+                        auto result = call(functionPointer, std::move(argsTuple));
+                        statement_binder<return_type>().result(context, result);
+                    },
+                    delete_function_callback<F>,
+                });
+
+                if(this->connection->retain_count() > 0) {
+                    auto db = this->connection->get();
+                    try_to_create_function(db, static_cast<scalar_function_t&>(*this->scalarFunctions.back()));
+                }
+            }
+
+            /**
+             * Call this to create user defined aggregate function. Can be called at any time no matter connection is opened or no.
+             * T - function class. T must have step member function, fin member function and static name function like this:
+             * ```
+             *   struct MeanFunction {
+             *       double total = 0;
+             *       int count = 0;
+             *
+             *       void step(double value) {
+             *           total += value;
+             *           ++count;
+             *       }
+             *
+             *       int fin() const {
+             *           return total / count;
+             *       }
+             *
+             *       static std::string name() {
+             *           return "MEAN";
+             *       }
+             *   };
+             * ```
+             */
+            template<class F>
+            void create_aggregate_function() {
+                static_assert(is_aggregate_function<F>::value, "F cannot be an aggregate function");
+
+                std::stringstream ss;
+                ss << F::name();
+                auto name = ss.str();
+                using args_tuple = typename callable_arguments<F>::args_tuple;
+                using return_type = typename callable_arguments<F>::return_type;
+                auto argsCount = int(std::tuple_size<args_tuple>::value);
+                if(std::is_same<args_tuple, std::tuple<arg_values>>::value) {
+                    argsCount = -1;
+                }
+                this->aggregateFunctions.emplace_back(new aggregate_function_t{
+                    move(name),
+                    argsCount,
+                    /* create = */
+                    []() -> int* {
+                        return (int*)(new F());
+                    },
+                    /* step = */
+                    [](sqlite3_context* context, void* functionVoidPointer, int argsCount, sqlite3_value** values) {
+                        auto& functionPointer = *static_cast<F*>(functionVoidPointer);
+                        args_tuple argsTuple;
+                        using tuple_size = std::tuple_size<args_tuple>;
+                        values_to_tuple<args_tuple, tuple_size::value - 1>().extract(values, argsTuple, argsCount);
+                        call(functionPointer, &F::step, move(argsTuple));
+                    },
+                    /* finalCall = */
+                    [](sqlite3_context* context, void* functionVoidPointer) {
+                        auto& functionPointer = *static_cast<F*>(functionVoidPointer);
+                        auto result = functionPointer.fin();
+                        statement_binder<return_type>().result(context, result);
+                    },
+                    delete_function_callback<F>,
+                });
+
+                if(this->connection->retain_count() > 0) {
+                    auto db = this->connection->get();
+                    try_to_create_function(db, static_cast<aggregate_function_t&>(*this->aggregateFunctions.back()));
+                }
+            }
+
+            /**
+             *  Use it to delete scalar function you created before. Can be called at any time no matter connection is open or no.
+             */
+            template<class F>
+            void delete_scalar_function() {
+                static_assert(is_scalar_function<F>::value, "F cannot be a scalar function");
+                std::stringstream ss;
+                ss << F::name();
+                auto name = ss.str();
+                this->delete_function_impl(name, this->scalarFunctions);
+            }
+
+            /**
+             *  Use it to delete aggregate function you created before. Can be called at any time no matter connection is open or no.
+             */
+            template<class F>
+            void delete_aggregate_function() {
+                static_assert(is_aggregate_function<F>::value, "F cannot be an aggregate function");
+                std::stringstream ss;
+                ss << F::name();
+                auto name = ss.str();
+                this->delete_function_impl(name, this->aggregateFunctions);
+            }
+
+            template<class C>
+            void create_collation() {
+                collating_function func = [](int leftLength, const void* lhs, int rightLength, const void* rhs) {
+                    C collatingObject;
+                    return collatingObject(leftLength, lhs, rightLength, rhs);
+                };
+                std::stringstream ss;
+                ss << C::name();
+                auto name = ss.str();
+                ss.flush();
+                this->create_collation(name, move(func));
+            }
+
+            void create_collation(const std::string& name, collating_function f) {
+                collating_function* functionPointer = nullptr;
+                const auto functionExists = bool(f);
+                if(functionExists) {
+                    functionPointer = &(collatingFunctions[name] = std::move(f));
+                } else {
+                    collatingFunctions.erase(name);
+                }
+
+                //  create collations if db is open
+                if(this->connection->retain_count() > 0) {
+                    auto db = this->connection->get();
+                    auto resultCode = sqlite3_create_collation(db,
+                                                               name.c_str(),
+                                                               SQLITE_UTF8,
+                                                               functionPointer,
+                                                               functionExists ? collate_callback : nullptr);
+                    if(resultCode != SQLITE_OK) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                }
+            }
+
+            template<class C>
+            void delete_collation() {
+                std::stringstream ss;
+                ss << C::name();
+                auto name = ss.str();
+                ss.flush();
+                this->create_collation(name, {});
+            }
+
+            void begin_transaction() {
+                this->connection->retain();
+                if(1 == this->connection->retain_count()) {
+                    this->on_open_internal(this->connection->get());
+                }
+                auto db = this->connection->get();
+                perform_void_exec(db, "BEGIN TRANSACTION");
+            }
+
+            void commit() {
+                auto db = this->connection->get();
+                perform_void_exec(db, "COMMIT");
+                this->connection->release();
+                if(this->connection->retain_count() < 0) {
+                    throw std::system_error(std::make_error_code(orm_error_code::no_active_transaction));
+                }
+            }
+
+            void rollback() {
+                auto db = this->connection->get();
+                perform_void_exec(db, "ROLLBACK");
+                this->connection->release();
+                if(this->connection->retain_count() < 0) {
+                    throw std::system_error(std::make_error_code(orm_error_code::no_active_transaction));
+                }
+            }
+
+            void backup_to(const std::string& filename) {
+                auto backup = this->make_backup_to(filename);
+                backup.step(-1);
+            }
+
+            void backup_to(storage_base& other) {
+                auto backup = this->make_backup_to(other);
+                backup.step(-1);
+            }
+
+            void backup_from(const std::string& filename) {
+                auto backup = this->make_backup_from(filename);
+                backup.step(-1);
+            }
+
+            void backup_from(storage_base& other) {
+                auto backup = this->make_backup_from(other);
+                backup.step(-1);
+            }
+
+            backup_t make_backup_to(const std::string& filename) {
+                auto holder = std::make_unique<connection_holder>(filename);
+                connection_ref conRef{*holder};
+                return {conRef, "main", this->get_connection(), "main", move(holder)};
+            }
+
+            backup_t make_backup_to(storage_base& other) {
+                return {other.get_connection(), "main", this->get_connection(), "main", {}};
+            }
+
+            backup_t make_backup_from(const std::string& filename) {
+                auto holder = std::make_unique<connection_holder>(filename);
+                connection_ref conRef{*holder};
+                return {this->get_connection(), "main", conRef, "main", move(holder)};
+            }
+
+            backup_t make_backup_from(storage_base& other) {
+                return {this->get_connection(), "main", other.get_connection(), "main", {}};
+            }
+
+            const std::string& filename() const {
+                return this->connection->filename;
+            }
+
+            /**
+             * Checks whether connection to database is opened right now.
+             * Returns always `true` for in memory databases.
+             */
+            bool is_opened() const {
+                return this->connection->retain_count() > 0;
+            }
+
+            int busy_handler(std::function<int(int)> handler) {
+                _busy_handler = move(handler);
+                if(this->is_opened()) {
+                    if(_busy_handler) {
+                        return sqlite3_busy_handler(this->connection->get(), busy_handler_callback, this);
+                    } else {
+                        return sqlite3_busy_handler(this->connection->get(), nullptr, nullptr);
+                    }
+                } else {
+                    return SQLITE_OK;
+                }
+            }
+
+          protected:
+            storage_base(const std::string& filename_, int foreignKeysCount) :
+                pragma(std::bind(&storage_base::get_connection, this)),
+                limit(std::bind(&storage_base::get_connection, this)),
+                inMemory(filename_.empty() || filename_ == ":memory:"),
+                connection(std::make_unique<connection_holder>(filename_)), cachedForeignKeysCount(foreignKeysCount) {
+                if(this->inMemory) {
+                    this->connection->retain();
+                    this->on_open_internal(this->connection->get());
+                }
+            }
+
+            storage_base(const storage_base& other) :
+                on_open(other.on_open), pragma(std::bind(&storage_base::get_connection, this)),
+                limit(std::bind(&storage_base::get_connection, this)), inMemory(other.inMemory),
+                connection(std::make_unique<connection_holder>(other.connection->filename)),
+                cachedForeignKeysCount(other.cachedForeignKeysCount) {
+                if(this->inMemory) {
+                    this->connection->retain();
+                    this->on_open_internal(this->connection->get());
+                }
+            }
+
+            ~storage_base() {
+                if(this->isOpenedForever) {
+                    this->connection->release();
+                }
+                if(this->inMemory) {
+                    this->connection->release();
+                }
+            }
+
+            connection_ref get_connection() {
+                connection_ref res{*this->connection};
+                if(1 == this->connection->retain_count()) {
+                    this->on_open_internal(this->connection->get());
+                }
+                return res;
+            }
+
+#if SQLITE_VERSION_NUMBER >= 3006019
+
+            void foreign_keys(sqlite3* db, bool value) {
+                std::stringstream ss;
+                ss << "PRAGMA foreign_keys = " << value;
+                perform_void_exec(db, ss.str());
+            }
+
+            bool foreign_keys(sqlite3* db) {
+                std::string query = "PRAGMA foreign_keys";
+                auto result = false;
+                auto rc = sqlite3_exec(
+                    db,
+                    query.c_str(),
+                    [](void* data, int argc, char** argv, char**) -> int {
+                        auto& res = *(bool*)data;
+                        if(argc) {
+                            res = row_extractor<bool>().extract(argv[0]);
+                        }
+                        return 0;
+                    },
+                    &result,
+                    nullptr);
+                if(rc != SQLITE_OK) {
+                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                            sqlite3_errmsg(db));
+                }
+                return result;
+            }
+
+#endif
+            void on_open_internal(sqlite3* db) {
+
+#if SQLITE_VERSION_NUMBER >= 3006019
+                if(this->cachedForeignKeysCount) {
+                    this->foreign_keys(db, true);
+                }
+#endif
+                if(this->pragma._synchronous != -1) {
+                    this->pragma.synchronous(this->pragma._synchronous);
+                }
+
+                if(this->pragma._journal_mode != -1) {
+                    this->pragma.set_pragma("journal_mode", static_cast<journal_mode>(this->pragma._journal_mode), db);
+                }
+
+                for(auto& p: this->collatingFunctions) {
+                    auto resultCode =
+                        sqlite3_create_collation(db, p.first.c_str(), SQLITE_UTF8, &p.second, collate_callback);
+                    if(resultCode != SQLITE_OK) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                }
+
+                for(auto& p: this->limit.limits) {
+                    sqlite3_limit(db, p.first, p.second);
+                }
+
+                if(_busy_handler) {
+                    sqlite3_busy_handler(this->connection->get(), busy_handler_callback, this);
+                }
+
+                for(auto& functionPointer: this->scalarFunctions) {
+                    try_to_create_function(db, static_cast<scalar_function_t&>(*functionPointer));
+                }
+
+                for(auto& functionPointer: this->aggregateFunctions) {
+                    try_to_create_function(db, static_cast<aggregate_function_t&>(*functionPointer));
+                }
+
+                if(this->on_open) {
+                    this->on_open(db);
+                }
+            }
+
+            void delete_function_impl(const std::string& name,
+                                      std::vector<std::unique_ptr<function_base>>& functionsVector) const {
+                auto it = find_if(functionsVector.begin(), functionsVector.end(), [&name](auto& functionPointer) {
+                    return functionPointer->name == name;
+                });
+                if(it != functionsVector.end()) {
+                    functionsVector.erase(it);
+                    it = functionsVector.end();
+
+                    if(this->connection->retain_count() > 0) {
+                        auto db = this->connection->get();
+                        auto resultCode = sqlite3_create_function_v2(db,
+                                                                     name.c_str(),
+                                                                     0,
+                                                                     SQLITE_UTF8,
+                                                                     nullptr,
+                                                                     nullptr,
+                                                                     nullptr,
+                                                                     nullptr,
+                                                                     nullptr);
+                        if(resultCode != SQLITE_OK) {
+                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                    sqlite3_errmsg(db));
+                        }
+                    }
+                } else {
+                    throw std::system_error(std::make_error_code(orm_error_code::function_not_found));
+                }
+            }
+
+            void try_to_create_function(sqlite3* db, scalar_function_t& function) {
+                auto resultCode = sqlite3_create_function_v2(db,
+                                                             function.name.c_str(),
+                                                             function.argumentsCount,
+                                                             SQLITE_UTF8,
+                                                             &function,
+                                                             scalar_function_callback,
+                                                             nullptr,
+                                                             nullptr,
+                                                             nullptr);
+                if(resultCode != SQLITE_OK) {
+                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                            sqlite3_errmsg(db));
+                }
+            }
+
+            void try_to_create_function(sqlite3* db, aggregate_function_t& function) {
+                auto resultCode = sqlite3_create_function(db,
+                                                          function.name.c_str(),
+                                                          function.argumentsCount,
+                                                          SQLITE_UTF8,
+                                                          &function,
+                                                          nullptr,
+                                                          aggregate_function_step_callback,
+                                                          aggregate_function_final_callback);
+                if(resultCode != SQLITE_OK) {
+                    throw std::system_error(std::error_code(resultCode, get_sqlite_error_category()),
+                                            sqlite3_errstr(resultCode));
+                }
+            }
+
+            static void
+            aggregate_function_step_callback(sqlite3_context* context, int argsCount, sqlite3_value** values) {
+                auto functionVoidPointer = sqlite3_user_data(context);
+                auto functionPointer = static_cast<aggregate_function_t*>(functionVoidPointer);
+                auto aggregateContextVoidPointer = sqlite3_aggregate_context(context, sizeof(int**));
+                auto aggregateContextIntPointer = static_cast<int**>(aggregateContextVoidPointer);
+                if(*aggregateContextIntPointer == nullptr) {
+                    *aggregateContextIntPointer = functionPointer->create();
+                }
+                functionPointer->step(context, *aggregateContextIntPointer, argsCount, values);
+            }
+
+            static void aggregate_function_final_callback(sqlite3_context* context) {
+                auto functionVoidPointer = sqlite3_user_data(context);
+                auto functionPointer = static_cast<aggregate_function_t*>(functionVoidPointer);
+                auto aggregateContextVoidPointer = sqlite3_aggregate_context(context, sizeof(int**));
+                auto aggregateContextIntPointer = static_cast<int**>(aggregateContextVoidPointer);
+                functionPointer->finalCall(context, *aggregateContextIntPointer);
+                functionPointer->destroy(*aggregateContextIntPointer);
+            }
+
+            static void scalar_function_callback(sqlite3_context* context, int argsCount, sqlite3_value** values) {
+                auto functionVoidPointer = sqlite3_user_data(context);
+                auto functionPointer = static_cast<scalar_function_t*>(functionVoidPointer);
+                std::unique_ptr<int, void (*)(int*)> callablePointer(functionPointer->create(),
+                                                                     functionPointer->destroy);
+                if(functionPointer->argumentsCount != -1 && functionPointer->argumentsCount != argsCount) {
+                    throw std::system_error(std::make_error_code(orm_error_code::arguments_count_does_not_match));
+                }
+                functionPointer->run(context, functionPointer, argsCount, values);
+            }
+
+            template<class F>
+            static void delete_function_callback(int* pointer) {
+                auto voidPointer = static_cast<void*>(pointer);
+                auto fPointer = static_cast<F*>(voidPointer);
+                delete fPointer;
+            }
+
+            std::string current_timestamp(sqlite3* db) {
+                std::string result;
+                std::stringstream ss;
+                ss << "SELECT CURRENT_TIMESTAMP";
+                auto query = ss.str();
+                auto rc = sqlite3_exec(
+                    db,
+                    query.c_str(),
+                    [](void* data, int argc, char** argv, char**) -> int {
+                        auto& res = *(std::string*)data;
+                        if(argc) {
+                            if(argv[0]) {
+                                res = row_extractor<std::string>().extract(argv[0]);
+                            }
+                        }
+                        return 0;
+                    },
+                    &result,
+                    nullptr);
+                if(rc != SQLITE_OK) {
+                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                            sqlite3_errmsg(db));
+                }
+                return result;
+            }
+
+            void drop_table_internal(const std::string& tableName, sqlite3* db) {
+                std::stringstream ss;
+                ss << "DROP TABLE '" << tableName + "'";
+                perform_void_exec(db, ss.str());
+            }
+
+            static int collate_callback(void* arg, int leftLen, const void* lhs, int rightLen, const void* rhs) {
+                auto& f = *(collating_function*)arg;
+                return f(leftLen, lhs, rightLen, rhs);
+            }
+
+            static int busy_handler_callback(void* selfPointer, int triesCount) {
+                auto& storage = *static_cast<storage_base*>(selfPointer);
+                if(storage._busy_handler) {
+                    return storage._busy_handler(triesCount);
+                } else {
+                    return 0;
+                }
+            }
+
+            //  returns foreign keys count in storage definition
+            template<class T>
+            static int foreign_keys_count(T& storageImpl) {
+                auto res = 0;
+                storageImpl.for_each([&res](auto& impl) {
+                    res += impl.foreign_keys_count();
+                });
+                return res;
+            }
+
+            const bool inMemory;
+            bool isOpenedForever = false;
+            std::unique_ptr<connection_holder> connection;
+            std::map<std::string, collating_function> collatingFunctions;
+            const int cachedForeignKeysCount;
+            std::function<int(int)> _busy_handler;
+            std::vector<std::unique_ptr<function_base>> scalarFunctions;
+            std::vector<std::unique_ptr<function_base>> aggregateFunctions;
+        };
+    }
+}
+
+// #include "prepared_statement.h"
+
+// #include "expression_object_type.h"
+
+#include <type_traits>  //  std::decay
+#include <functional>  //  std::reference_wrapper
+
+// #include "prepared_statement.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        template<class T, class SFINAE = void>
+        struct expression_object_type;
+
+        template<class T>
+        struct expression_object_type<update_t<T>> {
+            using type = typename std::decay<T>::type;
+        };
+
+        template<class T>
+        struct expression_object_type<update_t<std::reference_wrapper<T>>> {
+            using type = typename std::decay<T>::type;
+        };
+
+        template<class T>
+        struct expression_object_type<replace_t<T>> {
+            using type = typename std::decay<T>::type;
+        };
+
+        template<class T>
+        struct expression_object_type<replace_t<std::reference_wrapper<T>>> {
+            using type = typename std::decay<T>::type;
+        };
+
+        template<class It, class L, class O>
+        struct expression_object_type<replace_range_t<It, L, O>> {
+            using type = typename replace_range_t<It, L, O>::object_type;
+        };
+
+        template<class It, class L, class O>
+        struct expression_object_type<replace_range_t<std::reference_wrapper<It>, L, O>> {
+            using type = typename replace_range_t<std::reference_wrapper<It>, L, O>::object_type;
+        };
+
+        template<class T>
+        struct expression_object_type<insert_t<T>> {
+            using type = typename std::decay<T>::type;
+        };
+
+        template<class T>
+        struct expression_object_type<insert_t<std::reference_wrapper<T>>> {
+            using type = typename std::decay<T>::type;
+        };
+
+        template<class It, class L, class O>
+        struct expression_object_type<insert_range_t<It, L, O>> {
+            using transformer_type = L;
+            using type = typename insert_range_t<It, L, O>::object_type;
+        };
+
+        template<class It, class L, class O>
+        struct expression_object_type<insert_range_t<std::reference_wrapper<It>, L, O>> {
+            using type = typename insert_range_t<std::reference_wrapper<It>, L, O>::object_type;
+        };
+
+        template<class T, class... Cols>
+        struct expression_object_type<insert_explicit<T, Cols...>> {
+            using type = typename std::decay<T>::type;
+        };
+
+        template<class T, class... Cols>
+        struct expression_object_type<insert_explicit<std::reference_wrapper<T>, Cols...>> {
+            using type = typename std::decay<T>::type;
+        };
+
+        template<class T>
+        struct get_ref_t {
+
+            template<class O>
+            auto& operator()(O& t) const {
+                return t;
+            }
+        };
+
+        template<class T>
+        struct get_ref_t<std::reference_wrapper<T>> {
+
+            template<class O>
+            auto& operator()(O& t) const {
+                return t.get();
+            }
+        };
+
+        template<class T>
+        auto& get_ref(T& t) {
+            using arg_type = typename std::decay<T>::type;
+            get_ref_t<arg_type> g;
+            return g(t);
+        }
+
+        template<class T>
+        struct get_object_t;
+
+        template<class T>
+        struct get_object_t<const T> : get_object_t<T> {};
+
+        template<class T>
+        auto& get_object(T& t) {
+            using expression_type = typename std::decay<T>::type;
+            get_object_t<expression_type> obj;
+            return obj(t);
+        }
+
+        template<class T>
+        struct get_object_t<replace_t<T>> {
+            using expression_type = replace_t<T>;
+
+            template<class O>
+            auto& operator()(O& e) const {
+                return get_ref(e.object);
+            }
+        };
+
+        template<class T>
+        struct get_object_t<insert_t<T>> {
+            using expression_type = insert_t<T>;
+
+            template<class O>
+            auto& operator()(O& e) const {
+                return get_ref(e.object);
+            }
+        };
+
+        template<class T>
+        struct get_object_t<update_t<T>> {
+            using expression_type = update_t<T>;
+
+            template<class O>
+            auto& operator()(O& e) const {
+                return get_ref(e.object);
+            }
+        };
+    }
+}
+
+// #include "statement_serializator.h"
+
+#include <sstream>  //  std::stringstream
+#include <string>  //  std::string
+#include <type_traits>  //  std::enable_if, std::remove_pointer
+#include <vector>  //  std::vector
+#include <algorithm>  //  std::iter_swap
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+#include <optional>
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+
+// #include "cxx_polyfill.h"
+
+// #include "type_traits.h"
+
+// #include "core_functions.h"
+
+// #include "constraints.h"
+
+// #include "conditions.h"
+
+// #include "column.h"
+
+// #include "rowid.h"
+
+// #include "type_printer.h"
+
+// #include "table_name_collector.h"
+
+#include <set>  //  std::set
+#include <string>  //  std::string
+#include <functional>  //  std::function
+#include <typeindex>  //  std::type_index
+
+// #include "static_magic.h"
+
+// #include "select_constraints.h"
+
+// #include "alias.h"
+
+// #include "core_functions.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        struct table_name_collector {
+            using table_name_set = std::set<std::pair<std::string, std::string>>;
+            using find_table_name_t = std::function<std::string(std::type_index)>;
+
+            find_table_name_t find_table_name;
+            mutable table_name_set table_names;
+
+            table_name_collector() = default;
+
+            table_name_collector(find_table_name_t _find_table_name) : find_table_name(std::move(_find_table_name)) {}
+
+            template<class T>
+            table_name_set operator()(const T&) const {
+                return {};
+            }
+
+            template<class F, class O>
+            void operator()(F O::*, std::string alias = {}) const {
+                if(this->find_table_name) {
+                    table_names.insert(std::make_pair(this->find_table_name(typeid(O)), move(alias)));
+                }
+            }
+
+            template<class T, class F>
+            void operator()(const column_pointer<T, F>&) const {
+                if(this->find_table_name) {
+                    table_names.insert({this->find_table_name(typeid(T)), ""});
+                }
+            }
+
+            template<class T, class C>
+            void operator()(const alias_column_t<T, C>& a) const {
+                (*this)(a.column, alias_extractor<T>::get());
+            }
+
+            template<class T>
+            void operator()(const count_asterisk_t<T>&) const {
+                if(this->find_table_name) {
+                    auto tableName = this->find_table_name(typeid(T));
+                    if(!tableName.empty()) {
+                        table_names.insert(std::make_pair(move(tableName), ""));
+                    }
+                }
+            }
+
+            template<class T>
+            void operator()(const asterisk_t<T>&) const {
+                if(this->find_table_name) {
+                    static_if<std::is_base_of<alias_tag, T>{}>(
+                        [this]() {
+                            auto tableName = this->find_table_name(typeid(typename alias_extractor<T>::object_type));
+                            table_names.insert(std::make_pair(move(tableName), alias_extractor<T>::get()));
+                        },
+                        [this]() {
+                            auto tableName = this->find_table_name(typeid(T));
+                            table_names.insert(std::make_pair(move(tableName), ""));
+                        })();
+                }
+            }
+
+            template<class T>
+            void operator()(const object_t<T>&) const {
+                if(this->find_table_name) {
+                    auto tableName = this->find_table_name(typeid(T));
+                    table_names.insert(std::make_pair(move(tableName), ""));
+                }
+            }
+
+            template<class T>
+            void operator()(const table_rowid_t<T>&) const {
+                if(this->find_table_name) {
+                    auto tableName = this->find_table_name(typeid(T));
+                    table_names.insert(std::make_pair(move(tableName), ""));
+                }
+            }
+
+            template<class T>
+            void operator()(const table_oid_t<T>&) const {
+                if(this->find_table_name) {
+                    auto tableName = this->find_table_name(typeid(T));
+                    table_names.insert(std::make_pair(move(tableName), ""));
+                }
+            }
+
+            template<class T>
+            void operator()(const table__rowid_t<T>&) const {
+                if(this->find_table_name) {
+                    auto tableName = this->find_table_name(typeid(T));
+                    table_names.insert(std::make_pair(move(tableName), ""));
+                }
+            }
+        };
+
+    }
+
+}
+
+// #include "column_names_getter.h"
+
+#include <string>  //  std::string
+#include <vector>  //  std::vector
+#include <functional>  //  std::reference_wrapper
+#include <system_error>
+
+// #include "error_code.h"
+
+// #include "select_constraints.h"
+
+// #include "alias.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context);
+
+        template<class T, class SFINAE = void>
+        struct column_names_getter {
+            using expression_type = T;
+
+            template<class C>
+            std::vector<std::string> operator()(const expression_type& t, const C& context) {
+                auto newContext = context;
+                newContext.skip_table_name = false;
+                auto columnName = serialize(t, newContext);
+                if(columnName.length()) {
+                    return {move(columnName)};
+                } else {
+                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                }
+            }
+        };
+
+        template<class T, class C>
+        std::vector<std::string> get_column_names(const T& t, const C& context) {
+            column_names_getter<T> serializator;
+            return serializator(t, context);
+        }
+
+        template<class T>
+        struct column_names_getter<std::reference_wrapper<T>, void> {
+            using expression_type = std::reference_wrapper<T>;
+
+            template<class C>
+            std::vector<std::string> operator()(const expression_type& expression, const C& context) {
+                return get_column_names(expression.get(), context);
+            }
+        };
+
+        template<class T>
+        struct column_names_getter<asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>> {
+            using expression_type = asterisk_t<T>;
+
+            template<class C>
+            std::vector<std::string> operator()(const expression_type&, const C&) {
+                std::vector<std::string> res;
+                res.emplace_back("*");
+                return res;
+            }
+        };
+
+        template<class A>
+        struct column_names_getter<asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>> {
+            using expression_type = asterisk_t<A>;
+
+            template<class C>
+            std::vector<std::string> operator()(const expression_type&, const C&) {
+                std::vector<std::string> res;
+                res.push_back("'" + alias_extractor<A>::get() + "'.*");
+                return res;
+            }
+        };
+
+        template<class T>
+        struct column_names_getter<object_t<T>, void> {
+            using expression_type = object_t<T>;
+
+            template<class C>
+            std::vector<std::string> operator()(const expression_type&, const C&) {
+                std::vector<std::string> res;
+                res.emplace_back("*");
+                return res;
+            }
+        };
+
+        template<class... Args>
+        struct column_names_getter<columns_t<Args...>, void> {
+            using expression_type = columns_t<Args...>;
+
+            template<class C>
+            std::vector<std::string> operator()(const expression_type& cols, const C& context) {
+                std::vector<std::string> columnNames;
+                columnNames.reserve(static_cast<size_t>(cols.count));
+                auto newContext = context;
+                newContext.skip_table_name = false;
+                iterate_tuple(cols.columns, [&columnNames, &newContext](auto& m) {
+                    auto columnName = serialize(m, newContext);
+                    if(columnName.length()) {
+                        columnNames.push_back(std::move(columnName));
+                    } else {
+                        throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                    }
+                });
+                return columnNames;
+            }
+        };
+
+    }
+}
+
+// #include "cte_column_names_collector.h"
+
+#include <string>
+#include <vector>
+#include <functional>  //  std::reference_wrapper
+#include <system_error>
+
+// #include "cxx_polyfill.h"
+
+// #include "type_traits.h"
+
+// #include "error_code.h"
+
+// #include "select_constraints.h"
+
+namespace sqlite_orm {
+    namespace internal {
+        // collecting column names utilizes the statement serializer
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context);
+
+        template<class T, class SFINAE = void>
+        struct cte_column_names_collector {
+            using expression_type = T;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& t, const Ctx& context) const {
+                auto newContext = context;
+                newContext.skip_table_name = true;
+                std::string columnName = serialize(t, newContext);
+                if(columnName.empty()) {
+                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                }
+                return {move(columnName)};
+            }
+        };
+
+        template<class T, class Ctx>
+        std::vector<std::string> get_cte_column_names(const T& t, const Ctx& context) {
+            cte_column_names_collector<T> collector;
+            return collector(t, context);
+        }
+
+        // For compound statements we just need to collect the column alias names of the left expression
+        template<class Compound>
+        struct cte_column_names_collector<Compound,
+                                          std::enable_if_t<is_base_of_template<Compound, compound_operator>::value>> {
+            using expression_type = Compound;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& t, const Ctx& context) const {
+                auto newContext = context;
+                newContext.skip_table_name = true;
+                return get_cte_column_names(t.left.col, context);
+            }
+        };
+
+        template<class As>
+        struct cte_column_names_collector<As, match_specialization_of<As, as_t>> {
+            using expression_type = As;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& /*expression*/, const Ctx& /*context*/) const {
+                return {As::alias_type::get()};
+            }
+        };
+
+        template<class Wrapper>
+        struct cte_column_names_collector<Wrapper, match_specialization_of<Wrapper, std::reference_wrapper>> {
+            using expression_type = Wrapper;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& expression, const Ctx& context) const {
+                return get_cte_column_names(expression.get(), context);
+            }
+        };
+
+        template<class Asterisk>
+        struct cte_column_names_collector<Asterisk, match_specialization_of<Asterisk, asterisk_t>> {
+            using expression_type = Asterisk;
+            using T = typename Asterisk::type;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type&, const Ctx& context) const {
+                auto& tImpl = pick_impl<T>(context.impl);
+
+                std::vector<std::string> columnNames;
+                columnNames.reserve(size_t(tImpl.table.elements_count));
+
+                tImpl.table.for_each_column([&columnNames](const basic_column& column) {
+                    columnNames.push_back(column.name);
+                });
+                return columnNames;
+            }
+        };
+
+        // No CTE for object expressions.
+        template<class Object>
+        struct cte_column_names_collector<Object, match_specialization_of<Object, object_t>> {
+            static_assert(polyfill::always_false_v<Object>, "Selecting an object in a subselect is not allowed.");
+        };
+
+        template<class Columns>
+        struct cte_column_names_collector<Columns, match_specialization_of<Columns, columns_t>> {
+            using expression_type = Columns;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& cols, const Ctx& context) const {
+                std::vector<std::string> columnNames;
+                columnNames.reserve(size_t(cols.count));
+                auto newContext = context;
+                newContext.skip_table_name = true;
+                iterate_tuple(cols.columns, [&columnNames, &newContext](auto& m) {
+                    using value_type = polyfill::remove_cvref_t<decltype(m)>;
+
+                    std::string columnName;
+                    if constexpr(polyfill::is_specialization_of_v<value_type, as_t>) {
+                        columnName = alias_extractor<typename value_type::alias_type>::get();
+                    } else {
+                        columnName = serialize(m, newContext);
+                    }
+                    if(!columnName.empty()) {
+                        columnNames.push_back(move(columnName));
+                    } else {
+                        throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                    }
+                });
+                return columnNames;
+            }
+        };
+
+        template<typename Ctx, typename E, satisfies_is_specialization_of<E, select_t> = true>
+        std::vector<std::string> collect_cte_column_names(const E& sel,
+                                                          const std::vector<std::string>& explicitColumnNames,
+                                                          const Ctx& context) {
+            // 1. determine column names from subselect
+
+            std::vector<std::string> columnNames = get_cte_column_names(sel.col, context);
+
+            // unquote column names
+            for(std::string& name: columnNames) {
+                if(!name.empty() && name.front() == '"' && name.back() == '"') {
+                    name.erase(name.end() - 1);
+                    name.erase(name.begin());
+                }
+            }
+
+            // 2. override column names from cte expression
+            if(!explicitColumnNames.empty()) {
+                if(explicitColumnNames.size() != columnNames.size()) {
+                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                }
+
+                for(size_t i = 0, n = explicitColumnNames.size(); i < n; ++i) {
+                    if(!explicitColumnNames[i].empty()) {
+                        columnNames[i] = explicitColumnNames[i];
+                    }
+                }
+            }
+            // 3. fill in blanks with numerical column names
+            {
+                for(size_t i = 0, n = columnNames.size(); i < n; ++i) {
+                    if(columnNames[i].empty()) {
+                        columnNames[i] = std::to_string(i);
+                    }
+                }
+            }
+
+            return columnNames;
+        }
+    }
+}
+
+// #include "order_by_serializator.h"
+
+#include <string>  //  std::string
+#include <vector>  //  std::vector
+#include <sstream>  //  std::stringstream
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        template<class T, class SFINAE = void>
+        struct order_by_serializator;
+
+        template<class T, class C>
+        std::string serialize_order_by(const T& t, const C& context) {
+            order_by_serializator<T> serializator;
+            return serializator(t, context);
+        }
+
+        template<class O>
+        struct order_by_serializator<order_by_t<O>, void> {
+            using statement_type = order_by_t<O>;
+
+            template<class C>
+            std::string operator()(const statement_type& orderBy, const C& context) const {
+                std::stringstream ss;
+                auto newContext = context;
+                newContext.skip_table_name = false;
+                auto columnName = serialize(orderBy.expression, newContext);
+                ss << columnName << " ";
+                if(orderBy._collate_argument.length()) {
+                    ss << "COLLATE " << orderBy._collate_argument << " ";
+                }
+                switch(orderBy.asc_desc) {
+                    case 1:
+                        ss << "ASC";
+                        break;
+                    case -1:
+                        ss << "DESC";
+                        break;
+                }
+                return ss.str();
+            }
+        };
+
+        template<class S>
+        struct order_by_serializator<dynamic_order_by_t<S>, void> {
+            using statement_type = dynamic_order_by_t<S>;
+
+            template<class C>
+            std::string operator()(const statement_type& orderBy, const C&) const {
+                std::vector<std::string> expressions;
+                for(auto& entry: orderBy) {
+                    std::string entryString;
+                    {
+                        std::stringstream ss;
+                        ss << entry.name << " ";
+                        if(!entry._collate_argument.empty()) {
+                            ss << "COLLATE " << entry._collate_argument << " ";
+                        }
+                        switch(entry.asc_desc) {
+                            case 1:
+                                ss << "ASC";
+                                break;
+                            case -1:
+                                ss << "DESC";
+                                break;
+                        }
+                        entryString = ss.str();
+                    }
+                    expressions.push_back(move(entryString));
+                };
+                std::stringstream ss;
+                ss << static_cast<std::string>(orderBy) << " ";
+                for(size_t i = 0; i < expressions.size(); ++i) {
+                    ss << expressions[i];
+                    if(i < expressions.size() - 1) {
+                        ss << ", ";
+                    }
+                }
+                ss << " ";
+                return ss.str();
+            }
+        };
+
+    }
+}
+
+// #include "values.h"
+
+// #include "table_type.h"
+
+// #include "indexed_column.h"
+
+// #include "function.h"
+
+// #include "ast/upsert_clause.h"
+
+// #include "ast/excluded.h"
+
+// #include "ast/group_by.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        template<class T, class SFINAE = void>
+        struct statement_serializator;
+
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context) {
+            statement_serializator<T> serializator;
+            return serializator(t, context);
+        }
+
+        /**
+         *  Constant which gets never replaced in a bindable context.
+         *  Used together with order_by(1_nth_col).
+         */
+        template<unsigned int N>
+        struct statement_serializator<nth_constant<N>, void> {
+            using statement_type = nth_constant<N>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& /*expression*/, const Ctx&) {
+                static_assert(N > 0);
+                return std::to_string(N);
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<T, typename std::enable_if<is_bindable<T>::value>::type> {
+            using statement_type = T;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) {
+                if(context.replace_bindable_with_question) {
+                    return "?";
+                } else {
+                    return field_printer<T>{}(statement);
+                }
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<excluded_t<T>, void> {
+            using statement_type = excluded_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) {
+                std::stringstream ss;
+                ss << "excluded.";
+                if(auto columnNamePointer = find_column_name(context.impl, statement.expression)) {
+                    ss << "\"" << *columnNamePointer << "\"";
+                } else {
+                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                }
+                return ss.str();
+            }
+        };
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class T>
+        struct statement_serializator<as_optional_t<T>, void> {
+            using statement_type = as_optional_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) {
+                return serialize(statement.value, context);
+            }
+        };
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class T>
+        struct statement_serializator<std::reference_wrapper<T>, void> {
+            using statement_type = std::reference_wrapper<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& s, const C& context) {
+                return serialize(s.get(), context);
+            }
+        };
+
+        template<>
+        struct statement_serializator<std::nullptr_t, void> {
+            using statement_type = std::nullptr_t;
+
+            template<class C>
+            std::string operator()(const statement_type&, const C&) {
+                return "?";
+            }
+        };
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<>
+        struct statement_serializator<std::nullopt_t, void> {
+            using statement_type = std::nullopt_t;
+
+            template<class C>
+            std::string operator()(const statement_type&, const C&) {
+                return "?";
+            }
+        };
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class T>
+        struct statement_serializator<alias_holder<T>, void> {
+            using statement_type = alias_holder<T>;
+
+            template<class C>
+            std::string operator()(const statement_type&, const C&) {
+                return T::get();
+            }
+        };
+
+        template<class... TargetArgs, class... ActionsArgs>
+        struct statement_serializator<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void> {
+            using statement_type = upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                ss << "ON CONFLICT";
+                iterate_tuple(statement.target_args, [&ss, &context](auto& value) {
+                    using value_type = typename std::decay<decltype(value)>::type;
+                    auto needParenthesis = std::is_member_pointer<value_type>::value;
+                    ss << ' ';
+                    if(needParenthesis) {
+                        ss << '(';
+                    }
+                    ss << serialize(value, context);
+                    if(needParenthesis) {
+                        ss << ')';
+                    }
+                });
+                ss << ' ' << "DO";
+                if(std::tuple_size<typename statement_type::actions_tuple>::value == 0) {
+                    ss << " NOTHING";
+                } else {
+                    ss << " UPDATE";
+                    auto updateContext = context;
+                    updateContext.use_parentheses = false;
+                    iterate_tuple(statement.actions, [&ss, &updateContext](auto& value) {
+                        ss << ' ' << serialize(value, updateContext);
+                    });
+                }
+                return ss.str();
+            }
+        };
+
+        template<class R, class S, class... Args>
+        struct statement_serializator<built_in_function_t<R, S, Args...>, void> {
+            using statement_type = built_in_function_t<R, S, Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                ss << statement.serialize() << "(";
+                std::vector<std::string> args;
+                using args_type = typename std::decay<decltype(statement)>::type::args_type;
+                args.reserve(std::tuple_size<args_type>::value);
+                iterate_tuple(statement.args, [&args, &context](auto& v) {
+                    args.push_back(serialize(v, context));
+                });
+                for(size_t i = 0; i < args.size(); ++i) {
+                    ss << args[i];
+                    if(i < args.size() - 1) {
+                        ss << ", ";
+                    }
+                }
+                ss << ")";
+                return ss.str();
+            }
+        };
+
+        template<class F, class... Args>
+        struct statement_serializator<function_call<F, Args...>, void> {
+            using statement_type = function_call<F, Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                using args_tuple = std::tuple<Args...>;
+
+                std::stringstream ss;
+                ss << F::name() << "(";
+                auto index = 0;
+                iterate_tuple(statement.args, [&context, &ss, &index](auto& v) {
+                    auto value = serialize(v, context);
+                    ss << value;
+                    if(index < std::tuple_size<args_tuple>::value - 1) {
+                        ss << ", ";
+                    }
+                    ++index;
+                });
+                ss << ")";
+                return ss.str();
+            }
+        };
+
+        template<class T, class E>
+        struct statement_serializator<as_t<T, E>, void> {
+            using statement_type = as_t<T, E>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                auto aliasString = alias_extractor<T>::get();
+                return serialize(c.expression, context) + " AS " + aliasString;
+            }
+        };
+
+        template<class T, class P>
+        struct statement_serializator<alias_column_t<T, P>, void> {
+            using statement_type = alias_column_t<T, P>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                if(!context.skip_table_name) {
+                    ss << "'" << T::get() << "'.";
+                }
+                auto newContext = context;
+                newContext.skip_table_name = true;
+                ss << serialize(c.column, newContext);
+                return ss.str();
+            }
+        };
+
+        template<>
+        struct statement_serializator<std::string, void> {
+            using statement_type = std::string;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                if(context.replace_bindable_with_question) {
+                    return "?";
+                } else {
+                    return "'" + c + "'";
+                }
+            }
+        };
+
+        template<>
+        struct statement_serializator<const char*, void> {
+            using statement_type = const char*;
+
+            template<class C>
+            std::string operator()(const char* c, const C& context) const {
+                if(context.replace_bindable_with_question) {
+                    return "?";
+                } else {
+                    return std::string("'") + c + "'";
+                }
+            }
+        };
+
+#ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
+        template<>
+        struct statement_serializator<std::string_view, void> {
+            using statement_type = std::string_view;
+
+            template<class C>
+            std::string operator()(const std::string_view& c, const C& context) const {
+                if(context.replace_bindable_with_question) {
+                    return "?";
+                } else {
+                    return "'" + std::string(c) + "'";
+                }
+            }
+        };
+#endif
+
+        template<class O, class F>
+        struct statement_serializator<F O::*, void> {
+            using statement_type = F O::*;
+
+            template<class C>
+            std::string operator()(const statement_type& m, const C& context) const {
+                std::stringstream ss;
+                if(!context.skip_table_name) {
+                    ss << "\"" << lookup_table_name<O>(context.impl) << "\".";
+                }
+                if(auto columnnamePointer = find_column_name(context.impl, m)) {
+                    ss << "\"" << *columnnamePointer << "\"";
+                } else {
+                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                }
+                return ss.str();
+            }
+        };
+
+        template<>
+        struct statement_serializator<rowid_t, void> {
+            using statement_type = rowid_t;
+
+            template<class C>
+            std::string operator()(const statement_type& s, const C&) {
+                return static_cast<std::string>(s);
+            }
+        };
+
+        template<>
+        struct statement_serializator<oid_t, void> {
+            using statement_type = oid_t;
+
+            template<class C>
+            std::string operator()(const statement_type& s, const C&) {
+                return static_cast<std::string>(s);
+            }
+        };
+
+        template<>
+        struct statement_serializator<_rowid_t, void> {
+            using statement_type = _rowid_t;
+
+            template<class C>
+            std::string operator()(const statement_type& s, const C&) {
+                return static_cast<std::string>(s);
+            }
+        };
+
+        template<class O>
+        struct statement_serializator<table_rowid_t<O>, void> {
+            using statement_type = table_rowid_t<O>;
+
+            template<class C>
+            std::string operator()(const statement_type& s, const C& context) {
+                std::stringstream ss;
+                if(!context.skip_table_name) {
+                    ss << "'" << lookup_table_name<O>(context.impl) << "'.";
+                }
+                ss << static_cast<std::string>(s);
+                return ss.str();
+            }
+        };
+
+        template<class O>
+        struct statement_serializator<table_oid_t<O>, void> {
+            using statement_type = table_oid_t<O>;
+
+            template<class C>
+            std::string operator()(const statement_type& s, const C& context) {
+                std::stringstream ss;
+                if(!context.skip_table_name) {
+                    ss << "'" << lookup_table_name<O>(context.impl) << "'.";
+                }
+                ss << static_cast<std::string>(s);
+                return ss.str();
+            }
+        };
+
+        template<class O>
+        struct statement_serializator<table__rowid_t<O>, void> {
+            using statement_type = table__rowid_t<O>;
+
+            template<class C>
+            std::string operator()(const statement_type& s, const C& context) {
+                std::stringstream ss;
+                if(!context.skip_table_name) {
+                    ss << "'" << lookup_table_name<O>(context.impl) << "'.";
+                }
+                ss << static_cast<std::string>(s);
+                return ss.str();
+            }
+        };
+
+        template<class L, class R, class... Ds>
+        struct statement_serializator<binary_operator<L, R, Ds...>, void> {
+            using statement_type = binary_operator<L, R, Ds...>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                auto lhs = serialize(c.lhs, context);
+                auto rhs = serialize(c.rhs, context);
+                std::stringstream ss;
+                if(context.use_parentheses) {
+                    ss << '(';
+                }
+                ss << lhs << " " << static_cast<std::string>(c) << " " << rhs;
+                if(context.use_parentheses) {
+                    ss << ')';
+                }
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<count_asterisk_t<T>, void> {
+            using statement_type = count_asterisk_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type&, const C& context) const {
+                return serialize(count_asterisk_without_type{}, context);
+            }
+        };
+
+        template<>
+        struct statement_serializator<count_asterisk_without_type, void> {
+            using statement_type = count_asterisk_without_type;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C&) const {
+                std::stringstream ss;
+                auto functionName = c.serialize();
+                ss << functionName << "(*)";
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<distinct_t<T>, void> {
+            using statement_type = distinct_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                auto expr = serialize(c.value, context);
+                ss << static_cast<std::string>(c) << "(" << expr << ")";
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<all_t<T>, void> {
+            using statement_type = all_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                auto expr = serialize(c.value, context);
+                ss << static_cast<std::string>(c) << "(" << expr << ")";
+                return ss.str();
+            }
+        };
+
+        template<class O, class F, F O::*m>
+        struct statement_serializator<ice_t<m>, void> : statement_serializator<typename ice_t<m>::value_type> {};
+
+        template<class O, class F>
+        struct statement_serializator<column_pointer<O, F>, void> {
+            using statement_type = column_pointer<O, F>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                if(!context.skip_table_name) {
+                    ss << "'" << lookup_table_name<O>(context.impl) << "'.";
+                }
+                if(auto columnNamePointer = find_column_name(context.impl, c)) {
+                    ss << "\"" << *columnNamePointer << "\"";
+                } else {
+                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                }
+                return ss.str();
+            }
+        };
+
+        template<class T, class E>
+        struct statement_serializator<cast_t<T, E>, void> {
+            using statement_type = cast_t<T, E>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                ss << static_cast<std::string>(c) << " (";
+                ss << serialize(c.expression, context) << " AS " << type_printer<T>().print() << ")";
+                return ss.str();
+            }
+        };
+
+        template<class CTE>
+        struct statement_serializator<CTE, match_specialization_of<CTE, common_table_expression>> {
+            using statement_type = CTE;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& c, const Ctx& context) const {
+                // A CTE always starts a new 'highest level' context
+                Ctx cteContext = context;
+                cteContext.use_parentheses = false;
+
+                std::stringstream ss;
+                ss << static_cast<std::string>(c);
+                std::vector<std::string> columnNames =
+                    collect_cte_column_names(get_cte_driving_subselect(c.subselect), c.explicitColumnNames, context);
+                {
+                    ss << '(';
+                    for(size_t i = 0, n = columnNames.size(); i < n; ++i) {
+                        ss << "\"" << columnNames[i] << "\"";
+                        if(i < n - 1) {
+                            ss << ", ";
+                        }
+                    }
+                    ss << ')';
+                }
+                ss << " AS ";
+                ss << '(' << serialize(c.subselect, cteContext) << ')';
+                return ss.str();
+            }
+        };
+
+        template<class With>
+        struct statement_serializator<With, match_specialization_of<With, with_t>> {
+            using statement_type = With;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& c, const Ctx& context) const {
+                Ctx tupleContext = context;
+                tupleContext.use_parentheses = false;
+
+                std::stringstream ss;
+                ss << static_cast<std::string>(c) << " ";
+                ss << serialize(c.cte, tupleContext) << " ";
+                ss << serialize(c.expression, context);
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<T,
+                                      typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
+            using statement_type = T;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                ss << serialize(c.left, context) << " ";
+                ss << static_cast<std::string>(c) << " ";
+                ss << serialize(c.right, context);
+                return ss.str();
+            }
+        };
+
+        template<class R, class T, class E, class... Args>
+        struct statement_serializator<simple_case_t<R, T, E, Args...>, void> {
+            using statement_type = simple_case_t<R, T, E, Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                ss << "CASE ";
+                c.case_expression.apply([&ss, context](auto& c_) {
+                    ss << serialize(c_, context) << " ";
+                });
+                iterate_tuple(c.args, [&ss, context](auto& pair) {
+                    ss << "WHEN " << serialize(pair.first, context) << " ";
+                    ss << "THEN " << serialize(pair.second, context) << " ";
+                });
+                c.else_expression.apply([&ss, context](auto& el) {
+                    ss << "ELSE " << serialize(el, context) << " ";
+                });
+                ss << "END";
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<is_null_t<T>, void> {
+            using statement_type = is_null_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                ss << serialize(c.t, context) << " " << static_cast<std::string>(c);
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<is_not_null_t<T>, void> {
+            using statement_type = is_not_null_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                ss << serialize(c.t, context) << " " << static_cast<std::string>(c);
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<bitwise_not_t<T>, void> {
+            using statement_type = bitwise_not_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                ss << static_cast<std::string>(c) << " ";
+                auto cString = serialize(c.argument, context);
+                ss << " (" << cString << " )";
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<negated_condition_t<T>, void> {
+            using statement_type = negated_condition_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                ss << static_cast<std::string>(c) << " ";
+                auto cString = serialize(c.c, context);
+                ss << " (" << cString << " )";
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<T,
+                                      typename std::enable_if<is_base_of_template<T, binary_condition>::value>::type> {
+            using statement_type = T;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                auto leftString = serialize(c.l, context);
+                auto rightString = serialize(c.r, context);
+                std::stringstream ss;
+                if(context.use_parentheses) {
+                    ss << "(";
+                }
+                ss << leftString << " " << static_cast<std::string>(c) << " " << rightString;
+                if(context.use_parentheses) {
+                    ss << ")";
+                }
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<named_collate<T>, void> {
+            using statement_type = named_collate<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                auto newContext = context;
+                newContext.use_parentheses = false;
+                auto res = serialize(c.expr, newContext);
+                return res + " " + static_cast<std::string>(c);
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<collate_t<T>, void> {
+            using statement_type = collate_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                auto newContext = context;
+                newContext.use_parentheses = false;
+                auto res = serialize(c.expr, newContext);
+                return res + " " + static_cast<std::string>(c);
+            }
+        };
+
+        template<class L, class A>
+        struct statement_serializator<dynamic_in_t<L, A>, void> {
+            using statement_type = dynamic_in_t<L, A>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                auto leftString = serialize(c.left, context);
+                ss << leftString << " " << static_cast<std::string>(c) << " ";
+                auto newContext = context;
+                newContext.use_parentheses = true;
+                ss << serialize(c.argument, newContext);
+                return ss.str();
+            }
+        };
+
+        template<class L, class E>
+        struct statement_serializator<dynamic_in_t<L, std::vector<E>>, void> {
+            using statement_type = dynamic_in_t<L, std::vector<E>>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                auto leftString = serialize(c.left, context);
+                ss << leftString << " " << static_cast<std::string>(c) << " (";
+                for(size_t index = 0; index < c.argument.size(); ++index) {
+                    auto& value = c.argument[index];
+                    ss << serialize(value, context);
+                    if(index < c.argument.size() - 1) {
+                        ss << ", ";
+                    }
+                }
+                ss << ")";
+                return ss.str();
+            }
+        };
+
+        template<class L, class... Args>
+        struct statement_serializator<in_t<L, Args...>, void> {
+            using statement_type = in_t<L, Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                auto leftString = serialize(c.left, context);
+                ss << leftString << " " << static_cast<std::string>(c) << " (";
+                std::vector<std::string> args;
+                using args_type = std::tuple<Args...>;
+                args.reserve(std::tuple_size<args_type>::value);
+                iterate_tuple(c.argument, [&args, &context](auto& v) {
+                    args.push_back(serialize(v, context));
+                });
+                for(size_t i = 0; i < args.size(); ++i) {
+                    ss << args[i];
+                    if(i < args.size() - 1) {
+                        ss << ", ";
+                    }
+                }
+                ss << ")";
+                return ss.str();
+            }
+        };
+
+        template<class A, class T, class E>
+        struct statement_serializator<like_t<A, T, E>, void> {
+            using statement_type = like_t<A, T, E>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                ss << serialize(c.arg, context) << " ";
+                ss << static_cast<std::string>(c) << " ";
+                ss << serialize(c.pattern, context);
+                c.arg3.apply([&ss, &context](auto& value) {
+                    ss << " ESCAPE " << serialize(value, context);
+                });
+                return ss.str();
+            }
+        };
+
+        template<class A, class T>
+        struct statement_serializator<glob_t<A, T>, void> {
+            using statement_type = glob_t<A, T>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                ss << serialize(c.arg, context) << " ";
+                ss << static_cast<std::string>(c) << " ";
+                ss << serialize(c.pattern, context);
+                return ss.str();
+            }
+        };
+
+        template<class A, class T>
+        struct statement_serializator<between_t<A, T>, void> {
+            using statement_type = between_t<A, T>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                auto expr = serialize(c.expr, context);
+                ss << expr << " " << static_cast<std::string>(c) << " ";
+                ss << serialize(c.b1, context);
+                ss << " AND ";
+                ss << serialize(c.b2, context);
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<exists_t<T>, void> {
+            using statement_type = exists_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                ss << static_cast<std::string>(c) << " ";
+                ss << serialize(c.t, context);
+                return ss.str();
+            }
+        };
+
+        template<>
+        struct statement_serializator<autoincrement_t, void> {
+            using statement_type = autoincrement_t;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C&) const {
+                return "AUTOINCREMENT";
+            }
+        };
+
+        template<class... Cs>
+        struct statement_serializator<primary_key_t<Cs...>, void> {
+            using statement_type = primary_key_t<Cs...>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                auto res = static_cast<std::string>(c);
+                using columns_tuple = typename statement_type::columns_tuple;
+                auto columnsCount = std::tuple_size<columns_tuple>::value;
+                if(columnsCount) {
+                    res += "(";
+                    decltype(columnsCount) columnIndex = 0;
+                    iterate_tuple(c.columns, [&context, &res, &columnIndex, columnsCount](auto& column) {
+                        if(auto columnNamePointer = find_column_name(context.impl, column)) {
+                            res += *columnNamePointer;
+                            if(columnIndex < columnsCount - 1) {
+                                res += ", ";
+                            }
+                            ++columnIndex;
+                        } else {
+                            throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                        }
+                    });
+                    res += ")";
+                }
+                return res;
+            }
+        };
+
+        template<class... Args>
+        struct statement_serializator<unique_t<Args...>, void> {
+            using statement_type = unique_t<Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                auto res = static_cast<std::string>(c);
+                using columns_tuple = typename statement_type::columns_tuple;
+                auto columnsCount = std::tuple_size<columns_tuple>::value;
+                if(columnsCount) {
+                    res += "(";
+                    decltype(columnsCount) columnIndex = 0;
+                    iterate_tuple(c.columns, [&context, &res, &columnIndex, columnsCount](auto& column) {
+                        if(auto columnNamePointer = find_column_name(context.impl, column)) {
+                            res += *columnNamePointer;
+                            if(columnIndex < columnsCount - 1) {
+                                res += ", ";
+                            }
+                            ++columnIndex;
+                        } else {
+                            throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                        }
+                    });
+                    res += ")";
+                }
+                return res;
+            }
+        };
+
+        template<>
+        struct statement_serializator<collate_constraint_t, void> {
+            using statement_type = collate_constraint_t;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C&) const {
+                return static_cast<std::string>(c);
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<default_t<T>, void> {
+            using statement_type = default_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                return static_cast<std::string>(c) + " (" + serialize(c.value, context) + ")";
+            }
+        };
+
+        template<class... Cs, class... Rs>
+        struct statement_serializator<foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>>, void> {
+            using statement_type = foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>>;
+
+            template<class C>
+            std::string operator()(const statement_type& fk, const C& context) const {
+                std::stringstream ss;
+                std::vector<std::string> columnNames;
+                using columns_type_t = typename std::decay<decltype(fk)>::type::columns_type;
+                constexpr const size_t columnsCount = std::tuple_size<columns_type_t>::value;
+                columnNames.reserve(columnsCount);
+                iterate_tuple(fk.columns, [&columnNames, &context](auto& v) {
+                    if(auto columnNamePointer = find_column_name(context.impl, v)) {
+                        columnNames.push_back(*columnNamePointer);
+                    } else {
+                        columnNames.push_back({});
+                    }
+                });
+                ss << "FOREIGN KEY(";
+                for(size_t i = 0; i < columnNames.size(); ++i) {
+                    ss << "'" << columnNames[i] << "'";
+                    if(i < columnNames.size() - 1) {
+                        ss << ", ";
+                    }
+                }
+                ss << ") REFERENCES ";
+                std::vector<std::string> referencesNames;
+                using references_type_t = typename std::decay<decltype(fk)>::type::references_type;
+                constexpr const size_t referencesCount = std::tuple_size<references_type_t>::value;
+                referencesNames.reserve(referencesCount);
+                {
+                    using first_reference_t = typename std::tuple_element<0, references_type_t>::type;
+                    using first_reference_mapped_type = typename internal::table_type<first_reference_t>::type;
+                    auto refTableName = lookup_table_name<first_reference_mapped_type>(context.impl);
+                    ss << '\'' << refTableName << '\'';
+                }
+                iterate_tuple(fk.references, [&referencesNames, &context](auto& v) {
+                    if(auto columnNamePointer = find_column_name(context.impl, v)) {
+                        referencesNames.push_back(*columnNamePointer);
+                    } else {
+                        referencesNames.push_back({});
+                    }
+                });
+                ss << "(";
+                for(size_t i = 0; i < referencesNames.size(); ++i) {
+                    ss << "'" << referencesNames[i] << "'";
+                    if(i < referencesNames.size() - 1) {
+                        ss << ", ";
+                    }
+                }
+                ss << ")";
+                if(fk.on_update) {
+                    ss << ' ' << static_cast<std::string>(fk.on_update) << " " << fk.on_update._action;
+                }
+                if(fk.on_delete) {
+                    ss << ' ' << static_cast<std::string>(fk.on_delete) << " " << fk.on_delete._action;
+                }
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<check_t<T>, void> {
+            using statement_type = check_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                return static_cast<std::string>(statement) + " " + serialize(statement.expression, context);
+            }
+        };
+#if SQLITE_VERSION_NUMBER >= 3031000
+        template<class T>
+        struct statement_serializator<generated_always_t<T>, void> {
+            using statement_type = generated_always_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                if(statement.full) {
+                    ss << "GENERATED ALWAYS ";
+                }
+                ss << "AS ";
+                ss << serialize(statement.expression, context);
+                switch(statement.storage) {
+                    case decltype(statement.storage)::not_specified:
+                        //..
+                        break;
+                    case decltype(statement.storage)::virtual_:
+                        ss << " VIRTUAL";
+                        break;
+                    case decltype(statement.storage)::stored:
+                        ss << " STORED";
+                        break;
+                }
+                return ss.str();
+            }
+        };
+#endif
+        template<class O, class T, class G, class S, class... Op>
+        struct statement_serializator<column_t<O, T, G, S, Op...>, void> {
+            using statement_type = column_t<O, T, G, S, Op...>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                ss << "'" << c.name << "' ";
+                using column_type = typename std::decay<decltype(c)>::type;
+                using field_type = typename column_type::field_type;
+                using constraints_type = typename column_type::constraints_type;
+                ss << type_printer<field_type>().print() << " ";
+                {
+                    std::vector<std::string> constraintsStrings;
+                    constexpr const size_t constraintsCount = std::tuple_size<constraints_type>::value;
+                    constraintsStrings.reserve(constraintsCount);
+                    int primaryKeyIndex = -1;
+                    int autoincrementIndex = -1;
+                    int tupleIndex = 0;
+                    iterate_tuple(
+                        c.constraints,
+                        [&constraintsStrings, &primaryKeyIndex, &autoincrementIndex, &tupleIndex, &context](auto& v) {
+                            using constraint_type = typename std::decay<decltype(v)>::type;
+                            constraintsStrings.push_back(serialize(v, context));
+                            if(is_primary_key<constraint_type>::value) {
+                                primaryKeyIndex = tupleIndex;
+                            } else if(std::is_same<autoincrement_t, constraint_type>::value) {
+                                autoincrementIndex = tupleIndex;
+                            }
+                            ++tupleIndex;
+                        });
+                    if(primaryKeyIndex != -1 && autoincrementIndex != -1 && autoincrementIndex < primaryKeyIndex) {
+                        iter_swap(constraintsStrings.begin() + primaryKeyIndex,
+                                  constraintsStrings.begin() + autoincrementIndex);
+                    }
+                    for(auto& str: constraintsStrings) {
+                        ss << str << ' ';
+                    }
+                }
+                if(c.not_null()) {
+                    ss << "NOT NULL ";
+                }
+                return ss.str();
+            }
+        };
+
+        template<class T, class... Args>
+        struct statement_serializator<remove_all_t<T, Args...>, void> {
+            using statement_type = remove_all_t<T, Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& rem, const C& context) const {
+                auto& tImpl = context.impl.template get_impl<T>();
+                std::stringstream ss;
+                ss << "DELETE FROM '" << tImpl.table.name << "' ";
+                iterate_tuple(rem.conditions, [&context, &ss](auto& v) {
+                    ss << serialize(v, context);
+                });
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<replace_t<T>, void> {
+            using statement_type = replace_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                using expression_type = typename std::decay<decltype(statement)>::type;
+                using object_type = typename expression_object_type<expression_type>::type;
+                auto& tImpl = context.impl.template get_impl<object_type>();
+                std::stringstream ss;
+                ss << "REPLACE INTO '" << tImpl.table.name << "' (";
+
+                auto columnIndex = 0;
+                auto columnsCount = tImpl.table.non_generated_columns_count();
+                tImpl.table.for_each_column([&ss, &columnIndex, columnsCount](auto& column) {
+                    if(column.is_generated()) {
+                        return;
+                    }
+                    ss << "\"" << column.name << "\"";
+                    if(columnIndex < columnsCount - 1) {
+                        ss << ", ";
+                    } else {
+                        ss << ")";
+                    }
+                    ++columnIndex;
+                });
+                ss << " VALUES (";
+                columnIndex = 0;
+                auto& object = get_ref(statement.object);
+                tImpl.table.for_each_column([&ss, &columnIndex, columnsCount, &object, &context](auto& column) {
+                    if(column.is_generated()) {
+                        return;
+                    }
+                    if(column.member_pointer) {
+                        ss << serialize(object.*column.member_pointer, context);
+                    } else {
+                        ss << serialize((object.*column.getter)(), context);
+                    }
+                    if(columnIndex < columnsCount - 1) {
+                        ss << ", ";
+                    } else {
+                        ss << ")";
+                    }
+                    ++columnIndex;
+                });
+                return ss.str();
+            }
+        };
+
+        template<class T, class... Cols>
+        struct statement_serializator<insert_explicit<T, Cols...>, void> {
+            using statement_type = insert_explicit<T, Cols...>;
+
+            template<class C>
+            std::string operator()(const statement_type& ins, const C& context) const {
+                constexpr const size_t colsCount = std::tuple_size<std::tuple<Cols...>>::value;
+                static_assert(colsCount > 0, "Use insert or replace with 1 argument instead");
+                using expression_type = typename std::decay<decltype(ins)>::type;
+                using object_type = typename expression_object_type<expression_type>::type;
+                auto& tImpl = context.impl.template get_impl<object_type>();
+                std::stringstream ss;
+                ss << "INSERT INTO '" << tImpl.table.name << "' ";
+                std::vector<std::string> columnNames;
+                columnNames.reserve(colsCount);
+                {
+                    auto columnsContext = context;
+                    columnsContext.skip_table_name = true;
+                    iterate_tuple(ins.columns.columns, [&columnNames, &columnsContext](auto& m) {
+                        auto columnName = serialize(m, columnsContext);
+                        if(!columnName.empty()) {
+                            columnNames.push_back(columnName);
+                        } else {
+                            throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                        }
+                    });
+                }
+                ss << "(";
+                for(size_t i = 0; i < columnNames.size(); ++i) {
+                    ss << columnNames[i];
+                    if(i < columnNames.size() - 1) {
+                        ss << ",";
+                    } else {
+                        ss << ")";
+                    }
+                    ss << " ";
+                }
+                ss << "VALUES (";
+                for(size_t i = 0; i < columnNames.size(); ++i) {
+                    ss << "?";
+                    if(i < columnNames.size() - 1) {
+                        ss << ",";
+                    } else {
+                        ss << ")";
+                    }
+                    ss << " ";
+                }
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<update_t<T>, void> {
+            using statement_type = update_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                using expression_type = typename std::decay<decltype(statement)>::type;
+                using object_type = typename expression_object_type<expression_type>::type;
+                auto& tImpl = context.impl.template get_impl<object_type>();
+
+                std::stringstream ss;
+                ss << "UPDATE '" << tImpl.table.name << "' SET";
+                //                std::vector<std::string> setColumnNames;
+                auto columnIndex = 0;
+                auto& object = get_ref(statement.object);
+                tImpl.table.for_each_column([&tImpl, &columnIndex, &ss, &object, &context](auto& column) {
+                    if(!column.template has<primary_key_t<>>() &&
+                       !tImpl.table.exists_in_composite_primary_key(column)) {
+                        if(0 == columnIndex) {
+                            ss << ' ';
+                        } else {
+                            ss << ", ";
+                        }
+                        ss << "\"" << column.name << "\" = ";
+                        if(column.member_pointer) {
+                            ss << serialize(object.*column.member_pointer, context);
+                        } else {
+                            ss << serialize((object.*column.getter)(), context);
+                        }
+                        ++columnIndex;
+                    }
+                });
+                ss << " WHERE";
+                columnIndex = 0;
+                tImpl.table.for_each_column([&tImpl, &columnIndex, &ss, &object, &context](auto& column) {
+                    if(column.template has<primary_key_t<>>() || tImpl.table.exists_in_composite_primary_key(column)) {
+                        if(0 == columnIndex) {
+                            ss << ' ';
+                        } else {
+                            ss << " AND ";
+                        }
+                        ss << "\"" << column.name << "\" = ";
+                        if(column.member_pointer) {
+                            ss << serialize(object.*column.member_pointer, context);
+                        } else {
+                            ss << serialize((object.*column.getter)(), context);
+                        }
+                        ++columnIndex;
+                    }
+                });
+                return ss.str();
+            }
+        };
+
+        template<class... Args>
+        struct statement_serializator<set_t<Args...>, void> {
+            using statement_type = set_t<Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                ss << static_cast<std::string>(statement);
+                auto assignsCount = std::tuple_size<typename statement_type::assigns_type>::value;
+                decltype(assignsCount) assignIndex = 0;
+                auto leftContext = context;
+                leftContext.skip_table_name = true;
+                iterate_tuple(statement.assigns,
+                              [&ss, &context, &leftContext, &assignIndex, assignsCount](auto& value) {
+                                  ss << ' ' << serialize(value.lhs, leftContext);
+                                  ss << ' ' << static_cast<std::string>(value) << ' ';
+                                  ss << serialize(value.rhs, context);
+                                  if(assignIndex < assignsCount - 1) {
+                                      ss << ",";
+                                  }
+                                  ++assignIndex;
+                              });
+                return ss.str();
+            }
+        };
+
+        template<class... Args, class... Wargs>
+        struct statement_serializator<update_all_t<set_t<Args...>, Wargs...>, void> {
+            using statement_type = update_all_t<set_t<Args...>, Wargs...>;
+
+            template<class C>
+            std::string operator()(const statement_type& upd, const C& context) const {
+                std::stringstream ss;
+                ss << "UPDATE";
+                table_name_collector collector([&context](std::type_index ti) {
+                    return context.impl.find_table_name(ti);
+                });
+                iterate_ast(upd.set.assigns, collector);
+                if(!collector.table_names.empty()) {
+                    if(collector.table_names.size() == 1) {
+                        ss << " '" << collector.table_names.begin()->first << "' ";
+                        ss << static_cast<std::string>(upd.set) << " ";
+                        std::vector<std::string> setPairs;
+                        auto leftContext = context;
+                        leftContext.skip_table_name = true;
+                        iterate_tuple(upd.set.assigns, [&context, &leftContext, &setPairs](auto& asgn) {
+                            std::stringstream sss;
+                            sss << serialize(asgn.lhs, leftContext);
+                            sss << " " << static_cast<std::string>(asgn) << " ";
+                            sss << serialize(asgn.rhs, context);
+                            setPairs.push_back(sss.str());
+                        });
+                        auto setPairsCount = setPairs.size();
+                        for(size_t i = 0; i < setPairsCount; ++i) {
+                            ss << setPairs[i] << " ";
+                            if(i < setPairsCount - 1) {
+                                ss << ", ";
+                            }
+                        }
+                        iterate_tuple(upd.conditions, [&context, &ss](auto& v) {
+                            ss << serialize(v, context);
+                        });
+                        return ss.str();
+                    } else {
+                        throw std::system_error(std::make_error_code(orm_error_code::too_many_tables_specified));
+                    }
+                } else {
+                    throw std::system_error(std::make_error_code(orm_error_code::incorrect_set_fields_specified));
+                }
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<insert_t<T>, void> {
+            using statement_type = insert_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                using object_type = typename expression_object_type<statement_type>::type;
+                auto& tImpl = context.impl.template get_impl<object_type>();
+
+                std::stringstream ss;
+                ss << "INSERT INTO '" << tImpl.table.name << "' ";
+
+                auto columnIndex = 0;
+                tImpl.table.for_each_column([&tImpl, &columnIndex, &ss](auto& column) {
+                    using table_type = typename std::decay<decltype(tImpl.table)>::type;
+                    if(table_type::is_without_rowid ||
+                       (!column.template has<primary_key_t<>>() &&
+                        !tImpl.table.exists_in_composite_primary_key(column) && !column.is_generated())) {
+                        if(0 == columnIndex) {
+                            ss << '(';
+                        } else {
+                            ss << ", ";
+                        }
+                        ss << "\"" << column.name << "\"";
+                        ++columnIndex;
+                    }
+                });
+                auto columnsToInsertCount = columnIndex;
+                if(columnsToInsertCount > 0) {
+                    ss << ')';
+                } else {
+                    ss << "DEFAULT";
+                }
+                ss << " VALUES ";
+                if(columnsToInsertCount) {
+                    ss << "(";
+                    columnIndex = 0;
+                    auto& object = get_ref(statement.object);
+                    tImpl.table.for_each_column(
+                        [&tImpl, &columnIndex, &ss, columnsToInsertCount, &context, &object](auto& column) {
+                            using table_type = typename std::decay<decltype(tImpl.table)>::type;
+                            if(table_type::is_without_rowid ||
+                               (!column.template has<primary_key_t<>>() &&
+                                !tImpl.table.exists_in_composite_primary_key(column) && !column.is_generated())) {
+                                if(column.member_pointer) {
+                                    ss << serialize(object.*column.member_pointer, context);
+                                } else {
+                                    ss << serialize((object.*column.getter)(), context);
+                                }
+                                if(columnIndex < columnsToInsertCount - 1) {
+                                    ss << ", ";
+                                }
+                                ++columnIndex;
+                            }
+                        });
+                    ss << ")";
+                }
+
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<into_t<T>, void> {
+            using statement_type = into_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                auto& tImpl = context.impl.template get_impl<T>();
+                ss << "INTO " << tImpl.table.name;
+                return ss.str();
+            }
+        };
+
+        template<class... Args>
+        struct statement_serializator<columns_t<Args...>, void> {
+            using statement_type = columns_t<Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                auto index = 0;
+                if(context.use_parentheses) {
+                    ss << '(';
+                }
+                iterate_tuple(statement.columns, [&context, &ss, &index](auto& value) {
+                    ss << serialize(value, context);
+                    if(index < int(std::tuple_size<std::tuple<Args...>>::value) - 1) {
+                        ss << ", ";
+                    }
+                    ++index;
+                });
+                if(context.use_parentheses) {
+                    ss << ')';
+                }
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<
+            T,
+            typename std::enable_if<is_insert_raw<T>::value || is_replace_raw<T>::value>::type> {
+            using statement_type = T;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                if(is_insert_raw<T>::value) {
+                    ss << "INSERT";
+                } else {
+                    ss << "REPLACE";
+                }
+                iterate_tuple(statement.args, [&context, &ss](auto& value) {
+                    using value_type = typename std::decay<decltype(value)>::type;
+                    ss << ' ';
+                    if(is_columns<value_type>::value) {
+                        auto newContext = context;
+                        newContext.skip_table_name = true;
+                        newContext.use_parentheses = true;
+                        ss << serialize(value, newContext);
+                    } else if(is_values<value_type>::value || is_select<value_type>::value) {
+                        auto newContext = context;
+                        newContext.use_parentheses = false;
+                        ss << serialize(value, newContext);
+                    } else {
+                        ss << serialize(value, context);
+                    }
+                });
+                return ss.str();
+            }
+        };
+
+        template<class T, class... Ids>
+        struct statement_serializator<remove_t<T, Ids...>, void> {
+            using statement_type = remove_t<T, Ids...>;
+
+            template<class C>
+            std::string operator()(const statement_type&, const C& context) const {
+                auto& tImpl = context.impl.template get_impl<T>();
+                std::stringstream ss;
+                ss << "DELETE FROM '" << tImpl.table.name << "' ";
+                ss << "WHERE ";
+                auto primaryKeyColumnNames = tImpl.table.primary_key_column_names();
+                for(size_t i = 0; i < primaryKeyColumnNames.size(); ++i) {
+                    ss << "\"" << primaryKeyColumnNames[i] << "\""
+                       << " = ? ";
+                    if(i < primaryKeyColumnNames.size() - 1) {
+                        ss << "AND ";
+                    }
+                }
+                return ss.str();
+            }
+        };
+
+        template<class It, class L, class O>
+        struct statement_serializator<replace_range_t<It, L, O>, void> {
+            using statement_type = replace_range_t<It, L, O>;
+
+            template<class C>
+            std::string operator()(const statement_type& rep, const C& context) const {
+                auto valuesCount = static_cast<int>(std::distance(rep.range.first, rep.range.second));
+                using expression_type = typename std::decay<decltype(rep)>::type;
+                using object_type = typename expression_object_type<expression_type>::type;
+                auto& tImpl = context.impl.template get_impl<object_type>();
+                std::stringstream ss;
+                ss << "REPLACE INTO '" << tImpl.table.name << "' (";
+
+                auto columnIndex = 0;
+                auto columnsCount = tImpl.table.non_generated_columns_count();
+                tImpl.table.for_each_column([&ss, &columnIndex, columnsCount](auto& column) {
+                    if(column.is_generated()) {
+                        return;
+                    }
+                    ss << " \"" << column.name << "\"";
+                    if(columnIndex < columnsCount - 1) {
+                        ss << ",";
+                    } else {
+                        ss << ")";
+                    }
+                    ++columnIndex;
+                });
+                ss << " VALUES ";
+                auto valuesString = [columnsCount] {
+                    std::stringstream ss_;
+                    ss_ << "(";
+                    for(auto i = 0; i < columnsCount; ++i) {
+                        ss_ << "?";
+                        if(i < columnsCount - 1) {
+                            ss_ << ", ";
+                        } else {
+                            ss_ << ")";
+                        }
+                    }
+                    return ss_.str();
+                }();
+                for(auto i = 0; i < valuesCount; ++i) {
+                    ss << valuesString;
+                    if(i < valuesCount - 1) {
+                        ss << ",";
+                    }
+                    ss << " ";
+                }
+                return ss.str();
+            }
+        };
+
+        template<class It, class L, class O>
+        struct statement_serializator<insert_range_t<It, L, O>, void> {
+            using statement_type = insert_range_t<It, L, O>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                const auto valuesCount = static_cast<int>(std::distance(statement.range.first, statement.range.second));
+                using object_type = typename expression_object_type<statement_type>::type;
+                auto& tImpl = context.impl.template get_impl<object_type>();
+
+                std::stringstream ss;
+                ss << "INSERT INTO '" << tImpl.table.name << "' ";
+                std::vector<std::string> columnNames;
+
+                tImpl.table.for_each_column([&columnNames, &tImpl](auto& column) {
+                    using table_type = typename std::decay<decltype(tImpl.table)>::type;
+                    if(table_type::is_without_rowid ||
+                       (!column.template has<primary_key_t<>>() &&
+                        !tImpl.table.exists_in_composite_primary_key(column) && !column.is_generated())) {
+                        columnNames.emplace_back(column.name);
+                    }
+                });
+
+                const auto columnNamesCount = columnNames.size();
+                if(columnNamesCount) {
+                    ss << "(";
+                    for(size_t i = 0; i < columnNamesCount; ++i) {
+                        ss << "\"" << columnNames[i] << "\"";
+                        if(i < columnNamesCount - 1) {
+                            ss << ",";
+                        } else {
+                            ss << ")";
+                        }
+                        ss << " ";
+                    }
+                } else {
+                    ss << "DEFAULT ";
+                }
+                ss << "VALUES ";
+                if(columnNamesCount) {
+                    auto valuesString = [columnNamesCount] {
+                        std::stringstream ss_;
+                        ss_ << "(";
+                        for(size_t i = 0; i < columnNamesCount; ++i) {
+                            ss_ << "?";
+                            if(i < columnNamesCount - 1) {
+                                ss_ << ", ";
+                            } else {
+                                ss_ << ")";
+                            }
+                        }
+                        return ss_.str();
+                    }();
+                    for(auto i = 0; i < valuesCount; ++i) {
+                        ss << valuesString;
+                        if(i < valuesCount - 1) {
+                            ss << ",";
+                        }
+                        ss << " ";
+                    }
+                } else if(valuesCount != 1) {
+                    throw std::system_error(std::make_error_code(orm_error_code::cannot_use_default_value));
+                }
+                return ss.str();
+            }
+        };
+
+        template<class T, class C>
+        std::string serialize_get_all_impl(const T& get, const C& context) {
+            using primary_type = typename T::type;
+
+            table_name_collector collector;
+            collector.table_names.insert(
+                std::make_pair(context.impl.find_table_name(typeid(primary_type)), std::string{}));
+            iterate_ast(get.conditions, collector);
+            std::stringstream ss;
+            ss << "SELECT";
+            auto& tImpl = context.impl.template get_impl<primary_type>();
+            auto columnIndex = 0;
+            auto columnsCount = tImpl.table.count_columns_amount();
+            tImpl.table.for_each_column([&ss, &columnIndex, columnsCount, &tImpl](auto& column) {
+                ss << " \"" << tImpl.table.name << "\"."
+                   << "\"" << column.name << "\"";
+                if(columnIndex < columnsCount - 1) {
+                    ss << ",";
+                }
+                ++columnIndex;
+            });
+            ss << " FROM ";
+            std::vector<std::pair<std::string, std::string>> tableNames(collector.table_names.begin(),
+                                                                        collector.table_names.end());
+            for(size_t i = 0; i < tableNames.size(); ++i) {
+                auto& tableNamePair = tableNames[i];
+                ss << "'" << tableNamePair.first << "' ";
+                if(!tableNamePair.second.empty()) {
+                    ss << tableNamePair.second << " ";
+                }
+                if(int(i) < int(tableNames.size()) - 1) {
+                    ss << ",";
+                }
+                ss << " ";
+            }
+            iterate_tuple(get.conditions, [&context, &ss](auto& v) {
+                ss << serialize(v, context);
+            });
+            return ss.str();
+        }
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class T, class R, class... Args>
+        struct statement_serializator<get_all_optional_t<T, R, Args...>, void> {
+            using statement_type = get_all_optional_t<T, R, Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& get, const C& context) const {
+                return serialize_get_all_impl(get, context);
+            }
+        };
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+
+        template<class T, class R, class... Args>
+        struct statement_serializator<get_all_pointer_t<T, R, Args...>, void> {
+            using statement_type = get_all_pointer_t<T, R, Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& get, const C& context) const {
+                return serialize_get_all_impl(get, context);
+            }
+        };
+
+        template<class T, class R, class... Args>
+        struct statement_serializator<get_all_t<T, R, Args...>, void> {
+            using statement_type = get_all_t<T, R, Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& get, const C& context) const {
+                return serialize_get_all_impl(get, context);
+            }
+        };
+
+        template<class T, class C>
+        std::string serialize_get_impl(const T&, const C& context) {
+            using primary_type = typename T::type;
+            auto& tImpl = context.impl.template get_impl<primary_type>();
+            std::stringstream ss;
+            ss << "SELECT";
+            auto columnIndex = 0;
+            auto columnsCount = tImpl.table.count_columns_amount();
+            tImpl.table.for_each_column([&ss, &columnIndex, columnsCount](auto& column) {
+                ss << " \"" << column.name << "\"";
+                if(columnIndex < columnsCount - 1) {
+                    ss << ", ";
+                }
+                ++columnIndex;
+            });
+            ss << " FROM '" << tImpl.table.name << "' WHERE ";
+            auto primaryKeyColumnNames = tImpl.table.primary_key_column_names();
+            if(!primaryKeyColumnNames.empty()) {
+                for(size_t i = 0; i < primaryKeyColumnNames.size(); ++i) {
+                    ss << " \"" << primaryKeyColumnNames[i] << "\""
+                       << " = ?";
+                    if(i < primaryKeyColumnNames.size() - 1) {
+                        ss << " AND";
+                    }
+                }
+                return ss.str();
+            } else {
+                throw std::system_error(std::make_error_code(orm_error_code::table_has_no_primary_key_column));
+            }
+        }
+
+        template<class T, class... Ids>
+        struct statement_serializator<get_t<T, Ids...>, void> {
+            using statement_type = get_t<T, Ids...>;
+
+            template<class C>
+            std::string operator()(const statement_type& get, const C& context) const {
+                return serialize_get_impl(get, context);
+            }
+        };
+
+        template<class T, class... Ids>
+        struct statement_serializator<get_pointer_t<T, Ids...>, void> {
+            using statement_type = get_pointer_t<T, Ids...>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                return serialize_get_impl(statement, context);
+            }
+        };
+
+        template<>
+        struct statement_serializator<conflict_action, void> {
+            using statement_type = conflict_action;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                switch(statement) {
+                    case conflict_action::replace:
+                        return "REPLACE";
+                    case conflict_action::abort:
+                        return "ABORT";
+                    case conflict_action::fail:
+                        return "FAIL";
+                    case conflict_action::ignore:
+                        return "IGNORE";
+                    case conflict_action::rollback:
+                        return "ROLLBACK";
+                }
+            }
+        };
+
+        template<>
+        struct statement_serializator<insert_constraint, void> {
+            using statement_type = insert_constraint;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                return "OR " + serialize(statement.action, context);
+            }
+        };
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class T, class... Ids>
+        struct statement_serializator<get_optional_t<T, Ids...>, void> {
+            using statement_type = get_optional_t<T, Ids...>;
+
+            template<class C>
+            std::string operator()(const statement_type& get, const C& context) const {
+                return serialize_get_impl(get, context);
+            }
+        };
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class T, class... Args>
+        struct statement_serializator<select_t<T, Args...>, void> {
+            using statement_type = select_t<T, Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& sel, const C& context) const {
+                std::stringstream ss;
+                constexpr bool isCompoundOperator = is_base_of_template<T, compound_operator>::value;
+                if(!isCompoundOperator) {
+                    if(!sel.highest_level && context.use_parentheses) {
+                        ss << "(";
+                    }
+                    ss << "SELECT ";
+                }
+                if(get_distinct(sel.col)) {
+                    ss << static_cast<std::string>(distinct(0)) << " ";
+                }
+                auto columnNames = get_column_names(sel.col, context);
+                for(size_t i = 0; i < columnNames.size(); ++i) {
+                    ss << columnNames[i];
+                    if(i < columnNames.size() - 1) {
+                        ss << ", ";
+                    }
+                }
+                table_name_collector collector([&context](std::type_index ti) {
+                    return context.impl.find_table_name(ti);
+                });
+                const auto explicitFromItemsCount = count_tuple<std::tuple<Args...>, is_from>::value;
+                if(!explicitFromItemsCount) {
+                    iterate_ast(sel.col, collector);
+                    iterate_ast(sel.conditions, collector);
+                    join_iterator<Args...>()([&collector, &context](const auto& c) {
+                        using original_join_type = typename std::decay<decltype(c)>::type::join_type::type;
+                        using cross_join_type = typename internal::mapped_type_proxy<original_join_type>::type;
+                        auto crossJoinedTableName = lookup_table_name<cross_join_type>(context.impl);
+                        auto tableAliasString = alias_extractor<original_join_type>::get();
+                        std::pair<std::string, std::string> tableNameWithAlias(std::move(crossJoinedTableName),
+                                                                               std::move(tableAliasString));
+                        collector.table_names.erase(tableNameWithAlias);
+                    });
+                    if(!collector.table_names.empty() && !isCompoundOperator) {
+                        ss << " FROM ";
+                        std::vector<std::pair<std::string, std::string>> tableNames(collector.table_names.begin(),
+                                                                                    collector.table_names.end());
+                        for(size_t i = 0; i < tableNames.size(); ++i) {
+                            auto& tableNamePair = tableNames[i];
+                            ss << "'" << tableNamePair.first << "'";
+                            if(!tableNamePair.second.empty()) {
+                                ss << ' ' << tableNamePair.second;
+                            }
+                            if(int(i) < int(tableNames.size()) - 1) {
+                                ss << ", ";
+                            }
+                        }
+                    }
+                }
+                iterate_tuple(sel.conditions, [&context, &ss](auto& v) {
+                    ss << ' ' << serialize(v, context);
+                });
+                if(!isCompoundOperator) {
+                    if(!sel.highest_level && context.use_parentheses) {
+                        ss << ")";
+                    }
+                }
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<indexed_column_t<T>, void> {
+            using statement_type = indexed_column_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                ss << serialize(statement.column_or_expression, context);
+                if(!statement._collation_name.empty()) {
+                    ss << " COLLATE " << statement._collation_name;
+                }
+                if(statement._order) {
+                    switch(statement._order) {
+                        case -1:
+                            ss << " DESC";
+                            break;
+                        case 1:
+                            ss << " ASC";
+                            break;
+                        default:
+                            throw std::system_error(std::make_error_code(orm_error_code::incorrect_order));
+                    }
+                }
+                return ss.str();
+            }
+        };
+
+        template<class... Cols>
+        struct statement_serializator<index_t<Cols...>, void> {
+            using statement_type = index_t<Cols...>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                ss << "CREATE ";
+                if(statement.unique) {
+                    ss << "UNIQUE ";
+                }
+                using elements_type = typename std::decay<decltype(statement)>::type::elements_type;
+                using head_t = typename std::tuple_element<0, elements_type>::type::column_type;
+                using indexed_type = typename table_type<head_t>::type;
+                ss << "INDEX IF NOT EXISTS '" << statement.name << "' ON '"
+                   << lookup_table_name<indexed_type>(context.impl) << "' (";
+                std::vector<std::string> columnNames;
+                iterate_tuple(statement.elements, [&columnNames, &context](auto& v) {
+                    auto columnName = serialize(v, context);
+                    columnNames.push_back(move(columnName));
+                });
+                for(size_t i = 0; i < columnNames.size(); ++i) {
+                    ss << columnNames[i];
+                    if(i < columnNames.size() - 1) {
+                        ss << ", ";
+                    }
+                }
+                ss << ")";
+                return ss.str();
+            }
+        };
+
+        template<class... Args>
+        struct statement_serializator<from_t<Args...>, void> {
+            using statement_type = from_t<Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                using tuple = std::tuple<Args...>;
+
+                std::stringstream ss;
+                ss << "FROM ";
+                size_t index = 0;
+                iterate_tuple<tuple>([&context, &ss, &index](auto* itemPointer) {
+                    using from_type = std::remove_cv_t<std::remove_pointer_t<decltype(itemPointer)>>;
+
+                    auto aliasString = alias_extractor<from_type>::get();
+                    ss << "'" << lookup_table_name<typename mapped_type_proxy<from_type>::type>(context.impl) << "'";
+                    if(!aliasString.empty()) {
+                        ss << " '" << aliasString << "'";
+                    }
+                    if(index < std::tuple_size<tuple>::value - 1) {
+                        ss << ", ";
+                    }
+                    ++index;
+                });
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<where_t<T>, void> {
+            using statement_type = where_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                auto newContext = context;
+                // be on the safe side
+                newContext.skip_table_name = false;
+
+                std::stringstream ss;
+                ss << statement.serialize() << " ";
+                auto whereString = serialize(statement.expression, newContext);
+                ss << '(' << whereString << ')';
+                return ss.str();
+            }
+        };
+
+        template<class O>
+        struct statement_serializator<order_by_t<O>, void> {
+            using statement_type = order_by_t<O>;
+
+            template<class C>
+            std::string operator()(const statement_type& orderBy, const C& context) const {
+                std::stringstream ss;
+                ss << static_cast<std::string>(orderBy) << " ";
+                auto orderByString = serialize_order_by(orderBy, context);
+                ss << orderByString << " ";
+                return ss.str();
+            }
+        };
+
+        template<class C>
+        struct statement_serializator<dynamic_order_by_t<C>, void> {
+            using statement_type = dynamic_order_by_t<C>;
+
+            template<class CC>
+            std::string operator()(const statement_type& orderBy, const CC& context) const {
+                return serialize_order_by(orderBy, context);
+            }
+        };
+
+        template<class... Args>
+        struct statement_serializator<multi_order_by_t<Args...>, void> {
+            using statement_type = multi_order_by_t<Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& orderBy, const C& context) const {
+                std::stringstream ss;
+                std::vector<std::string> expressions;
+                iterate_tuple(orderBy.args, [&expressions, &context](auto& v) {
+                    auto expression = serialize_order_by(v, context);
+                    expressions.push_back(move(expression));
+                });
+                ss << static_cast<std::string>(orderBy) << " ";
+                for(size_t i = 0; i < expressions.size(); ++i) {
+                    ss << expressions[i];
+                    if(i < expressions.size() - 1) {
+                        ss << ", ";
+                    }
+                }
+                ss << " ";
+                return ss.str();
+            }
+        };
+
+        template<class O>
+        struct statement_serializator<cross_join_t<O>, void> {
+            using statement_type = cross_join_t<O>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                ss << static_cast<std::string>(c) << " ";
+                ss << " '" << lookup_table_name<O>(context.impl) << "'";
+                return ss.str();
+            }
+        };
+
+        template<class T, class O>
+        struct statement_serializator<inner_join_t<T, O>, void> {
+            using statement_type = inner_join_t<T, O>;
+
+            template<class C>
+            std::string operator()(const statement_type& l, const C& context) const {
+                std::stringstream ss;
+                ss << static_cast<std::string>(l) << " ";
+                auto aliasString = alias_extractor<T>::get();
+                ss << " '" << lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl) << "' ";
+                if(aliasString.length()) {
+                    ss << "'" << aliasString << "' ";
+                }
+                ss << serialize(l.constraint, context);
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<on_t<T>, void> {
+            using statement_type = on_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& t, const C& context) const {
+                std::stringstream ss;
+                auto newContext = context;
+                newContext.skip_table_name = false;
+                ss << static_cast<std::string>(t) << " " << serialize(t.arg, newContext) << " ";
+                return ss.str();
+            }
+        };
+
+        template<class T, class O>
+        struct statement_serializator<join_t<T, O>, void> {
+            using statement_type = join_t<T, O>;
+
+            template<class C>
+            std::string operator()(const statement_type& l, const C& context) const {
+                std::stringstream ss;
+                ss << static_cast<std::string>(l) << " ";
+                auto aliasString = alias_extractor<T>::get();
+                ss << " '" << lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl) << "' ";
+                if(aliasString.length()) {
+                    ss << "'" << aliasString << "' ";
+                }
+                ss << serialize(l.constraint, context);
+                return ss.str();
+            }
+        };
+
+        template<class T, class O>
+        struct statement_serializator<left_join_t<T, O>, void> {
+            using statement_type = left_join_t<T, O>;
+
+            template<class C>
+            std::string operator()(const statement_type& l, const C& context) const {
+                std::stringstream ss;
+                ss << static_cast<std::string>(l) << " ";
+                auto aliasString = alias_extractor<T>::get();
+                ss << " '" << lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl) << "' ";
+                if(aliasString.length()) {
+                    ss << "'" << aliasString << "' ";
+                }
+                ss << serialize(l.constraint, context);
+                return ss.str();
+            }
+        };
+
+        template<class T, class O>
+        struct statement_serializator<left_outer_join_t<T, O>, void> {
+            using statement_type = left_outer_join_t<T, O>;
+
+            template<class C>
+            std::string operator()(const statement_type& l, const C& context) const {
+                std::stringstream ss;
+                ss << static_cast<std::string>(l) << " ";
+                auto aliasString = alias_extractor<T>::get();
+                ss << " '" << lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl) << "' ";
+                if(aliasString.length()) {
+                    ss << "'" << aliasString << "' ";
+                }
+                ss << serialize(l.constraint, context);
+                return ss.str();
+            }
+        };
+
+        template<class O>
+        struct statement_serializator<natural_join_t<O>, void> {
+            using statement_type = natural_join_t<O>;
+
+            template<class C>
+            std::string operator()(const statement_type& c, const C& context) const {
+                std::stringstream ss;
+                ss << static_cast<std::string>(c) << " ";
+                ss << " '" << lookup_table_name<O>(context.impl) << "'";
+                return ss.str();
+            }
+        };
+
+        template<class T, class... Args>
+        struct statement_serializator<group_by_with_having<T, Args...>, void> {
+            using statement_type = group_by_with_having<T, Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                std::vector<std::string> expressions;
+                auto newContext = context;
+                newContext.skip_table_name = false;
+                iterate_tuple(statement.args, [&expressions, &newContext](auto& v) {
+                    auto expression = serialize(v, newContext);
+                    expressions.push_back(expression);
+                });
+                ss << "GROUP BY";
+                for(size_t i = 0; i < expressions.size(); ++i) {
+                    ss << ' ' << expressions[i];
+                    if(i < expressions.size() - 1) {
+                        ss << ",";
+                    }
+                }
+                ss << " HAVING";
+                ss << ' ' << serialize(statement.expression, context);
+                return ss.str();
+            }
+        };
+
+        template<class... Args>
+        struct statement_serializator<group_by_t<Args...>, void> {
+            using statement_type = group_by_t<Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                std::vector<std::string> expressions;
+                auto newContext = context;
+                newContext.skip_table_name = false;
+                iterate_tuple(statement.args, [&expressions, &newContext](auto& v) {
+                    auto expression = serialize(v, newContext);
+                    expressions.push_back(expression);
+                });
+                ss << "GROUP BY";
+                for(size_t i = 0; i < expressions.size(); ++i) {
+                    ss << ' ' << expressions[i];
+                    if(i < expressions.size() - 1) {
+                        ss << ",";
+                    }
+                }
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<having_t<T>, void> {
+            using statement_type = having_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                auto newContext = context;
+                newContext.skip_table_name = false;
+                ss << "HAVING";
+                ss << " " << serialize(statement.expression, newContext);
+                return ss.str();
+            }
+        };
+
+        /**
+         *  HO - has offset
+         *  OI - offset is implicit
+         */
+        template<class T, bool HO, bool OI, class O>
+        struct statement_serializator<limit_t<T, HO, OI, O>, void> {
+            using statement_type = limit_t<T, HO, OI, O>;
+
+            template<class C>
+            std::string operator()(const statement_type& limt, const C& context) const {
+                auto newContext = context;
+                newContext.skip_table_name = false;
+                std::stringstream ss;
+                ss << static_cast<std::string>(limt) << " ";
+                if(HO) {
+                    if(OI) {
+                        limt.off.apply([&newContext, &ss](auto& value) {
+                            ss << serialize(value, newContext);
+                        });
+                        ss << ", ";
+                        ss << serialize(limt.lim, newContext);
+                    } else {
+                        ss << serialize(limt.lim, newContext) << " OFFSET ";
+                        limt.off.apply([&newContext, &ss](auto& value) {
+                            ss << serialize(value, newContext);
+                        });
+                    }
+                } else {
+                    ss << serialize(limt.lim, newContext);
+                }
+                return ss.str();
+            }
+        };
+
+        template<>
+        struct statement_serializator<default_values_t, void> {
+            using statement_type = default_values_t;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                return "DEFAULT VALUES";
+            }
+        };
+
+        template<class F, class O>
+        struct statement_serializator<using_t<F, O>, void> {
+            using statement_type = using_t<F, O>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                auto newContext = context;
+                newContext.skip_table_name = true;
+                return static_cast<std::string>(statement) + " (" + serialize(statement.column, newContext) + " )";
+            }
+        };
+
+        template<class... Args>
+        struct statement_serializator<std::tuple<Args...>, void> {
+            using statement_type = std::tuple<Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                if(context.use_parentheses) {
+                    ss << '(';
+                }
+                auto index = 0;
+                using TupleSize = std::tuple_size<statement_type>;
+                iterate_tuple(statement, [&context, &index, &ss](auto& value) {
+                    ss << serialize(value, context);
+                    if(index < TupleSize::value - 1) {
+                        ss << ", ";
+                    }
+                    ++index;
+                });
+                if(context.use_parentheses) {
+                    ss << ')';
+                }
+                return ss.str();
+            }
+        };
+
+        template<class... Args>
+        struct statement_serializator<values_t<Args...>, void> {
+            using statement_type = values_t<Args...>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                if(context.use_parentheses) {
+                    ss << '(';
+                }
+                ss << "VALUES ";
+                {
+                    auto index = 0;
+                    auto& tuple = statement.tuple;
+                    using tuple_type = typename std::decay<decltype(tuple)>::type;
+                    using TupleSize = std::tuple_size<tuple_type>;
+                    iterate_tuple(tuple, [&context, &index, &ss](auto& value) {
+                        ss << serialize(value, context);
+                        if(index < TupleSize::value - 1) {
+                            ss << ", ";
+                        }
+                        ++index;
+                    });
+                }
+                if(context.use_parentheses) {
+                    ss << ')';
+                }
+                return ss.str();
+            }
+        };
+
+        template<class T>
+        struct statement_serializator<dynamic_values_t<T>, void> {
+            using statement_type = dynamic_values_t<T>;
+
+            template<class C>
+            std::string operator()(const statement_type& statement, const C& context) const {
+                std::stringstream ss;
+                if(context.use_parentheses) {
+                    ss << '(';
+                }
+                ss << "VALUES ";
+                {
+                    auto vectorSize = statement.vector.size();
+                    for(decltype(vectorSize) index = 0; index < vectorSize; ++index) {
+                        auto& value = statement.vector[index];
+                        ss << serialize(value, context);
+                        if(index < vectorSize - 1) {
+                            ss << ", ";
+                        }
+                    }
+                }
+                if(context.use_parentheses) {
+                    ss << ')';
+                }
+                return ss.str();
+            }
+        };
+
+    }
+}
+
+// #include "table_name_collector.h"
+
+// #include "object_from_column_builder.h"
+
+// #include "table.h"
+
+// #include "column.h"
+
+// #include "cte_storage.h"
+
+#include <type_traits>
+#include <tuple>
+#include <string>
+#include <vector>
+
+// #include "column_result.h"
+
+// #include "column_expression.h"
+
+#include <type_traits>  //  std::enable_if, std::is_same, std::decay, std::is_arithmetic
+#include <tuple>  //  std::tuple
+#include <functional>  //  std::reference_wrapper
+
+// #include "cxx_polyfill.h"
+
+// #include "type_traits.h"
+
+// #include "select_constraints.h"
+
+// #include "alias.h"
+
+// #include "storage_traits.h"
+
+// #include "tuple_helper/tuple_transformer.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        template<class St, class T, class SFINAE = void>
+        struct column_expression_type;
+
+        /**
+         *  Obains the expressions that form the columns of a subselect statement.
+         */
+        template<class St, class T>
+        using column_expression_of_t = typename column_expression_type<St, T>::type;
+
+        template<class St, class T, class SFINAE>
+        struct column_expression_type {
+            using type = T;
+        };
+
+        template<class St, class T>
+        struct column_expression_type<St, std::reference_wrapper<T>, void>
+            : std::add_lvalue_reference<column_expression_of_t<St, T>> {};
+
+        // No CTE for object expressions.
+        template<class St, class T>
+        struct column_expression_type<St, object_t<T>, void> {
+            static_assert(polyfill::always_false_v<T>, "Selecting an object in a subselect is not allowed.");
+        };
+
+        template<class St, class T>
+        struct column_expression_type<St, asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>>
+            : storage_traits::storage_mapped_column_expressions<St, T> {};
+
+        template<class A>
+        struct add_column_alias {
+            template<typename ColExpr>
+            struct apply {
+                using type = alias_column_t<A, ColExpr>;
+            };
+        };
+        template<class St, class A>
+        struct column_expression_type<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>>
+            : tuple_transformer<typename storage_traits::storage_mapped_column_expressions<St, type_t<A>>::type,
+                                add_column_alias<A>::template apply> {};
+
+        template<class St, class O, class F, F O::*m>
+        struct column_expression_type<St, ice_t<m>, void> : ice_t<m> {};
+
+        template<class St, class... Args>
+        struct column_expression_type<St, columns_t<Args...>, void> {
+            using type = std::tuple<column_expression_of_t<St, std::decay_t<Args>>...>;
+        };
+
+        template<class St, class T, class... Args>
+        struct column_expression_type<St, select_t<T, Args...>> : column_expression_type<St, T> {};
+    }
+}
+
+// #include "select_constraints.h"
+
+// #include "table.h"
+
+// #include "cte_types.h"
+
+// #include "cte_column_names_collector.h"
+
+// #include "storage_lookup.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+        // F = field_type
+        template<typename Label, typename Expression, typename F>
+        struct create_cte_mapper {
+            using type = subselect_mapper<Label, Expression, F>;
+        };
+
+        template<typename Label, typename Expression, typename... Fs>
+        struct create_cte_mapper<Label, Expression, std::tuple<Fs...>> {
+            using type = subselect_mapper<Label, Expression, Fs...>;
+        };
+
+        template<typename Label, typename Expression, typename... Fs>
+        using create_cte_mapper_t = typename create_cte_mapper<Label, Expression, Fs...>::type;
+
+        template<typename O, size_t CI>
+        struct create_cte_column {
+            using cte_object_type = O;
+            using field_type = std::tuple_element_t<CI, typename O::fields_type>;
+            using getter_type = cte_getter_t<O, CI>;
+            using setter_type = cte_setter_t<O, CI>;
+
+            using type = column_t<cte_object_type, field_type, getter_type, setter_type>;
+        };
+
+        /**
+         *  Metafunction to create a CTE column_t type.
+         */
+        template<typename O, size_t CI>
+        using create_cte_column_t = typename create_cte_column<O, CI>::type;
+
+        template<typename M, typename IdxSeq>
+        struct create_cte_table;
+
+        template<typename Label, typename Expression, typename... Fs, size_t... CIs>
+        struct create_cte_table<subselect_mapper<Label, Expression, Fs...>, std::index_sequence<CIs...>> {
+            using cte_mapper_type = subselect_mapper<Label, Expression, Fs...>;
+            using table_type =
+                table_t<cte_mapper_type, true, create_cte_column_t<cte_object_type_t<cte_mapper_type>, CIs>...>;
+
+            using type = table_type;
+        };
+
+        /**
+         *  Metafunction to create a CTE table_t type.
+         */
+        template<typename M, typename IdxSeq>
+        using create_cte_table_t = typename create_cte_table<M, IdxSeq>::type;
+
+        /**
+         *  Concatenate newly created tables with those from an existing storage, forming a
+         *  new storage object
+         */
+        template<typename... Ts, typename... CTETables>
+        storage_impl<CTETables..., Ts...> storage_impl_cat(const storage_impl<Ts...>& storage,
+                                                           CTETables&&... cteTables) {
+            return {std::forward<CTETables>(cteTables)..., pick_impl<object_type_t<Ts>>(storage).table...};
+        }
+
+        /**
+         *  This function returns the expression contained in a subselect that is relevant for
+         *  creating the definition of a CTE table.
+         *  Because CTEs can recursively refer to themselves in a compound statement, parsing
+         *  the whole compound statement would lead to compiler errors if a column_pointer<>
+         *  can't be resolved. Therefore, at the time of building a CTE table, we are only
+         *  interested in the column results of the left expression.
+         */
+        template<class Select>
+        decltype(auto) get_cte_driving_subselect(const Select& subSelect);
+
+        /**
+         *  Return given select expression.
+         */
+        template<class Select>
+        decltype(auto) get_cte_driving_subselect(const Select& subSelect) {
+            return subSelect;
+        }
+
+        /**
+         *  Return left expression of compound statement.
+         */
+        template<class Compound,
+                 class... Args,
+                 std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+        decltype(auto) get_cte_driving_subselect(const select_t<Compound, Args...>& subSelect) {
+            return subSelect.col.left;
+        }
+
+        template<typename Select>
+        using cte_driving_subselect_t =
+            polyfill::remove_cvref_t<decltype(get_cte_driving_subselect(std::declval<Select>()))>;
+
+        template<typename M, typename S, typename CTE, size_t... CIs>
+        create_cte_table_t<M, typename M::index_sequence>
+        make_cte_table_using_column_indices(const S& impl, const CTE& cte, std::index_sequence<CIs...>) {
+            using O = cte_object_type_t<M>;
+            using context_type = serializator_context<S>;
+            context_type context{impl};
+
+            std::vector<std::string> columnNames =
+                collect_cte_column_names(get_cte_driving_subselect(cte.subselect), cte.explicitColumnNames, context);
+
+            return create_cte_table_t<M, typename M::index_sequence>{
+                cte.label(),
+                std::make_tuple(
+                    make_column<>(move(columnNames.at(CIs)), cte_getter_v<O, CIs>, cte_setter_v<O, CIs>)...)};
+        }
+
+        template<typename M, typename S, typename CTE>
+        create_cte_table_t<M, typename M::index_sequence> make_cte_table(const S& impl, const CTE& cte) {
+            return make_cte_table_using_column_indices<M>(impl, cte, typename M::index_sequence{});
+        }
+
+        template<typename S, typename... CTEs, size_t TI1>
+        decltype(auto) make_recursive_cte_storage_using_table_indices(const S& impl,
+                                                                      const common_table_expressions<CTEs...>& cte,
+                                                                      std::index_sequence<TI1>) {
+            using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
+            using M = create_cte_mapper_t<cte_label_type_t<cte_t>,
+                                          column_expression_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>,
+                                          column_result_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>>;
+            static_assert(cte_t::explicit_column_count == 0 ||
+                          cte_t::explicit_column_count == M::index_sequence::size());
+
+            auto tbl = make_cte_table<M>(impl, get<TI1>(cte));
+
+            return storage_impl_cat(impl, std::move(tbl));
+        }
+
+        template<typename S, typename... CTEs, size_t TI1, size_t... TIn>
+        decltype(auto) make_recursive_cte_storage_using_table_indices(const S& impl,
+                                                                      const common_table_expressions<CTEs...>& cte,
+                                                                      std::index_sequence<TI1, TIn...>) {
+            using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
+            using M = create_cte_mapper_t<cte_label_type_t<cte_t>,
+                                          column_expression_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>,
+                                          column_result_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>>;
+            static_assert(cte_t::explicit_column_count == 0 ||
+                          cte_t::explicit_column_count == M::index_sequence::size());
+
+            auto tbl = make_cte_table<M>(impl, get<TI1>(cte));
+
+            return make_recursive_cte_storage_using_table_indices(
+                // Because CTEs can depend on their predecessor we recursively pass in a new storage object
+                storage_impl_cat(impl, std::move(tbl)),
+                cte,
+                std::index_sequence<TIn...>{});
+        }
+
+        /**
+         *  Return const storage_impl of storage_t.
+         */
+        template<class S, class E, satisfies<is_storage, S> = true>
+        decltype(auto) storage_for_expression(S& storage, const E&) {
+            return obtain_const_impl(storage);
+        }
+
+        /**
+         *  Return new storage_impl for CTE expressions.
+         */
+        template<class S, class E, class... CTEs, satisfies<is_storage, S> = true>
+        decltype(auto) storage_for_expression(S& storage, const with_t<E, CTEs...>& e) {
+            return make_recursive_cte_storage_using_table_indices(obtain_const_impl(storage),
+                                                                  e.cte,
+                                                                  std::index_sequence_for<CTEs...>{});
+        }
+    }
+}
+
+// #include "util.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  Storage class itself. Create an instanse to use it as an interfacto to sqlite db by calling `make_storage`
+         *  function.
+         */
+        template<class... Ts>
+        struct storage_t : storage_base {
+            using self = storage_t<Ts...>;
+            using impl_type = storage_impl<Ts...>;
+
+            /**
+             *  @param filename database filename.
+             *  @param impl_ storage_impl head
+             */
+            storage_t(const std::string& filename, impl_type impl_) :
+                storage_base{filename, foreign_keys_count(impl_)}, impl(std::move(impl_)) {}
+
+            storage_t(const storage_t&) = default;
+
+          protected:
+            impl_type impl;
+
+            /**
+             *  Obtain a storage_t's const storage_impl.
+             *  
+             *  @note Historically, `serializator_context_builder` was declared friend, along with
+             *  a few other library stock objects, in order limit access to the storage_impl.
+             *  However, one could gain access to a storage_t's storage_impl through
+             *  `serializator_context_builder`, hence leading the whole friend declaration mambo-jumbo
+             *  ad absurdum.
+             *  Providing a free function is way better and cleaner.
+             *
+             *  Hence, friend was replaced by `obtain_const_impl()` and `pick_const_impl()`.
+             */
+            friend const impl_type& obtain_const_impl(const self& storage) noexcept {
+                return storage.impl;
+            }
+
+            template<class I>
+            void create_table(sqlite3* db, const std::string& tableName, const I& tableImpl) {
+                using table_type = typename std::decay<decltype(tableImpl.table)>::type;
+                std::stringstream ss;
+                ss << "CREATE TABLE '" << tableName << "' ( ";
+                auto elementsCount = tableImpl.table.elements_count;
+                auto index = 0;
+                using context_t = serializator_context<impl_type>;
+                context_t context{this->impl};
+                iterate_tuple(tableImpl.table.elements, [elementsCount, &index, &ss, &context](auto& element) {
+                    ss << serialize(element, context);
+                    if(index < elementsCount - 1) {
+                        ss << ", ";
+                    }
+                    index++;
+                });
+                ss << ")";
+                if(table_type::is_without_rowid) {
+                    ss << " WITHOUT ROWID";
+                }
+                perform_void_exec(db, ss.str());
+            }
+#if SQLITE_VERSION_NUMBER >= 3035000  //  DROP COLUMN feature exists (v3.35.0)
+            void drop_column(sqlite3* db, const std::string& tableName, const std::string& columnName) {
+                std::stringstream ss;
+                ss << "ALTER TABLE '" << tableName << "' DROP COLUMN \"" << columnName << "\"";
+                perform_void_exec(db, ss.str());
+            }
+#endif
+            template<class I>
+            void backup_table(sqlite3* db, const I& tableImpl, const std::vector<table_info*>& columnsToIgnore) {
+
+                //  here we copy source table to another with a name with '_backup' suffix, but in case table with such
+                //  a name already exists we append suffix 1, then 2, etc until we find a free name..
+                auto backupTableName = tableImpl.table.name + "_backup";
+                if(tableImpl.table_exists(backupTableName, db)) {
+                    int suffix = 1;
+                    do {
+                        std::stringstream stream;
+                        stream << suffix;
+                        auto anotherBackupTableName = backupTableName + stream.str();
+                        if(!tableImpl.table_exists(anotherBackupTableName, db)) {
+                            backupTableName = anotherBackupTableName;
+                            break;
+                        }
+                        ++suffix;
+                    } while(true);
+                }
+
+                this->create_table(db, backupTableName, tableImpl);
+
+                tableImpl.copy_table(db, backupTableName, columnsToIgnore);
+
+                this->drop_table_internal(tableImpl.table.name, db);
+
+                tableImpl.rename_table(db, backupTableName, tableImpl.table.name);
+            }
+
+            template<class O>
+            void assert_mapped_type() const {
+                using mapped_types_tuples = std::tuple<object_type_t<Ts>...>;
+                static_assert(tuple_helper::has_type<O, mapped_types_tuples>::value, "type is not mapped to a storage");
+            }
+
+            template<class O>
+            void assert_insertable_type() const {
+                auto& tImpl = this->get_impl<O>();
+                using table_type = table_type_t<polyfill::remove_cvref_t<decltype(tImpl)>>;
+                using elements_type = typename table_type::elements_type;
+
+                using is_without_rowid = std::integral_constant<bool, table_type::is_without_rowid>;
+
+                static_if<is_without_rowid{}>(
+                    [](auto&) {
+                        static_assert(std::is_void<cte_label_type_t<table_type>>::value,
+                                      "Attempting to execute 'insert' request for a CTE mapping.");
+                    },
+                    [](auto& tImpl) {  // unfortunately, this static_assert's can't see any composite keys((
+                        std::ignore = tImpl;
+                        static_assert(
+                            count_tuple<elements_type, is_column_with_insertable_primary_key>::value <= 1,
+                            "Attempting to execute 'insert' request into an noninsertable table was detected. "
+                            "Insertable table cannot contain > 1 primary keys. Please use 'replace' instead of "
+                            "'insert', or you can use 'insert' with explicit column listing.");
+                        static_assert(
+                            count_tuple<elements_type, is_column_with_noninsertable_primary_key>::value == 0,
+                            "Attempting to execute 'insert' request into an noninsertable table was detected. "
+                            "Insertable table cannot contain non-standard primary keys. Please use 'replace' instead "
+                            "of 'insert', or you can use 'insert' with explicit column listing.");
+                    })(tImpl);
+            }
+
+            template<class Lookup>
+            storage_pick_impl_t<self, Lookup>& get_impl() {
+                return this->impl;
+            }
+            template<class Lookup>
+            storage_pick_impl_t<const self, Lookup>& get_impl() const {
+                return this->impl;
+            }
+
+          public:
+            template<class T, class... Args>
+            view_t<T, self, Args...> iterate(Args&&... args) {
+                this->assert_mapped_type<T>();
+
+                auto con = this->get_connection();
+                return {*this, std::move(con), std::forward<Args>(args)...};
+            }
+
+            /**
+             * Delete from routine.
+             * O is an object's type. Must be specified explicitly.
+             * @param args optional conditions: `where`, `join` etc
+             * @example: storage.remove_all<User>(); - DELETE FROM users
+             * @example: storage.remove_all<User>(where(in(&User::id, {5, 6, 7}))); - DELETE FROM users WHERE id IN (5, 6, 7)
+             */
+            template<class O, class... Args>
+            void remove_all(Args&&... args) {
+                this->assert_mapped_type<O>();
+                auto statement = this->prepare(sqlite_orm::remove_all<O>(std::forward<Args>(args)...));
+                this->execute(statement);
+            }
+
+            /**
+             *  Delete routine.
+             *  O is an object's type. Must be specified explicitly.
+             *  @param ids ids of object to be removed.
+             */
+            template<class O, class... Ids>
+            void remove(Ids... ids) {
+                this->assert_mapped_type<O>();
+                auto statement = this->prepare(sqlite_orm::remove<O>(std::forward<Ids>(ids)...));
+                this->execute(statement);
+            }
+
+            /**
+             *  Update routine. Sets all non primary key fields where primary key is equal.
+             *  O is an object type. May be not specified explicitly cause it can be deduced by
+             *      compiler from first parameter.
+             *  @param o object to be updated.
+             */
+            template<class O>
+            void update(const O& o) {
+                this->assert_mapped_type<O>();
+                auto statement = this->prepare(sqlite_orm::update(std::ref(o)));
+                this->execute(statement);
+            }
+
+            template<class... Args, class... Wargs>
+            void update_all(internal::set_t<Args...> set, Wargs... wh) {
+                auto statement = this->prepare(sqlite_orm::update_all(std::move(set), std::forward<Wargs>(wh)...));
+                this->execute(statement);
+            }
+
+          protected:
+            template<class F, class O, class... Args>
+            std::string group_concat_internal(F O::*m, std::unique_ptr<std::string> y, Args&&... args) {
+                this->assert_mapped_type<O>();
+                std::vector<std::string> rows;
+                if(y) {
+                    rows = this->select(sqlite_orm::group_concat(m, move(*y)), std::forward<Args>(args)...);
+                } else {
+                    rows = this->select(sqlite_orm::group_concat(m), std::forward<Args>(args)...);
+                }
+                if(!rows.empty()) {
+                    return move(rows.front());
+                } else {
+                    return {};
+                }
+            }
+
+          public:
+            /**
+             *  SELECT * routine.
+             *  O is an object type to be extracted. Must be specified explicitly.
+             *  @return All objects of type O stored in database at the moment in `std::vector`.
+             *  @note If you need to return the result in a different container type then use a different `get_all` function overload `get_all<User, std::list<User>>`
+             *  @example: storage.get_all<User>() - SELECT * FROM users
+             *  @example: storage.get_all<User>(where(like(&User::name, "N%")), order_by(&User::id)); - SELECT * FROM users WHERE name LIKE 'N%' ORDER BY id
+             */
+            template<class O, class... Args>
+            auto get_all(Args&&... args) {
+                this->assert_mapped_type<O>();
+                auto statement = this->prepare(sqlite_orm::get_all<O>(std::forward<Args>(args)...));
+                return this->execute(statement);
+            }
+
+            /**
+             *  SELECT * routine.
+             *  O is an object type to be extracted. Must be specified explicitly.
+             *  R is an explicit return type. This type must have `push_back(O &&)` function.
+             *  @return All objects of type O stored in database at the moment in `R`.
+             *  @example: storage.get_all<User, std::list<User>>(); - SELECT * FROM users
+             *  @example: storage.get_all<User, std::list<User>>(where(like(&User::name, "N%")), order_by(&User::id)); - SELECT * FROM users WHERE name LIKE 'N%' ORDER BY id
+            */
+            template<class O, class R, class... Args>
+            auto get_all(Args&&... args) {
+                this->assert_mapped_type<O>();
+                auto statement = this->prepare(sqlite_orm::get_all<O, R>(std::forward<Args>(args)...));
+                return this->execute(statement);
+            }
+
+            /**
+             *  SELECT * routine.
+             *  O is an object type to be extracted. Must be specified explicitly.
+             *  @return All objects of type O as `std::unique_ptr<O>` inside a `std::vector` stored in database at the moment.
+             *  @note If you need to return the result in a different container type then use a different `get_all_pointer` function overload `get_all_pointer<User, std::list<User>>`
+             *  @example: storage.get_all_pointer<User>(); - SELECT * FROM users
+             *  @example: storage.get_all_pointer<User>(where(length(&User::name) > 6)); - SELECT * FROM users WHERE LENGTH(name)  > 6
+             */
+            template<class O, class... Args>
+            auto get_all_pointer(Args&&... args) {
+                this->assert_mapped_type<O>();
+                auto statement = this->prepare(sqlite_orm::get_all_pointer<O>(std::forward<Args>(args)...));
+                return this->execute(statement);
+            }
+
+            /**
+             *  SELECT * routine.
+             *  O is an object type to be extracted. Must be specified explicitly.
+             *  R is a container type. std::vector<std::unique_ptr<O>> is default
+             *  @return All objects of type O as std::unique_ptr<O> stored in database at the moment.
+             *  @example: storage.get_all_pointer<User, std::list<User>>(); - SELECT * FROM users
+             *  @example: storage.get_all_pointer<User, std::list<User>>(where(length(&User::name) > 6)); - SELECT * FROM users WHERE LENGTH(name)  > 6
+            */
+            template<class O, class R, class... Args>
+            auto get_all_pointer(Args&&... args) {
+                this->assert_mapped_type<O>();
+                auto statement = this->prepare(sqlite_orm::get_all_pointer<O, R>(std::forward<Args>(args)...));
+                return this->execute(statement);
+            }
+
+            /**
+             *  Select * by id routine.
+             *  throws std::system_error(orm_error_code::not_found, orm_error_category) if object not found with given
+             * id. throws std::system_error with orm_error_category in case of db error. O is an object type to be
+             * extracted. Must be specified explicitly.
+             *  @return Object of type O where id is equal parameter passed or throws
+             * `std::system_error(orm_error_code::not_found, orm_error_category)` if there is no object with such id.
+             */
+            template<class O, class... Ids>
+            O get(Ids... ids) {
+                this->assert_mapped_type<O>();
+                auto statement = this->prepare(sqlite_orm::get<O>(std::forward<Ids>(ids)...));
+                return this->execute(statement);
+            }
+
+            /**
+             *  The same as `get` function but doesn't throw an exception if noting found but returns std::unique_ptr
+             * with null value. throws std::system_error in case of db error.
+             */
+            template<class O, class... Ids>
+            std::unique_ptr<O> get_pointer(Ids... ids) {
+                this->assert_mapped_type<O>();
+                auto statement = this->prepare(sqlite_orm::get_pointer<O>(std::forward<Ids>(ids)...));
+                return this->execute(statement);
+            }
+
+            /**
+             * A previous version of get_pointer() that returns a shared_ptr
+             * instead of a unique_ptr. New code should prefer get_pointer()
+             * unless the data needs to be shared.
+             *
+             * @note
+             * Most scenarios don't need shared ownership of data, so we should prefer
+             * unique_ptr when possible. It's more efficient, doesn't require atomic
+             * ops for a reference count (which can cause major slowdowns on
+             * weakly-ordered platforms like ARM), and can be easily promoted to a
+             * shared_ptr, exactly like we're doing here.
+             * (Conversely, you _can't_ go from shared back to unique.)
+             */
+            template<class O, class... Ids>
+            std::shared_ptr<O> get_no_throw(Ids... ids) {
+                return std::shared_ptr<O>(get_pointer<O>(std::forward<Ids>(ids)...));
+            }
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+            /**
+             *  The same as `get` function but doesn't throw an exception if noting found but
+             * returns an empty std::optional. throws std::system_error in case of db error.
+             */
+            template<class O, class... Ids>
+            std::optional<O> get_optional(Ids... ids) {
+                this->assert_mapped_type<O>();
+                auto statement = this->prepare(sqlite_orm::get_optional<O>(std::forward<Ids>(ids)...));
+                return this->execute(statement);
+            }
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+            /**
+             *  SELECT COUNT(*) https://www.sqlite.org/lang_aggfunc.html#count
+             *  @return Number of O object in table.
+             */
+            template<class O, class... Args, class R = typename mapped_type_proxy<O>::type>
+            int count(Args&&... args) {
+                this->assert_mapped_type<R>();
+                auto rows = this->select(sqlite_orm::count<R>(), std::forward<Args>(args)...);
+                if(!rows.empty()) {
+                    return rows.front();
+                } else {
+                    return 0;
+                }
+            }
+
+            /**
+             *  SELECT COUNT(X) https://www.sqlite.org/lang_aggfunc.html#count
+             *  @param m member pointer to class mapped to the storage.
+             *  @return count of `m` values from database.
+             */
+            template<class F, class O, class... Args>
+            int count(F O::*m, Args&&... args) {
+                this->assert_mapped_type<O>();
+                auto rows = this->select(sqlite_orm::count(m), std::forward<Args>(args)...);
+                if(!rows.empty()) {
+                    return rows.front();
+                } else {
+                    return 0;
+                }
+            }
+
+            /**
+             *  AVG(X) query.   https://www.sqlite.org/lang_aggfunc.html#avg
+             *  @param m is a class member pointer (the same you passed into make_column).
+             *  @return average value from database.
+             */
+            template<class F, class O, class... Args>
+            double avg(F O::*m, Args&&... args) {
+                this->assert_mapped_type<O>();
+                auto rows = this->select(sqlite_orm::avg(m), std::forward<Args>(args)...);
+                if(!rows.empty()) {
+                    return rows.front();
+                } else {
+                    return 0;
+                }
+            }
+
+            template<class F, class O>
+            std::string group_concat(F O::*m) {
+                return this->group_concat_internal(m, {});
+            }
+
+            /**
+             *  GROUP_CONCAT(X) query.  https://www.sqlite.org/lang_aggfunc.html#groupconcat
+             *  @param m is a class member pointer (the same you passed into make_column).
+             *  @return group_concat query result.
+             */
+            template<class F,
+                     class O,
+                     class... Args,
+                     class Tuple = std::tuple<Args...>,
+                     std::enable_if_t<std::tuple_size<Tuple>::value >= 1> = true>
+            std::string group_concat(F O::*m, Args&&... args) {
+                return this->group_concat_internal(m, {}, std::forward<Args>(args)...);
+            }
+
+            /**
+             *  GROUP_CONCAT(X, Y) query.   https://www.sqlite.org/lang_aggfunc.html#groupconcat
+             *  @param m is a class member pointer (the same you passed into make_column).
+             *  @return group_concat query result.
+             */
+            template<class F, class O, class... Args>
+            std::string group_concat(F O::*m, std::string y, Args&&... args) {
+                return this->group_concat_internal(m,
+                                                   std::make_unique<std::string>(move(y)),
+                                                   std::forward<Args>(args)...);
+            }
+
+            template<class F, class O, class... Args>
+            std::string group_concat(F O::*m, const char* y, Args&&... args) {
+                std::unique_ptr<std::string> str;
+                if(y) {
+                    str = std::make_unique<std::string>(y);
+                } else {
+                    str = std::make_unique<std::string>();
+                }
+                return this->group_concat_internal(m, move(str), std::forward<Args>(args)...);
+            }
+
+            /**
+             *  MAX(x) query.
+             *  @param m is a class member pointer (the same you passed into make_column).
+             *  @return std::unique_ptr with max value or null if sqlite engine returned null.
+             */
+            template<class F, class O, class... Args, class Ret = typename column_result_t<self, F O::*>::type>
+            std::unique_ptr<Ret> max(F O::*m, Args&&... args) {
+                this->assert_mapped_type<O>();
+                auto rows = this->select(sqlite_orm::max(m), std::forward<Args>(args)...);
+                if(!rows.empty()) {
+                    return std::move(rows.front());
+                } else {
+                    return {};
+                }
+            }
+
+            /**
+             *  MIN(x) query.
+             *  @param m is a class member pointer (the same you passed into make_column).
+             *  @return std::unique_ptr with min value or null if sqlite engine returned null.
+             */
+            template<class F, class O, class... Args, class Ret = typename column_result_t<self, F O::*>::type>
+            std::unique_ptr<Ret> min(F O::*m, Args&&... args) {
+                this->assert_mapped_type<O>();
+                auto rows = this->select(sqlite_orm::min(m), std::forward<Args>(args)...);
+                if(!rows.empty()) {
+                    return std::move(rows.front());
+                } else {
+                    return {};
+                }
+            }
+
+            /**
+             *  SUM(x) query.
+             *  @param m is a class member pointer (the same you passed into make_column).
+             *  @return std::unique_ptr with sum value or null if sqlite engine returned null.
+             */
+            template<class F, class O, class... Args, class Ret = typename column_result_t<self, F O::*>::type>
+            std::unique_ptr<Ret> sum(F O::*m, Args&&... args) {
+                this->assert_mapped_type<O>();
+                std::vector<std::unique_ptr<double>> rows =
+                    this->select(sqlite_orm::sum(m), std::forward<Args>(args)...);
+                if(!rows.empty()) {
+                    if(rows.front()) {
+                        return std::make_unique<Ret>(std::move(*rows.front()));
+                    } else {
+                        return {};
+                    }
+                } else {
+                    return {};
+                }
+            }
+
+            /**
+             *  TOTAL(x) query.
+             *  @param m is a class member pointer (the same you passed into make_column).
+             *  @return total value (the same as SUM but not nullable. More details here
+             * https://www.sqlite.org/lang_aggfunc.html)
+             */
+            template<class F, class O, class... Args>
+            double total(F O::*m, Args&&... args) {
+                this->assert_mapped_type<O>();
+                auto rows = this->select(sqlite_orm::total(m), std::forward<Args>(args)...);
+                if(!rows.empty()) {
+                    return std::move(rows.front());
+                } else {
+                    return {};
+                }
+            }
+
+            /**
+             *  Select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             *  For a single column use `auto rows = storage.select(&User::id, where(...));
+             *  For multicolumns use `auto rows = storage.select(columns(&User::id, &User::name), where(...));
+             */
+            template<class T, class... Args, class R = column_result_of_t<self, T>>
+            std::vector<R> select(T m, Args... args) {
+                static_assert(!is_base_of_template<T, compound_operator>::value ||
+                                  std::tuple_size<std::tuple<Args...>>::value == 0,
+                              "Cannot use args with a compound operator");
+                auto statement = this->prepare(sqlite_orm::select(std::move(m), std::forward<Args>(args)...));
+                return this->execute(statement);
+            }
+
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class Label, class Select, class nExplicitCols, class T, class... Args>
+            auto with(common_table_expression<Label, Select, nExplicitCols> cte, select_t<T, Args...> sel) {
+                auto statement = this->prepare(sqlite_orm::with(move(cte), std::move(sel)));
+                return this->execute(statement);
+            }
+
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class... CTEs, class T, class... Args>
+            auto with(common_table_expressions<CTEs...> cte, select_t<T, Args...> sel) {
+                auto statement = this->prepare(sqlite_orm::with(move(cte), std::move(sel)));
+                return this->execute(statement);
+            }
+
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class Label,
+                     class Select,
+                     class nExplicitCols,
+                     class Compound,
+                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            auto with(common_table_expression<Label, Select, nExplicitCols> cte, Compound sel) {
+                auto statement = this->prepare(sqlite_orm::with(move(cte), sqlite_orm::select(std::move(sel))));
+                return this->execute(statement);
+            }
+
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class... CTEs,
+                     class Compound,
+                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            auto with(common_table_expressions<CTEs...> cte, Compound sel) {
+                auto statement = this->prepare(sqlite_orm::with(move(cte), sqlite_orm::select(std::move(sel))));
+                return this->execute(statement);
+            }
+
+            template<class T, satisfies<is_prepared_statement, T> = true>
+            std::string dump(const T& preparedStatement, bool asBindable = true) const {
+                return this->dump(preparedStatement.expression, asBindable);
+            }
+
+            template<class E, satisfies_not<is_prepared_statement, E> = true>
+            std::string dump(const E& expression, bool asBindable = false) const {
+                const auto& exprImpl = storage_for_expression(*this, expression);
+                using context_t = serializator_context<polyfill::remove_cvref_t<decltype(exprImpl)>>;
+                context_t context{exprImpl};
+                context.replace_bindable_with_question = asBindable;
+                context.skip_table_name = false;
+                return serialize(expression, context);
+            }
+
+            /**
+             *  Returns a string representation of object of a class mapped to the storage.
+             *  Type of string has json-like style.
+             */
+            template<class O, satisfies<storage_traits::type_is_mapped, self, O> = true>
+            std::string dump(const O& o) {
+                auto& tImpl = this->get_impl<O>();
+                std::stringstream ss;
+                ss << "{ ";
+                using pair = std::pair<std::string, std::string>;
+                std::vector<pair> pairs;
+                tImpl.table.for_each_column([&pairs, &o](auto& c) {
+                    using column_type = typename std::decay<decltype(c)>::type;
+                    using field_type = typename column_type::field_type;
+                    pair p{c.name, std::string()};
+                    if(c.member_pointer) {
+                        p.second = field_printer<field_type>()(o.*c.member_pointer);
+                    } else {
+                        using getter_type = typename column_type::getter_type;
+                        field_value_holder<getter_type> valueHolder{((o).*(c.getter))()};
+                        p.second = field_printer<field_type>()(valueHolder.value);
+                    }
+                    pairs.push_back(move(p));
+                });
+                for(size_t i = 0; i < pairs.size(); ++i) {
+                    auto& p = pairs[i];
+                    ss << p.first << " : '" << p.second << "'";
+                    if(i < pairs.size() - 1) {
+                        ss << ", ";
+                    } else {
+                        ss << " }";
+                    }
+                }
+                return ss.str();
+            }
+
+            /**
+             *  This is REPLACE (INSERT OR REPLACE) function.
+             *  Also if you need to insert value with knows id you should
+             *  also you this function instead of insert cause inserts ignores
+             *  id and creates own one.
+             */
+            template<class O>
+            void replace(const O& o) {
+                this->assert_mapped_type<O>();
+                auto statement = this->prepare(sqlite_orm::replace(std::ref(o)));
+                this->execute(statement);
+            }
+
+            template<class It>
+            void replace_range(It from, It to) {
+                using O = typename std::iterator_traits<It>::value_type;
+                this->assert_mapped_type<O>();
+                if(from == to) {
+                    return;
+                }
+
+                auto statement = this->prepare(sqlite_orm::replace_range(from, to));
+                this->execute(statement);
+            }
+
+            template<class T, class It, class L>
+            void replace_range(It from, It to, L transformer) {
+                this->assert_mapped_type<T>();
+                if(from == to) {
+                    return;
+                }
+
+                auto statement = this->prepare(sqlite_orm::replace_range<T>(from, to, std::move(transformer)));
+                this->execute(statement);
+            }
+
+            template<class O, class... Cols>
+            int insert(const O& o, columns_t<Cols...> cols) {
+                constexpr const size_t colsCount = std::tuple_size<std::tuple<Cols...>>::value;
+                static_assert(colsCount > 0, "Use insert or replace with 1 argument instead");
+                this->assert_mapped_type<O>();
+                auto statement = this->prepare(sqlite_orm::insert(std::ref(o), std::move(cols)));
+                return int(this->execute(statement));
+            }
+
+            /**
+             *  Insert routine. Inserts object with all non primary key fields in passed object. Id of passed
+             *  object doesn't matter.
+             *  @return id of just created object.
+             */
+            template<class O>
+            int insert(const O& o) {
+                this->assert_mapped_type<O>();
+                this->assert_insertable_type<O>();
+
+                return call_insert_impl_and_catch_constraint_failed([this, &o]() {
+                    auto statement = this->prepare(sqlite_orm::insert(std::ref(o)));
+                    return int(this->execute(statement));
+                });
+            }
+
+            /**
+             *  Raw insert routine. Use this if `insert` with object does not fit you. This insert is designed to be able
+             *  to call any type of `INSERT` query with no limitations.
+             *  @example
+             *  ```sql
+             *  INSERT INTO users (id, name) VALUES(5, 'Little Mix')
+             *  ```
+             *  will be
+             *  ```c++
+             *  storage.insert(into<User>, columns(&User::id, &User::name), values(std::make_tuple(5, "Little Mix")));
+             *  ```
+             *  One more example:
+             *  ```sql
+             *  INSERT INTO singers (name) VALUES ('Sofia Reyes')('Kungs')
+             *  ```
+             *  will be
+             *  ```c++
+             *  storage.insert(into<Singer>(), columns(&Singer::name), values(std::make_tuple("Sofia Reyes"), std::make_tuple("Kungs")));
+             *  ```
+             *  One can use `default_values` to add `DEFAULT VALUES` modifier:
+             *  ```sql
+             *  INSERT INTO users DEFAULT VALUES
+             *  ```
+             *  will be
+             *  ```c++
+             *  storage.insert(into<Singer>(), default_values());
+             *  ```
+             *  Also one can use `INSERT OR ABORT`/`INSERT OR FAIL`/`INSERT OR IGNORE`/`INSERT OR REPLACE`/`INSERT ROLLBACK`:
+             *  ```c++
+             *  storage.insert(or_ignore(), into<Singer>(), columns(&Singer::name), values(std::make_tuple("Sofia Reyes"), std::make_tuple("Kungs")));
+             *  storage.insert(or_rollback(), into<Singer>(), default_values());
+             *  storage.insert(or_abort(), into<User>, columns(&User::id, &User::name), values(std::make_tuple(5, "Little Mix")));
+             *  ```
+             */
+            template<class... Args>
+            void insert(Args... args) {
+                auto statement = this->prepare(sqlite_orm::insert(std::forward<Args>(args)...));
+                this->execute(statement);
+            }
+
+            /**
+             *  Raw replace statement creation routine. Use this if `replace` with object does not fit you. This replace is designed to be able
+             *  to call any type of `REPLACE` query with no limitations. Actually this is the same query as raw insert except `OR...` option existance.
+             *  @example
+             *  ```sql
+             *  REPLACE INTO users (id, name) VALUES(5, 'Little Mix')
+             *  ```
+             *  will be
+             *  ```c++
+             *  storage.prepare(replace(into<User>, columns(&User::id, &User::name), values(std::make_tuple(5, "Little Mix"))));
+             *  ```
+             *  One more example:
+             *  ```sql
+             *  REPLACE INTO singers (name) VALUES ('Sofia Reyes')('Kungs')
+             *  ```
+             *  will be
+             *  ```c++
+             *  storage.prepare(replace(into<Singer>(), columns(&Singer::name), values(std::make_tuple("Sofia Reyes"), std::make_tuple("Kungs"))));
+             *  ```
+             *  One can use `default_values` to add `DEFAULT VALUES` modifier:
+             *  ```sql
+             *  REPLACE INTO users DEFAULT VALUES
+             *  ```
+             *  will be
+             *  ```c++
+             *  storage.prepare(replace(into<Singer>(), default_values()));
+             *  ```
+             */
+            template<class... Args>
+            void replace(Args... args) {
+                auto statement = this->prepare(sqlite_orm::replace(std::forward<Args>(args)...));
+                this->execute(statement);
+            }
+
+            template<class It>
+            void insert_range(It from, It to) {
+                using O = typename std::iterator_traits<It>::value_type;
+                this->assert_mapped_type<O>();
+                this->assert_insertable_type<O>();
+                if(from == to) {
+                    return;
+                }
+
+                call_insert_impl_and_catch_constraint_failed([this, from, to]() {
+                    auto statement = this->prepare(sqlite_orm::insert_range(from, to));
+                    this->execute(statement);
+                });
+            }
+
+            template<class T, class It, class L>
+            void insert_range(It from, It to, L transformer) {
+                this->assert_mapped_type<T>();
+                this->assert_insertable_type<T>();
+                if(from == to) {
+                    return;
+                }
+                call_insert_impl_and_catch_constraint_failed([this, from, to, transformer = std::move(transformer)]() {
+                    auto statement = this->prepare(sqlite_orm::insert_range<T>(from, to, std::move(transformer)));
+                    this->execute(statement);
+                });
+            }
+
+            /**
+             * Change table name inside storage's schema info. This function does not
+             * affect database
+             */
+            template<class O>
+            void rename_table(std::string name) {
+                this->assert_mapped_type<O>();
+                auto& tImpl = this->get_impl<O>();
+                tImpl.table.name = move(name);
+            }
+
+            using storage_base::rename_table;
+
+            /**
+             * Get table's name stored in storage's schema info. This function does not call
+             * any SQLite queries
+             */
+            template<class O>
+            const std::string& tablename() const {
+                this->assert_mapped_type<O>();
+                auto& tImpl = this->get_impl<O>();
+                return tImpl.table.name;
+            }
+
+            template<class F, class O>
+            [[deprecated("Use the more accurately named function `find_column_name()`")]] const std::string*
+            column_name(F O::*memberPointer) const {
+                return internal::find_column_name(this->impl, memberPointer);
+            }
+
+            template<class F, class O>
+            const std::string* find_column_name(F O::*memberPointer) const {
+                return internal::find_column_name(this->impl, memberPointer);
+            }
+
+          protected:
+            template<class... Tss, class... Cols>
+            sync_schema_result schema_status(const storage_impl<index_t<Cols...>, Tss...>&, sqlite3*, bool) {
+                return sync_schema_result::already_in_sync;
+            }
+
+            template<class T, bool WithoutRowId, class... Cs, class... Tss>
+            sync_schema_result schema_status(const storage_impl<table_t<T, WithoutRowId, Cs...>, Tss...>& tImpl,
+                                             sqlite3* db,
+                                             bool preserve) {
+                return tImpl.schema_status(db, preserve);
+            }
+
+            template<class... Tss, class... Cols>
+            sync_schema_result sync_table(const storage_impl<index_t<Cols...>, Tss...>& tableImpl, sqlite3* db, bool) {
+                auto res = sync_schema_result::already_in_sync;
+                using context_t = serializator_context<impl_type>;
+                context_t context{this->impl};
+                auto query = serialize(tableImpl.table, context);
+                perform_void_exec(db, query);
+                return res;
+            }
+
+            template<class T, bool WithoutRowId, class... Args, class... Tss>
+            sync_schema_result sync_table(const storage_impl<table_t<T, WithoutRowId, Args...>, Tss...>& tImpl,
+                                          sqlite3* db,
+                                          bool preserve) {
+                auto res = sync_schema_result::already_in_sync;
+
+                auto schema_stat = tImpl.schema_status(db, preserve);
+                if(schema_stat != decltype(schema_stat)::already_in_sync) {
+                    if(schema_stat == decltype(schema_stat)::new_table_created) {
+                        this->create_table(db, tImpl.table.name, tImpl);
+                        res = decltype(res)::new_table_created;
+                    } else {
+                        if(schema_stat == sync_schema_result::old_columns_removed ||
+                           schema_stat == sync_schema_result::new_columns_added ||
+                           schema_stat == sync_schema_result::new_columns_added_and_old_columns_removed) {
+
+                            //  get table info provided in `make_table` call..
+                            auto storageTableInfo = tImpl.table.get_table_info();
+
+                            //  now get current table info from db using `PRAGMA table_info` query..
+                            auto dbTableInfo = tImpl.get_table_info(tImpl.table.name, db);
+
+                            //  this vector will contain pointers to columns that gotta be added..
+                            std::vector<table_info*> columnsToAdd;
+
+                            tImpl.calculate_remove_add_columns(columnsToAdd, storageTableInfo, dbTableInfo);
+
+                            if(schema_stat == sync_schema_result::old_columns_removed) {
+#if SQLITE_VERSION_NUMBER >= 3035000  //  DROP COLUMN feature exists (v3.35.0)
+                                for(auto& tableInfo: dbTableInfo) {
+                                    this->drop_column(db, tImpl.table.name, tableInfo.name);
+                                }
+                                res = decltype(res)::old_columns_removed;
+#else
+                                    //  extra table columns than storage columns
+                                    this->backup_table(db, tImpl, {});
+                                    res = decltype(res)::old_columns_removed;
+#endif
+                            }
+
+                            if(schema_stat == sync_schema_result::new_columns_added) {
+                                for(auto columnPointer: columnsToAdd) {
+                                    tImpl.table.for_each_column([this, columnPointer, &tImpl, db](auto& column) {
+                                        if(column.name != columnPointer->name) {
+                                            return;
+                                        }
+                                        this->add_column(tImpl.table.name, column, db);
+                                    });
+                                }
+                                res = decltype(res)::new_columns_added;
+                            }
+
+                            if(schema_stat == sync_schema_result::new_columns_added_and_old_columns_removed) {
+
+                                // remove extra columns
+                                this->backup_table(db, tImpl, columnsToAdd);
+                                res = decltype(res)::new_columns_added_and_old_columns_removed;
+                            }
+                        } else if(schema_stat == sync_schema_result::dropped_and_recreated) {
+                            this->drop_table_internal(tImpl.table.name, db);
+                            this->create_table(db, tImpl.table.name, tImpl);
+                            res = decltype(res)::dropped_and_recreated;
+                        }
+                    }
+                }
+                return res;
+            }
+
+            template<class C>
+            void add_column(const std::string& tableName, const C& column, sqlite3* db) const {
+                std::stringstream ss;
+                ss << "ALTER TABLE " << tableName << " ADD COLUMN ";
+                using context_t = serializator_context<impl_type>;
+                context_t context{this->impl};
+                ss << serialize(column, context);
+                perform_void_exec(db, ss.str());
+            }
+
+            template<typename S>
+            prepared_statement_t<S> prepare_impl(S statement) {
+                auto con = this->get_connection();
+                sqlite3_stmt* stmt;
+                auto db = con.get();
+                const auto& exprImpl = storage_for_expression(*this, statement);
+                using context_t = serializator_context<polyfill::remove_cvref_t<decltype(exprImpl)>>;
+                context_t context{exprImpl};
+                context.skip_table_name = false;
+                context.replace_bindable_with_question = true;
+                auto query = serialize(statement, context);
+                if(sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) == SQLITE_OK) {
+                    return prepared_statement_t<S>{std::forward<S>(statement), stmt, con};
+                } else {
+                    throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                            sqlite3_errmsg(db));
+                }
+            }
+
+          public:
+            /**
+             *  This is a cute function used to replace migration up/down functionality.
+             *  It performs check storage schema with actual db schema and:
+             *  * if there are excess tables exist in db they are ignored (not dropped)
+             *  * every table from storage is compared with it's db analog and
+             *      * if table doesn't exist it is being created
+             *      * if table exists its colums are being compared with table_info from db and
+             *          * if there are columns in db that do not exist in storage (excess) table will be dropped and
+             * recreated
+             *          * if there are columns in storage that do not exist in db they will be added using `ALTER TABLE
+             * ... ADD COLUMN ...' command
+             *          * if there is any column existing in both db and storage but differs by any of
+             * properties/constraints (pk, notnull, dflt_value) table will be dropped and recreated. Be aware that
+             * `sync_schema` doesn't guarantee that data will not be dropped. It guarantees only that it will make db
+             * schema the same as you specified in `make_storage` function call. A good point is that if you have no db
+             * file at all it will be created and all tables also will be created with exact tables and columns you
+             * specified in `make_storage`, `make_table` and `make_column` calls. The best practice is to call this
+             * function right after storage creation.
+             *  @param preserve affects function's behaviour in case it is needed to remove a column. If it is `false`
+             * so table will be dropped if there is column to remove if SQLite version is < 3.35.0 and rmeove column if SQLite version >= 3.35.0,
+             * if `true` -  table is being copied into another table, dropped and copied table is renamed with source table name.
+             * Warning: sync_schema doesn't check foreign keys cause it is unable to do so in sqlite3. If you know how to get foreign key info please
+             * submit an issue https://github.com/fnc12/sqlite_orm/issues
+             *  @return std::map with std::string key equal table name and `sync_schema_result` as value.
+             * `sync_schema_result` is a enum value that stores table state after syncing a schema. `sync_schema_result`
+             * can be printed out on std::ostream with `operator<<`.
+             */
+            std::map<std::string, sync_schema_result> sync_schema(bool preserve = false) {
+                auto con = this->get_connection();
+                std::map<std::string, sync_schema_result> result;
+                auto db = con.get();
+                this->impl.for_each([&result, db, preserve, this](auto& storageImpl) {
+                    auto res = this->sync_table(storageImpl, db, preserve);
+                    result.insert({storageImpl.table.name, res});
+                });
+                return result;
+            }
+
+            /**
+             *  This function returns the same map that `sync_schema` returns but it
+             *  doesn't perform `sync_schema` actually - just simulates it in case you want to know
+             *  what will happen if you sync your schema.
+             */
+            std::map<std::string, sync_schema_result> sync_schema_simulate(bool preserve = false) {
+                auto con = this->get_connection();
+                std::map<std::string, sync_schema_result> result;
+                auto db = con.get();
+                this->impl.for_each([&result, db, preserve, this](auto& tableImpl) {
+                    auto schemaStatus = this->schema_status(tableImpl, db, preserve);
+                    result.insert({tableImpl.table.name, schemaStatus});
+                });
+                return result;
+            }
+
+            /**
+             *  Checks whether table exists in db. Doesn't check storage itself - works only with actual database.
+             *  Note: table can be not mapped to a storage
+             *  @return true if table with a given name exists in db, false otherwise.
+             */
+            bool table_exists(const std::string& tableName) {
+                auto con = this->get_connection();
+                return this->impl.table_exists(tableName, con.get());
+            }
+
+            template<class... CTEs, class T, class... Args>
+            prepared_statement_t<with_t<select_t<T, Args...>, CTEs...>>
+            prepare(with_t<select_t<T, Args...>, CTEs...> sel) {
+                return prepare_impl<with_t<select_t<T, Args...>, CTEs...>>(std::move(sel));
+            }
+
+            template<class T, class... Args>
+            prepared_statement_t<select_t<T, Args...>> prepare(select_t<T, Args...> sel) {
+                sel.highest_level = true;
+                return prepare_impl<select_t<T, Args...>>(std::move(sel));
+            }
+
+            template<class T, class... Args>
+            prepared_statement_t<get_all_t<T, Args...>> prepare(get_all_t<T, Args...> get_) {
+                return prepare_impl<get_all_t<T, Args...>>(std::move(get_));
+            }
+
+            template<class T, class... Args>
+            prepared_statement_t<get_all_pointer_t<T, Args...>> prepare(get_all_pointer_t<T, Args...> get_) {
+                return prepare_impl<get_all_pointer_t<T, Args...>>(std::move(get_));
+            }
+
+            template<class... Args>
+            prepared_statement_t<replace_raw_t<Args...>> prepare(replace_raw_t<Args...> ins) {
+                return prepare_impl<replace_raw_t<Args...>>(std::move(ins));
+            }
+
+            template<class... Args>
+            prepared_statement_t<insert_raw_t<Args...>> prepare(insert_raw_t<Args...> ins) {
+                return prepare_impl<insert_raw_t<Args...>>(std::move(ins));
+            }
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+            template<class T, class R, class... Args>
+            prepared_statement_t<get_all_optional_t<T, R, Args...>> prepare(get_all_optional_t<T, R, Args...> get_) {
+                return prepare_impl<get_all_optional_t<T, R, Args...>>(std::move(get_));
+            }
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+            template<class... Args, class... Wargs>
+            prepared_statement_t<update_all_t<set_t<Args...>, Wargs...>>
+            prepare(update_all_t<set_t<Args...>, Wargs...> upd) {
+                return prepare_impl<update_all_t<set_t<Args...>, Wargs...>>(std::move(upd));
+            }
+
+            template<class T, class... Args>
+            prepared_statement_t<remove_all_t<T, Args...>> prepare(remove_all_t<T, Args...> rem) {
+                return prepare_impl<remove_all_t<T, Args...>>(std::move(rem));
+            }
+
+            template<class T, class... Ids>
+            prepared_statement_t<get_t<T, Ids...>> prepare(get_t<T, Ids...> get_) {
+                return prepare_impl<get_t<T, Ids...>>(std::move(get_));
+            }
+
+            template<class T, class... Ids>
+            prepared_statement_t<get_pointer_t<T, Ids...>> prepare(get_pointer_t<T, Ids...> get_) {
+                return prepare_impl<get_pointer_t<T, Ids...>>(std::move(get_));
+            }
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+            template<class T, class... Ids>
+            prepared_statement_t<get_optional_t<T, Ids...>> prepare(get_optional_t<T, Ids...> get_) {
+                return prepare_impl<get_optional_t<T, Ids...>>(std::move(get_));
+            }
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+            template<class T>
+            prepared_statement_t<update_t<T>> prepare(update_t<T> upd) {
+                return prepare_impl<update_t<T>>(std::move(upd));
+            }
+
+            template<class T, class... Ids>
+            prepared_statement_t<remove_t<T, Ids...>> prepare(remove_t<T, Ids...> rem) {
+                return prepare_impl<remove_t<T, Ids...>>(std::move(rem));
+            }
+
+            template<class T>
+            prepared_statement_t<insert_t<T>> prepare(insert_t<T> ins) {
+                using object_type = typename expression_object_type<decltype(ins)>::type;
+                this->assert_mapped_type<object_type>();
+                this->assert_insertable_type<object_type>();
+                return prepare_impl<insert_t<T>>(std::move(ins));
+            }
+
+            template<class T>
+            prepared_statement_t<replace_t<T>> prepare(replace_t<T> rep) {
+                using object_type = typename expression_object_type<decltype(rep)>::type;
+                this->assert_mapped_type<object_type>();
+                return prepare_impl<replace_t<T>>(std::move(rep));
+            }
+
+            template<class It, class L, class O>
+            prepared_statement_t<insert_range_t<It, L, O>> prepare(insert_range_t<It, L, O> statement) {
+                using object_type = typename expression_object_type<decltype(statement)>::type;
+                this->assert_mapped_type<object_type>();
+                this->assert_insertable_type<object_type>();
+                return prepare_impl<insert_range_t<It, L, O>>(std::move(statement));
+            }
+
+            template<class It, class L, class O>
+            prepared_statement_t<replace_range_t<It, L, O>> prepare(replace_range_t<It, L, O> rep) {
+                return prepare_impl<replace_range_t<It, L, O>>(std::move(rep));
+            }
+
+            template<class T, class... Cols>
+            prepared_statement_t<insert_explicit<T, Cols...>> prepare(insert_explicit<T, Cols...> ins) {
+                using object_type = typename expression_object_type<decltype(ins)>::type;
+                this->assert_mapped_type<object_type>();
+                return prepare_impl<insert_explicit<T, Cols...>>(std::move(ins));
+            }
+
+            template<class... Args>
+            void execute(const prepared_statement_t<replace_raw_t<Args...>>& statement) {
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                sqlite3_reset(stmt);
+                auto index = 1;
+                iterate_ast(statement.expression.args, [stmt, &index, db](auto& node) {
+                    using node_type = typename std::decay<decltype(node)>::type;
+                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
+                    if(SQLITE_OK != binder(node)) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                });
+                perform_step(db, stmt);
+            }
+
+            template<class... Args>
+            void execute(const prepared_statement_t<insert_raw_t<Args...>>& statement) {
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                sqlite3_reset(stmt);
+                auto index = 1;
+                iterate_ast(statement.expression.args, [stmt, &index, db](auto& node) {
+                    using node_type = typename std::decay<decltype(node)>::type;
+                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
+                    if(SQLITE_OK != binder(node)) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                });
+                perform_step(db, stmt);
+            }
+
+            template<class T, class... Cols>
+            int64 execute(const prepared_statement_t<insert_explicit<T, Cols...>>& statement) {
+                using statement_type = typename std::decay<decltype(statement)>::type;
+                using expression_type = typename statement_type::expression_type;
+                using object_type = typename expression_object_type<expression_type>::type;
+                auto index = 1;
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                auto& tImpl = this->get_impl<object_type>();
+                auto& o = statement.expression.obj;
+                sqlite3_reset(stmt);
+                iterate_tuple(statement.expression.columns.columns, [&o, &index, &stmt, &tImpl, db](auto& m) {
+                    using column_type = typename std::decay<decltype(m)>::type;
+                    using field_type = typename column_result_t<self, column_type>::type;
+                    const field_type* value = tImpl.table.template get_object_field_pointer<field_type>(o, m);
+                    if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, *value)) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                });
+                perform_step(db, stmt);
+                return sqlite3_last_insert_rowid(db);
+            }
+
+            template<class T, std::enable_if_t<is_replace_range<T>::value || is_replace<T>::value, bool> = true>
+            void execute(const prepared_statement_t<T>& statement) {
+                using statement_type = typename std::decay<decltype(statement)>::type;
+                using expression_type = typename statement_type::expression_type;
+                using object_type = typename expression_object_type<expression_type>::type;
+                auto& tImpl = this->get_impl<object_type>();
+                auto index = 1;
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                sqlite3_reset(stmt);
+
+                auto processObject = [&index, &stmt, &tImpl, db](auto& object) {
+                    tImpl.table.for_each_column([&index, stmt, &object, db](auto& column) {
+                        if(column.is_generated()) {
+                            return;
+                        }
+                        using column_type = typename std::decay<decltype(column)>::type;
+                        using field_type = typename column_type::field_type;
+                        if(column.member_pointer) {
+                            if(SQLITE_OK !=
+                               statement_binder<field_type>().bind(stmt, index++, object.*column.member_pointer)) {
+                                throw std::system_error(
+                                    std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                    sqlite3_errmsg(db));
+                            }
+                        } else {
+                            using getter_type = typename column_type::getter_type;
+                            field_value_holder<getter_type> valueHolder{((object).*(column.getter))()};
+                            if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, valueHolder.value)) {
+                                throw std::system_error(
+                                    std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                    sqlite3_errmsg(db));
+                            }
+                        }
+                    });
+                };
+
+                static_if<is_replace_range<T>{}>(
+                    [&processObject](auto& statement) {
+                        auto& transformer = statement.expression.transformer;
+                        std::for_each(  ///
+                            statement.expression.range.first,
+                            statement.expression.range.second,
+                            [&processObject, &transformer](auto& object) {
+                                auto& realObject = transformer(object);
+                                processObject(realObject);
+                            });
+                    },
+                    [&processObject](auto& statement) {
+                        auto& o = get_object(statement.expression);
+                        processObject(o);
+                    })(statement);
+                perform_step(db, stmt);
+            }
+
+            template<class T, std::enable_if_t<is_insert_range<T>::value || is_insert<T>::value, bool> = true>
+            int64 execute(const prepared_statement_t<T>& statement) {
+                using statement_type = typename std::decay<decltype(statement)>::type;
+                using expression_type = typename statement_type::expression_type;
+                using object_type = typename expression_object_type<expression_type>::type;
+                auto index = 1;
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                auto& tImpl = this->get_impl<object_type>();
+                sqlite3_reset(stmt);
+                auto processObject = [&index, stmt, &tImpl, db](auto& object) {
+                    tImpl.table.for_each_column([&tImpl, &index, &object, db, stmt](auto& column) {
+                        using table_type = typename std::decay<decltype(tImpl.table)>::type;
+                        if(table_type::is_without_rowid ||
+                           (!column.template has<primary_key_t<>>() &&
+                            !tImpl.table.exists_in_composite_primary_key(column) && !column.is_generated())) {
+                            using column_type = typename std::decay<decltype(column)>::type;
+                            using field_type = typename column_type::field_type;
+                            if(column.member_pointer) {
+                                if(SQLITE_OK !=
+                                   statement_binder<field_type>().bind(stmt, index++, object.*column.member_pointer)) {
+                                    throw std::system_error(
+                                        std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                        sqlite3_errmsg(db));
+                                }
+                            } else {
+                                using getter_type = typename column_type::getter_type;
+                                field_value_holder<getter_type> valueHolder{((object).*(column.getter))()};
+                                if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, valueHolder.value)) {
+                                    throw std::system_error(
+                                        std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                        sqlite3_errmsg(db));
+                                }
+                            }
+                        }
+                    });
+                };
+
+                static_if<is_insert_range<T>{}>(
+                    [&processObject](auto& statement) {
+                        auto& transformer = statement.expression.transformer;
+                        std::for_each(  ///
+                            statement.expression.range.first,
+                            statement.expression.range.second,
+                            [&processObject, &transformer](auto& object) {
+                                auto& realObject = transformer(object);
+                                processObject(realObject);
+                            });
+                    },
+                    [&processObject](auto& statement) {
+                        auto& o = get_object(statement.expression);
+                        processObject(o);
+                    })(statement);
+
+                perform_step(db, stmt);
+                return sqlite3_last_insert_rowid(db);
+            }
+
+            template<class T, class... Ids>
+            void execute(const prepared_statement_t<remove_t<T, Ids...>>& statement) {
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                auto index = 1;
+                sqlite3_reset(stmt);
+                iterate_ast(statement.expression.ids, [stmt, &index, db](auto& v) {
+                    using field_type = typename std::decay<decltype(v)>::type;
+                    if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, v)) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                });
+                perform_step(db, stmt);
+            }
+
+            template<class T>
+            void execute(const prepared_statement_t<update_t<T>>& statement) {
+                using statement_type = typename std::decay<decltype(statement)>::type;
+                using expression_type = typename statement_type::expression_type;
+                using object_type = typename expression_object_type<expression_type>::type;
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto& tImpl = this->get_impl<object_type>();
+                auto stmt = statement.stmt;
+                auto index = 1;
+                auto& o = get_object(statement.expression);
+                sqlite3_reset(stmt);
+                tImpl.table.for_each_column([&o, stmt, &index, db, &tImpl](auto& column) {
+                    if(!column.template has<primary_key_t<>>() &&
+                       !tImpl.table.exists_in_composite_primary_key(column)) {
+                        using column_type = typename std::decay<decltype(column)>::type;
+                        using field_type = typename column_type::field_type;
+                        if(column.member_pointer) {
+                            auto bind_res =
+                                statement_binder<field_type>().bind(stmt, index++, o.*column.member_pointer);
+                            if(SQLITE_OK != bind_res) {
+                                throw std::system_error(
+                                    std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                    sqlite3_errmsg(db));
+                            }
+                        } else {
+                            using getter_type = typename column_type::getter_type;
+                            field_value_holder<getter_type> valueHolder{((o).*(column.getter))()};
+                            if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, valueHolder.value)) {
+                                throw std::system_error(
+                                    std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                    sqlite3_errmsg(db));
+                            }
+                        }
+                    }
+                });
+                tImpl.table.for_each_column([&o, stmt, &index, db, &tImpl](auto& column) {
+                    if(column.template has<primary_key_t<>>() || tImpl.table.exists_in_composite_primary_key(column)) {
+                        using column_type = typename std::decay<decltype(column)>::type;
+                        using field_type = typename column_type::field_type;
+                        if(column.member_pointer) {
+                            if(SQLITE_OK !=
+                               statement_binder<field_type>().bind(stmt, index++, o.*column.member_pointer)) {
+                                throw std::system_error(
+                                    std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                    sqlite3_errmsg(db));
+                            }
+                        } else {
+                            using getter_type = typename column_type::getter_type;
+                            field_value_holder<getter_type> valueHolder{((o).*(column.getter))()};
+                            if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, valueHolder.value)) {
+                                throw std::system_error(
+                                    std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                    sqlite3_errmsg(db));
+                            }
+                        }
+                    }
+                });
+                perform_step(db, stmt);
+            }
+
+            template<class T, class... Ids>
+            std::unique_ptr<T> execute(const prepared_statement_t<get_pointer_t<T, Ids...>>& statement) {
+                auto& tImpl = this->get_impl<T>();
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                auto index = 1;
+                sqlite3_reset(stmt);
+                iterate_ast(statement.expression.ids, [stmt, &index, db](auto& v) {
+                    using field_type = typename std::decay<decltype(v)>::type;
+                    if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, v)) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                });
+                auto stepRes = sqlite3_step(stmt);
+                switch(stepRes) {
+                    case SQLITE_ROW: {
+                        auto res = std::make_unique<T>();
+                        object_from_column_builder<T> builder{*res, stmt};
+                        tImpl.table.for_each_column(builder);
+                        return res;
+                    } break;
+                    case SQLITE_DONE: {
+                        return {};
+                    } break;
+                    default: {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                }
+            }
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+            template<class T, class... Ids>
+            std::optional<T> execute(const prepared_statement_t<get_optional_t<T, Ids...>>& statement) {
+                auto& tImpl = this->get_impl<T>();
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                auto index = 1;
+                sqlite3_reset(stmt);
+                iterate_ast(statement.expression.ids, [stmt, &index, db](auto& v) {
+                    using field_type = typename std::decay<decltype(v)>::type;
+                    if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, v)) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                });
+                auto stepRes = sqlite3_step(stmt);
+                switch(stepRes) {
+                    case SQLITE_ROW: {
+                        auto res = std::make_optional<T>();
+                        object_from_column_builder<T> builder{res.value(), stmt};
+                        tImpl.table.for_each_column(builder);
+                        return res;
+                    } break;
+                    case SQLITE_DONE: {
+                        return {};
+                    } break;
+                    default: {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                }
+            }
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+            template<class T, class... Ids>
+            T execute(const prepared_statement_t<get_t<T, Ids...>>& statement) {
+                auto& tImpl = this->get_impl<T>();
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                auto index = 1;
+                sqlite3_reset(stmt);
+                iterate_ast(statement.expression.ids, [stmt, &index, db](auto& v) {
+                    using field_type = typename std::decay<decltype(v)>::type;
+                    if(SQLITE_OK != statement_binder<field_type>().bind(stmt, index++, v)) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                });
+                auto stepRes = sqlite3_step(stmt);
+                switch(stepRes) {
+                    case SQLITE_ROW: {
+                        T res;
+                        object_from_column_builder<T> builder{res, stmt};
+                        tImpl.table.for_each_column(builder);
+                        return res;
+                    } break;
+                    case SQLITE_DONE: {
+                        throw std::system_error(std::make_error_code(sqlite_orm::orm_error_code::not_found));
+                    } break;
+                    default: {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                }
+            }
+
+            template<class T, class... Args>
+            void execute(const prepared_statement_t<remove_all_t<T, Args...>>& statement) {
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                auto index = 1;
+                sqlite3_reset(stmt);
+                iterate_ast(statement.expression.conditions, [stmt, &index, db](auto& node) {
+                    using node_type = typename std::decay<decltype(node)>::type;
+                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
+                    if(SQLITE_OK != binder(node)) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                });
+                perform_step(db, stmt);
+            }
+
+            template<class... Args, class... Wargs>
+            void execute(const prepared_statement_t<update_all_t<set_t<Args...>, Wargs...>>& statement) {
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                auto index = 1;
+                sqlite3_reset(stmt);
+                iterate_tuple(statement.expression.set.assigns, [&index, stmt, db](auto& setArg) {
+                    iterate_ast(setArg, [&index, stmt, db](auto& node) {
+                        using node_type = typename std::decay<decltype(node)>::type;
+                        conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
+                        if(SQLITE_OK != binder(node)) {
+                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                    sqlite3_errmsg(db));
+                        }
+                    });
+                });
+                iterate_ast(statement.expression.conditions, [stmt, &index, db](auto& node) {
+                    using node_type = typename std::decay<decltype(node)>::type;
+                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
+                    if(SQLITE_OK != binder(node)) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                });
+                perform_step(db, stmt);
+            }
+
+            template<class R, class S>
+            std::vector<R> _execute_select(const S& statement) {
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                auto index = 1;
+                sqlite3_reset(stmt);
+                iterate_ast(statement.expression, [stmt, &index, db](auto& node) {
+                    using node_type = typename std::decay<decltype(node)>::type;
+                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
+                    if(SQLITE_OK != binder(node)) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                });
+                std::vector<R> res;
+                auto tableInfoPointer = lookup_table<R>(this->impl);
+                int stepRes;
+                do {
+                    stepRes = sqlite3_step(stmt);
+                    switch(stepRes) {
+                        case SQLITE_ROW: {
+                            using table_info_pointer_t = typename std::remove_pointer<decltype(tableInfoPointer)>::type;
+                            using table_info_t = typename std::decay<table_info_pointer_t>::type;
+                            row_extractor_builder<R, storage_traits::type_is_mapped<self, R>::value, table_info_t>
+                                builder;
+                            auto rowExtractor = builder(tableInfoPointer);
+                            res.push_back(rowExtractor.extract(stmt, 0));
+                        } break;
+                        case SQLITE_DONE:
+                            break;
+                        default: {
+                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                    sqlite3_errmsg(db));
+                        }
+                    }
+                } while(stepRes != SQLITE_DONE);
+                return res;
+            }
+
+            template<class... CTEs, class T, class... Args>
+            auto execute(const prepared_statement_t<with_t<select_t<T, Args...>, CTEs...>>& statement) {
+                using S =
+                    decltype(storage_for_expression(*this, std::declval<with_t<select_t<T, Args...>, CTEs...>>()));
+                using R = column_result_of_t<S, T>;
+                return _execute_select<R>(statement);
+            }
+
+            template<class T, class... Args>
+            auto execute(const prepared_statement_t<select_t<T, Args...>>& statement) {
+                using R = column_result_of_t<self, T>;
+                return _execute_select<R>(statement);
+            }
+
+            template<class T, class R, class... Args>
+            R execute(const prepared_statement_t<get_all_t<T, R, Args...>>& statement) {
+                auto& tImpl = this->get_impl<T>();
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                auto index = 1;
+                sqlite3_reset(stmt);
+                iterate_ast(statement.expression, [stmt, &index, db](auto& node) {
+                    using node_type = typename std::decay<decltype(node)>::type;
+                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
+                    if(SQLITE_OK != binder(node)) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                });
+                R res;
+                int stepRes;
+                do {
+                    stepRes = sqlite3_step(stmt);
+                    switch(stepRes) {
+                        case SQLITE_ROW: {
+                            T obj;
+                            object_from_column_builder<T> builder{obj, stmt};
+                            tImpl.table.for_each_column(builder);
+                            res.push_back(std::move(obj));
+                        } break;
+                        case SQLITE_DONE:
+                            break;
+                        default: {
+                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                    sqlite3_errmsg(db));
+                        }
+                    }
+                } while(stepRes != SQLITE_DONE);
+                return res;
+            }
+
+            template<class T, class R, class... Args>
+            R execute(const prepared_statement_t<get_all_pointer_t<T, R, Args...>>& statement) {
+                auto& tImpl = this->get_impl<T>();
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                auto index = 1;
+                sqlite3_reset(stmt);
+                iterate_ast(statement.expression, [stmt, &index, db](auto& node) {
+                    using node_type = typename std::decay<decltype(node)>::type;
+                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
+                    if(SQLITE_OK != binder(node)) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                });
+                R res;
+                int stepRes;
+                do {
+                    stepRes = sqlite3_step(stmt);
+                    switch(stepRes) {
+                        case SQLITE_ROW: {
+                            auto obj = std::make_unique<T>();
+                            object_from_column_builder<T> builder{*obj, stmt};
+                            tImpl.table.for_each_column(builder);
+                            res.push_back(move(obj));
+                        } break;
+                        case SQLITE_DONE:
+                            break;
+                        default: {
+                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                    sqlite3_errmsg(db));
+                        }
+                    }
+                } while(stepRes != SQLITE_DONE);
+                return res;
+            }
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+            template<class T, class R, class... Args>
+            R execute(const prepared_statement_t<get_all_optional_t<T, R, Args...>>& statement) {
+                auto& tImpl = this->get_impl<T>();
+                auto con = this->get_connection();
+                auto db = con.get();
+                auto stmt = statement.stmt;
+                auto index = 1;
+                sqlite3_reset(stmt);
+                iterate_ast(statement.expression, [stmt, &index, db](auto& node) {
+                    using node_type = typename std::decay<decltype(node)>::type;
+                    conditional_binder<node_type, is_bindable<node_type>> binder{stmt, index};
+                    if(SQLITE_OK != binder(node)) {
+                        throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                    }
+                });
+                R res;
+                int stepRes;
+                do {
+                    stepRes = sqlite3_step(stmt);
+                    switch(stepRes) {
+                        case SQLITE_ROW: {
+                            auto obj = std::make_optional<T>();
+                            object_from_column_builder<T> builder{*obj, stmt};
+                            tImpl.table.for_each_column(builder);
+                            res.push_back(move(obj));
+                        } break;
+                        case SQLITE_DONE:
+                            break;
+                        default: {
+                            throw std::system_error(std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                    sqlite3_errmsg(db));
+                        }
+                    }
+                } while(stepRes != SQLITE_DONE);
+                return res;
+            }
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+            template<class O>
+            bool has_dependent_rows(const O& object) {
+                auto res = false;
+                this->impl.for_each([this, &object, &res](auto& storageImpl) {
+                    if(res) {
+                        return;
+                    }
+                    storageImpl.table.for_each_foreign_key([&storageImpl, this, &object, &res](auto& foreignKey) {
+                        using ForeignKey = typename std::decay<decltype(foreignKey)>::type;
+                        using TargetType = typename ForeignKey::target_type;
+                        if(std::is_same<TargetType, O>::value) {
+                            std::stringstream ss;
+                            ss << "SELECT COUNT(*)";
+                            ss << " FROM " << storageImpl.table.name;
+                            ss << " WHERE";
+                            auto columnIndex = 0;
+                            iterate_tuple(foreignKey.columns, [&ss, &columnIndex, &storageImpl](auto& column) {
+                                if(columnIndex > 0) {
+                                    ss << " AND";
+                                }
+                                if(auto columnName = storageImpl.table.find_column_name(column)) {
+                                    ss << ' ' << *columnName << " = ?";
+                                } else {
+                                    throw std::system_error(
+                                        std::make_error_code(sqlite_orm::orm_error_code::column_not_found));
+                                }
+                                ++columnIndex;
+                            });
+                            auto query = ss.str();
+                            ss.flush();
+                            auto con = this->get_connection();
+                            sqlite3_stmt* stmt;
+                            auto db = con.get();
+                            if(sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) == SQLITE_OK) {
+                                statement_finalizer finalizer(stmt);
+                                columnIndex = 1;
+                                iterate_tuple(
+                                    foreignKey.references,
+                                    [&columnIndex, stmt, &object, db](auto& memberPointer) {
+                                        using MemberPointer = typename std::decay<decltype(memberPointer)>::type;
+                                        using field_type = typename member_traits<MemberPointer>::field_type;
+                                        //                                    if(column.member_pointer) {
+                                        if(SQLITE_OK != statement_binder<field_type>().bind(stmt,
+                                                                                            columnIndex++,
+                                                                                            object.*memberPointer)) {
+                                            throw std::system_error(
+                                                std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                                        }
+                                        /*} else {
+                                        using getter_type = typename column_type::getter_type;
+                                        field_value_holder<getter_type> valueHolder{((object).*(column.getter))()};
+                                        if(SQLITE_OK != statement_binder<field_type>().bind(stmt, columnIndex++, valueHolder.value)) {
+                                            throw std::system_error(
+                                                std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                                sqlite3_errmsg(db));
+                                        }
+                                    }*/
+                                    });
+                                if(SQLITE_ROW != sqlite3_step(stmt)) {
+                                    throw std::system_error(
+                                        std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                        sqlite3_errmsg(db));
+                                }
+                                auto countResult = sqlite3_column_int(stmt, 0);
+                                res = countResult > 0;
+                                if(SQLITE_DONE != sqlite3_step(stmt)) {
+                                    throw std::system_error(
+                                        std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                        sqlite3_errmsg(db));
+                                }
+                            } else {
+                                throw std::system_error(
+                                    std::error_code(sqlite3_errcode(db), get_sqlite_error_category()),
+                                    sqlite3_errmsg(db));
+                            }
+                        }
+                    });
+                });
+                return res;
+            }
+        };  // struct storage_t
+    }
+
+    template<class... Ts>
+    internal::storage_t<Ts...> make_storage(const std::string& filename, Ts... tables) {
+        return {filename, internal::storage_impl<Ts...>(std::forward<Ts>(tables)...)};
+    }
+
+    /**
+     *  sqlite3_threadsafe() interface.
+     */
+    inline int threadsafe() {
+        return sqlite3_threadsafe();
+    }
+}
+#pragma once
+
+#include <type_traits>
+#include <string>
+
+// #include "cxx_polyfill.h"
+
+// #include "select_constraints.h"
+
+// #include "cte_types.h"
+
+namespace sqlite_orm {
+
+    template<char C, char... Chars>
+    struct cte_label {
+        using label_tag = cte_label_tag;
+
+        static constexpr char str[] = {C, Chars..., '\0'};
+
+        static constexpr const char* label() {
+            return str;
+        }
+
+        // CTE derives from a label, hence provide a string conversion operator
+        explicit operator std::string() const {
+            return cte_label::label();
+        }
+    };
+
+    using cte_1 = cte_label<'c', 't', 'e', '_', '1'>;
+    using cte_2 = cte_label<'c', 't', 'e', '_', '2'>;
+    using cte_3 = cte_label<'c', 't', 'e', '_', '3'>;
+    using cte_4 = cte_label<'c', 't', 'e', '_', '4'>;
+    using cte_5 = cte_label<'c', 't', 'e', '_', '5'>;
+    using cte_6 = cte_label<'c', 't', 'e', '_', '6'>;
+    using cte_7 = cte_label<'c', 't', 'e', '_', '7'>;
+    using cte_8 = cte_label<'c', 't', 'e', '_', '8'>;
+    using cte_9 = cte_label<'c', 't', 'e', '_', '9'>;
+
+#if __cplusplus >= 201703L  // use of C++17 or higher
+    namespace internal {
+        constexpr size_t _10_pow(size_t n) {
+            if(n == 0) {
+                return 1;
+            } else {
+                return 10 * _10_pow(n - 1);
+            }
+        }
+
+        template<class... Chars, size_t... Is>
+        constexpr size_t n_from_literal(std::index_sequence<Is...>, Chars... chars) {
+            return (((chars - '0') * _10_pow(sizeof...(Is) - 1u - Is /*reversed index sequence*/)) + ...);
+        }
+    }
+
+    /**
+     *  index_constant<> from numeric literal.
+     *  E.g. 0_col, 1_col
+     */
+    template<char... Chars>
+    [[nodiscard]] constexpr decltype(auto) operator"" _col() {
+        return polyfill::index_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{},
+                                                                 Chars...)>{};
+    }
+
+    /**
+     *  integral_constant<unsigned int> from numeric literal.
+     *  E.g. 1_nth_col, 2_nth_col
+     */
+    template<char... Chars>
+    [[nodiscard]] constexpr decltype(auto) operator"" _nth_col() {
+        static_assert(((Chars != '0') && ...));
+        return internal::nth_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{},
+                                                               Chars...)>{};
+    }
+#else
+        constexpr polyfill::index_constant<0> _0_col{};
+        constexpr polyfill::index_constant<1> _1_col{};
+        constexpr polyfill::index_constant<2> _2_col{};
+        constexpr polyfill::index_constant<3> _3_col{};
+        constexpr polyfill::index_constant<4> _4_col{};
+        constexpr polyfill::index_constant<5> _5_col{};
+        constexpr polyfill::index_constant<6> _6_col{};
+        constexpr polyfill::index_constant<7> _7_col{};
+        constexpr polyfill::index_constant<8> _8_col{};
+        constexpr polyfill::index_constant<9> _9_col{};
+
+        constexpr internal::nth_constant<1> _1_nth_col{};
+        constexpr internal::nth_constant<2> _2_nth_col{};
+        constexpr internal::nth_constant<3> _3_nth_col{};
+        constexpr internal::nth_constant<4> _4_nth_col{};
+        constexpr internal::nth_constant<5> _5_nth_col{};
+        constexpr internal::nth_constant<6> _6_nth_col{};
+        constexpr internal::nth_constant<7> _7_nth_col{};
+        constexpr internal::nth_constant<8> _8_nth_col{};
+        constexpr internal::nth_constant<9> _9_nth_col{};
+        constexpr internal::nth_constant<10> _10_nth_col{};
+#endif
+}
+#pragma once
+
+#if defined(_MSC_VER)
+#if defined(__RESTORE_MIN__)
+__pragma(pop_macro("min"))
+#undef __RESTORE_MIN__
+#endif
+#if defined(__RESTORE_MAX__)
+    __pragma(pop_macro("max"))
+#undef __RESTORE_MAX__
+#endif
+#endif  // defined(_MSC_VER)
+#pragma once
+
+#include <tuple>  //  std::tuple
+#include <utility>  //  std::pair
+#include <functional>  //  std::reference_wrapper
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+#include <optional>  // std::optional
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+    // #include "conditions.h"
+
+    // #include "operators.h"
+
+    // #include "select_constraints.h"
+
+    // #include "prepared_statement.h"
+
+    // #include "optional_container.h"
+
+    // #include "core_functions.h"
+
+    // #include "function.h"
+
+    // #include "ast/excluded.h"
+
+    // #include "ast/upsert_clause.h"
+
+    // #include "ast/where.h"
+
+    // #include "ast/into.h"
+
+    // #include "ast/group_by.h"
+
+    namespace sqlite_orm {
+
+    namespace internal {
+
+        template<class T, class SFINAE = void>
+        struct node_tuple {
+            using type = std::tuple<T>;
+        };
+
+        template<>
+        struct node_tuple<void, void> {
+            using type = std::tuple<>;
+        };
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class T>
+        struct node_tuple<as_optional_t<T>, void> {
+            using type = typename node_tuple<T>::type;
+        };
+#endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class T>
+        struct node_tuple<std::reference_wrapper<T>, void> {
+            using type = typename node_tuple<T>::type;
+        };
+
+        template<class... Args>
+        struct node_tuple<group_by_t<Args...>, void> {
+            using type = typename node_tuple<std::tuple<Args...>>::type;
+        };
+
+        template<class T, class... Args>
+        struct node_tuple<group_by_with_having<T, Args...>, void> {
+            using args_tuple = typename node_tuple<std::tuple<Args...>>::type;
+            using expression_tuple = typename node_tuple<T>::type;
+            using type = typename conc_tuple<args_tuple, expression_tuple>::type;
+        };
+
+        template<class... TargetArgs, class... ActionsArgs>
+        struct node_tuple<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void> {
+            using type = typename node_tuple<std::tuple<ActionsArgs...>>::type;
+        };
+
+        template<class... Args>
+        struct node_tuple<set_t<Args...>, void> {
+            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+        };
+
+        template<class T>
+        struct node_tuple<excluded_t<T>, void> {
+            using type = typename node_tuple<T>::type;
+        };
+
+        template<class C>
+        struct node_tuple<where_t<C>, void> {
+            using node_type = where_t<C>;
+            using type = typename node_tuple<C>::type;
+        };
+
+        template<class T>
+        struct node_tuple<T, typename std::enable_if<is_base_of_template<T, binary_condition>::value>::type> {
+            using node_type = T;
+            using left_type = typename node_type::left_type;
+            using right_type = typename node_type::right_type;
+            using left_node_tuple = typename node_tuple<left_type>::type;
+            using right_node_tuple = typename node_tuple<right_type>::type;
+            using type = typename conc_tuple<left_node_tuple, right_node_tuple>::type;
+        };
+
+        template<class L, class R, class... Ds>
+        struct node_tuple<binary_operator<L, R, Ds...>, void> {
+            using node_type = binary_operator<L, R, Ds...>;
+            using left_type = typename node_type::left_type;
+            using right_type = typename node_type::right_type;
+            using left_node_tuple = typename node_tuple<left_type>::type;
+            using right_node_tuple = typename node_tuple<right_type>::type;
+            using type = typename conc_tuple<left_node_tuple, right_node_tuple>::type;
+        };
+
+        template<class... Args>
+        struct node_tuple<columns_t<Args...>, void> {
+            using node_type = columns_t<Args...>;
+            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+        };
+
+        template<class L, class A>
+        struct node_tuple<dynamic_in_t<L, A>, void> {
+            using node_type = dynamic_in_t<L, A>;
+            using left_tuple = typename node_tuple<L>::type;
+            using right_tuple = typename node_tuple<A>::type;
+            using type = typename conc_tuple<left_tuple, right_tuple>::type;
+        };
+
+        template<class L, class... Args>
+        struct node_tuple<in_t<L, Args...>, void> {
+            using node_type = in_t<L, Args...>;
+            using left_tuple = typename node_tuple<L>::type;
+            using right_tuple = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+            using type = typename conc_tuple<left_tuple, right_tuple>::type;
+        };
+
+        template<class T>
+        struct node_tuple<T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
+            using node_type = T;
+            using left_type = typename node_type::left_type;
+            using right_type = typename node_type::right_type;
+            using left_tuple = typename node_tuple<left_type>::type;
+            using right_tuple = typename node_tuple<right_type>::type;
+            using type = typename conc_tuple<left_tuple, right_tuple>::type;
+        };
+
+        template<class T>
+        struct node_tuple<T, typename std::enable_if<is_base_of_template<T, common_table_expression>::value>::type> {
+            using node_type = T;
+            using cte_type = typename node_type::cte_type;
+            using expression_type = typename node_type::expression_type;
+            using cte_tuple = typename node_tuple<cte_type>::type;
+            using expression_tuple = typename node_tuple<expression_type>::type;
+            using type = typename conc_tuple<cte_tuple, expression_tuple>::type;
+        };
+
+        template<class T, class... Args>
+        struct node_tuple<select_t<T, Args...>, void> {
+            using node_type = select_t<T, Args...>;
+            using columns_tuple = typename node_tuple<T>::type;
+            using args_tuple = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+            using type = typename conc_tuple<columns_tuple, args_tuple>::type;
+        };
+
+        template<class... Args>
+        struct node_tuple<insert_raw_t<Args...>, void> {
+            using node_type = insert_raw_t<Args...>;
+            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+        };
+
+        template<class... Args>
+        struct node_tuple<replace_raw_t<Args...>, void> {
+            using node_type = replace_raw_t<Args...>;
+            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+        };
+
+        template<class T>
+        struct node_tuple<into_t<T>, void> {
+            using node_type = into_t<T>;
+            using type = std::tuple<>;
+        };
+
+        template<class... Args>
+        struct node_tuple<values_t<Args...>, void> {
+            using node_type = values_t<Args...>;
+            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+        };
+
+        template<class... Args>
+        struct node_tuple<std::tuple<Args...>, void> {
+            using node_type = std::tuple<Args...>;
+            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+        };
+
+        template<class T, class R, class... Args>
+        struct node_tuple<get_all_t<T, R, Args...>, void> {
+            using node_type = get_all_t<T, R, Args...>;
+            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+        };
+
+        template<class T, class... Args>
+        struct node_tuple<get_all_pointer_t<T, Args...>, void> {
+            using node_type = get_all_pointer_t<T, Args...>;
+            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+        };
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+        template<class T, class... Args>
+        struct node_tuple<get_all_optional_t<T, Args...>, void> {
+            using node_type = get_all_optional_t<T, Args...>;
+            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+        };
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+        template<class... Args, class... Wargs>
+        struct node_tuple<update_all_t<set_t<Args...>, Wargs...>, void> {
+            using node_type = update_all_t<set_t<Args...>, Wargs...>;
+            using set_tuple = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+            using conditions_tuple = typename conc_tuple<typename node_tuple<Wargs>::type...>::type;
+            using type = typename conc_tuple<set_tuple, conditions_tuple>::type;
+        };
+
+        template<class T, class... Args>
+        struct node_tuple<remove_all_t<T, Args...>, void> {
+            using node_type = remove_all_t<T, Args...>;
+            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+        };
+
+        template<class T>
+        struct node_tuple<having_t<T>, void> {
+            using node_type = having_t<T>;
+            using type = typename node_tuple<T>::type;
+        };
+
+        template<class T, class E>
+        struct node_tuple<cast_t<T, E>, void> {
+            using node_type = cast_t<T, E>;
+            using type = typename node_tuple<E>::type;
+        };
+
+        template<class T>
+        struct node_tuple<exists_t<T>, void> {
+            using node_type = exists_t<T>;
+            using type = typename node_tuple<T>::type;
+        };
+
+        template<class T>
+        struct node_tuple<optional_container<T>, void> {
+            using node_type = optional_container<T>;
+            using type = typename node_tuple<T>::type;
+        };
+
+        template<>
+        struct node_tuple<optional_container<void>, void> {
+            using node_type = optional_container<void>;
+            using type = std::tuple<>;
+        };
+
+        template<class A, class T, class E>
+        struct node_tuple<like_t<A, T, E>, void> {
+            using node_type = like_t<A, T, E>;
+            using arg_tuple = typename node_tuple<A>::type;
+            using pattern_tuple = typename node_tuple<T>::type;
+            using escape_tuple = typename node_tuple<E>::type;
+            using type = typename conc_tuple<arg_tuple, pattern_tuple, escape_tuple>::type;
+        };
+
+        template<class A, class T>
+        struct node_tuple<glob_t<A, T>, void> {
+            using node_type = glob_t<A, T>;
+            using arg_tuple = typename node_tuple<A>::type;
+            using pattern_tuple = typename node_tuple<T>::type;
+            using type = typename conc_tuple<arg_tuple, pattern_tuple>::type;
+        };
+
+        template<class A, class T>
+        struct node_tuple<between_t<A, T>, void> {
+            using node_type = between_t<A, T>;
+            using expression_tuple = typename node_tuple<A>::type;
+            using lower_tuple = typename node_tuple<T>::type;
+            using upper_tuple = typename node_tuple<T>::type;
+            using type = typename conc_tuple<expression_tuple, lower_tuple, upper_tuple>::type;
+        };
+
+        template<class T>
+        struct node_tuple<named_collate<T>, void> {
+            using node_type = named_collate<T>;
+            using type = typename node_tuple<T>::type;
+        };
+
+        template<class T>
+        struct node_tuple<is_null_t<T>, void> {
+            using node_type = is_null_t<T>;
+            using type = typename node_tuple<T>::type;
+        };
+
+        template<class T>
+        struct node_tuple<is_not_null_t<T>, void> {
+            using node_type = is_not_null_t<T>;
+            using type = typename node_tuple<T>::type;
+        };
+
+        template<class C>
+        struct node_tuple<negated_condition_t<C>, void> {
+            using node_type = negated_condition_t<C>;
+            using type = typename node_tuple<C>::type;
+        };
+
+        template<class R, class S, class... Args>
+        struct node_tuple<built_in_function_t<R, S, Args...>, void> {
+            using node_type = built_in_function_t<R, S, Args...>;
+            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+        };
+
+        template<class F, class... Args>
+        struct node_tuple<function_call<F, Args...>, void> {
+            using node_type = function_call<F, Args...>;
+            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+        };
+
+        template<class T, class O>
+        struct node_tuple<left_join_t<T, O>, void> {
+            using node_type = left_join_t<T, O>;
+            using type = typename node_tuple<O>::type;
+        };
+
+        template<class T>
+        struct node_tuple<on_t<T>, void> {
+            using node_type = on_t<T>;
+            using type = typename node_tuple<T>::type;
+        };
+
+        template<class T, class O>
+        struct node_tuple<join_t<T, O>, void> {
+            using node_type = join_t<T, O>;
+            using type = typename node_tuple<O>::type;
+        };
+
+        template<class T, class O>
+        struct node_tuple<left_outer_join_t<T, O>, void> {
+            using node_type = left_outer_join_t<T, O>;
+            using type = typename node_tuple<O>::type;
+        };
+
+        template<class T, class O>
+        struct node_tuple<inner_join_t<T, O>, void> {
+            using node_type = inner_join_t<T, O>;
+            using type = typename node_tuple<O>::type;
+        };
+
+        template<class R, class T, class E, class... Args>
+        struct node_tuple<simple_case_t<R, T, E, Args...>, void> {
+            using node_type = simple_case_t<R, T, E, Args...>;
+            using case_tuple = typename node_tuple<T>::type;
+            using args_tuple = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+            using else_tuple = typename node_tuple<E>::type;
+            using type = typename conc_tuple<case_tuple, args_tuple, else_tuple>::type;
+        };
+
+        template<class L, class R>
+        struct node_tuple<std::pair<L, R>, void> {
+            using node_type = std::pair<L, R>;
+            using left_tuple = typename node_tuple<L>::type;
+            using right_tuple = typename node_tuple<R>::type;
+            using type = typename conc_tuple<left_tuple, right_tuple>::type;
+        };
+
+        template<class T, class E>
+        struct node_tuple<as_t<T, E>, void> {
+            using node_type = as_t<T, E>;
+            using type = typename node_tuple<E>::type;
+        };
+
+        template<class T>
+        struct node_tuple<limit_t<T, false, false, void>, void> {
+            using node_type = limit_t<T, false, false, void>;
+            using type = typename node_tuple<T>::type;
+        };
+
+        template<class T, class O>
+        struct node_tuple<limit_t<T, true, false, O>, void> {
+            using node_type = limit_t<T, true, false, O>;
+            using type = typename conc_tuple<typename node_tuple<T>::type, typename node_tuple<O>::type>::type;
+        };
+
+        template<class T, class O>
+        struct node_tuple<limit_t<T, true, true, O>, void> {
+            using node_type = limit_t<T, true, true, O>;
+            using type = typename conc_tuple<typename node_tuple<O>::type, typename node_tuple<T>::type>::type;
+        };
+    }
+}
+#pragma once
+
+#include <type_traits>  //  std::is_same, std::decay, std::remove_reference
+
+// #include "prepared_statement.h"
+
+// #include "ast_iterator.h"
+
+// #include "static_magic.h"
+
+// #include "expression_object_type.h"
+
+namespace sqlite_orm {
+
+    template<int N, class It, class L, class O>
+    auto& get(internal::prepared_statement_t<internal::insert_range_t<It, L, O>>& statement) {
+        return std::get<N>(statement.expression.range);
+    }
+
+    template<int N, class It, class L, class O>
+    const auto& get(const internal::prepared_statement_t<internal::insert_range_t<It, L, O>>& statement) {
+        return std::get<N>(statement.expression.range);
+    }
+
+    template<int N, class It, class L, class O>
+    auto& get(internal::prepared_statement_t<internal::replace_range_t<It, L, O>>& statement) {
+        return std::get<N>(statement.expression.range);
+    }
+
+    template<int N, class It, class L, class O>
+    const auto& get(const internal::prepared_statement_t<internal::replace_range_t<It, L, O>>& statement) {
+        return std::get<N>(statement.expression.range);
+    }
+
+    template<int N, class T, class... Ids>
+    auto& get(internal::prepared_statement_t<internal::get_t<T, Ids...>>& statement) {
+        return internal::get_ref(std::get<N>(statement.expression.ids));
+    }
+
+    template<int N, class T, class... Ids>
+    const auto& get(const internal::prepared_statement_t<internal::get_t<T, Ids...>>& statement) {
+        return internal::get_ref(std::get<N>(statement.expression.ids));
+    }
+
+    template<int N, class T, class... Ids>
+    auto& get(internal::prepared_statement_t<internal::get_pointer_t<T, Ids...>>& statement) {
+        return internal::get_ref(std::get<N>(statement.expression.ids));
+    }
+
+    template<int N, class T, class... Ids>
+    const auto& get(const internal::prepared_statement_t<internal::get_pointer_t<T, Ids...>>& statement) {
+        return internal::get_ref(std::get<N>(statement.expression.ids));
+    }
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+    template<int N, class T, class... Ids>
+    auto& get(internal::prepared_statement_t<internal::get_optional_t<T, Ids...>>& statement) {
+        return internal::get_ref(std::get<N>(statement.expression.ids));
+    }
+
+    template<int N, class T, class... Ids>
+    const auto& get(const internal::prepared_statement_t<internal::get_optional_t<T, Ids...>>& statement) {
+        return internal::get_ref(std::get<N>(statement.expression.ids));
+    }
+#endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
+
+    template<int N, class T, class... Ids>
+    auto& get(internal::prepared_statement_t<internal::remove_t<T, Ids...>>& statement) {
+        return internal::get_ref(std::get<N>(statement.expression.ids));
+    }
+
+    template<int N, class T, class... Ids>
+    const auto& get(const internal::prepared_statement_t<internal::remove_t<T, Ids...>>& statement) {
+        return internal::get_ref(std::get<N>(statement.expression.ids));
+    }
+
+    template<int N, class T>
+    auto& get(internal::prepared_statement_t<internal::update_t<T>>& statement) {
+        static_assert(N == 0, "get<> works only with 0 argument for update statement");
+        return internal::get_ref(statement.expression.object);
+    }
+
+    template<int N, class T>
+    const auto& get(const internal::prepared_statement_t<internal::update_t<T>>& statement) {
+        static_assert(N == 0, "get<> works only with 0 argument for update statement");
+        return internal::get_ref(statement.expression.object);
+    }
+
+    template<int N, class T, class... Cols>
+    auto& get(internal::prepared_statement_t<internal::insert_explicit<T, Cols...>>& statement) {
+        static_assert(N == 0, "get<> works only with 0 argument for insert statement");
+        return internal::get_ref(statement.expression.obj);
+    }
+
+    template<int N, class T, class... Cols>
+    const auto& get(const internal::prepared_statement_t<internal::insert_explicit<T, Cols...>>& statement) {
+        static_assert(N == 0, "get<> works only with 0 argument for insert statement");
+        return internal::get_ref(statement.expression.obj);
+    }
+
+    template<int N, class T>
+    auto& get(internal::prepared_statement_t<internal::replace_t<T>>& statement) {
+        static_assert(N == 0, "get<> works only with 0 argument for replace statement");
+        return internal::get_ref(statement.expression.object);
+    }
+
+    template<int N, class T>
+    const auto& get(const internal::prepared_statement_t<internal::replace_t<T>>& statement) {
+        static_assert(N == 0, "get<> works only with 0 argument for replace statement");
+        return internal::get_ref(statement.expression.object);
+    }
+
+    template<int N, class T>
+    auto& get(internal::prepared_statement_t<internal::insert_t<T>>& statement) {
+        static_assert(N == 0, "get<> works only with 0 argument for insert statement");
+        return internal::get_ref(statement.expression.object);
+    }
+
+    template<int N, class T>
+    const auto& get(const internal::prepared_statement_t<internal::insert_t<T>>& statement) {
+        static_assert(N == 0, "get<> works only with 0 argument for insert statement");
+        return internal::get_ref(statement.expression.object);
+    }
+
+    template<int N, class T>
+    const auto& get(const internal::prepared_statement_t<T>& statement) {
+        using statement_type = typename std::decay<decltype(statement)>::type;
+        using expression_type = typename statement_type::expression_type;
+        using node_tuple = typename internal::node_tuple<expression_type>::type;
+        using bind_tuple = typename internal::bindable_filter<node_tuple>::type;
+        using result_tupe = typename std::tuple_element<static_cast<size_t>(N), bind_tuple>::type;
+        const result_tupe* result = nullptr;
+        auto index = -1;
+        internal::iterate_ast(statement.expression, [&result, &index](auto& node) {
+            using node_type = typename std::decay<decltype(node)>::type;
+            if(internal::is_bindable<node_type>::value) {
+                ++index;
+            }
+            if(index == N) {
+                internal::static_if<std::is_same<result_tupe, node_type>{}>([](auto& r, auto& n) {
+                    r = const_cast<typename std::remove_reference<decltype(r)>::type>(&n);
+                })(result, node);
+            }
+        });
+        return internal::get_ref(*result);
+    }
+
+    template<int N, class T>
+    auto& get(internal::prepared_statement_t<T>& statement) {
+        using statement_type = typename std::decay<decltype(statement)>::type;
+        using expression_type = typename statement_type::expression_type;
+        using node_tuple = typename internal::node_tuple<expression_type>::type;
+        using bind_tuple = typename internal::bindable_filter<node_tuple>::type;
+        using result_tupe = typename std::tuple_element<static_cast<size_t>(N), bind_tuple>::type;
+        result_tupe* result = nullptr;
+        auto index = -1;
+        internal::iterate_ast(statement.expression, [&result, &index](auto& node) {
+            using node_type = typename std::decay<decltype(node)>::type;
+            if(internal::is_bindable<node_type>::value) {
+                ++index;
+            }
+            if(index == N) {
+                internal::static_if<std::is_same<result_tupe, node_type>{}>([](auto& r, auto& n) {
+                    r = const_cast<typename std::remove_reference<decltype(r)>::type>(&n);
+                })(result, node);
+            }
+        });
+        return internal::get_ref(*result);
+    }
+}
+#pragma once
+
+#include <type_traits>
+
+// #include "start_macros.h"
+
+// #include "pointer_value.h"
+
+namespace sqlite_orm {
+
+    SQLITE_ORM_INLINE_VAR constexpr const char carray_pvt_name[] = "carray";
+    using carray_pvt = std::integral_constant<const char*, carray_pvt_name>;
+
+    template<typename P>
+    using carray_pointer_arg = pointer_arg<P, carray_pvt>;
+    template<typename P, typename D>
+    using carray_pointer_binding = pointer_binding<P, carray_pvt, D>;
+    template<typename P>
+    using static_carray_pointer_binding = static_pointer_binding<P, carray_pvt>;
+
+    /**
+     *  Wrap a pointer of type 'carray' and its deleter function for binding it to a statement.
+     *  
+     *  Unless the deleter yields a nullptr 'xDestroy' function the ownership of the pointed-to-object
+     *  is transferred to the pointer binding, which will delete it through
+     *  the deleter when the statement finishes.
+     */
+    template<class P, class D>
+    auto bindable_carray_pointer(P* p, D d) noexcept -> pointer_binding<P, carray_pvt, D> {
+        return bindable_pointer<carray_pvt>(p, std::move(d));
+    }
+
+    /**
+     *  Wrap a pointer of type 'carray' for binding it to a statement.
+     *  
+     *  Note: 'Static' means that ownership of the pointed-to-object won't be transferred
+     *  and sqlite assumes the object pointed to is valid throughout the lifetime of a statement.
+     */
+    template<class P>
+    auto statically_bindable_carray_pointer(P* p) noexcept -> static_pointer_binding<P, carray_pvt> {
+        return statically_bindable_pointer<carray_pvt>(p);
+    }
+
+    /**
+     *  Generalized form of the 'remember' SQL function that is a pass-through for values
+     *  (it returns its argument unchanged using move semantics) but also saves the
+     *  value that is passed through into a bound variable.
+     */
+    template<typename P>
+    struct note_value_fn {
+        P operator()(P&& value, carray_pointer_arg<P> pv) const {
+            if(P* observer = pv) {
+                *observer = value;
+            }
+            return std::move(value);
+        }
+
+        static constexpr const char* name() {
+            return "note_value";
+        }
+    };
+
+    /**
+     *  remember(V, $PTR) extension function https://sqlite.org/src/file/ext/misc/remember.c
+     */
+    struct remember_fn : note_value_fn<int64> {
+        static constexpr const char* name() {
+            return "remember";
+        }
+    };
+}

From fe5ba659f96a49d8bfd70e073b0f23dac1d260e0 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Wed, 19 Jan 2022 19:22:38 +0200
Subject: [PATCH 035/161] Simplified and described storage lookup methods

---
 dev/storage_lookup.h | 44 +++++++++++++++++++++++++++++++-------------
 1 file changed, 31 insertions(+), 13 deletions(-)

diff --git a/dev/storage_lookup.h b/dev/storage_lookup.h
index 0faa6fe24..be48f186c 100644
--- a/dev/storage_lookup.h
+++ b/dev/storage_lookup.h
@@ -31,26 +31,32 @@ namespace sqlite_orm {
         struct is_storage_impl<const storage_impl<Ts...>> : std::true_type {};
 
         /**
-         *  A data type's CTE alias, otherwise T itself is used as a CTE alias.
+         *  A data type's CTE label, otherwise T itself is used as a CTE alias.
+         * 
+         *  Note: This is useful if operating on a storage implementation pack,
+         *  which already contains a mapping for a label.
          */
         template<typename T>
         using detected_cte_label_t = polyfill::detected_or_t<T, cte_label_type_t, T>;
 
         /**
-         *  std::true_type if given object is mapped, std::false_type otherwise
+         *  std::true_type if given object is mapped, std::false_type otherwise.
          */
         template<typename S, typename O>
         using object_type_matches = typename polyfill::conjunction<std::is_void<storage_cte_label_type_t<S>>,
                                                                    std::is_same<O, storage_object_type_t<S>>>::type;
 
         /**
-         *  std::true_type if object is mapped via given (CTE) label, std::false_type otherwise
+         *  std::true_type if given label is mapped, std::false_type otherwise
          */
         template<typename S, typename Label>
         using cte_label_type_matches = typename polyfill::conjunction<
             std::negation<std::is_void<storage_cte_label_type_t<S>>>,
             std::is_same<detected_cte_label_t<Label>, storage_cte_label_type_t<S>>>::type;
 
+        /**
+         *  std::true_type if given lookup type (object or label) is mapped, std::false_type otherwise.
+         */
         template<typename S, typename Lookup>
         using lookup_type_matches =
             typename polyfill::disjunction<object_type_matches<S, Lookup>, cte_label_type_matches<S, Lookup>>::type;
@@ -122,43 +128,55 @@ namespace sqlite_orm {
 
     namespace internal {
 
+        template<typename T, typename U>
+        using reapply_const_of_t = std::conditional_t<std::is_const<T>::value, std::add_const_t<U>, U>;
+
         /**
-         *  S - storage_t or storage_impl type
+         *  S - storage_t or storage_impl type, possibly const-qualified
          *  Lookup - mapped data type or CTE label
          */
         template<class S, class Lookup>
         using storage_pick_impl_t =
-            std::conditional_t<std::is_const<S>::value,
-                               const typename storage_pick_impl_type<std::remove_const_t<S>, Lookup>::type,
-                               // note: need to remove const on this branch, too, due to SFINAE
-                               typename storage_pick_impl_type<std::remove_const_t<S>, Lookup>::type>;
+            reapply_const_of_t<S, type_t<storage_pick_impl_type<std::remove_const_t<S>, Lookup>>>;
 
         /**
-         *  S - storage_t or storage_impl type
+         *  S - storage_t or storage_impl type, possibly const-qualified
          *  Lookup - mapped data type or CTE label
          */
         template<class S, class Lookup>
         using storage_find_impl_t =
-            std::conditional_t<std::is_const<S>::value,
-                               const typename storage_find_impl_type<std::remove_const_t<S>, Lookup>::type,
-                               // note: need to remove const on this branch, too, due to SFINAE
-                               typename storage_find_impl_type<std::remove_const_t<S>, Lookup>::type>;
+            reapply_const_of_t<S, type_t<storage_find_impl_type<std::remove_const_t<S>, Lookup>>>;
     }
 }
 
 // runtime lookup functions
 namespace sqlite_orm {
     namespace internal {
+        /**
+         *  Given a storage implementation pack, pick the specific storage implementation for the given lookup type.
+         * 
+         *  Note: This function requires Lookup to be mapped, otherwise it is removed from the overload resolution set.
+         */
         template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
         storage_pick_impl_t<S, Lookup>& pick_impl(S& impl) {
             return impl;
         }
 
+        /**
+         *  Given a storage implementation pack, find the specific storage implementation for the given lookup type.
+         * 
+         *  Note: This function returns the empty `storage_impl<>` if Lookup isn't mapped.
+         */
         template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
         storage_find_impl_t<S, Lookup>& find_impl(S& impl) {
             return impl;
         }
 
+        /**
+         *  Given a storage, pick the specific const-qualified storage implementation for the lookup type.
+         * 
+         *  Note: This function requires Lookup to be mapped, otherwise it is removed from the overload resolution set.
+         */
         template<class Lookup, class S, satisfies<is_storage, S> = true>
         storage_pick_impl_t<const S, Lookup>& pick_const_impl(S& storage) {
             return obtain_const_impl(storage);

From 917c34bb0ede68728966a9c6bb00cadc14b7cc18 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 20 Jan 2022 18:01:56 +0200
Subject: [PATCH 036/161] Addressed compiler errors found with clang (LLVM 12)

---
 dev/column_expression.h              |  32 +++----
 dev/cte_storage.h                    |  16 ++--
 dev/cte_types.h                      |   4 +-
 dev/cxx_polyfill.h                   |   8 +-
 dev/storage_traits.h                 |   7 +-
 dev/table.h                          |   8 +-
 dev/tuple_helper/tuple_transformer.h |  10 ++-
 include/sqlite_orm/sqlite_orm.h      | 127 +++++++++++++++++----------
 8 files changed, 129 insertions(+), 83 deletions(-)

diff --git a/dev/column_expression.h b/dev/column_expression.h
index 3c968a61b..cc64152f8 100644
--- a/dev/column_expression.h
+++ b/dev/column_expression.h
@@ -15,33 +15,33 @@ namespace sqlite_orm {
 
     namespace internal {
 
-        template<class St, class T, class SFINAE = void>
+        template<class St, class E, class SFINAE = void>
         struct column_expression_type;
 
         /**
          *  Obains the expressions that form the columns of a subselect statement.
          */
-        template<class St, class T>
-        using column_expression_of_t = typename column_expression_type<St, T>::type;
+        template<class St, class E>
+        using column_expression_of_t = typename column_expression_type<St, E>::type;
 
-        template<class St, class T, class SFINAE>
+        template<class St, class E, class SFINAE>
         struct column_expression_type {
-            using type = T;
+            using type = E;
         };
 
-        template<class St, class T>
-        struct column_expression_type<St, std::reference_wrapper<T>, void>
-            : std::add_lvalue_reference<column_expression_of_t<St, T>> {};
+        template<class St, class E>
+        struct column_expression_type<St, std::reference_wrapper<E>, void>
+            : std::add_lvalue_reference<column_expression_of_t<St, E>> {};
 
         // No CTE for object expressions.
-        template<class St, class T>
-        struct column_expression_type<St, object_t<T>, void> {
-            static_assert(polyfill::always_false_v<T>, "Selecting an object in a subselect is not allowed.");
+        template<class St, class E>
+        struct column_expression_type<St, object_t<E>, void> {
+            static_assert(polyfill::always_false_v<E>, "Selecting an object in a subselect is not allowed.");
         };
 
-        template<class St, class T>
-        struct column_expression_type<St, asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>>
-            : storage_traits::storage_mapped_column_expressions<St, T> {};
+        template<class St, class E>
+        struct column_expression_type<St, asterisk_t<E>, match_if_not<std::is_base_of, alias_tag, E>>
+            : storage_traits::storage_mapped_column_expressions<St, E> {};
 
         template<class A>
         struct add_column_alias {
@@ -63,7 +63,7 @@ namespace sqlite_orm {
             using type = std::tuple<column_expression_of_t<St, std::decay_t<Args>>...>;
         };
 
-        template<class St, class T, class... Args>
-        struct column_expression_type<St, select_t<T, Args...>> : column_expression_type<St, T> {};
+        template<class St, class E, class... Args>
+        struct column_expression_type<St, select_t<E, Args...>> : column_expression_type<St, E> {};
     }
 }
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index fac5fcf49..537d889ab 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -136,22 +136,28 @@ namespace sqlite_orm {
             using M = create_cte_mapper_t<cte_label_type_t<cte_t>,
                                           column_expression_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>,
                                           column_result_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>>;
-            static_assert(cte_t::explicit_column_count == 0 || cte_t::explicit_column_count == M::index_sequence::size());
+            static_assert(cte_t::explicit_column_count == 0 ||
+                              cte_t::explicit_column_count == M::index_sequence::size(),
+                          "Number of explicit columns of common table expression doesn't match the number of columns "
+                          "in the subselect.");
 
             auto tbl = make_cte_table<M>(impl, get<TI1>(cte));
 
             return storage_impl_cat(impl, std::move(tbl));
         }
 
-        template<typename S, typename... CTEs, size_t TI1, size_t... TIn>
+        template<typename S, typename... CTEs, size_t TI1, size_t TI2, size_t... TIn>
         decltype(auto) make_recursive_cte_storage_using_table_indices(const S& impl,
                                                                       const common_table_expressions<CTEs...>& cte,
-                                                                      std::index_sequence<TI1, TIn...>) {
+                                                                      std::index_sequence<TI1, TI2, TIn...>) {
             using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
             using M = create_cte_mapper_t<cte_label_type_t<cte_t>,
                                           column_expression_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>,
                                           column_result_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>>;
-            static_assert(cte_t::explicit_column_count == 0 || cte_t::explicit_column_count == M::index_sequence::size());
+            static_assert(cte_t::explicit_column_count == 0 ||
+                              cte_t::explicit_column_count == M::index_sequence::size(),
+                          "Number of explicit columns of common table expression doesn't match the number of columns "
+                          "in the subselect.");
 
             auto tbl = make_cte_table<M>(impl, get<TI1>(cte));
 
@@ -159,7 +165,7 @@ namespace sqlite_orm {
                 // Because CTEs can depend on their predecessor we recursively pass in a new storage object
                 storage_impl_cat(impl, std::move(tbl)),
                 cte,
-                std::index_sequence<TIn...>{});
+                std::index_sequence<TI2, TIn...>{});
         }
 
         /**
diff --git a/dev/cte_types.h b/dev/cte_types.h
index e583263ed..223c66802 100644
--- a/dev/cte_types.h
+++ b/dev/cte_types.h
@@ -51,9 +51,9 @@ namespace sqlite_orm {
         };
 
         template<class O, size_t I>
-        SQLITE_ORM_INLINE_VAR auto cte_getter_v = &(O::template cget<I>);
+        SQLITE_ORM_INLINE_VAR auto cte_getter_v = &O::template cget<I>;
         template<class O, size_t I>
-        SQLITE_ORM_INLINE_VAR auto cte_setter_v = &(O::template set<I>);
+        SQLITE_ORM_INLINE_VAR auto cte_setter_v = &O::template set<I>;
 
         template<class O, size_t I>
         using cte_getter_t = decltype(cte_getter_v<O, I>);
diff --git a/dev/cxx_polyfill.h b/dev/cxx_polyfill.h
index 763e7c830..624459e30 100644
--- a/dev/cxx_polyfill.h
+++ b/dev/cxx_polyfill.h
@@ -108,19 +108,19 @@ namespace sqlite_orm {
             SQLITE_ORM_INLINE_VAR constexpr bool is_detected_v = is_detected<Op, Args...>::value;
 #endif
 
-            template<template<typename...> typename Base, typename... Fs>
+            template<template<typename...> class Base, typename... Fs>
             Base<Fs...>& as_template_base(Base<Fs...>& base) {
                 return base;
             }
-            template<template<typename...> typename Base, typename... Fs>
+            template<template<typename...> class Base, typename... Fs>
             const Base<Fs...>& as_template_base(const Base<Fs...>& base) {
                 return base;
             }
-            template<template<typename...> typename Base, typename... Fs>
+            template<template<typename...> class Base, typename... Fs>
             Base<Fs...>&& as_template_base(Base<Fs...>&& base) {
                 return std::move(base);
             }
-            template<template<typename...> typename Base, typename... Fs>
+            template<template<typename...> class Base, typename... Fs>
             const Base<Fs...>&& as_template_base(const Base<Fs...>&& base) {
                 return std::move(base);
             }
diff --git a/dev/storage_traits.h b/dev/storage_traits.h
index d68ed97b7..6c05277ca 100644
--- a/dev/storage_traits.h
+++ b/dev/storage_traits.h
@@ -45,14 +45,17 @@ namespace sqlite_orm {
 
             /**
              *  T - table type.
+             *  TransformOp - Unary metafunction that transforms a column into a type.
+             *                (Note that multiple arguments are accepted to allow for
+             *                 metafunctions that need SFINAE specialization)
              */
-            template<class T, template<class> class TranfsormOp>
+            template<class T, template<class...> class TransformOp>
             struct table_types;
 
             /**
              *  type is std::tuple of field types of mapped colums.
              */
-            template<class O, bool WithoutRowId, class... Args, template<class> class TransformOp>
+            template<class O, bool WithoutRowId, class... Args, template<class...> class TransformOp>
             struct table_types<table_t<O, WithoutRowId, Args...>, TransformOp> {
                 using args_tuple = std::tuple<Args...>;
                 using columns_tuple = typename tuple_filter<args_tuple, is_column>::type;
diff --git a/dev/table.h b/dev/table.h
index 58d747787..b5f63bdad 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -171,10 +171,10 @@ namespace sqlite_orm {
              *  @return column name or empty string if nothing found.
              */
             template<class F,
-                     class O,
-                     typename = typename std::enable_if<std::is_member_pointer<F O::*>::value &&
-                                                        !std::is_member_function_pointer<F O::*>::value>::type>
-            const std::string* find_column_name(F O::*m) const {
+                     class C,
+                     typename = typename std::enable_if<std::is_member_pointer<F C::*>::value &&
+                                                        !std::is_member_function_pointer<F C::*>::value>::type>
+            const std::string* find_column_name(F C::*m) const {
                 const std::string* res = nullptr;
                 this->template for_each_column_with_field_type<F>([&res, m](auto& c) {
                     if(c.member_pointer == m) {
diff --git a/dev/tuple_helper/tuple_transformer.h b/dev/tuple_helper/tuple_transformer.h
index 7086707d7..75a1a6173 100644
--- a/dev/tuple_helper/tuple_transformer.h
+++ b/dev/tuple_helper/tuple_transformer.h
@@ -5,10 +5,16 @@
 namespace sqlite_orm {
     namespace internal {
 
-        template<class T, template<class C> class F>
+        /**
+          *  T - table type.
+          *  F - Unary metafunction that transforms the types in a tuple.
+          *      (Note that multiple arguments are accepted to allow for
+          *       metafunctions that need SFINAE specialization)
+         */
+        template<class T, template<class...> class F>
         struct tuple_transformer;
 
-        template<class... Args, template<class C> class F>
+        template<class... Args, template<class...> class F>
         struct tuple_transformer<std::tuple<Args...>, F> {
             using type = std::tuple<typename F<Args>::type...>;
         };
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 643a1cc73..3d8221398 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -421,10 +421,16 @@ namespace sqlite_orm {
 namespace sqlite_orm {
     namespace internal {
 
-        template<class T, template<class C> class F>
+        /**
+          *  T - table type.
+          *  F - Unary metafunction that transforms the types in a tuple.
+          *      (Note that multiple arguments are accepted to allow for
+          *       metafunctions that need SFINAE specialization)
+         */
+        template<class T, template<class...> class F>
         struct tuple_transformer;
 
-        template<class... Args, template<class C> class F>
+        template<class... Args, template<class...> class F>
         struct tuple_transformer<std::tuple<Args...>, F> {
             using type = std::tuple<typename F<Args>::type...>;
         };
@@ -605,19 +611,19 @@ namespace sqlite_orm {
             SQLITE_ORM_INLINE_VAR constexpr bool is_detected_v = is_detected<Op, Args...>::value;
 #endif
 
-            template<template<typename...> typename Base, typename... Fs>
+            template<template<typename...> class Base, typename... Fs>
             Base<Fs...>& as_template_base(Base<Fs...>& base) {
                 return base;
             }
-            template<template<typename...> typename Base, typename... Fs>
+            template<template<typename...> class Base, typename... Fs>
             const Base<Fs...>& as_template_base(const Base<Fs...>& base) {
                 return base;
             }
-            template<template<typename...> typename Base, typename... Fs>
+            template<template<typename...> class Base, typename... Fs>
             Base<Fs...>&& as_template_base(Base<Fs...>&& base) {
                 return std::move(base);
             }
-            template<template<typename...> typename Base, typename... Fs>
+            template<template<typename...> class Base, typename... Fs>
             const Base<Fs...>&& as_template_base(const Base<Fs...>&& base) {
                 return std::move(base);
             }
@@ -8874,9 +8880,9 @@ namespace sqlite_orm {
         };
 
         template<class O, size_t I>
-        SQLITE_ORM_INLINE_VAR auto cte_getter_v = &(O::template cget<I>);
+        SQLITE_ORM_INLINE_VAR auto cte_getter_v = &O::template cget<I>;
         template<class O, size_t I>
-        SQLITE_ORM_INLINE_VAR auto cte_setter_v = &(O::template set<I>);
+        SQLITE_ORM_INLINE_VAR auto cte_setter_v = &O::template set<I>;
 
         template<class O, size_t I>
         using cte_getter_t = decltype(cte_getter_v<O, I>);
@@ -8926,26 +8932,32 @@ namespace sqlite_orm {
         struct is_storage_impl<const storage_impl<Ts...>> : std::true_type {};
 
         /**
-         *  A data type's CTE alias, otherwise T itself is used as a CTE alias.
+         *  A data type's CTE label, otherwise T itself is used as a CTE alias.
+         * 
+         *  Note: This is useful if operating on a storage implementation pack,
+         *  which already contains a mapping for a label.
          */
         template<typename T>
         using detected_cte_label_t = polyfill::detected_or_t<T, cte_label_type_t, T>;
 
         /**
-         *  std::true_type if given object is mapped, std::false_type otherwise
+         *  std::true_type if given object is mapped, std::false_type otherwise.
          */
         template<typename S, typename O>
         using object_type_matches = typename polyfill::conjunction<std::is_void<storage_cte_label_type_t<S>>,
                                                                    std::is_same<O, storage_object_type_t<S>>>::type;
 
         /**
-         *  std::true_type if object is mapped via given (CTE) label, std::false_type otherwise
+         *  std::true_type if given label is mapped, std::false_type otherwise
          */
         template<typename S, typename Label>
         using cte_label_type_matches = typename polyfill::conjunction<
             std::negation<std::is_void<storage_cte_label_type_t<S>>>,
             std::is_same<detected_cte_label_t<Label>, storage_cte_label_type_t<S>>>::type;
 
+        /**
+         *  std::true_type if given lookup type (object or label) is mapped, std::false_type otherwise.
+         */
         template<typename S, typename Lookup>
         using lookup_type_matches =
             typename polyfill::disjunction<object_type_matches<S, Lookup>, cte_label_type_matches<S, Lookup>>::type;
@@ -9017,43 +9029,55 @@ namespace sqlite_orm {
 
     namespace internal {
 
+        template<typename T, typename U>
+        using reapply_const_of_t = std::conditional_t<std::is_const<T>::value, std::add_const_t<U>, U>;
+
         /**
-         *  S - storage_t or storage_impl type
+         *  S - storage_t or storage_impl type, possibly const-qualified
          *  Lookup - mapped data type or CTE label
          */
         template<class S, class Lookup>
         using storage_pick_impl_t =
-            std::conditional_t<std::is_const<S>::value,
-                               const typename storage_pick_impl_type<std::remove_const_t<S>, Lookup>::type,
-                               // note: need to remove const on this branch, too, due to SFINAE
-                               typename storage_pick_impl_type<std::remove_const_t<S>, Lookup>::type>;
+            reapply_const_of_t<S, type_t<storage_pick_impl_type<std::remove_const_t<S>, Lookup>>>;
 
         /**
-         *  S - storage_t or storage_impl type
+         *  S - storage_t or storage_impl type, possibly const-qualified
          *  Lookup - mapped data type or CTE label
          */
         template<class S, class Lookup>
         using storage_find_impl_t =
-            std::conditional_t<std::is_const<S>::value,
-                               const typename storage_find_impl_type<std::remove_const_t<S>, Lookup>::type,
-                               // note: need to remove const on this branch, too, due to SFINAE
-                               typename storage_find_impl_type<std::remove_const_t<S>, Lookup>::type>;
+            reapply_const_of_t<S, type_t<storage_find_impl_type<std::remove_const_t<S>, Lookup>>>;
     }
 }
 
 // runtime lookup functions
 namespace sqlite_orm {
     namespace internal {
+        /**
+         *  Given a storage implementation pack, pick the specific storage implementation for the given lookup type.
+         * 
+         *  Note: This function requires Lookup to be mapped, otherwise it is removed from the overload resolution set.
+         */
         template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
         storage_pick_impl_t<S, Lookup>& pick_impl(S& impl) {
             return impl;
         }
 
+        /**
+         *  Given a storage implementation pack, find the specific storage implementation for the given lookup type.
+         * 
+         *  Note: This function returns the empty `storage_impl<>` if Lookup isn't mapped.
+         */
         template<class Lookup, class S, satisfies<is_storage_impl, S> = true>
         storage_find_impl_t<S, Lookup>& find_impl(S& impl) {
             return impl;
         }
 
+        /**
+         *  Given a storage, pick the specific const-qualified storage implementation for the lookup type.
+         * 
+         *  Note: This function requires Lookup to be mapped, otherwise it is removed from the overload resolution set.
+         */
         template<class Lookup, class S, satisfies<is_storage, S> = true>
         storage_pick_impl_t<const S, Lookup>& pick_const_impl(S& storage) {
             return obtain_const_impl(storage);
@@ -9100,14 +9124,17 @@ namespace sqlite_orm {
 
             /**
              *  T - table type.
+             *  TransformOp - Unary metafunction that transforms a column into a type.
+             *                (Note that multiple arguments are accepted to allow for
+             *                 metafunctions that need SFINAE specialization)
              */
-            template<class T, template<class> class TranfsormOp>
+            template<class T, template<class...> class TransformOp>
             struct table_types;
 
             /**
              *  type is std::tuple of field types of mapped colums.
              */
-            template<class O, bool WithoutRowId, class... Args, template<class> class TransformOp>
+            template<class O, bool WithoutRowId, class... Args, template<class...> class TransformOp>
             struct table_types<table_t<O, WithoutRowId, Args...>, TransformOp> {
                 using args_tuple = std::tuple<Args...>;
                 using columns_tuple = typename tuple_filter<args_tuple, is_column>::type;
@@ -10141,10 +10168,10 @@ namespace sqlite_orm {
              *  @return column name or empty string if nothing found.
              */
             template<class F,
-                     class O,
-                     typename = typename std::enable_if<std::is_member_pointer<F O::*>::value &&
-                                                        !std::is_member_function_pointer<F O::*>::value>::type>
-            const std::string* find_column_name(F O::*m) const {
+                     class C,
+                     typename = typename std::enable_if<std::is_member_pointer<F C::*>::value &&
+                                                        !std::is_member_function_pointer<F C::*>::value>::type>
+            const std::string* find_column_name(F C::*m) const {
                 const std::string* res = nullptr;
                 this->template for_each_column_with_field_type<F>([&res, m](auto& c) {
                     if(c.member_pointer == m) {
@@ -17164,33 +17191,33 @@ namespace sqlite_orm {
 
     namespace internal {
 
-        template<class St, class T, class SFINAE = void>
+        template<class St, class E, class SFINAE = void>
         struct column_expression_type;
 
         /**
          *  Obains the expressions that form the columns of a subselect statement.
          */
-        template<class St, class T>
-        using column_expression_of_t = typename column_expression_type<St, T>::type;
+        template<class St, class E>
+        using column_expression_of_t = typename column_expression_type<St, E>::type;
 
-        template<class St, class T, class SFINAE>
+        template<class St, class E, class SFINAE>
         struct column_expression_type {
-            using type = T;
+            using type = E;
         };
 
-        template<class St, class T>
-        struct column_expression_type<St, std::reference_wrapper<T>, void>
-            : std::add_lvalue_reference<column_expression_of_t<St, T>> {};
+        template<class St, class E>
+        struct column_expression_type<St, std::reference_wrapper<E>, void>
+            : std::add_lvalue_reference<column_expression_of_t<St, E>> {};
 
         // No CTE for object expressions.
-        template<class St, class T>
-        struct column_expression_type<St, object_t<T>, void> {
-            static_assert(polyfill::always_false_v<T>, "Selecting an object in a subselect is not allowed.");
+        template<class St, class E>
+        struct column_expression_type<St, object_t<E>, void> {
+            static_assert(polyfill::always_false_v<E>, "Selecting an object in a subselect is not allowed.");
         };
 
-        template<class St, class T>
-        struct column_expression_type<St, asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>>
-            : storage_traits::storage_mapped_column_expressions<St, T> {};
+        template<class St, class E>
+        struct column_expression_type<St, asterisk_t<E>, match_if_not<std::is_base_of, alias_tag, E>>
+            : storage_traits::storage_mapped_column_expressions<St, E> {};
 
         template<class A>
         struct add_column_alias {
@@ -17212,8 +17239,8 @@ namespace sqlite_orm {
             using type = std::tuple<column_expression_of_t<St, std::decay_t<Args>>...>;
         };
 
-        template<class St, class T, class... Args>
-        struct column_expression_type<St, select_t<T, Args...>> : column_expression_type<St, T> {};
+        template<class St, class E, class... Args>
+        struct column_expression_type<St, select_t<E, Args...>> : column_expression_type<St, E> {};
     }
 }
 
@@ -17351,23 +17378,27 @@ namespace sqlite_orm {
                                           column_expression_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>,
                                           column_result_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>>;
             static_assert(cte_t::explicit_column_count == 0 ||
-                          cte_t::explicit_column_count == M::index_sequence::size());
+                              cte_t::explicit_column_count == M::index_sequence::size(),
+                          "Number of explicit columns of common table expression doesn't match the number of columns "
+                          "in the subselect.");
 
             auto tbl = make_cte_table<M>(impl, get<TI1>(cte));
 
             return storage_impl_cat(impl, std::move(tbl));
         }
 
-        template<typename S, typename... CTEs, size_t TI1, size_t... TIn>
+        template<typename S, typename... CTEs, size_t TI1, size_t TI2, size_t... TIn>
         decltype(auto) make_recursive_cte_storage_using_table_indices(const S& impl,
                                                                       const common_table_expressions<CTEs...>& cte,
-                                                                      std::index_sequence<TI1, TIn...>) {
+                                                                      std::index_sequence<TI1, TI2, TIn...>) {
             using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
             using M = create_cte_mapper_t<cte_label_type_t<cte_t>,
                                           column_expression_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>,
                                           column_result_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>>;
             static_assert(cte_t::explicit_column_count == 0 ||
-                          cte_t::explicit_column_count == M::index_sequence::size());
+                              cte_t::explicit_column_count == M::index_sequence::size(),
+                          "Number of explicit columns of common table expression doesn't match the number of columns "
+                          "in the subselect.");
 
             auto tbl = make_cte_table<M>(impl, get<TI1>(cte));
 
@@ -17375,7 +17406,7 @@ namespace sqlite_orm {
                 // Because CTEs can depend on their predecessor we recursively pass in a new storage object
                 storage_impl_cat(impl, std::move(tbl)),
                 cte,
-                std::index_sequence<TIn...>{});
+                std::index_sequence<TI2, TIn...>{});
         }
 
         /**

From 45018e1fc7782bd2a612763f558b331d8a8c577a Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 22 Jan 2022 19:56:43 +0200
Subject: [PATCH 037/161] Addressed issues while compiling all examples and
 unit tests

Also allowed lookup by storage's table type
---
 dev/alias.h                     |   4 --
 dev/cte_storage.h               |   6 +-
 dev/cte_types.h                 |   1 +
 dev/storage.h                   |   2 +-
 dev/storage_impl.h              |   7 +-
 dev/storage_lookup.h            |  55 ++++++++++++----
 dev/storage_traits.h            |   2 +-
 dev/table.h                     |  12 +++-
 dev/table_name_collector.h      |  24 ++++---
 include/sqlite_orm/sqlite_orm.h | 113 +++++++++++++++++++++-----------
 10 files changed, 148 insertions(+), 78 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 9602254d5..c72d66b33 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -47,8 +47,6 @@ namespace sqlite_orm {
 
         template<class A>
         struct alias_extractor<A, typename std::enable_if<std::is_base_of<alias_tag, A>::value>::type> {
-            using object_type = typename A::type;
-
             static std::string get() {
                 std::stringstream ss;
                 ss << A::get();
@@ -58,8 +56,6 @@ namespace sqlite_orm {
 
         template<class T>
         struct alias_extractor<T, typename std::enable_if<!std::is_base_of<alias_tag, T>::value>::type> {
-            using object_type = T;
-
             static std::string get() {
                 return {};
             }
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 537d889ab..2661f8daa 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -65,13 +65,13 @@ namespace sqlite_orm {
         using create_cte_table_t = typename create_cte_table<M, IdxSeq>::type;
 
         /**
-         *  Concatenate newly created tables with those from an existing storage, forming a
-         *  new storage object
+         *  Concatenate newly created tables with those from an existing storage implementation,
+         *  forming a new storage implementation object.
          */
         template<typename... Ts, typename... CTETables>
         storage_impl<CTETables..., Ts...> storage_impl_cat(const storage_impl<Ts...>& storage,
                                                            CTETables&&... cteTables) {
-            return {std::forward<CTETables>(cteTables)..., pick_impl<object_type_t<Ts>>(storage).table...};
+            return {std::forward<CTETables>(cteTables)..., pick_impl<Ts>(storage).table...};
         }
 
         /**
diff --git a/dev/cte_types.h b/dev/cte_types.h
index 223c66802..0ea814037 100644
--- a/dev/cte_types.h
+++ b/dev/cte_types.h
@@ -46,6 +46,7 @@ namespace sqlite_orm {
             using index_sequence = std::index_sequence_for<Fs...>;
             // this type name is used to detect the mapping from label to object
             using cte_label_type = Label;
+            // this type name is used to detect the mapping from label to object
             using cte_object_type = column_results<Label, Fs...>;
             using expressions_type = tuplify_t<Expression>;
         };
diff --git a/dev/storage.h b/dev/storage.h
index 35b0f5993..889c3ee43 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -445,7 +445,7 @@ namespace sqlite_orm {
                      class O,
                      class... Args,
                      class Tuple = std::tuple<Args...>,
-                     std::enable_if_t<std::tuple_size<Tuple>::value >= 1> = true>
+                     std::enable_if_t<std::tuple_size<Tuple>::value >= 1, bool> = true>
             std::string group_concat(F O::*m, Args&&... args) {
                 return this->group_concat_internal(m, {}, std::forward<Args>(args)...);
             }
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 660eb744e..27b1607a3 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -181,9 +181,8 @@ namespace sqlite_orm {
             }
 
             std::string find_table_name(std::type_index ti) const {
-                std::type_index thisTypeIndex{typeid(std::conditional_t<std::is_void<cte_label_type_t<H>>::value,
-                                                                        object_type_t<H>,
-                                                                        cte_label_type_t<H>>)};
+                std::type_index thisTypeIndex{
+                    typeid(std::conditional_t<std::is_void<label_of_t<H>>::value, object_type_t<H>, label_of_t<H>>)};
                 if(thisTypeIndex == ti) {
                     return this->table.name;
                 } else {
@@ -399,7 +398,7 @@ namespace sqlite_orm {
             return pick_impl<O>(strg).table.find_column_name(field);
         }
 
-        template<class Label, class O, class F, class S, satisfies<is_storage_impl, S> = true>
+        template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
         constexpr decltype(auto) materialize_column_pointer(const S&, const column_pointer<O, F>& cp) {
             return cp.field;
         }
diff --git a/dev/storage_lookup.h b/dev/storage_lookup.h
index be48f186c..677b23951 100644
--- a/dev/storage_lookup.h
+++ b/dev/storage_lookup.h
@@ -31,35 +31,64 @@ namespace sqlite_orm {
         struct is_storage_impl<const storage_impl<Ts...>> : std::true_type {};
 
         /**
-         *  A data type's CTE label, otherwise T itself is used as a CTE alias.
+         *  A data type's label type, void otherwise.
+         */
+        template<typename O>
+        using label_of_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
+
+        /**
+         *  A data type's label type, void otherwise.
+         */
+        template<typename O>
+        using storage_label_of_t = polyfill::detected_or_t<void, storage_cte_label_type_t, O>;
+
+        /**
+         *  A data type's CTE label, otherwise T itself is used as a CTE label.
          * 
-         *  Note: This is useful if operating on a storage implementation pack,
-         *  which already contains a mapping for a label.
+         *  Note: This is useful if the cte object type `column_reuslts` gets ever looked up,
+         *  and we want to ensure that the lookup happens by label instead.
          */
         template<typename T>
-        using detected_cte_label_t = polyfill::detected_or_t<T, cte_label_type_t, T>;
+        using cte_label_or_nested_t = polyfill::detected_or_t<T, cte_label_type_t, T>;
+
+        /**
+         *  std::true_type if given 'table' type matches, std::false_type otherwise.
+         *  
+         *  A 'table' type is one of: table_t<>, index_t<> [, subselect_mapper<>]
+         */
+        template<typename S, typename T>
+        using table_type_matches = std::is_same<T, table_type_t<S>>;
 
         /**
          *  std::true_type if given object is mapped, std::false_type otherwise.
+         * 
+         *  Note: unlike table_t<>, index_t<> doesn't have a nested I::cte_label_type typename,
+         *  that's why we use storage_label_of_t<> for a fallback to void.
          */
         template<typename S, typename O>
-        using object_type_matches = typename polyfill::conjunction<std::is_void<storage_cte_label_type_t<S>>,
+        using object_type_matches = typename polyfill::conjunction<std::is_void<storage_label_of_t<S>>,
                                                                    std::is_same<O, storage_object_type_t<S>>>::type;
 
         /**
          *  std::true_type if given label is mapped, std::false_type otherwise
+         * 
+         *  Note: unlike table_t<>, index_t<> doesn't have a nested index_t::cte_label_type typename,
+         *  that's why we use storage_label_of_t<> for a fallback to void.
          */
         template<typename S, typename Label>
-        using cte_label_type_matches = typename polyfill::conjunction<
-            std::negation<std::is_void<storage_cte_label_type_t<S>>>,
-            std::is_same<detected_cte_label_t<Label>, storage_cte_label_type_t<S>>>::type;
+        using cte_label_type_matches =
+            typename polyfill::conjunction<std::negation<std::is_void<storage_label_of_t<S>>>,
+                                           std::is_same<cte_label_or_nested_t<Label>, storage_label_of_t<S>>>::type;
 
         /**
-         *  std::true_type if given lookup type (object or label) is mapped, std::false_type otherwise.
+         *  std::true_type if given lookup type ('table' type, object or label) is mapped, std::false_type otherwise.
+         * 
+         *  Note: we allow lookup via S::table_type because it allows us to walk the storage_impl chain (in storage_impl_cat()).
          */
         template<typename S, typename Lookup>
-        using lookup_type_matches =
-            typename polyfill::disjunction<object_type_matches<S, Lookup>, cte_label_type_matches<S, Lookup>>::type;
+        using lookup_type_matches = typename polyfill::disjunction<table_type_matches<S, Lookup>,
+                                                                   object_type_matches<S, Lookup>,
+                                                                   cte_label_type_matches<S, Lookup>>::type;
     }
 
     // pick/lookup metafunctions
@@ -133,7 +162,7 @@ namespace sqlite_orm {
 
         /**
          *  S - storage_t or storage_impl type, possibly const-qualified
-         *  Lookup - mapped data type or CTE label
+         *  Lookup - 'table' type, mapped data type or CTE label
          */
         template<class S, class Lookup>
         using storage_pick_impl_t =
@@ -141,7 +170,7 @@ namespace sqlite_orm {
 
         /**
          *  S - storage_t or storage_impl type, possibly const-qualified
-         *  Lookup - mapped data type or CTE label
+         *  Lookup - 'table' type, mapped data type or CTE label
          */
         template<class S, class Lookup>
         using storage_find_impl_t =
diff --git a/dev/storage_traits.h b/dev/storage_traits.h
index 6c05277ca..bdccaf7e3 100644
--- a/dev/storage_traits.h
+++ b/dev/storage_traits.h
@@ -49,7 +49,7 @@ namespace sqlite_orm {
              *                (Note that multiple arguments are accepted to allow for
              *                 metafunctions that need SFINAE specialization)
              */
-            template<class T, template<class...> class TransformOp>
+            template<class T, template<class...> class TransformOp = column_field_type>
             struct table_types;
 
             /**
diff --git a/dev/table.h b/dev/table.h
index b5f63bdad..0fa1e7e7b 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -27,8 +27,12 @@ namespace sqlite_orm {
         template<typename O>
         using label_of_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
 
+        /** 
+         *  If O is a subselect_mapper then returns its nested O::cte_object_type typename,
+         *  otherwise O itself is a regular object type to be mapped.
+         */
         template<typename O>
-        using mapped_object_type_of_t = polyfill::detected_or_t<O, cte_object_type_t, O>;
+        using mapped_object_type_for_t = polyfill::detected_or_t<O, cte_object_type_t, O>;
 
         struct basic_table {
 
@@ -44,15 +48,17 @@ namespace sqlite_orm {
          *  Can be either for a table mapped to storage or for a common table expression (CTE).
          * 
          *  The template parameter O is either a regular data structure object (i.e. direct mapping from storage to data)
-         *  or an abstract 'mapper' object with a label attached.
+         *  or an abstract 'mapper' type with a label attached.
          *  The driving force behind this 'mapper' abstraction is the presence of a T::cte_label_type.
          */
         template<class O, bool WithoutRowId, class... Cs>
         struct table_t : basic_table {
             using super = basic_table;
+            // this typename is used in contexts where it is known that the 'table' holds a subselect_mapper
+            // instead of a regular object type
             using cte_mapper_type = O;
             using cte_label_type = label_of_t<O>;
-            using object_type = mapped_object_type_of_t<O>;
+            using object_type = mapped_object_type_for_t<O>;
             using elements_type = std::tuple<Cs...>;
 
             static constexpr const int elements_count = static_cast<int>(std::tuple_size<elements_type>::value);
diff --git a/dev/table_name_collector.h b/dev/table_name_collector.h
index c99dcc96a..e97d09dc0 100644
--- a/dev/table_name_collector.h
+++ b/dev/table_name_collector.h
@@ -59,18 +59,22 @@ namespace sqlite_orm {
                 }
             }
 
-            template<class T>
+            template<class T, satisfies_not<std::is_base_of, alias_tag, T> = true>
+            void operator()(const asterisk_t<T> &) const {
+                if(this->find_table_name) {
+                    auto tableName = this->find_table_name(typeid(T));
+                    table_names.insert(std::make_pair(move(tableName), ""));
+                }
+            }
+
+            template<class T, satisfies<std::is_base_of, alias_tag, T> = true>
             void operator()(const asterisk_t<T> &) const {
                 if(this->find_table_name) {
-                    static_if<std::is_base_of<alias_tag, T>{}>(
-                        [this]() {
-                            auto tableName = this->find_table_name(typeid(typename alias_extractor<T>::object_type));
-                            table_names.insert(std::make_pair(move(tableName), alias_extractor<T>::get()));
-                        },
-                        [this]() {
-                            auto tableName = this->find_table_name(typeid(T));
-                            table_names.insert(std::make_pair(move(tableName), ""));
-                        })();
+                    // note: not all alias classes have a nested A::type
+                    static_assert(polyfill::is_detected_v<type_t, T>,
+                                  "alias<O> must have a nested alias<O>::type typename");
+                    auto tableName = this->find_table_name(typeid(type_t<T>));
+                    table_names.insert(std::make_pair(move(tableName), alias_extractor<T>::get()));
                 }
             }
 
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 3d8221398..1e0928d2f 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4471,8 +4471,6 @@ namespace sqlite_orm {
 
         template<class A>
         struct alias_extractor<A, typename std::enable_if<std::is_base_of<alias_tag, A>::value>::type> {
-            using object_type = typename A::type;
-
             static std::string get() {
                 std::stringstream ss;
                 ss << A::get();
@@ -4482,8 +4480,6 @@ namespace sqlite_orm {
 
         template<class T>
         struct alias_extractor<T, typename std::enable_if<!std::is_base_of<alias_tag, T>::value>::type> {
-            using object_type = T;
-
             static std::string get() {
                 return {};
             }
@@ -8875,6 +8871,7 @@ namespace sqlite_orm {
             using index_sequence = std::index_sequence_for<Fs...>;
             // this type name is used to detect the mapping from label to object
             using cte_label_type = Label;
+            // this type name is used to detect the mapping from label to object
             using cte_object_type = column_results<Label, Fs...>;
             using expressions_type = tuplify_t<Expression>;
         };
@@ -8932,35 +8929,64 @@ namespace sqlite_orm {
         struct is_storage_impl<const storage_impl<Ts...>> : std::true_type {};
 
         /**
-         *  A data type's CTE label, otherwise T itself is used as a CTE alias.
+         *  A data type's label type, void otherwise.
+         */
+        template<typename O>
+        using label_of_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
+
+        /**
+         *  A data type's label type, void otherwise.
+         */
+        template<typename O>
+        using storage_label_of_t = polyfill::detected_or_t<void, storage_cte_label_type_t, O>;
+
+        /**
+         *  A data type's CTE label, otherwise T itself is used as a CTE label.
          * 
-         *  Note: This is useful if operating on a storage implementation pack,
-         *  which already contains a mapping for a label.
+         *  Note: This is useful if the cte object type `column_reuslts` gets ever looked up,
+         *  and we want to ensure that the lookup happens by label instead.
          */
         template<typename T>
-        using detected_cte_label_t = polyfill::detected_or_t<T, cte_label_type_t, T>;
+        using cte_label_or_nested_t = polyfill::detected_or_t<T, cte_label_type_t, T>;
+
+        /**
+         *  std::true_type if given 'table' type matches, std::false_type otherwise.
+         *  
+         *  A 'table' type is one of: table_t<>, index_t<> [, subselect_mapper<>]
+         */
+        template<typename S, typename T>
+        using table_type_matches = std::is_same<T, table_type_t<S>>;
 
         /**
          *  std::true_type if given object is mapped, std::false_type otherwise.
+         * 
+         *  Note: unlike table_t<>, index_t<> doesn't have a nested I::cte_label_type typename,
+         *  that's why we use storage_label_of_t<> for a fallback to void.
          */
         template<typename S, typename O>
-        using object_type_matches = typename polyfill::conjunction<std::is_void<storage_cte_label_type_t<S>>,
+        using object_type_matches = typename polyfill::conjunction<std::is_void<storage_label_of_t<S>>,
                                                                    std::is_same<O, storage_object_type_t<S>>>::type;
 
         /**
          *  std::true_type if given label is mapped, std::false_type otherwise
+         * 
+         *  Note: unlike table_t<>, index_t<> doesn't have a nested index_t::cte_label_type typename,
+         *  that's why we use storage_label_of_t<> for a fallback to void.
          */
         template<typename S, typename Label>
-        using cte_label_type_matches = typename polyfill::conjunction<
-            std::negation<std::is_void<storage_cte_label_type_t<S>>>,
-            std::is_same<detected_cte_label_t<Label>, storage_cte_label_type_t<S>>>::type;
+        using cte_label_type_matches =
+            typename polyfill::conjunction<std::negation<std::is_void<storage_label_of_t<S>>>,
+                                           std::is_same<cte_label_or_nested_t<Label>, storage_label_of_t<S>>>::type;
 
         /**
-         *  std::true_type if given lookup type (object or label) is mapped, std::false_type otherwise.
+         *  std::true_type if given lookup type ('table' type, object or label) is mapped, std::false_type otherwise.
+         * 
+         *  Note: we allow lookup via S::table_type because it allows us to walk the storage_impl chain (in storage_impl_cat()).
          */
         template<typename S, typename Lookup>
-        using lookup_type_matches =
-            typename polyfill::disjunction<object_type_matches<S, Lookup>, cte_label_type_matches<S, Lookup>>::type;
+        using lookup_type_matches = typename polyfill::disjunction<table_type_matches<S, Lookup>,
+                                                                   object_type_matches<S, Lookup>,
+                                                                   cte_label_type_matches<S, Lookup>>::type;
     }
 
     // pick/lookup metafunctions
@@ -9034,7 +9060,7 @@ namespace sqlite_orm {
 
         /**
          *  S - storage_t or storage_impl type, possibly const-qualified
-         *  Lookup - mapped data type or CTE label
+         *  Lookup - 'table' type, mapped data type or CTE label
          */
         template<class S, class Lookup>
         using storage_pick_impl_t =
@@ -9042,7 +9068,7 @@ namespace sqlite_orm {
 
         /**
          *  S - storage_t or storage_impl type, possibly const-qualified
-         *  Lookup - mapped data type or CTE label
+         *  Lookup - 'table' type, mapped data type or CTE label
          */
         template<class S, class Lookup>
         using storage_find_impl_t =
@@ -9128,7 +9154,7 @@ namespace sqlite_orm {
              *                (Note that multiple arguments are accepted to allow for
              *                 metafunctions that need SFINAE specialization)
              */
-            template<class T, template<class...> class TransformOp>
+            template<class T, template<class...> class TransformOp = column_field_type>
             struct table_types;
 
             /**
@@ -10024,8 +10050,12 @@ namespace sqlite_orm {
         template<typename O>
         using label_of_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
 
+        /** 
+         *  If O is a subselect_mapper then returns its nested O::cte_object_type typename,
+         *  otherwise O itself is a regular object type to be mapped.
+         */
         template<typename O>
-        using mapped_object_type_of_t = polyfill::detected_or_t<O, cte_object_type_t, O>;
+        using mapped_object_type_for_t = polyfill::detected_or_t<O, cte_object_type_t, O>;
 
         struct basic_table {
 
@@ -10041,15 +10071,17 @@ namespace sqlite_orm {
          *  Can be either for a table mapped to storage or for a common table expression (CTE).
          * 
          *  The template parameter O is either a regular data structure object (i.e. direct mapping from storage to data)
-         *  or an abstract 'mapper' object with a label attached.
+         *  or an abstract 'mapper' type with a label attached.
          *  The driving force behind this 'mapper' abstraction is the presence of a T::cte_label_type.
          */
         template<class O, bool WithoutRowId, class... Cs>
         struct table_t : basic_table {
             using super = basic_table;
+            // this typename is used in contexts where it is known that the 'table' holds a subselect_mapper
+            // instead of a regular object type
             using cte_mapper_type = O;
             using cte_label_type = label_of_t<O>;
-            using object_type = mapped_object_type_of_t<O>;
+            using object_type = mapped_object_type_for_t<O>;
             using elements_type = std::tuple<Cs...>;
 
             static constexpr const int elements_count = static_cast<int>(std::tuple_size<elements_type>::value);
@@ -10554,9 +10586,8 @@ namespace sqlite_orm {
             }
 
             std::string find_table_name(std::type_index ti) const {
-                std::type_index thisTypeIndex{typeid(std::conditional_t<std::is_void<cte_label_type_t<H>>::value,
-                                                                        object_type_t<H>,
-                                                                        cte_label_type_t<H>>)};
+                std::type_index thisTypeIndex{
+                    typeid(std::conditional_t<std::is_void<label_of_t<H>>::value, object_type_t<H>, label_of_t<H>>)};
                 if(thisTypeIndex == ti) {
                     return this->table.name;
                 } else {
@@ -10772,7 +10803,7 @@ namespace sqlite_orm {
             return pick_impl<O>(strg).table.find_column_name(field);
         }
 
-        template<class Label, class O, class F, class S, satisfies<is_storage_impl, S> = true>
+        template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
         constexpr decltype(auto) materialize_column_pointer(const S&, const column_pointer<O, F>& cp) {
             return cp.field;
         }
@@ -14482,18 +14513,22 @@ namespace sqlite_orm {
                 }
             }
 
-            template<class T>
+            template<class T, satisfies_not<std::is_base_of, alias_tag, T> = true>
+            void operator()(const asterisk_t<T>&) const {
+                if(this->find_table_name) {
+                    auto tableName = this->find_table_name(typeid(T));
+                    table_names.insert(std::make_pair(move(tableName), ""));
+                }
+            }
+
+            template<class T, satisfies<std::is_base_of, alias_tag, T> = true>
             void operator()(const asterisk_t<T>&) const {
                 if(this->find_table_name) {
-                    static_if<std::is_base_of<alias_tag, T>{}>(
-                        [this]() {
-                            auto tableName = this->find_table_name(typeid(typename alias_extractor<T>::object_type));
-                            table_names.insert(std::make_pair(move(tableName), alias_extractor<T>::get()));
-                        },
-                        [this]() {
-                            auto tableName = this->find_table_name(typeid(T));
-                            table_names.insert(std::make_pair(move(tableName), ""));
-                        })();
+                    // note: not all alias classes have a nested A::type
+                    static_assert(polyfill::is_detected_v<type_t, T>,
+                                  "alias<O> must have a nested alias<O>::type typename");
+                    auto tableName = this->find_table_name(typeid(type_t<T>));
+                    table_names.insert(std::make_pair(move(tableName), alias_extractor<T>::get()));
                 }
             }
 
@@ -17306,13 +17341,13 @@ namespace sqlite_orm {
         using create_cte_table_t = typename create_cte_table<M, IdxSeq>::type;
 
         /**
-         *  Concatenate newly created tables with those from an existing storage, forming a
-         *  new storage object
+         *  Concatenate newly created tables with those from an existing storage implementation,
+         *  forming a new storage implementation object.
          */
         template<typename... Ts, typename... CTETables>
         storage_impl<CTETables..., Ts...> storage_impl_cat(const storage_impl<Ts...>& storage,
                                                            CTETables&&... cteTables) {
-            return {std::forward<CTETables>(cteTables)..., pick_impl<object_type_t<Ts>>(storage).table...};
+            return {std::forward<CTETables>(cteTables)..., pick_impl<Ts>(storage).table...};
         }
 
         /**
@@ -17823,7 +17858,7 @@ namespace sqlite_orm {
                      class O,
                      class... Args,
                      class Tuple = std::tuple<Args...>,
-                     std::enable_if_t<std::tuple_size<Tuple>::value >= 1> = true>
+                     std::enable_if_t<std::tuple_size<Tuple>::value >= 1, bool> = true>
             std::string group_concat(F O::*m, Args&&... args) {
                 return this->group_concat_internal(m, {}, std::forward<Args>(args)...);
             }

From 13807c73025fd8c846cd57dc21c7812883a8ff9e Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 22 Jan 2022 20:03:22 +0200
Subject: [PATCH 038/161] Removed unused system_error variable in unit tests

---
 tests/constraints/unique.cpp                       | 4 ++--
 tests/prepared_statement_tests/insert_explicit.cpp | 2 +-
 tests/prepared_statement_tests/insert_range.cpp    | 4 ++--
 tests/prepared_statement_tests/replace_range.cpp   | 4 ++--
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/constraints/unique.cpp b/tests/constraints/unique.cpp
index cba98d686..3d1ba11dd 100644
--- a/tests/constraints/unique.cpp
+++ b/tests/constraints/unique.cpp
@@ -41,7 +41,7 @@ TEST_CASE("Unique") {
     try {
         storage.insert(Contact{0, "Johnny", "Doe", "john.doe@gmail.com"});
         REQUIRE(false);
-    } catch(const std::system_error& e) {
+    } catch(const std::system_error&) {
         //..
     } catch(...) {
         REQUIRE(false);
@@ -52,7 +52,7 @@ TEST_CASE("Unique") {
     try {
         storage.insert(Shape{0, "red", "green"});
         REQUIRE(false);
-    } catch(const std::system_error& e) {
+    } catch(const std::system_error&) {
         //..
     } catch(...) {
         REQUIRE(false);
diff --git a/tests/prepared_statement_tests/insert_explicit.cpp b/tests/prepared_statement_tests/insert_explicit.cpp
index b1f01ddcb..c1f998fc6 100644
--- a/tests/prepared_statement_tests/insert_explicit.cpp
+++ b/tests/prepared_statement_tests/insert_explicit.cpp
@@ -69,7 +69,7 @@ TEST_CASE("Prepared insert explicit") {
                 try {
                     storage.execute(statement);
                     REQUIRE(false);
-                } catch(const std::system_error& e) {
+                } catch(const std::system_error&) {
                     REQUIRE(storage.count<User>(where(is_equal(&User::name, "Nate Dogg"))) == 0);
                 } catch(...) {
                     REQUIRE(false);
diff --git a/tests/prepared_statement_tests/insert_range.cpp b/tests/prepared_statement_tests/insert_range.cpp
index 03f19a0b5..8a23fc9d6 100644
--- a/tests/prepared_statement_tests/insert_range.cpp
+++ b/tests/prepared_statement_tests/insert_range.cpp
@@ -49,7 +49,7 @@ TEST_CASE("Prepared insert range") {
             try {
                 auto statement = storage.prepare(insert_range(users.begin(), users.end()));
                 REQUIRE(false);
-            } catch(const std::system_error &e) {
+            } catch(const std::system_error &) {
                 //..
             }
         }
@@ -62,7 +62,7 @@ TEST_CASE("Prepared insert range") {
                                                                         return *pointer;
                                                                     }));
                 REQUIRE(false);
-            } catch(const std::system_error &e) {
+            } catch(const std::system_error &) {
                 //..
             }
         }
diff --git a/tests/prepared_statement_tests/replace_range.cpp b/tests/prepared_statement_tests/replace_range.cpp
index 9fc10cb50..5e5a5154d 100644
--- a/tests/prepared_statement_tests/replace_range.cpp
+++ b/tests/prepared_statement_tests/replace_range.cpp
@@ -51,7 +51,7 @@ TEST_CASE("Prepared replace range") {
             try {
                 auto statement = storage.prepare(replace_range(users.begin(), users.end()));
                 REQUIRE(false);
-            } catch(const std::system_error& e) {
+            } catch(const std::system_error&) {
                 //..
             }
         }
@@ -59,7 +59,7 @@ TEST_CASE("Prepared replace range") {
             try {
                 auto statement = storage.prepare(replace_range<User>(userPointers.begin(), userPointers.end(), lambda));
                 REQUIRE(false);
-            } catch(const std::system_error& e) {
+            } catch(const std::system_error&) {
                 //..
             }
         }

From 403022716597e379d586aed6ce6c4a8688303d7e Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 24 Jan 2022 00:33:32 +0200
Subject: [PATCH 039/161] `tuplify` metafunction must do what it is supposed to
 do

---
 dev/type_traits.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev/type_traits.h b/dev/type_traits.h
index cab9a06e7..9d10cf463 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -111,7 +111,7 @@ namespace sqlite_orm {
 
         template<typename T>
         struct tuplify {
-            using type = T;
+            using type = std::tuple<T>;
         };
         template<typename... Ts>
         struct tuplify<std::tuple<Ts...>> {

From 757c9a975b62f1e02ed92898ece35e57b2abdbe0 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Wed, 26 Jan 2022 22:14:34 +0200
Subject: [PATCH 040/161] Ability to refer back to a CTE column via column
 alias

---
 dev/column_expression.h               | 38 ++++++++++-
 dev/cte.h                             | 64 +++++++++++++++++-
 dev/cte_column_names_collector.h      |  9 ++-
 dev/cte_storage.h                     | 60 ++++++++---------
 dev/cte_types.h                       |  2 +-
 dev/cxx_polyfill.h                    |  3 +
 dev/storage_impl.h                    | 51 +++++++++++++--
 dev/storage_lookup.h                  |  2 +-
 dev/table.h                           |  4 +-
 examples/common_table_expressions.cpp | 93 +++++++++++++++++++++------
 10 files changed, 264 insertions(+), 62 deletions(-)

diff --git a/dev/column_expression.h b/dev/column_expression.h
index cc64152f8..4c0137b92 100644
--- a/dev/column_expression.h
+++ b/dev/column_expression.h
@@ -24,21 +24,41 @@ namespace sqlite_orm {
         template<class St, class E>
         using column_expression_of_t = typename column_expression_type<St, E>::type;
 
+        /**
+         *  Identity.
+         */
         template<class St, class E, class SFINAE>
         struct column_expression_type {
             using type = E;
         };
 
+        /**
+         *  Resolve column alias.
+         *  as_t<Alias, E> -> as_t<Alias, ColExpr>
+         */
+        template<class St, class As>
+        struct column_expression_type<St, As, match_specialization_of<As, as_t>> {
+            using type = as_t<typename As::alias_type, column_expression_of_t<St, expression_type_t<As>>>;
+        };
+
+        /**
+         *  Resolve reference wrapper.
+         *  reference_wrapper<T> -> T&
+         */
         template<class St, class E>
         struct column_expression_type<St, std::reference_wrapper<E>, void>
             : std::add_lvalue_reference<column_expression_of_t<St, E>> {};
 
-        // No CTE for object expressions.
+        // No CTE for object expression.
         template<class St, class E>
         struct column_expression_type<St, object_t<E>, void> {
             static_assert(polyfill::always_false_v<E>, "Selecting an object in a subselect is not allowed.");
         };
 
+        /**
+         *  Resolve all columns of an object.
+         *  asterisk_t<O> -> tuple<ColExpr...>
+         */
         template<class St, class E>
         struct column_expression_type<St, asterisk_t<E>, match_if_not<std::is_base_of, alias_tag, E>>
             : storage_traits::storage_mapped_column_expressions<St, E> {};
@@ -50,19 +70,35 @@ namespace sqlite_orm {
                 using type = alias_column_t<A, ColExpr>;
             };
         };
+        /**
+         *  Resolve all columns of an aliased object.
+         *  asterisk_t<Alias> -> tuple<alias_column_t<Alias, ColExpr>...>
+         */
         template<class St, class A>
         struct column_expression_type<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>>
             : tuple_transformer<typename storage_traits::storage_mapped_column_expressions<St, type_t<A>>::type,
                                 add_column_alias<A>::template apply> {};
 
+        /**
+         *  Resolve member pointer constant (actually covered by identity matcher above).
+         *  F O::*member -> F O::*member
+         */
         template<class St, class O, class F, F O::*m>
         struct column_expression_type<St, ice_t<m>, void> : ice_t<m> {};
 
+        /**
+         *  Resolve multiple columns.
+         *  columns_t<C...> -> tuple<ColExpr...>
+         */
         template<class St, class... Args>
         struct column_expression_type<St, columns_t<Args...>, void> {
             using type = std::tuple<column_expression_of_t<St, std::decay_t<Args>>...>;
         };
 
+        /**
+         *  Resolve column(s) of subselect.
+         *  select_t<E, Args...> -> ColExpr, tuple<ColExpr....>
+         */
         template<class St, class E, class... Args>
         struct column_expression_type<St, select_t<E, Args...>> : column_expression_type<St, E> {};
     }
diff --git a/dev/cte.h b/dev/cte.h
index d2cd690a5..70352ad55 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -9,8 +9,70 @@
 
 namespace sqlite_orm {
 
+    namespace internal {
+        template<typename Alias>
+        using get_fn_t = decltype(Alias::get());
+
+        template<typename A>
+        struct notanalias {
+            static_assert(polyfill::always_false_v<A>,
+                          "als_v<Alias>: Alias must have a static `Alias::get()` function.");
+        };
+    }
+
+    template<class Label, class Alias, class SFINAE = void>
+    SQLITE_ORM_INLINE_VAR constexpr internal::notanalias<Alias> als_of_v{};
+
+    /**
+     *  Refer to a CTE column by mapped integral constant.
+     *  
+     *  col_v<&Object::member> -> column_pointer<Label, ice_t<&Object::member>>
+     */
+    template<class Label, auto c>
+    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer<Label, internal::ice_t<c>> col_of_v{};
+    /**
+     *  Refer to a CTE column by mapped object member.
+     *  
+     *  col_v<&Object::member> -> column_pointer<Label, ice_t<&Object::member>>
+     */
+    template<class Label, class O, class F, F O::*m>
+    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer<Label, internal::ice_t<m>> col_of_v<Label, m>{};
+
+    /**
+     *  Refer to a CTE column by mapped alias.
+     *  
+     *  The alias type must have a static `Alias::get()` function.
+     *
+     *  als_v<Alias> -> column_pointer<Label, alias_holder<Alias>>
+     */
+    template<class Label, class Alias>
+    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer<Label, internal::alias_holder<Alias>>
+        als_of_v<Label, Alias, polyfill::void_t<internal::get_fn_t<Alias>>>{};
+
+    template<class Label>
+    struct cte_label_interface {
+        /**
+         *  Refer to a CTE column by mapped object member.
+         *  
+         *  col_v<&Object::member> -> column_pointer<Label, ice_t<&Object::member>>
+         */
+        template<auto c>
+        static constexpr auto col_v = col_of_v<Label, c>;
+
+        /**
+         *  Refer to a CTE column by mapped alias.
+         *  
+         *  The alias type must have a static `Alias::get()` function.
+         *
+         *  als_v<Alias> -> column_pointer<Label, alias_holder<Alias>>
+         */
+        template<class Alias>
+        static constexpr auto als_v = als_of_v<Label, Alias>;
+    };
+
     template<char C, char... Chars>
-    struct cte_label {
+    struct cte_label : cte_label_interface<cte_label<C, Chars...>> {
+        // Optional label classification tag
         using label_tag = cte_label_tag;
 
         static constexpr char str[] = {C, Chars..., '\0'};
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index f69eed03c..12a47565f 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -40,7 +40,8 @@ namespace sqlite_orm {
 
         // For compound statements we just need to collect the column alias names of the left expression
         template<class Compound>
-        struct cte_column_names_collector<Compound, std::enable_if_t<is_base_of_template<Compound, compound_operator>::value>> {
+        struct cte_column_names_collector<Compound,
+                                          std::enable_if_t<is_base_of_template<Compound, compound_operator>::value>> {
             using expression_type = Compound;
 
             template<class Ctx>
@@ -57,7 +58,9 @@ namespace sqlite_orm {
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type& /*expression*/, const Ctx& /*context*/) const {
-                return {As::alias_type::get()};
+                std::stringstream s;
+                s << As::alias_type::get();
+                return {s.str()};
             }
         };
 
@@ -146,7 +149,7 @@ namespace sqlite_orm {
                 if(explicitColumnNames.size() != columnNames.size()) {
                     throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
                 }
-                
+
                 for(size_t i = 0, n = explicitColumnNames.size(); i < n; ++i) {
                     if(!explicitColumnNames[i].empty()) {
                         columnNames[i] = explicitColumnNames[i];
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 2661f8daa..4bb53c0df 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -46,7 +46,7 @@ namespace sqlite_orm {
         template<typename O, size_t CI>
         using create_cte_column_t = typename create_cte_column<O, CI>::type;
 
-        template<typename M, typename IdxSeq>
+        template<typename Mapper, typename IdxSeq>
         struct create_cte_table;
 
         template<typename Label, typename Expression, typename... Fs, size_t... CIs>
@@ -61,8 +61,8 @@ namespace sqlite_orm {
         /**
          *  Metafunction to create a CTE table_t type.
          */
-        template<typename M, typename IdxSeq>
-        using create_cte_table_t = typename create_cte_table<M, IdxSeq>::type;
+        template<typename Mapper, typename IdxSeq>
+        using create_cte_table_t = typename create_cte_table<Mapper, IdxSeq>::type;
 
         /**
          *  Concatenate newly created tables with those from an existing storage implementation,
@@ -107,65 +107,67 @@ namespace sqlite_orm {
         using cte_driving_subselect_t =
             polyfill::remove_cvref_t<decltype(get_cte_driving_subselect(std::declval<Select>()))>;
 
-        template<typename M, typename S, typename CTE, size_t... CIs>
-        create_cte_table_t<M, typename M::index_sequence>
+        template<typename Mapper, typename S, typename CTE, size_t... CIs>
+        create_cte_table_t<Mapper, typename Mapper::index_sequence>
         make_cte_table_using_column_indices(const S& impl, const CTE& cte, std::index_sequence<CIs...>) {
-            using O = cte_object_type_t<M>;
+            using O = cte_object_type_t<Mapper>;
             using context_type = serializator_context<S>;
             context_type context{impl};
 
             std::vector<std::string> columnNames =
                 collect_cte_column_names(get_cte_driving_subselect(cte.subselect), cte.explicitColumnNames, context);
 
-            return create_cte_table_t<M, typename M::index_sequence>{
+            return create_cte_table_t<Mapper, typename Mapper::index_sequence>{
                 cte.label(),
                 std::make_tuple(
                     make_column<>(move(columnNames.at(CIs)), cte_getter_v<O, CIs>, cte_setter_v<O, CIs>)...)};
         }
 
-        template<typename M, typename S, typename CTE>
-        create_cte_table_t<M, typename M::index_sequence> make_cte_table(const S& impl, const CTE& cte) {
-            return make_cte_table_using_column_indices<M>(impl, cte, typename M::index_sequence{});
+        template<typename Mapper, typename S, typename CTE>
+        create_cte_table_t<Mapper, typename Mapper::index_sequence> make_cte_table(const S& impl, const CTE& cte) {
+            return make_cte_table_using_column_indices<Mapper>(impl, cte, typename Mapper::index_sequence{});
         }
 
-        template<typename S, typename... CTEs, size_t TI1>
+        template<typename S, typename... CTEs, size_t Ii>
         decltype(auto) make_recursive_cte_storage_using_table_indices(const S& impl,
                                                                       const common_table_expressions<CTEs...>& cte,
-                                                                      std::index_sequence<TI1>) {
-            using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
-            using M = create_cte_mapper_t<cte_label_type_t<cte_t>,
-                                          column_expression_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>,
-                                          column_result_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>>;
-            static_assert(cte_t::explicit_column_count == 0 ||
-                              cte_t::explicit_column_count == M::index_sequence::size(),
+                                                                      std::index_sequence<Ii>) {
+            using cte_type = std::tuple_element_t<Ii, common_table_expressions<CTEs...>>;
+            using subselect_type = cte_driving_subselect_t<expression_type_t<cte_type>>;
+            using mapper_type = create_cte_mapper_t<cte_label_type_t<cte_type>,
+                                                    column_expression_of_t<S, subselect_type>,
+                                                    column_result_of_t<S, subselect_type>>;
+            static_assert(cte_type::explicit_column_count == 0 ||
+                              cte_type::explicit_column_count == mapper_type::index_sequence::size(),
                           "Number of explicit columns of common table expression doesn't match the number of columns "
                           "in the subselect.");
 
-            auto tbl = make_cte_table<M>(impl, get<TI1>(cte));
+            auto tbl = make_cte_table<mapper_type>(impl, get<Ii>(cte));
 
             return storage_impl_cat(impl, std::move(tbl));
         }
 
-        template<typename S, typename... CTEs, size_t TI1, size_t TI2, size_t... TIn>
+        template<typename S, typename... CTEs, size_t Ii, size_t Ij, size_t... In>
         decltype(auto) make_recursive_cte_storage_using_table_indices(const S& impl,
                                                                       const common_table_expressions<CTEs...>& cte,
-                                                                      std::index_sequence<TI1, TI2, TIn...>) {
-            using cte_t = std::tuple_element_t<TI1, common_table_expressions<CTEs...>>;
-            using M = create_cte_mapper_t<cte_label_type_t<cte_t>,
-                                          column_expression_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>,
-                                          column_result_of_t<S, cte_driving_subselect_t<expression_type_t<cte_t>>>>;
-            static_assert(cte_t::explicit_column_count == 0 ||
-                              cte_t::explicit_column_count == M::index_sequence::size(),
+                                                                      std::index_sequence<Ii, Ij, In...>) {
+            using cte_type = std::tuple_element_t<Ii, common_table_expressions<CTEs...>>;
+            using subselect_type = cte_driving_subselect_t<expression_type_t<cte_type>>;
+            using mapper_type = create_cte_mapper_t<cte_label_type_t<cte_type>,
+                                                    column_expression_of_t<S, subselect_type>,
+                                                    column_result_of_t<S, subselect_type>>;
+            static_assert(cte_type::explicit_column_count == 0 ||
+                              cte_type::explicit_column_count == mapper_type::index_sequence::size(),
                           "Number of explicit columns of common table expression doesn't match the number of columns "
                           "in the subselect.");
 
-            auto tbl = make_cte_table<M>(impl, get<TI1>(cte));
+            auto tbl = make_cte_table<mapper_type>(impl, get<Ii>(cte));
 
             return make_recursive_cte_storage_using_table_indices(
                 // Because CTEs can depend on their predecessor we recursively pass in a new storage object
                 storage_impl_cat(impl, std::move(tbl)),
                 cte,
-                std::index_sequence<TI2, TIn...>{});
+                std::index_sequence<Ij, In...>{});
         }
 
         /**
diff --git a/dev/cte_types.h b/dev/cte_types.h
index 0ea814037..4022914bc 100644
--- a/dev/cte_types.h
+++ b/dev/cte_types.h
@@ -48,7 +48,7 @@ namespace sqlite_orm {
             using cte_label_type = Label;
             // this type name is used to detect the mapping from label to object
             using cte_object_type = column_results<Label, Fs...>;
-            using expressions_type = tuplify_t<Expression>;
+            using expressions_tuple = tuplify_t<Expression>;
         };
 
         template<class O, size_t I>
diff --git a/dev/cxx_polyfill.h b/dev/cxx_polyfill.h
index 624459e30..4cadaaab6 100644
--- a/dev/cxx_polyfill.h
+++ b/dev/cxx_polyfill.h
@@ -95,6 +95,9 @@ namespace sqlite_orm {
             template<template<class...> class Op, class... Args>
             using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
 
+            template<template<class...> class Op, class... Args>
+            using detected = detector<nonesuch, void, Op, Args...>;
+
             template<template<class...> class Op, class... Args>
             using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
 
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 27b1607a3..6e9f56f70 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -181,8 +181,9 @@ namespace sqlite_orm {
             }
 
             std::string find_table_name(std::type_index ti) const {
-                std::type_index thisTypeIndex{
-                    typeid(std::conditional_t<std::is_void<label_of_t<H>>::value, object_type_t<H>, label_of_t<H>>)};
+                std::type_index thisTypeIndex{typeid(std::conditional_t<std::is_void<label_of_or_void_t<H>>::value,
+                                                                        object_type_t<H>,
+                                                                        label_of_or_void_t<H>>)};
                 if(thisTypeIndex == ti) {
                     return this->table.name;
                 } else {
@@ -398,24 +399,65 @@ namespace sqlite_orm {
             return pick_impl<O>(strg).table.find_column_name(field);
         }
 
+        /**
+         *  Materialize column pointer:
+         *  1. by explicit object type and member pointer.
+         */
         template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
         constexpr decltype(auto) materialize_column_pointer(const S&, const column_pointer<O, F>& cp) {
             return cp.field;
         }
 
+        /**
+         *  Materialize column pointer:
+         *  2. by label type and index constant.
+         */
         template<class Label, size_t I, class S, satisfies<is_storage_impl, S> = true>
         constexpr decltype(auto) materialize_column_pointer(const S&,
                                                             const column_pointer<Label, polyfill::index_constant<I>>&) {
             using timpl_type = storage_pick_impl_t<S, Label>;
+
             return cte_getter_v<storage_object_type_t<timpl_type>, I>;
         }
 
+        /**
+         *  Materialize column pointer:
+         *  3. by label type and member pointer constant.
+         */
         template<class Label, class O, class F, F O::*m, class S, satisfies<is_storage_impl, S> = true>
         constexpr decltype(auto) materialize_column_pointer(const S&, const column_pointer<Label, ice_t<m>>&) {
             using timpl_type = storage_pick_impl_t<S, Label>;
             using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
-            // lookup index in column_results object (aka fields tuple) by member pointer
-            constexpr auto I = tuple_index_of_v<ice_t<m>, typename cte_mapper_type::expressions_type>;
+
+            // lookup index in column expressions tuple by member pointer constant
+            constexpr auto I = tuple_index_of_v<ice_t<m>, typename cte_mapper_type::expressions_tuple>;
+            static_assert(I != -1, "No such column mapped into the CTE.");
+            return cte_getter_v<cte_object_type_t<cte_mapper_type>, I>;
+        }
+
+        template<class As>
+        using alias_type_t = typename As::alias_type;
+
+        // as_t::alias_type or nonesuch
+        template<class T>
+        using alias_type_or_none = polyfill::detected<alias_type_t, T>;
+
+        /**
+         *  Materialize column pointer:
+         *  4. by label type and alias_holder<>.
+         */
+        template<class Label, class Alias, class S, satisfies<is_storage_impl, S> = true>
+        constexpr decltype(auto) materialize_column_pointer(const S&,
+                                                            const column_pointer<Label, alias_holder<Alias>>&) {
+            using timpl_type = storage_pick_impl_t<S, Label>;
+            using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
+            // filter all column alias expressions [`as_t<>`]
+            using alias_types_tuple =
+                typename tuple_transformer<typename cte_mapper_type::expressions_tuple, alias_type_or_none>::type;
+
+            // lookup index in alias_types_tuple by Alias
+            constexpr auto I = tuple_index_of_v<Alias, alias_types_tuple>;
+            static_assert(I != -1, "No such column mapped into the CTE.");
             return cte_getter_v<cte_object_type_t<cte_mapper_type>, I>;
         }
 
@@ -424,6 +466,7 @@ namespace sqlite_orm {
          *  1. by explicit object type and member pointer.
          *  2. by label type and index constant.
          *  3. by label type and member pointer constant.
+         *  4. by label type and alias_holder<>.
          */
         template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
         const std::string* find_column_name(const S& strg, const column_pointer<O, F>& cp) {
diff --git a/dev/storage_lookup.h b/dev/storage_lookup.h
index 677b23951..1d9880b45 100644
--- a/dev/storage_lookup.h
+++ b/dev/storage_lookup.h
@@ -34,7 +34,7 @@ namespace sqlite_orm {
          *  A data type's label type, void otherwise.
          */
         template<typename O>
-        using label_of_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
+        using label_of_or_void_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
 
         /**
          *  A data type's label type, void otherwise.
diff --git a/dev/table.h b/dev/table.h
index 0fa1e7e7b..781117a98 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -25,7 +25,7 @@ namespace sqlite_orm {
          *  A data type's label type, void otherwise.
          */
         template<typename O>
-        using label_of_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
+        using label_of_or_void_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
 
         /** 
          *  If O is a subselect_mapper then returns its nested O::cte_object_type typename,
@@ -57,7 +57,7 @@ namespace sqlite_orm {
             // this typename is used in contexts where it is known that the 'table' holds a subselect_mapper
             // instead of a regular object type
             using cte_mapper_type = O;
-            using cte_label_type = label_of_t<O>;
+            using cte_label_type = label_of_or_void_t<O>;
             using object_type = mapped_object_type_for_t<O>;
             using elements_type = std::tuple<Cs...>;
 
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index babd7fcd2..b2c6fa105 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -77,8 +77,8 @@ void all_integers_between(int from, int end) {
         for(int n:
             storage.with(cte<cte_1>("x").as(union_all(select(from), select(column<cte_1>(0_col) + c(1), limit(end)))),
                          select(column<cte_1>(0_col)))) {
-                cout << n << ", ";
-            }
+            cout << n << ", ";
+        }
         cout << endl;
     }
     cout << endl;
@@ -142,7 +142,7 @@ void supervisor_chain() {
         }
         cout << endl;
     }
-        cout << endl;
+    cout << endl;
 #endif
 }
 
@@ -179,9 +179,9 @@ void works_for_alice() {
         //WITH RECURSIVE
         //    works_for_alice(n) AS(
         //        VALUES('Alice')
-    //        UNION
-    //        SELECT name FROM org, works_for_alice
-    //        WHERE org.boss = works_for_alice.n
+        //        UNION
+        //        SELECT name FROM org, works_for_alice
+        //        WHERE org.boss = works_for_alice.n
         //    )
         //    SELECT avg(height) FROM org
         //    WHERE org.name IN works_for_alice;
@@ -190,20 +190,20 @@ void works_for_alice() {
             select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<cte_1>(0_col))))));
 
         //WITH cte_1("n")
-    //    AS(
-    //        SELECT 'Alice'
-    //        UNION
-    //        SELECT "org"."name" FROM 'cte_1', 'org'
-    //        WHERE("org"."boss" = 'cte_1'."n")
-    //    )
-    //    SELECT AVG("org"."height")
-    //    FROM 'org'
-    //    WHERE(
-    //        "name" IN(
-    //            SELECT 'cte_1'."n" FROM 'cte_1'
-    //        )
-    //    )
-    string sql = storage.dump(ast);
+        //    AS(
+        //        SELECT 'Alice'
+        //        UNION
+        //        SELECT "org"."name" FROM 'cte_1', 'org'
+        //        WHERE("org"."boss" = 'cte_1'."n")
+        //    )
+        //    SELECT AVG("org"."height")
+        //    FROM 'org'
+        //    WHERE(
+        //        "name" IN(
+        //            SELECT 'cte_1'."n" FROM 'cte_1'
+        //        )
+        //    )
+        string sql = storage.dump(ast);
 
         auto stmt = storage.prepare(ast);
         auto results = storage.execute(stmt);
@@ -477,6 +477,58 @@ void apfelmaennchen() {
     cout << endl;
 }
 
+void show_mapping_and_backreferencing() {
+    struct Object {
+        int64 id;
+    };
+
+    // column alias
+    struct cnt : alias_tag {
+        static constexpr std::string_view get() {
+            return "counter";
+        }
+    };
+
+    auto storage = make_storage("", make_table("object", make_column("id", &Object::id)));
+
+    // map column via alias_holder into cte,
+    // back-reference via `column_pointer<cte_1, alias_holder>`
+    {
+        auto ast =
+            with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(column<cte_1>(get<cnt>()) + c(1), limit(10)))),
+                 select(column<cte_1>(get<cnt>())));
+
+        string sql = storage.dump(ast);
+    }
+    // map column via alias_holder into cte,
+    // back-reference via `cte_1::als_v<>`
+    {
+        auto ast = with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(cte_1::als_v<cnt> + c(1), limit(10)))),
+                        select(cte_1::als_v<cnt>));
+
+        string sql = storage.dump(ast);
+    }
+
+    // map column via integral pointer-to-member into cte,
+    // back-reference via `column_pointer<cte_1, ice_t<>>`
+    {
+        auto ast = with(cte<cte_1>("x")(union_all(select(c_v<&Object::id>),
+                                                  select(column<cte_1>(c_v<&Object::id>) + c(1), limit(10)))),
+                        select(column<cte_1>(c_v<&Object::id>)));
+
+        string sql = storage.dump(ast);
+    }
+    // map column via integral pointer-to-member into cte,
+    // back-reference via `cte_1::col_v<>`
+    {
+        auto ast = with(
+            cte<cte_1>("x")(union_all(select(c_v<&Object::id>), select(cte_1::col_v<&Object::id> + c(1), limit(10)))),
+            select(cte_1::col_v<&Object::id>));
+
+        string sql = storage.dump(ast);
+    }
+}
+
 int main() {
     try {
         all_integers_between(1, 10);
@@ -485,6 +537,7 @@ int main() {
         family_tree();
         depth_or_breadth_first();
         apfelmaennchen();
+        show_mapping_and_backreferencing();
     } catch(const system_error& e) {
         cout << "[" << e.code() << "] " << e.what();
     }

From 357cf3fb44abc17c9085441edebae9006f2ed94b Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 28 Jan 2022 11:42:54 +0200
Subject: [PATCH 041/161] Runner-up: Ability to refer back to a CTE column via
 column alias

---
 dev/column_result.h                   | 37 ++++++++++++++++++++++++++-
 dev/storage_impl.h                    |  5 +---
 dev/type_traits.h                     |  3 +++
 examples/common_table_expressions.cpp |  4 +++
 4 files changed, 44 insertions(+), 5 deletions(-)

diff --git a/dev/column_result.h b/dev/column_result.h
index 618f0c59b..0416fa87b 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -215,9 +215,44 @@ namespace sqlite_orm {
         struct column_result_t<St, column_pointer<Label, polyfill::index_constant<I>>, void>
             : column_result_t<St, cte_getter_t<storage_object_type_t<storage_pick_impl_t<St, Label>>, I>> {};
 
+        /**
+         *  Obtain result type from member pointer constant mapped into a CTE.
+         * 
+         *  Note: Even though we actually know the member's type we don't assume anything
+         *  and perform a lookup, such that we ensure that the member pointer has been mapped.
+         */
         template<class St, class Label, class O, class F, F O::*m>
         struct column_result_t<St, column_pointer<Label, ice_t<m>>, void> {
-            using type = F;
+            using timpl_type = storage_pick_impl_t<St, Label>;
+            using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
+
+            // lookup index in expressions_tuple by member pointer constant
+            static constexpr auto I = tuple_index_of_v<ice_t<m>, typename cte_mapper_type::expressions_tuple>;
+            static_assert(I != -1, "No such column mapped into the CTE.");
+
+            using type = column_result_of_t<St, cte_getter_t<storage_object_type_t<timpl_type>, I>>;
+        };
+
+        // as_t::alias_type or nonesuch
+        template<class T>
+        using alias_type_or_none = polyfill::detected<alias_type_t, T>;
+
+        /**
+         *  Obtain result type from aliased column mapped into a CTE.
+         */
+        template<class St, class Label, class Alias>
+        struct column_result_t<St, column_pointer<Label, alias_holder<Alias>>, void> {
+            using timpl_type = storage_pick_impl_t<St, Label>;
+            using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
+            // filter all column alias expressions [`as_t<A>`]
+            using alias_types_tuple =
+                typename tuple_transformer<typename cte_mapper_type::expressions_tuple, alias_type_or_none>::type;
+
+            // lookup index in alias_types_tuple by Alias
+            static constexpr auto I = tuple_index_of_v<Alias, alias_types_tuple>;
+            static_assert(I != -1, "No such column mapped into the CTE.");
+
+            using type = column_result_of_t<St, cte_getter_t<storage_object_type_t<timpl_type>, I>>;
         };
 
         template<class St, class... Args>
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 6e9f56f70..d963a96df 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -435,9 +435,6 @@ namespace sqlite_orm {
             return cte_getter_v<cte_object_type_t<cte_mapper_type>, I>;
         }
 
-        template<class As>
-        using alias_type_t = typename As::alias_type;
-
         // as_t::alias_type or nonesuch
         template<class T>
         using alias_type_or_none = polyfill::detected<alias_type_t, T>;
@@ -451,7 +448,7 @@ namespace sqlite_orm {
                                                             const column_pointer<Label, alias_holder<Alias>>&) {
             using timpl_type = storage_pick_impl_t<S, Label>;
             using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
-            // filter all column alias expressions [`as_t<>`]
+            // filter all column alias expressions [`as_t<A>`]
             using alias_types_tuple =
                 typename tuple_transformer<typename cte_mapper_type::expressions_tuple, alias_type_or_none>::type;
 
diff --git a/dev/type_traits.h b/dev/type_traits.h
index 9d10cf463..905b7a6fb 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -79,6 +79,9 @@ namespace sqlite_orm {
 
         template<typename T>
         using expression_type_t = typename T::expression_type;
+
+        template<class As>
+        using alias_type_t = typename As::alias_type;
     }
 
     namespace internal {
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index b2c6fa105..2fc13fe44 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -499,6 +499,7 @@ void show_mapping_and_backreferencing() {
                  select(column<cte_1>(get<cnt>())));
 
         string sql = storage.dump(ast);
+        auto stmt = storage.prepare(ast);
     }
     // map column via alias_holder into cte,
     // back-reference via `cte_1::als_v<>`
@@ -507,6 +508,7 @@ void show_mapping_and_backreferencing() {
                         select(cte_1::als_v<cnt>));
 
         string sql = storage.dump(ast);
+        auto stmt = storage.prepare(ast);
     }
 
     // map column via integral pointer-to-member into cte,
@@ -517,6 +519,7 @@ void show_mapping_and_backreferencing() {
                         select(column<cte_1>(c_v<&Object::id>)));
 
         string sql = storage.dump(ast);
+        auto stmt = storage.prepare(ast);
     }
     // map column via integral pointer-to-member into cte,
     // back-reference via `cte_1::col_v<>`
@@ -526,6 +529,7 @@ void show_mapping_and_backreferencing() {
             select(cte_1::col_v<&Object::id>));
 
         string sql = storage.dump(ast);
+        auto stmt = storage.prepare(ast);
     }
 }
 

From 5a33340c0d5d8bf85b1b350d58af575acdb3cf42 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 13 Mar 2022 20:54:49 +0200
Subject: [PATCH 042/161] Restored parentheses around VALUES expression

---
 dev/statement_serializator.h    | 6 ++++--
 include/sqlite_orm/sqlite_orm.h | 6 ++++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/dev/statement_serializator.h b/dev/statement_serializator.h
index 500c48500..3c5d75609 100644
--- a/dev/statement_serializator.h
+++ b/dev/statement_serializator.h
@@ -2448,12 +2448,14 @@ namespace sqlite_orm {
                 }
                 ss << "VALUES ";
                 {
+                    auto newContext = context;
+                    newContext.use_parentheses = true;
                     auto index = 0;
                     auto& tuple = statement.tuple;
                     using tuple_type = typename std::decay<decltype(tuple)>::type;
                     using TupleSize = std::tuple_size<tuple_type>;
-                    iterate_tuple(tuple, [&context, &index, &ss](auto& value) {
-                        ss << serialize(value, context);
+                    iterate_tuple(tuple, [&newContext, &index, &ss](auto& value) {
+                        ss << serialize(value, newContext);
                         if(index < TupleSize::value - 1) {
                             ss << ", ";
                         }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index cabeb008e..3bb7ebb4b 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -17932,12 +17932,14 @@ namespace sqlite_orm {
                 }
                 ss << "VALUES ";
                 {
+                    auto newContext = context;
+                    newContext.use_parentheses = true;
                     auto index = 0;
                     auto& tuple = statement.tuple;
                     using tuple_type = typename std::decay<decltype(tuple)>::type;
                     using TupleSize = std::tuple_size<tuple_type>;
-                    iterate_tuple(tuple, [&context, &index, &ss](auto& value) {
-                        ss << serialize(value, context);
+                    iterate_tuple(tuple, [&newContext, &index, &ss](auto& value) {
+                        ss << serialize(value, newContext);
                         if(index < TupleSize::value - 1) {
                             ss << ", ";
                         }

From 83d7fe4945bdfec09d790b132d1cfc5ba4c6e069 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 15 Mar 2022 22:15:02 +0200
Subject: [PATCH 043/161] make_error_code can now be called unqualified

---
 dev/cte_column_names_collector.h | 6 +++---
 include/sqlite_orm/sqlite_orm.h  | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index 12a47565f..d66b7dd70 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -26,7 +26,7 @@ namespace sqlite_orm {
                 newContext.skip_table_name = true;
                 std::string columnName = serialize(t, newContext);
                 if(columnName.empty()) {
-                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                    throw std::system_error(orm_error_code::column_not_found);
                 }
                 return {move(columnName)};
             }
@@ -121,7 +121,7 @@ namespace sqlite_orm {
                     if(!columnName.empty()) {
                         columnNames.push_back(move(columnName));
                     } else {
-                        throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                        throw std::system_error(orm_error_code::column_not_found);
                     }
                 });
                 return columnNames;
@@ -147,7 +147,7 @@ namespace sqlite_orm {
             // 2. override column names from cte expression
             if(!explicitColumnNames.empty()) {
                 if(explicitColumnNames.size() != columnNames.size()) {
-                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                    throw std::system_error(orm_error_code::column_not_found);
                 }
 
                 for(size_t i = 0, n = explicitColumnNames.size(); i < n; ++i) {
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 3bb7ebb4b..451e361b8 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -15283,7 +15283,7 @@ namespace sqlite_orm {
                 newContext.skip_table_name = true;
                 std::string columnName = serialize(t, newContext);
                 if(columnName.empty()) {
-                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                    throw std::system_error(orm_error_code::column_not_found);
                 }
                 return {move(columnName)};
             }
@@ -15378,7 +15378,7 @@ namespace sqlite_orm {
                     if(!columnName.empty()) {
                         columnNames.push_back(move(columnName));
                     } else {
-                        throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                        throw std::system_error(orm_error_code::column_not_found);
                     }
                 });
                 return columnNames;
@@ -15404,7 +15404,7 @@ namespace sqlite_orm {
             // 2. override column names from cte expression
             if(!explicitColumnNames.empty()) {
                 if(explicitColumnNames.size() != columnNames.size()) {
-                    throw std::system_error(std::make_error_code(orm_error_code::column_not_found));
+                    throw std::system_error(orm_error_code::column_not_found);
                 }
 
                 for(size_t i = 0, n = explicitColumnNames.size(); i < n; ++i) {

From b28bfe16f3f380a632967ff44af50863bd737f58 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 15 Mar 2022 22:25:27 +0200
Subject: [PATCH 044/161] Updated unit tests in regard to expected serialized
 statements

Explanation: since commit #df34bb5b1b34 of the CTEs branch the table name gets always serialized in where expressions, to be on the safe side
---
 tests/statement_serializator_tests/schema/index.cpp          | 2 +-
 tests/statement_serializator_tests/statements/update.cpp     | 4 ++--
 tests/statement_serializator_tests/statements/update_all.cpp | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/statement_serializator_tests/schema/index.cpp b/tests/statement_serializator_tests/schema/index.cpp
index 3e07df3ad..5126ef0ae 100644
--- a/tests/statement_serializator_tests/schema/index.cpp
+++ b/tests/statement_serializator_tests/schema/index.cpp
@@ -48,7 +48,7 @@ TEST_CASE("statement_serializator index") {
     SECTION("where") {
         auto index = make_index("idx", &User::id, where(is_not_null(&User::id)));
         value = internal::serialize(index, context);
-        expected = "CREATE INDEX IF NOT EXISTS 'idx' ON 'users' (\"id\") WHERE (\"id\" IS NOT NULL)";
+        expected = "CREATE INDEX IF NOT EXISTS 'idx' ON 'users' (\"id\") WHERE (\"users\".\"id\" IS NOT NULL)";
     }
     REQUIRE(value == expected);
 }
diff --git a/tests/statement_serializator_tests/statements/update.cpp b/tests/statement_serializator_tests/statements/update.cpp
index d14e1b799..c68a0d7e1 100644
--- a/tests/statement_serializator_tests/statements/update.cpp
+++ b/tests/statement_serializator_tests/statements/update.cpp
@@ -42,11 +42,11 @@ TEST_CASE("statement_serializator update") {
                 auto expression = update_all(set(assign(&A::value, 5)), where(is_equal(&A::address, 1)));
                 SECTION("with question marks") {
                     context.replace_bindable_with_question = true;
-                    expected = "UPDATE 'table' SET \"value\" = ? WHERE ((\"address\" = ?))";
+                    expected = "UPDATE 'table' SET \"value\" = ? WHERE ((\"table\".\"address\" = ?))";
                 }
                 SECTION("without question marks") {
                     context.replace_bindable_with_question = false;
-                    expected = "UPDATE 'table' SET \"value\" = 5 WHERE ((\"address\" = 1))";
+                    expected = "UPDATE 'table' SET \"value\" = 5 WHERE ((\"table\".\"address\" = 1))";
                 }
                 value = serialize(expression, context);
             }
diff --git a/tests/statement_serializator_tests/statements/update_all.cpp b/tests/statement_serializator_tests/statements/update_all.cpp
index 8e03e4872..8449ea3a0 100644
--- a/tests/statement_serializator_tests/statements/update_all.cpp
+++ b/tests/statement_serializator_tests/statements/update_all.cpp
@@ -55,6 +55,6 @@ TEST_CASE("statement_serializator update_all") {
         update_all(set(c(&Contact::phone) = select(&Customer::phone, from<Customer>(), where(c(&Customer::id) == 1))));
     auto value = serialize(statement, context);
     decltype(value) expected = "UPDATE 'contacts' SET \"phone\" = (SELECT \"customers\".\"Phone\" FROM 'customers' "
-                               "WHERE ((\"CustomerId\" = 1)))";
+                               "WHERE ((\"customers\".\"CustomerId\" = 1)))";
     REQUIRE(expected == value);
 }

From c3f72ed13a896aa5d53d88697cd3e220eab0adfe Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 4 Apr 2022 23:45:57 +0300
Subject: [PATCH 045/161] Updated code after merge

* `order_by(2)` intead of `order_by(2_nth_col)`
* using 'streaming' functions
---
 dev/statement_serializer.h            | 33 +++++----------------------
 examples/common_table_expressions.cpp |  4 ++--
 include/sqlite_orm/sqlite_orm.h       | 33 +++++----------------------
 3 files changed, 14 insertions(+), 56 deletions(-)

diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index 6265eb01c..7a3b2ab71 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -371,21 +371,6 @@ namespace sqlite_orm {
             return ss;
         }
 
-        /**
-         *  Constant which gets never replaced in a bindable context.
-         *  Used together with order_by(1_nth_col).
-         */
-        template<unsigned int N>
-        struct statement_serializer<nth_constant<N>, void> {
-            using statement_type = nth_constant<N>;
-
-            template<class Ctx>
-            std::string operator()(const statement_type& /*expression*/, const Ctx&) {
-                static_assert(N > 0);
-                return std::to_string(N);
-            }
-        };
-
         /**
          *  Serializer for bindable types.
          */
@@ -846,20 +831,14 @@ namespace sqlite_orm {
 
                 std::stringstream ss;
                 ss << static_cast<std::string>(c);
-                std::vector<std::string> columnNames =
-                    collect_cte_column_names(get_cte_driving_subselect(c.subselect), c.explicitColumnNames, context);
                 {
-                    ss << '(';
-                    for(size_t i = 0, n = columnNames.size(); i < n; ++i) {
-                        ss << "\"" << columnNames[i] << "\"";
-                        if(i < n - 1) {
-                            ss << ", ";
-                        }
-                    }
-                    ss << ')';
+                    std::vector<std::string> columnNames =
+                        collect_cte_column_names(get_cte_driving_subselect(c.subselect),
+                                                 c.explicitColumnNames,
+                                                 context);
+                    ss << '(' << streaming_identifiers(columnNames) << ')';
                 }
-                ss << " AS ";
-                ss << '(' << serialize(c.subselect, cteContext) << ')';
+                ss << " AS " << '(' << serialize(c.subselect, cteContext) << ')';
                 return ss.str();
             }
         };
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 2fc13fe44..3e1aa677b 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -367,7 +367,7 @@ void depth_or_breadth_first() {
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
                                                        select(columns(&Org::name, column<cte_1>(1_col) + c(1)),
                                                               join<cte_1>(on(c(&Org::boss) == column<cte_1>(0_col))),
-                                                              order_by(2_nth_col)))),
+                                                              order_by(2)))),
                  select(substr("..........", 1, column<cte_1>(1_col) * c(3)) || c(column<cte_1>(0_col))));
 
         string sql = storage.dump(ast);
@@ -397,7 +397,7 @@ void depth_or_breadth_first() {
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
                                                        select(columns(&Org::name, column<cte_1>(1_col) + c(1)),
                                                               join<cte_1>(on(c(&Org::boss) == column<cte_1>(0_col))),
-                                                              order_by(2_nth_col).desc()))),
+                                                              order_by(2).desc()))),
                  select(substr("..........", 1, column<cte_1>(1_col) * c(3)) || c(column<cte_1>(0_col))));
 
         string sql = storage.dump(ast);
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 0c4d3d821..30070ba38 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -15696,21 +15696,6 @@ namespace sqlite_orm {
             return ss;
         }
 
-        /**
-         *  Constant which gets never replaced in a bindable context.
-         *  Used together with order_by(1_nth_col).
-         */
-        template<unsigned int N>
-        struct statement_serializer<nth_constant<N>, void> {
-            using statement_type = nth_constant<N>;
-
-            template<class Ctx>
-            std::string operator()(const statement_type& /*expression*/, const Ctx&) {
-                static_assert(N > 0);
-                return std::to_string(N);
-            }
-        };
-
         /**
          *  Serializer for bindable types.
          */
@@ -16171,20 +16156,14 @@ namespace sqlite_orm {
 
                 std::stringstream ss;
                 ss << static_cast<std::string>(c);
-                std::vector<std::string> columnNames =
-                    collect_cte_column_names(get_cte_driving_subselect(c.subselect), c.explicitColumnNames, context);
                 {
-                    ss << '(';
-                    for(size_t i = 0, n = columnNames.size(); i < n; ++i) {
-                        ss << "\"" << columnNames[i] << "\"";
-                        if(i < n - 1) {
-                            ss << ", ";
-                        }
-                    }
-                    ss << ')';
+                    std::vector<std::string> columnNames =
+                        collect_cte_column_names(get_cte_driving_subselect(c.subselect),
+                                                 c.explicitColumnNames,
+                                                 context);
+                    ss << '(' << streaming_identifiers(columnNames) << ')';
                 }
-                ss << " AS ";
-                ss << '(' << serialize(c.subselect, cteContext) << ')';
+                ss << " AS " << '(' << serialize(c.subselect, cteContext) << ')';
                 return ss.str();
             }
         };

From 1b9e53cb4693d7133fe3b0c4828dacb5ab21b348 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 7 Apr 2022 14:46:03 +0300
Subject: [PATCH 046/161] Replaced `constexpr const` variable declarations

---
 dev/constraints.h                 |  4 ++--
 dev/member_traits/getter_traits.h | 24 ++++++++++++------------
 dev/select_constraints.h          |  2 +-
 dev/storage.h                     |  2 +-
 dev/storage_traits.h              | 12 ++++++------
 dev/table.h                       |  4 ++--
 dev/tuple_helper/count_tuple.h    |  4 ++--
 7 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/dev/constraints.h b/dev/constraints.h
index ed0c5878e..c3563c403 100644
--- a/dev/constraints.h
+++ b/dev/constraints.h
@@ -407,12 +407,12 @@ namespace sqlite_orm {
 
         template<>
         struct constraints_size<> {
-            static constexpr const int value = 0;
+            static constexpr int value = 0;
         };
 
         template<class H, class... Args>
         struct constraints_size<H, Args...> {
-            static constexpr const int value = is_constraint<H>::value + constraints_size<Args...>::value;
+            static constexpr int value = is_constraint<H>::value + constraints_size<Args...>::value;
         };
     }
 #if SQLITE_VERSION_NUMBER >= 3031000
diff --git a/dev/member_traits/getter_traits.h b/dev/member_traits/getter_traits.h
index 99c37ba2d..0b3c85cc2 100644
--- a/dev/member_traits/getter_traits.h
+++ b/dev/member_traits/getter_traits.h
@@ -13,7 +13,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = false;
+            static constexpr bool returns_lvalue = false;
         };
 
         template<class O, class T>
@@ -21,7 +21,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = false;
+            static constexpr bool returns_lvalue = false;
         };
 
         template<class O, class T>
@@ -29,7 +29,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 
         template<class O, class T>
@@ -37,7 +37,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 
         template<class O, class T>
@@ -45,7 +45,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 
         template<class O, class T>
@@ -53,7 +53,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 #ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
         template<class O, class T>
@@ -61,7 +61,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = false;
+            static constexpr bool returns_lvalue = false;
         };
 
         template<class O, class T>
@@ -69,7 +69,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = false;
+            static constexpr bool returns_lvalue = false;
         };
 
         template<class O, class T>
@@ -77,7 +77,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 
         template<class O, class T>
@@ -85,7 +85,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 
         template<class O, class T>
@@ -93,7 +93,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 
         template<class O, class T>
@@ -101,7 +101,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 #endif
     }
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index de056e6f4..9a9d274b5 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -69,7 +69,7 @@ namespace sqlite_orm {
             columns_type columns;
             bool distinct = false;
 
-            static constexpr const int count = std::tuple_size<columns_type>::value;
+            static constexpr int count = std::tuple_size<columns_type>::value;
         };
 
         template<class T>
diff --git a/dev/storage.h b/dev/storage.h
index 69321f06c..7ec2e5263 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -721,7 +721,7 @@ namespace sqlite_orm {
 
             template<class O, class... Cols>
             int insert(const O& o, columns_t<Cols...> cols) {
-                constexpr const size_t colsCount = std::tuple_size<std::tuple<Cols...>>::value;
+                constexpr size_t colsCount = std::tuple_size<std::tuple<Cols...>>::value;
                 static_assert(colsCount > 0, "Use insert or replace with 1 argument instead");
                 this->assert_mapped_type<O>();
                 auto statement = this->prepare(sqlite_orm::insert(std::ref(o), std::move(cols)));
diff --git a/dev/storage_traits.h b/dev/storage_traits.h
index ccf5b30fb..1a5b4e7ff 100644
--- a/dev/storage_traits.h
+++ b/dev/storage_traits.h
@@ -117,7 +117,7 @@ namespace sqlite_orm {
             struct column_foreign_keys_count<foreign_key_t<A, B>, O> {
                 using target_type = typename foreign_key_t<A, B>::target_type;
 
-                static constexpr const int value = std::is_same<O, target_type>::value ? 1 : 0;
+                static constexpr int value = std::is_same<O, target_type>::value ? 1 : 0;
             };
 
             /**
@@ -129,12 +129,12 @@ namespace sqlite_orm {
 
             template<class O>
             struct table_foreign_keys_count_impl<O> {
-                static constexpr const int value = 0;
+                static constexpr int value = 0;
             };
 
             template<class O, class H, class... Tail>
             struct table_foreign_keys_count_impl<O, H, Tail...> {
-                static constexpr const int value =
+                static constexpr int value =
                     column_foreign_keys_count<H, O>::value + table_foreign_keys_count_impl<O, Tail...>::value;
             };
 
@@ -149,7 +149,7 @@ namespace sqlite_orm {
             struct table_foreign_keys_count<table_t<O, false, Cs...>, P> {
                 using table_type = table_t<O, false, Cs...>;
 
-                static constexpr const int value = table_foreign_keys_count_impl<P, Cs...>::value;
+                static constexpr int value = table_foreign_keys_count_impl<P, Cs...>::value;
             };
 
             /**
@@ -164,7 +164,7 @@ namespace sqlite_orm {
 
             template<class H, class... Ts, class O>
             struct storage_foreign_keys_count_impl<storage_impl<H, Ts...>, O> {
-                static constexpr const int value = table_foreign_keys_count<H, O>::value +
+                static constexpr int value = table_foreign_keys_count<H, O>::value +
                                                    storage_foreign_keys_count_impl<storage_impl<Ts...>, O>::value;
             };
 
@@ -177,7 +177,7 @@ namespace sqlite_orm {
             struct storage_foreign_keys_count {
                 using impl_type = typename S::impl_type;
 
-                static constexpr const int value = storage_foreign_keys_count_impl<impl_type, O>::value;
+                static constexpr int value = storage_foreign_keys_count_impl<impl_type, O>::value;
             };
 
             /**
diff --git a/dev/table.h b/dev/table.h
index e21a2cd35..d72716b59 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -58,8 +58,8 @@ namespace sqlite_orm {
             using object_type = mapped_object_type_for_t<O>;
             using elements_type = std::tuple<Cs...>;
 
-            static constexpr const int elements_count = static_cast<int>(std::tuple_size<elements_type>::value);
-            static constexpr const bool is_without_rowid = WithoutRowId;
+            static constexpr int elements_count = static_cast<int>(std::tuple_size<elements_type>::value);
+            static constexpr bool is_without_rowid = WithoutRowId;
 
             elements_type elements;
 
diff --git a/dev/tuple_helper/count_tuple.h b/dev/tuple_helper/count_tuple.h
index 5822b050a..c01bac38d 100644
--- a/dev/tuple_helper/count_tuple.h
+++ b/dev/tuple_helper/count_tuple.h
@@ -10,12 +10,12 @@ namespace sqlite_orm {
 
         template<template<class> class C>
         struct count_tuple<std::tuple<>, C> {
-            static constexpr const int value = 0;
+            static constexpr int value = 0;
         };
 
         template<class H, class... Args, template<class> class C>
         struct count_tuple<std::tuple<H, Args...>, C> {
-            static constexpr const int value = C<H>::value + count_tuple<std::tuple<Args...>, C>::value;
+            static constexpr int value = C<H>::value + count_tuple<std::tuple<Args...>, C>::value;
         };
     }
 }

From 015027fc4a8f83c951eda87e3c0ec0508f998d68 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 7 Apr 2022 14:49:28 +0300
Subject: [PATCH 047/161] Renamed `alias_exctractor::get()` ->
 `alias_exctractor::extract()`

---
 dev/alias.h                      |  4 ++--
 dev/column_names_getter.h        |  2 +-
 dev/cte_column_names_collector.h |  2 +-
 dev/statement_serializer.h       | 16 ++++++++--------
 dev/table_name_collector.h       |  4 ++--
 5 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 28ef710fb..5d8f14542 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -47,7 +47,7 @@ namespace sqlite_orm {
 
         template<class A>
         struct alias_extractor<A, typename std::enable_if<std::is_base_of<alias_tag, A>::value>::type> {
-            static std::string get() {
+            static std::string extract() {
                 std::stringstream ss;
                 ss << A::get();
                 return ss.str();
@@ -56,7 +56,7 @@ namespace sqlite_orm {
 
         template<class T>
         struct alias_extractor<T, typename std::enable_if<!std::is_base_of<alias_tag, T>::value>::type> {
-            static std::string get() {
+            static std::string extract() {
                 return {};
             }
         };
diff --git a/dev/column_names_getter.h b/dev/column_names_getter.h
index 9cf3faf84..9e08b2020 100644
--- a/dev/column_names_getter.h
+++ b/dev/column_names_getter.h
@@ -66,7 +66,7 @@ namespace sqlite_orm {
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type&, const Ctx&) const {
-                return {quote_identifier(alias_extractor<A>::get()) + ".*"};
+                return {quote_identifier(alias_extractor<A>::extract()) + ".*"};
             }
         };
 
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index d66b7dd70..cf6c52db6 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -114,7 +114,7 @@ namespace sqlite_orm {
 
                     std::string columnName;
                     if constexpr(polyfill::is_specialization_of_v<value_type, as_t>) {
-                        columnName = alias_extractor<typename value_type::alias_type>::get();
+                        columnName = alias_extractor<typename value_type::alias_type>::extract();
                     } else {
                         columnName = serialize(m, newContext);
                     }
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index c36e5531c..bb5510359 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -601,7 +601,7 @@ namespace sqlite_orm {
             template<class Ctx>
             std::string operator()(const statement_type& c, const Ctx& context) const {
                 std::stringstream ss;
-                ss << serialize(c.expression, context) + " AS " << streaming_identifier(alias_extractor<T>::get());
+                ss << serialize(c.expression, context) + " AS " << streaming_identifier(alias_extractor<T>::extract());
                 return ss.str();
             }
         };
@@ -614,7 +614,7 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& c, const Ctx& context) const {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
-                    ss << streaming_identifier(alias_extractor<T>::get()) << ".";
+                    ss << streaming_identifier(alias_extractor<T>::extract()) << ".";
                 }
                 auto newContext = context;
                 newContext.skip_table_name = true;
@@ -1907,7 +1907,7 @@ namespace sqlite_orm {
                         using original_join_type = typename std::decay<decltype(c)>::type::join_type::type;
                         using cross_join_type = typename internal::mapped_type_proxy<original_join_type>::type;
                         auto crossJoinedTableName = lookup_table_name<cross_join_type>(context.impl);
-                        auto tableAliasString = alias_extractor<original_join_type>::get();
+                        auto tableAliasString = alias_extractor<original_join_type>::extract();
                         std::pair<std::string, std::string> tableNameWithAlias{std::move(crossJoinedTableName),
                                                                                std::move(tableAliasString)};
                         collector.table_names.erase(tableNameWithAlias);
@@ -2010,7 +2010,7 @@ namespace sqlite_orm {
                     }
                     ss << streaming_identifier(
                         lookup_table_name<typename mapped_type_proxy<from_type>::type>(context.impl),
-                        alias_extractor<from_type>::get());
+                        alias_extractor<from_type>::extract());
                     ++index;
                 });
                 return ss.str();
@@ -2258,7 +2258,7 @@ namespace sqlite_orm {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
                    << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::get())
+                                           alias_extractor<T>::extract())
                    << serialize(l.constraint, context);
                 return ss.str();
             }
@@ -2287,7 +2287,7 @@ namespace sqlite_orm {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
                    << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::get())
+                                           alias_extractor<T>::extract())
                    << " " << serialize(l.constraint, context);
                 return ss.str();
             }
@@ -2302,7 +2302,7 @@ namespace sqlite_orm {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
                    << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::get())
+                                           alias_extractor<T>::extract())
                    << " " << serialize(l.constraint, context);
                 return ss.str();
             }
@@ -2317,7 +2317,7 @@ namespace sqlite_orm {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
                    << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::get())
+                                           alias_extractor<T>::extract())
                    << " " << serialize(l.constraint, context);
                 return ss.str();
             }
diff --git a/dev/table_name_collector.h b/dev/table_name_collector.h
index 640b7d934..6b59dc8d8 100644
--- a/dev/table_name_collector.h
+++ b/dev/table_name_collector.h
@@ -43,7 +43,7 @@ namespace sqlite_orm {
 
             template<class T, class C>
             void operator()(const alias_column_t<T, C> &a) const {
-                (*this)(a.column, alias_extractor<T>::get());
+                (*this)(a.column, alias_extractor<T>::extract());
             }
 
             template<class T>
@@ -65,7 +65,7 @@ namespace sqlite_orm {
                 static_assert(polyfill::is_detected_v<type_t, T>,
                               "alias<O> must have a nested alias<O>::type typename");
                 auto tableName = this->find_table_name(typeid(type_t<T>));
-                table_names.emplace(move(tableName), alias_extractor<T>::get());
+                table_names.emplace(move(tableName), alias_extractor<T>::extract());
             }
 
             template<class T>

From 8fdce3acad5d991f4b0cdca8b412e332f666d709 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 7 Apr 2022 14:56:33 +0300
Subject: [PATCH 048/161] Properly unquote collected CTE column names

---
 dev/cte_column_names_collector.h | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index cf6c52db6..3faee62cf 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -137,11 +137,19 @@ namespace sqlite_orm {
             std::vector<std::string> columnNames = get_cte_column_names(sel.col, context);
 
             // unquote column names
-            for(std::string& name: columnNames) {
-                if(!name.empty() && name.front() == '"' && name.back() == '"') {
-                    name.erase(name.end() - 1);
-                    name.erase(name.begin());
+            constexpr auto unquote = [](std::string& identifier) {
+                if(!identifier.empty()) {
+                    constexpr char quoteChar = '"';
+                    constexpr char sqlEscaped[] = {quoteChar, quoteChar};
+                    identifier.erase(identifier.end() - 1);
+                    identifier.erase(identifier.begin());
+                    for(size_t pos = 0; (pos = identifier.find(sqlEscaped, pos, 2)) != identifier.npos; ++pos) {
+                        identifier.erase(pos, 1);
+                    }
                 }
+            };
+            for(std::string& name: columnNames) {
+                unquote(name);
             }
 
             // 2. override column names from cte expression

From 57e4bb3f0bdbf509cba5c7f6bb954158e8be31b0 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 7 Apr 2022 14:59:28 +0300
Subject: [PATCH 049/161] Reused sqlite_orm's alias concept for CTE tables

---
 dev/alias.h                           |  21 ++++--
 dev/cte.h                             | 103 +++++--------------------
 dev/cte_storage.h                     |   3 +-
 dev/mapped_type_proxy.h               |   5 +-
 dev/select_constraints.h              | 105 +++++++++++++++++++++-----
 dev/statement_serializer.h            |   2 +-
 examples/common_table_expressions.cpp |  10 ---
 7 files changed, 126 insertions(+), 123 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 5d8f14542..5e1d2066d 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -4,6 +4,8 @@
 #include <sstream>  //  std::stringstream
 #include <string>  //  std::string
 
+#include "static_magic.h"
+
 namespace sqlite_orm {
 
     /**
@@ -46,16 +48,23 @@ namespace sqlite_orm {
         struct alias_extractor;
 
         template<class A>
-        struct alias_extractor<A, typename std::enable_if<std::is_base_of<alias_tag, A>::value>::type> {
-            static std::string extract() {
-                std::stringstream ss;
-                ss << A::get();
-                return ss.str();
+        struct alias_extractor<A, match_if<std::is_base_of, alias_tag, A>> {
+            template<bool always = !std::is_same<polyfill::detected_t<type_t, A>, A>::value>
+            static std::string extract(polyfill::bool_constant<always> = {}) {
+                return static_if<always>(
+                    []() {
+                        std::stringstream ss;
+                        ss << A::get();
+                        return ss.str();
+                    },
+                    []() {
+                        return std::string{};
+                    })();
             }
         };
 
         template<class T>
-        struct alias_extractor<T, typename std::enable_if<!std::is_base_of<alias_tag, T>::value>::type> {
+        struct alias_extractor<T, match_if_not<std::is_base_of, alias_tag, T>> {
             static std::string extract() {
                 return {};
             }
diff --git a/dev/cte.h b/dev/cte.h
index 70352ad55..04a6ee3ba 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -4,98 +4,29 @@
 #include <string>
 
 #include "cxx_polyfill.h"
+#include "alias.h"
 #include "select_constraints.h"
 #include "cte_types.h"
 
 namespace sqlite_orm {
 
-    namespace internal {
-        template<typename Alias>
-        using get_fn_t = decltype(Alias::get());
-
-        template<typename A>
-        struct notanalias {
-            static_assert(polyfill::always_false_v<A>,
-                          "als_v<Alias>: Alias must have a static `Alias::get()` function.");
-        };
-    }
-
-    template<class Label, class Alias, class SFINAE = void>
-    SQLITE_ORM_INLINE_VAR constexpr internal::notanalias<Alias> als_of_v{};
-
-    /**
-     *  Refer to a CTE column by mapped integral constant.
-     *  
-     *  col_v<&Object::member> -> column_pointer<Label, ice_t<&Object::member>>
-     */
-    template<class Label, auto c>
-    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer<Label, internal::ice_t<c>> col_of_v{};
-    /**
-     *  Refer to a CTE column by mapped object member.
-     *  
-     *  col_v<&Object::member> -> column_pointer<Label, ice_t<&Object::member>>
-     */
-    template<class Label, class O, class F, F O::*m>
-    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer<Label, internal::ice_t<m>> col_of_v<Label, m>{};
-
-    /**
-     *  Refer to a CTE column by mapped alias.
-     *  
-     *  The alias type must have a static `Alias::get()` function.
-     *
-     *  als_v<Alias> -> column_pointer<Label, alias_holder<Alias>>
+    /** 
+     *  A special table alias that is both, a storage lookup type (mapping type) and an alias.
      */
-    template<class Label, class Alias>
-    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer<Label, internal::alias_holder<Alias>>
-        als_of_v<Label, Alias, polyfill::void_t<internal::get_fn_t<Alias>>>{};
-
-    template<class Label>
-    struct cte_label_interface {
-        /**
-         *  Refer to a CTE column by mapped object member.
-         *  
-         *  col_v<&Object::member> -> column_pointer<Label, ice_t<&Object::member>>
-         */
-        template<auto c>
-        static constexpr auto col_v = col_of_v<Label, c>;
-
-        /**
-         *  Refer to a CTE column by mapped alias.
-         *  
-         *  The alias type must have a static `Alias::get()` function.
-         *
-         *  als_v<Alias> -> column_pointer<Label, alias_holder<Alias>>
-         */
-        template<class Alias>
-        static constexpr auto als_v = als_of_v<Label, Alias>;
-    };
-
-    template<char C, char... Chars>
-    struct cte_label : cte_label_interface<cte_label<C, Chars...>> {
-        // Optional label classification tag
-        using label_tag = cte_label_tag;
-
-        static constexpr char str[] = {C, Chars..., '\0'};
-
-        static constexpr const char* label() {
-            return str;
-        }
-
-        // CTE derives from a label, hence provide a string conversion operator
-        explicit operator std::string() const {
-            return cte_label::label();
-        }
-    };
-
-    using cte_1 = cte_label<'c', 't', 'e', '_', '1'>;
-    using cte_2 = cte_label<'c', 't', 'e', '_', '2'>;
-    using cte_3 = cte_label<'c', 't', 'e', '_', '3'>;
-    using cte_4 = cte_label<'c', 't', 'e', '_', '4'>;
-    using cte_5 = cte_label<'c', 't', 'e', '_', '5'>;
-    using cte_6 = cte_label<'c', 't', 'e', '_', '6'>;
-    using cte_7 = cte_label<'c', 't', 'e', '_', '7'>;
-    using cte_8 = cte_label<'c', 't', 'e', '_', '8'>;
-    using cte_9 = cte_label<'c', 't', 'e', '_', '9'>;
+    template<char C>
+    struct cte_alias
+        : internal::table_alias<cte_alias<C> /* refer to self, since a label is both, an alias and a lookup type */,
+                                C> {};
+
+    using cte_1 = cte_alias<'1'>;
+    using cte_2 = cte_alias<'2'>;
+    using cte_3 = cte_alias<'3'>;
+    using cte_4 = cte_alias<'4'>;
+    using cte_5 = cte_alias<'5'>;
+    using cte_6 = cte_alias<'6'>;
+    using cte_7 = cte_alias<'7'>;
+    using cte_8 = cte_alias<'8'>;
+    using cte_9 = cte_alias<'9'>;
 
 #if __cplusplus >= 201703L  // use of C++17 or higher
     namespace internal {
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 32185ae1b..62677ef68 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -9,6 +9,7 @@
 #include "column_expression.h"
 #include "select_constraints.h"
 #include "table.h"
+#include "alias.h"
 #include "cte_types.h"
 #include "cte_column_names_collector.h"
 #include "storage_lookup.h"
@@ -118,7 +119,7 @@ namespace sqlite_orm {
                 collect_cte_column_names(get_cte_driving_subselect(cte.subselect), cte.explicitColumnNames, context);
 
             return create_cte_table_t<Mapper, typename Mapper::index_sequence>{
-                cte.label(),
+                alias_extractor<cte_label_type_t<CTE>>::extract(std::true_type{}),
                 std::make_tuple(
                     make_column<>(move(columnNames.at(CIs)), cte_getter_v<O, CIs>, cte_setter_v<O, CIs>)...)};
         }
diff --git a/dev/mapped_type_proxy.h b/dev/mapped_type_proxy.h
index 4acbe3f4e..639f1b41b 100644
--- a/dev/mapped_type_proxy.h
+++ b/dev/mapped_type_proxy.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "type_traits.h"
 #include "alias.h"
 
 namespace sqlite_orm {
@@ -16,8 +17,8 @@ namespace sqlite_orm {
         };
 
         template<class T>
-        struct mapped_type_proxy<T, typename std::enable_if<std::is_base_of<alias_tag, T>::value>::type> {
-            using type = typename T::type;
+        struct mapped_type_proxy<T, match_if<std::is_base_of, alias_tag, T>> {
+            using type = type_t<T>;
         };
     }
 }
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 9a9d274b5..ee1f92cfe 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -128,6 +128,72 @@ namespace sqlite_orm {
             }
         };
 
+        template<class O, class SFINAE = void>
+        struct column_pointer_builder {
+            using mapped_type = O;
+
+            /**
+             *  Explicitly refer to a column, used in contexts
+             *  where the automatic object mapping deduction needs to be overridden.
+             *  
+             *  Example:
+             *  struct MyType : BaseType { ... };
+             *  storage.select(column<MyType>(&BaseType::id));
+             */
+            template<class F>
+            column_pointer<mapped_type, F> operator()(F field) const {
+                return {std::move(field)};
+            }
+        };
+
+        template<class A>
+        struct column_pointer_builder<A, match_if<std::is_base_of, alias_tag, A>> {
+            static_assert(std::is_same<polyfill::detected_t<type_t, A>, A>::value, "`A' must be a mapped table alias");
+
+            using mapped_type = A;
+
+            /** 
+             *  Instantiate table alias object A in order to use it with the overloaded pointer-to-member operator.
+             */
+            constexpr mapped_type operator()() const {
+                return mapped_type{};
+            }
+
+            /**
+             *  Explicitly refer to a column alias mapped into a CTE or subquery.
+             *  
+             *  Example:
+             *  struct Object { ... };
+             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(c_v<&Object::id>)));
+             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
+             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
+             */
+            template<class F, satisfies_not<std::is_base_of, alias_tag, F> = true>
+            column_pointer<mapped_type, F> operator()(F field) const {
+                return {std::move(field)};
+            }
+
+            /** 
+             *  Explicitly refer to a column alias mapped into a CTE or subquery.
+             *  
+             *  Example:
+             *  struct Object { ... };
+             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
+             */
+            template<class ColAlias, satisfies<std::is_base_of, alias_tag, ColAlias> = true>
+            column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
+                return {{}};
+            }
+
+            /**
+             *  Turn 1_nth_col -> 0_col
+             */
+            template<unsigned int I>
+            auto operator()(internal::nth_constant<I>) const {
+                return (*this)(polyfill::index_constant<I - 1>{});
+            }
+        };
+
         /**
          *  Subselect object type.
          */
@@ -235,7 +301,7 @@ namespace sqlite_orm {
          *  Labeled (aliased) CTE expression.
          */
         template<class Label, class Select, class nExplicitCols>
-        struct common_table_expression : public Label {
+        struct common_table_expression {
             using cte_label_type = Label;
             using expression_type = Select;
             static constexpr size_t explicit_column_count = nExplicitCols::value;
@@ -466,30 +532,35 @@ namespace sqlite_orm {
         return {std::make_tuple<Args...>(std::forward<Args>(args)...)};
     }
 
+    /** 
+     *  Explicit column references.
+     */
+    template<class Lookup>
+    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer_builder<Lookup> column{};
+
     /**
-     *  Explicitly refer to a column, used in contexts
-     *  where the automatic object mapping deduction needs to be overridden,
-     *  or when you need to refer to a column in a CTE.
+     *  Explicitly refer to a column mapped into a CTE or subquery.
      *  
-     *  Use it like this:
-     *  struct MyType : BaseType { ... };
-     *  storage.select(column<MyType>(&BaseType::id));
-     *  // ... or
+     *  Example:
      *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(c_v<&Object::id>)));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>()->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(cte_1{}->*&Object::id));
      */
-    template<class O, class F>
-    internal::column_pointer<O, F> column(F f) {
-        return {std::move(f)};
+    template<class A, class F, internal::satisfies<std::is_base_of, alias_tag, A> = true>
+    auto operator->*(const A& /*tableAlias*/, F field) {
+        return column<A>(std::move(field));
     }
 
     /**
-     *  Turn 1_nth_col -> 0_col
+     *  Explicitly refer to an aliased column mapped into a CTE or subquery.
+     *  
+     *  Use it like this:
+     *  struct Object { ... };
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*0_col));
      */
-    template<class O, unsigned int I>
-    auto column(internal::nth_constant<I>) {
-        return column<O>(polyfill::index_constant<I - 1>{});
+    template<class A, class F, internal::satisfies<std::is_base_of, alias_tag, A> = true>
+    auto operator->*(const internal::column_pointer_builder<A>&, F field) {
+        return column<A>(std::move(field));
     }
 
     /**
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index bb5510359..84768f8b5 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -832,7 +832,7 @@ namespace sqlite_orm {
                 cteContext.use_parentheses = false;
 
                 std::stringstream ss;
-                ss << static_cast<std::string>(c);
+                ss << streaming_identifier(alias_extractor<cte_label_type_t<CTE>>::extract(std::true_type{}));
                 {
                     std::vector<std::string> columnNames =
                         collect_cte_column_names(get_cte_driving_subselect(c.subselect),
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 3e1aa677b..ffae27832 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -521,16 +521,6 @@ void show_mapping_and_backreferencing() {
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);
     }
-    // map column via integral pointer-to-member into cte,
-    // back-reference via `cte_1::col_v<>`
-    {
-        auto ast = with(
-            cte<cte_1>("x")(union_all(select(c_v<&Object::id>), select(cte_1::col_v<&Object::id> + c(1), limit(10)))),
-            select(cte_1::col_v<&Object::id>));
-
-        string sql = storage.dump(ast);
-        auto stmt = storage.prepare(ast);
-    }
 }
 
 int main() {

From 97c9bdfefc8e17d0f5572815180d6b5b05cc0fef Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 7 Apr 2022 15:44:38 +0300
Subject: [PATCH 050/161] Updated CTE examples, using new column pointer syntax
 abilities

---
 examples/common_table_expressions.cpp | 120 +++++++++++++++-----------
 1 file changed, 68 insertions(+), 52 deletions(-)

diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index ffae27832..9f1a09655 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -21,16 +21,15 @@ using namespace sqlite_orm;
 
 void all_integers_between(int from, int end) {
     auto storage = make_storage("");
-
     // variant 1, where-clause
     {
         //WITH RECURSIVE
         //    cnt(x) AS(VALUES(1) UNION ALL SELECT x + 1 FROM cnt WHERE x < 1000000)
         //    SELECT x FROM cnt;
-        auto ast =
-            with(cte<cte_1>("x")(
-                     union_all(select(from), select(column<cte_1>(0_col) + c(1), where(column<cte_1>(0_col) < end)))),
-                 select(column<cte_1>(0_col)));
+        auto ast = with(cte<cte_1>()(union_all(
+                            select(as<colalias_f>(from)),
+                            select(column<cte_1>->*colalias_f{} + c(1), where(column<cte_1>->*colalias_f{} < end)))),
+                        select(column<cte_1>->*colalias_f{}));
 
         string sql = storage.dump(ast);
 
@@ -54,8 +53,9 @@ void all_integers_between(int from, int end) {
         //        LIMIT 1000000
         //    )
         //    SELECT x FROM cnt;
-        auto ast = with(cte<cte_1>("x")(union_all(select(from), select(column<cte_1>(0_col) + c(1), limit(end)))),
-                        select(column<cte_1>(0_col)));
+        auto ast = with(cte<cte_1>()(union_all(select(as<colalias_f>(from)),
+                                               select(column<cte_1>->*colalias_f{} + c(1), limit(end)))),
+                        select(column<cte_1>->*colalias_f{}));
 
         string sql = storage.dump(ast);
 
@@ -74,9 +74,9 @@ void all_integers_between(int from, int end) {
         cout << "Integer range (limit-clause) [" << from << ", " << end
              << "]"
                 "\n";
-        for(int n:
-            storage.with(cte<cte_1>("x").as(union_all(select(from), select(column<cte_1>(0_col) + c(1), limit(end)))),
-                         select(column<cte_1>(0_col)))) {
+        for(int n: storage.with(cte<cte_1>().as(union_all(select(as<colalias_f>(from)),
+                                                          select(column<cte_1>->*colalias_f{} + c(1), limit(end)))),
+                                select(column<cte_1>->*colalias_f{}))) {
             cout << n << ", ";
         }
         cout << endl;
@@ -186,8 +186,8 @@ void works_for_alice() {
         //    SELECT avg(height) FROM org
         //    WHERE org.name IN works_for_alice;
         auto ast = with(
-            cte<cte_1>("n")(union_(select("Alice"), select(&Org::name, where(c(&Org::boss) == column<cte_1>(0_col))))),
-            select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<cte_1>(0_col))))));
+            cte<cte_1>("n")(union_(select("Alice"), select(&Org::name, where(c(&Org::boss) == column<cte_1>->*0_col)))),
+            select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<cte_1>->*0_col)))));
 
         //WITH cte_1("n")
         //    AS(
@@ -265,10 +265,10 @@ void family_tree() {
         with(make_tuple(cte<cte_1>("name", "parent")(union_(select(columns(c_v<&Family::name>, &Family::mom)),
                                                             select(columns(&Family::name, &Family::dad)))),
                         cte<cte_2>("name")(union_all(
-                            select(column<cte_1>(1_col), where(column<cte_1>(c_v<&Family::name>) == "Alice")),
-                            select(column<cte_1>(1_col), join<cte_2>(using_(column<cte_1>(c_v<&Family::name>))))))),
+                            select(column<cte_1>->*1_col, where(column<cte_1>(c_v<&Family::name>) == "Alice")),
+                            select(column<cte_1>->*1_col, join<cte_2>(using_(column<cte_1>(c_v<&Family::name>))))))),
              select(&Family::name,
-                    where(is_equal(column<cte_2>(0_col), &Family::name) && is_null(&Family::died)),
+                    where(is_equal(column<cte_2>->*0_col, &Family::name) && is_null(&Family::died)),
                     order_by(&Family::born)));
 
     //WITH cte_1("name", "parent")
@@ -365,10 +365,10 @@ void depth_or_breadth_first() {
         //    SELECT substr('..........', 1, level * 3) || name FROM under_alice;
         auto ast =
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
-                                                       select(columns(&Org::name, column<cte_1>(1_col) + c(1)),
-                                                              join<cte_1>(on(c(&Org::boss) == column<cte_1>(0_col))),
+                                                       select(columns(&Org::name, column<cte_1>->*1_col + c(1)),
+                                                              join<cte_1>(on(c(&Org::boss) == column<cte_1>->*0_col)),
                                                               order_by(2)))),
-                 select(substr("..........", 1, column<cte_1>(1_col) * c(3)) || c(column<cte_1>(0_col))));
+                 select(substr("..........", 1, column<cte_1>->*1_col * c(3)) || c(column<cte_1>->*0_col)));
 
         string sql = storage.dump(ast);
 
@@ -395,10 +395,10 @@ void depth_or_breadth_first() {
         //    SELECT substr('..........', 1, level * 3) || name FROM under_alice;
         auto ast =
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
-                                                       select(columns(&Org::name, column<cte_1>(1_col) + c(1)),
-                                                              join<cte_1>(on(c(&Org::boss) == column<cte_1>(0_col))),
+                                                       select(columns(&Org::name, column<cte_1>->*1_col + c(1)),
+                                                              join<cte_1>(on(c(&Org::boss) == column<cte_1>->*0_col)),
                                                               order_by(2).desc()))),
-                 select(substr("..........", 1, column<cte_1>(1_col) * c(3)) || c(column<cte_1>(0_col))));
+                 select(substr("..........", 1, column<cte_1>->*1_col * c(3)) || c(column<cte_1>->*0_col)));
 
         string sql = storage.dump(ast);
 
@@ -434,36 +434,33 @@ void apfelmaennchen() {
     //        FROM m2 GROUP BY cy
     //    )
     //    SELECT group_concat(rtrim(t), x'0a') FROM a;
-    using cte_xaxis = cte_label<'x', 'a', 'x', 'i', 's'>;
-    using cte_yaxis = cte_label<'y', 'a', 'x', 'i', 's'>;
-    using cte_m = cte_label<'m'>;
-    using cte_m2 = cte_label<'m', '2'>;
-    using cte_a = cte_label<'a'>;
+    using cte_xaxis = cte_alias<'x'>;
+    using cte_yaxis = cte_alias<'y'>;
+    using cte_m = cte_alias<'i'>;
+    using cte_m2 = cte_alias<'m'>;
+    using cte_a = cte_alias<'a'>;
+    constexpr cte_xaxis xaxis{};
+    constexpr cte_yaxis yaxis{};
+    constexpr cte_m m{};
+    constexpr cte_m2 m2{};
+    constexpr cte_a a{};
     auto ast = with(
         make_tuple(
-            cte<cte_xaxis>("x")(
-                union_all(select(-2.0),
-                          select(column<cte_xaxis>(0_col) + c(0.05), where(column<cte_xaxis>(0_col) < 1.2)))),
-            cte<cte_yaxis>("y")(
-                union_all(select(-1.0),
-                          select(column<cte_yaxis>(0_col) + c(0.1), where(column<cte_yaxis>(0_col) < 1.0)))),
-            cte<cte_m>("iter", "cx", "cy", "x", "y")(
-                union_all(select(columns(0, column<cte_xaxis>(0_col), column<cte_yaxis>(0_col), 0.0, 0.0)),
-                          select(columns(column<cte_m>(0_col) + c(1),
-                                         column<cte_m>(1_col),
-                                         column<cte_m>(2_col),
-                                         column<cte_m>(3_col) * c(column<cte_m>(3_col)) -
-                                             column<cte_m>(4_col) * c(column<cte_m>(4_col)) + column<cte_m>(1_col),
-                                         c(2.0) * column<cte_m>(3_col) * column<cte_m>(4_col) + column<cte_m>(2_col)),
-                                 where((column<cte_m>(3_col) * c(column<cte_m>(3_col)) +
-                                        column<cte_m>(4_col) * c(column<cte_m>(4_col))) < c(4.0) &&
-                                       column<cte_m>(0_col) < 28)))),
-            cte<cte_m2>("iter", "cx", "cy")(select(
-                columns(max<>(column<cte_m>(0_col)), column<cte_m>(1_col), column<cte_m>(2_col)),
-                group_by(column<cte_m>(1_col), column<cte_m>(2_col)))),
-            cte<cte_a>("t")(select(group_concat(substr(" .+*#", 1 + min<>(column<cte_m2>(0_col) / c(7.0), 4.0), 1), ""),
-                                   group_by(column<cte_m2>(2_col))))),
-        select(group_concat(rtrim(column<cte_a>(0_col)), "\n")));
+            cte<cte_xaxis>("x")(union_all(select(-2.0), select(xaxis->*0_col + c(0.05), where(xaxis->*0_col < 1.2)))),
+            cte<cte_yaxis>("y")(union_all(select(-1.0), select(yaxis->*0_col + c(0.1), where(yaxis->*0_col < 1.0)))),
+            cte<cte_m>("iter", "cx", "cy", "x", "y")(union_all(
+                select(columns(0, xaxis->*0_col, yaxis->*0_col, 0.0, 0.0)),
+                select(columns(m->*0_col + c(1),
+                               m->*1_col,
+                               m->*2_col,
+                               m->*3_col * c(m->*3_col) - m->*4_col * c(m->*4_col) + m->*1_col,
+                               c(2.0) * m->*3_col * m->*4_col + m->*2_col),
+                       where((m->*3_col * c(m->*3_col) + m->*4_col * c(m->*4_col)) < c(4.0) && m->*0_col < 28)))),
+            cte<cte_m2>("iter", "cx", "cy")(
+                select(columns(max<>(m->*0_col), m->*1_col, m->*2_col), group_by(m->*1_col, m->*2_col))),
+            cte<cte_a>("t")(select(group_concat(substr(" .+*#", 1 + min<>(m2->*0_col / c(7.0), 4.0), 1), ""),
+                                   group_by(m2->*2_col)))),
+        select(group_concat(rtrim(a->*0_col), "\n")));
 
     string sql = storage.dump(ast);
 
@@ -502,10 +499,29 @@ void show_mapping_and_backreferencing() {
         auto stmt = storage.prepare(ast);
     }
     // map column via alias_holder into cte,
-    // back-reference via `cte_1::als_v<>`
+    // back-reference via `column_pointer<cte_1, alias_holder>`
+    {
+        auto ast = with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(column<cte_1>->*cnt{} + c(1), limit(10)))),
+                        select(column<cte_1>->*cnt{}));
+
+        string sql = storage.dump(ast);
+        auto stmt = storage.prepare(ast);
+    }
+    // map column via alias_holder into cte,
+    // back-reference via `column_pointer<cte_1, alias_holder>`
+    {
+        auto ast =
+            with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(column<cte_1>()->*cnt{} + c(1), limit(10)))),
+                 select(column<cte_1>()->*cnt{}));
+
+        string sql = storage.dump(ast);
+        auto stmt = storage.prepare(ast);
+    }
+    // map column via alias_holder into cte,
+    // back-reference via `column_pointer<cte_1, alias_holder>`
     {
-        auto ast = with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(cte_1::als_v<cnt> + c(1), limit(10)))),
-                        select(cte_1::als_v<cnt>));
+        auto ast = with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(cte_1{}->*cnt{} + c(1), limit(10)))),
+                        select(cte_1{}->*cnt{}));
 
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);

From 3490ca0979d0e0b0fb778653f19fca65dda8653c Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 7 Apr 2022 15:45:28 +0300
Subject: [PATCH 051/161] Updated sqlite_orm.h

---
 dev/column_expression.h          |   2 +-
 dev/cte_column_names_collector.h |  10 +-
 dev/cte_types.h                  |   7 -
 include/sqlite_orm/sqlite_orm.h  | 359 ++++++++++++++++---------------
 4 files changed, 195 insertions(+), 183 deletions(-)

diff --git a/dev/column_expression.h b/dev/column_expression.h
index 4c0137b92..07212fabc 100644
--- a/dev/column_expression.h
+++ b/dev/column_expression.h
@@ -38,7 +38,7 @@ namespace sqlite_orm {
          */
         template<class St, class As>
         struct column_expression_type<St, As, match_specialization_of<As, as_t>> {
-            using type = as_t<typename As::alias_type, column_expression_of_t<St, expression_type_t<As>>>;
+            using type = as_t<alias_type_t<As>, column_expression_of_t<St, expression_type_t<As>>>;
         };
 
         /**
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index 3faee62cf..16eee1f34 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -8,13 +8,15 @@
 #include "cxx_polyfill.h"
 #include "type_traits.h"
 #include "error_code.h"
+#include "alias.h"
 #include "select_constraints.h"
+#include "serializer_context.h"
 
 namespace sqlite_orm {
     namespace internal {
         // collecting column names utilizes the statement serializer
-        template<class T, class C>
-        std::string serialize(const T& t, const C& context);
+        template<class T, class I>
+        std::string serialize(const T& t, const serializer_context<I>& context);
 
         template<class T, class SFINAE = void>
         struct cte_column_names_collector {
@@ -58,9 +60,7 @@ namespace sqlite_orm {
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type& /*expression*/, const Ctx& /*context*/) const {
-                std::stringstream s;
-                s << As::alias_type::get();
-                return {s.str()};
+                return {alias_extractor<alias_type_t<As>>::extract()};
             }
         };
 
diff --git a/dev/cte_types.h b/dev/cte_types.h
index 4022914bc..0e40814a5 100644
--- a/dev/cte_types.h
+++ b/dev/cte_types.h
@@ -9,11 +9,6 @@
 
 namespace sqlite_orm {
 
-    /**
-     *  Classification of a label as a 'CTE' label.
-     */
-    struct cte_label_tag {};
-
     namespace internal {
 
         /**
@@ -23,8 +18,6 @@ namespace sqlite_orm {
         class column_results : fields_t<Fs...> {
           public:
             using fields_type = fields_t<Fs...>;
-            // this type name is used to detect the mapping from label to mapper
-            using cte_label_type = Label;
 
             template<size_t I>
             decltype(auto) cget() const noexcept {
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 79e43a924..d889e6da1 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -774,12 +774,12 @@ namespace sqlite_orm {
 
         template<template<class> class C>
         struct count_tuple<std::tuple<>, C> {
-            static constexpr const int value = 0;
+            static constexpr int value = 0;
         };
 
         template<class H, class... Args, template<class> class C>
         struct count_tuple<std::tuple<H, Args...>, C> {
-            static constexpr const int value = C<H>::value + count_tuple<std::tuple<Args...>, C>::value;
+            static constexpr int value = C<H>::value + count_tuple<std::tuple<Args...>, C>::value;
         };
     }
 }
@@ -1010,7 +1010,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = false;
+            static constexpr bool returns_lvalue = false;
         };
 
         template<class O, class T>
@@ -1018,7 +1018,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = false;
+            static constexpr bool returns_lvalue = false;
         };
 
         template<class O, class T>
@@ -1026,7 +1026,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 
         template<class O, class T>
@@ -1034,7 +1034,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 
         template<class O, class T>
@@ -1042,7 +1042,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 
         template<class O, class T>
@@ -1050,7 +1050,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 #ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
         template<class O, class T>
@@ -1058,7 +1058,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = false;
+            static constexpr bool returns_lvalue = false;
         };
 
         template<class O, class T>
@@ -1066,7 +1066,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = false;
+            static constexpr bool returns_lvalue = false;
         };
 
         template<class O, class T>
@@ -1074,7 +1074,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 
         template<class O, class T>
@@ -1082,7 +1082,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 
         template<class O, class T>
@@ -1090,7 +1090,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 
         template<class O, class T>
@@ -1098,7 +1098,7 @@ namespace sqlite_orm {
             using object_type = O;
             using field_type = T;
 
-            static constexpr const bool returns_lvalue = true;
+            static constexpr bool returns_lvalue = true;
         };
 #endif
     }
@@ -1703,12 +1703,12 @@ namespace sqlite_orm {
 
         template<>
         struct constraints_size<> {
-            static constexpr const int value = 0;
+            static constexpr int value = 0;
         };
 
         template<class H, class... Args>
         struct constraints_size<H, Args...> {
-            static constexpr const int value = is_constraint<H>::value + constraints_size<Args...>::value;
+            static constexpr int value = is_constraint<H>::value + constraints_size<Args...>::value;
         };
     }
 #if SQLITE_VERSION_NUMBER >= 3031000
@@ -4210,6 +4210,8 @@ namespace sqlite_orm {
 #include <sstream>  //  std::stringstream
 #include <string>  //  std::string
 
+// #include "static_magic.h"
+
 namespace sqlite_orm {
 
     /**
@@ -4252,17 +4254,24 @@ namespace sqlite_orm {
         struct alias_extractor;
 
         template<class A>
-        struct alias_extractor<A, typename std::enable_if<std::is_base_of<alias_tag, A>::value>::type> {
-            static std::string get() {
-                std::stringstream ss;
-                ss << A::get();
-                return ss.str();
+        struct alias_extractor<A, match_if<std::is_base_of, alias_tag, A>> {
+            template<bool always = !std::is_same<polyfill::detected_t<type_t, A>, A>::value>
+            static std::string extract(polyfill::bool_constant<always> = {}) {
+                return static_if<always>(
+                    []() {
+                        std::stringstream ss;
+                        ss << A::get();
+                        return ss.str();
+                    },
+                    []() {
+                        return std::string{};
+                    })();
             }
         };
 
         template<class T>
-        struct alias_extractor<T, typename std::enable_if<!std::is_base_of<alias_tag, T>::value>::type> {
-            static std::string get() {
+        struct alias_extractor<T, match_if_not<std::is_base_of, alias_tag, T>> {
+            static std::string extract() {
                 return {};
             }
         };
@@ -6806,7 +6815,7 @@ namespace sqlite_orm {
             columns_type columns;
             bool distinct = false;
 
-            static constexpr const int count = std::tuple_size<columns_type>::value;
+            static constexpr int count = std::tuple_size<columns_type>::value;
         };
 
         template<class T>
@@ -6865,6 +6874,72 @@ namespace sqlite_orm {
             }
         };
 
+        template<class O, class SFINAE = void>
+        struct column_pointer_builder {
+            using mapped_type = O;
+
+            /**
+             *  Explicitly refer to a column, used in contexts
+             *  where the automatic object mapping deduction needs to be overridden.
+             *  
+             *  Example:
+             *  struct MyType : BaseType { ... };
+             *  storage.select(column<MyType>(&BaseType::id));
+             */
+            template<class F>
+            column_pointer<mapped_type, F> operator()(F field) const {
+                return {std::move(field)};
+            }
+        };
+
+        template<class A>
+        struct column_pointer_builder<A, match_if<std::is_base_of, alias_tag, A>> {
+            static_assert(std::is_same<polyfill::detected_t<type_t, A>, A>::value, "`A' must be a mapped table alias");
+
+            using mapped_type = A;
+
+            /** 
+             *  Instantiate table alias object A in order to use it with the overloaded pointer-to-member operator.
+             */
+            constexpr mapped_type operator()() const {
+                return mapped_type{};
+            }
+
+            /**
+             *  Explicitly refer to a column alias mapped into a CTE or subquery.
+             *  
+             *  Example:
+             *  struct Object { ... };
+             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(c_v<&Object::id>)));
+             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
+             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
+             */
+            template<class F, satisfies_not<std::is_base_of, alias_tag, F> = true>
+            column_pointer<mapped_type, F> operator()(F field) const {
+                return {std::move(field)};
+            }
+
+            /** 
+             *  Explicitly refer to a column alias mapped into a CTE or subquery.
+             *  
+             *  Example:
+             *  struct Object { ... };
+             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
+             */
+            template<class ColAlias, satisfies<std::is_base_of, alias_tag, ColAlias> = true>
+            column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
+                return {{}};
+            }
+
+            /**
+             *  Turn 1_nth_col -> 0_col
+             */
+            template<unsigned int I>
+            auto operator()(internal::nth_constant<I>) const {
+                return (*this)(polyfill::index_constant<I - 1>{});
+            }
+        };
+
         /**
          *  Subselect object type.
          */
@@ -6972,7 +7047,7 @@ namespace sqlite_orm {
          *  Labeled (aliased) CTE expression.
          */
         template<class Label, class Select, class nExplicitCols>
-        struct common_table_expression : public Label {
+        struct common_table_expression {
             using cte_label_type = Label;
             using expression_type = Select;
             static constexpr size_t explicit_column_count = nExplicitCols::value;
@@ -7203,30 +7278,35 @@ namespace sqlite_orm {
         return {std::make_tuple<Args...>(std::forward<Args>(args)...)};
     }
 
+    /** 
+     *  Explicit column references.
+     */
+    template<class Lookup>
+    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer_builder<Lookup> column{};
+
     /**
-     *  Explicitly refer to a column, used in contexts
-     *  where the automatic object mapping deduction needs to be overridden,
-     *  or when you need to refer to a column in a CTE.
+     *  Explicitly refer to a column mapped into a CTE or subquery.
      *  
-     *  Use it like this:
-     *  struct MyType : BaseType { ... };
-     *  storage.select(column<MyType>(&BaseType::id));
-     *  // ... or
+     *  Example:
      *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(c_v<&Object::id>)));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>()->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(cte_1{}->*&Object::id));
      */
-    template<class O, class F>
-    internal::column_pointer<O, F> column(F f) {
-        return {std::move(f)};
+    template<class A, class F, internal::satisfies<std::is_base_of, alias_tag, A> = true>
+    auto operator->*(const A& /*tableAlias*/, F field) {
+        return column<A>(std::move(field));
     }
 
     /**
-     *  Turn 1_nth_col -> 0_col
+     *  Explicitly refer to an aliased column mapped into a CTE or subquery.
+     *  
+     *  Use it like this:
+     *  struct Object { ... };
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*0_col));
      */
-    template<class O, unsigned int I>
-    auto column(internal::nth_constant<I>) {
-        return column<O>(polyfill::index_constant<I - 1>{});
+    template<class A, class F, internal::satisfies<std::is_base_of, alias_tag, A> = true>
+    auto operator->*(const internal::column_pointer_builder<A>&, F field) {
+        return column<A>(std::move(field));
     }
 
     /**
@@ -9111,6 +9191,8 @@ namespace sqlite_orm {
 }
 #pragma once
 
+// #include "type_traits.h"
+
 // #include "alias.h"
 
 namespace sqlite_orm {
@@ -9127,8 +9209,8 @@ namespace sqlite_orm {
         };
 
         template<class T>
-        struct mapped_type_proxy<T, typename std::enable_if<std::is_base_of<alias_tag, T>::value>::type> {
-            using type = typename T::type;
+        struct mapped_type_proxy<T, match_if<std::is_base_of, alias_tag, T>> {
+            using type = type_t<T>;
         };
     }
 }
@@ -9234,11 +9316,6 @@ namespace sqlite_orm {
 
 namespace sqlite_orm {
 
-    /**
-     *  Classification of a label as a 'CTE' label.
-     */
-    struct cte_label_tag {};
-
     namespace internal {
 
         /**
@@ -9248,8 +9325,6 @@ namespace sqlite_orm {
         class column_results : fields_t<Fs...> {
           public:
             using fields_type = fields_t<Fs...>;
-            // this type name is used to detect the mapping from label to mapper
-            using cte_label_type = Label;
 
             template<size_t I>
             decltype(auto) cget() const noexcept {
@@ -9623,7 +9698,7 @@ namespace sqlite_orm {
             struct column_foreign_keys_count<foreign_key_t<A, B>, O> {
                 using target_type = typename foreign_key_t<A, B>::target_type;
 
-                static constexpr const int value = std::is_same<O, target_type>::value ? 1 : 0;
+                static constexpr int value = std::is_same<O, target_type>::value ? 1 : 0;
             };
 
             /**
@@ -9635,12 +9710,12 @@ namespace sqlite_orm {
 
             template<class O>
             struct table_foreign_keys_count_impl<O> {
-                static constexpr const int value = 0;
+                static constexpr int value = 0;
             };
 
             template<class O, class H, class... Tail>
             struct table_foreign_keys_count_impl<O, H, Tail...> {
-                static constexpr const int value =
+                static constexpr int value =
                     column_foreign_keys_count<H, O>::value + table_foreign_keys_count_impl<O, Tail...>::value;
             };
 
@@ -9655,7 +9730,7 @@ namespace sqlite_orm {
             struct table_foreign_keys_count<table_t<O, false, Cs...>, P> {
                 using table_type = table_t<O, false, Cs...>;
 
-                static constexpr const int value = table_foreign_keys_count_impl<P, Cs...>::value;
+                static constexpr int value = table_foreign_keys_count_impl<P, Cs...>::value;
             };
 
             /**
@@ -9670,8 +9745,8 @@ namespace sqlite_orm {
 
             template<class H, class... Ts, class O>
             struct storage_foreign_keys_count_impl<storage_impl<H, Ts...>, O> {
-                static constexpr const int value = table_foreign_keys_count<H, O>::value +
-                                                   storage_foreign_keys_count_impl<storage_impl<Ts...>, O>::value;
+                static constexpr int value = table_foreign_keys_count<H, O>::value +
+                                             storage_foreign_keys_count_impl<storage_impl<Ts...>, O>::value;
             };
 
             /**
@@ -9683,7 +9758,7 @@ namespace sqlite_orm {
             struct storage_foreign_keys_count {
                 using impl_type = typename S::impl_type;
 
-                static constexpr const int value = storage_foreign_keys_count_impl<impl_type, O>::value;
+                static constexpr int value = storage_foreign_keys_count_impl<impl_type, O>::value;
             };
 
             /**
@@ -10542,8 +10617,8 @@ namespace sqlite_orm {
             using object_type = mapped_object_type_for_t<O>;
             using elements_type = std::tuple<Cs...>;
 
-            static constexpr const int elements_count = static_cast<int>(std::tuple_size<elements_type>::value);
-            static constexpr const bool is_without_rowid = WithoutRowId;
+            static constexpr int elements_count = static_cast<int>(std::tuple_size<elements_type>::value);
+            static constexpr bool is_without_rowid = WithoutRowId;
 
             elements_type elements;
 
@@ -14935,7 +15010,7 @@ namespace sqlite_orm {
 
             template<class T, class C>
             void operator()(const alias_column_t<T, C>& a) const {
-                (*this)(a.column, alias_extractor<T>::get());
+                (*this)(a.column, alias_extractor<T>::extract());
             }
 
             template<class T>
@@ -14957,7 +15032,7 @@ namespace sqlite_orm {
                 static_assert(polyfill::is_detected_v<type_t, T>,
                               "alias<O> must have a nested alias<O>::type typename");
                 auto tableName = this->find_table_name(typeid(type_t<T>));
-                table_names.emplace(move(tableName), alias_extractor<T>::get());
+                table_names.emplace(move(tableName), alias_extractor<T>::extract());
             }
 
             template<class T>
@@ -15055,7 +15130,7 @@ namespace sqlite_orm {
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type&, const Ctx&) const {
-                return {quote_identifier(alias_extractor<A>::get()) + ".*"};
+                return {quote_identifier(alias_extractor<A>::extract()) + ".*"};
             }
         };
 
@@ -15107,13 +15182,17 @@ namespace sqlite_orm {
 
 // #include "error_code.h"
 
+// #include "alias.h"
+
 // #include "select_constraints.h"
 
+// #include "serializer_context.h"
+
 namespace sqlite_orm {
     namespace internal {
         // collecting column names utilizes the statement serializer
-        template<class T, class C>
-        std::string serialize(const T& t, const C& context);
+        template<class T, class I>
+        std::string serialize(const T& t, const serializer_context<I>& context);
 
         template<class T, class SFINAE = void>
         struct cte_column_names_collector {
@@ -15157,9 +15236,7 @@ namespace sqlite_orm {
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type& /*expression*/, const Ctx& /*context*/) const {
-                std::stringstream s;
-                s << As::alias_type::get();
-                return {s.str()};
+                return {alias_extractor<alias_type_t<As>>::extract()};
             }
         };
 
@@ -15213,7 +15290,7 @@ namespace sqlite_orm {
 
                     std::string columnName;
                     if constexpr(polyfill::is_specialization_of_v<value_type, as_t>) {
-                        columnName = alias_extractor<typename value_type::alias_type>::get();
+                        columnName = alias_extractor<typename value_type::alias_type>::extract();
                     } else {
                         columnName = serialize(m, newContext);
                     }
@@ -15236,11 +15313,19 @@ namespace sqlite_orm {
             std::vector<std::string> columnNames = get_cte_column_names(sel.col, context);
 
             // unquote column names
-            for(std::string& name: columnNames) {
-                if(!name.empty() && name.front() == '"' && name.back() == '"') {
-                    name.erase(name.end() - 1);
-                    name.erase(name.begin());
+            constexpr auto unquote = [](std::string& identifier) {
+                if(!identifier.empty()) {
+                    constexpr char quoteChar = '"';
+                    constexpr char sqlEscaped[] = {quoteChar, quoteChar};
+                    identifier.erase(identifier.end() - 1);
+                    identifier.erase(identifier.begin());
+                    for(size_t pos = 0; (pos = identifier.find(sqlEscaped, pos, 2)) != identifier.npos; ++pos) {
+                        identifier.erase(pos, 1);
+                    }
                 }
+            };
+            for(std::string& name: columnNames) {
+                unquote(name);
             }
 
             // 2. override column names from cte expression
@@ -15926,7 +16011,7 @@ namespace sqlite_orm {
             template<class Ctx>
             std::string operator()(const statement_type& c, const Ctx& context) const {
                 std::stringstream ss;
-                ss << serialize(c.expression, context) + " AS " << streaming_identifier(alias_extractor<T>::get());
+                ss << serialize(c.expression, context) + " AS " << streaming_identifier(alias_extractor<T>::extract());
                 return ss.str();
             }
         };
@@ -15939,7 +16024,7 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& c, const Ctx& context) const {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
-                    ss << streaming_identifier(alias_extractor<T>::get()) << ".";
+                    ss << streaming_identifier(alias_extractor<T>::extract()) << ".";
                 }
                 auto newContext = context;
                 newContext.skip_table_name = true;
@@ -16157,7 +16242,7 @@ namespace sqlite_orm {
                 cteContext.use_parentheses = false;
 
                 std::stringstream ss;
-                ss << static_cast<std::string>(c);
+                ss << streaming_identifier(alias_extractor<cte_label_type_t<CTE>>::extract(std::true_type{}));
                 {
                     std::vector<std::string> columnNames =
                         collect_cte_column_names(get_cte_driving_subselect(c.subselect),
@@ -17232,7 +17317,7 @@ namespace sqlite_orm {
                         using original_join_type = typename std::decay<decltype(c)>::type::join_type::type;
                         using cross_join_type = typename internal::mapped_type_proxy<original_join_type>::type;
                         auto crossJoinedTableName = lookup_table_name<cross_join_type>(context.impl);
-                        auto tableAliasString = alias_extractor<original_join_type>::get();
+                        auto tableAliasString = alias_extractor<original_join_type>::extract();
                         std::pair<std::string, std::string> tableNameWithAlias{std::move(crossJoinedTableName),
                                                                                std::move(tableAliasString)};
                         collector.table_names.erase(tableNameWithAlias);
@@ -17335,7 +17420,7 @@ namespace sqlite_orm {
                     }
                     ss << streaming_identifier(
                         lookup_table_name<typename mapped_type_proxy<from_type>::type>(context.impl),
-                        alias_extractor<from_type>::get());
+                        alias_extractor<from_type>::extract());
                     ++index;
                 });
                 return ss.str();
@@ -17583,7 +17668,7 @@ namespace sqlite_orm {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
                    << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::get())
+                                           alias_extractor<T>::extract())
                    << serialize(l.constraint, context);
                 return ss.str();
             }
@@ -17612,7 +17697,7 @@ namespace sqlite_orm {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
                    << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::get())
+                                           alias_extractor<T>::extract())
                    << " " << serialize(l.constraint, context);
                 return ss.str();
             }
@@ -17627,7 +17712,7 @@ namespace sqlite_orm {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
                    << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::get())
+                                           alias_extractor<T>::extract())
                    << " " << serialize(l.constraint, context);
                 return ss.str();
             }
@@ -17642,7 +17727,7 @@ namespace sqlite_orm {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
                    << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::get())
+                                           alias_extractor<T>::extract())
                    << " " << serialize(l.constraint, context);
                 return ss.str();
             }
@@ -17884,7 +17969,7 @@ namespace sqlite_orm {
          */
         template<class St, class As>
         struct column_expression_type<St, As, match_specialization_of<As, as_t>> {
-            using type = as_t<typename As::alias_type, column_expression_of_t<St, expression_type_t<As>>>;
+            using type = as_t<alias_type_t<As>, column_expression_of_t<St, expression_type_t<As>>>;
         };
 
         /**
@@ -17954,6 +18039,8 @@ namespace sqlite_orm {
 
 // #include "table.h"
 
+// #include "alias.h"
+
 // #include "cte_types.h"
 
 // #include "cte_column_names_collector.h"
@@ -18065,7 +18152,7 @@ namespace sqlite_orm {
                 collect_cte_column_names(get_cte_driving_subselect(cte.subselect), cte.explicitColumnNames, context);
 
             return create_cte_table_t<Mapper, typename Mapper::index_sequence>{
-                cte.label(),
+                alias_extractor<cte_label_type_t<CTE>>::extract(std::true_type{}),
                 std::make_tuple(
                     make_column<>(move(columnNames.at(CIs)), cte_getter_v<O, CIs>, cte_setter_v<O, CIs>)...)};
         }
@@ -18805,7 +18892,7 @@ namespace sqlite_orm {
 
             template<class O, class... Cols>
             int insert(const O& o, columns_t<Cols...> cols) {
-                constexpr const size_t colsCount = std::tuple_size<std::tuple<Cols...>>::value;
+                constexpr size_t colsCount = std::tuple_size<std::tuple<Cols...>>::value;
                 static_assert(colsCount > 0, "Use insert or replace with 1 argument instead");
                 this->assert_mapped_type<O>();
                 auto statement = this->prepare(sqlite_orm::insert(std::ref(o), std::move(cols)));
@@ -19840,99 +19927,31 @@ namespace sqlite_orm {
 
 // #include "cxx_polyfill.h"
 
+// #include "alias.h"
+
 // #include "select_constraints.h"
 
 // #include "cte_types.h"
 
 namespace sqlite_orm {
 
-    namespace internal {
-        template<typename Alias>
-        using get_fn_t = decltype(Alias::get());
-
-        template<typename A>
-        struct notanalias {
-            static_assert(polyfill::always_false_v<A>,
-                          "als_v<Alias>: Alias must have a static `Alias::get()` function.");
-        };
-    }
-
-    template<class Label, class Alias, class SFINAE = void>
-    SQLITE_ORM_INLINE_VAR constexpr internal::notanalias<Alias> als_of_v{};
-
-    /**
-     *  Refer to a CTE column by mapped integral constant.
-     *  
-     *  col_v<&Object::member> -> column_pointer<Label, ice_t<&Object::member>>
-     */
-    template<class Label, auto c>
-    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer<Label, internal::ice_t<c>> col_of_v{};
-    /**
-     *  Refer to a CTE column by mapped object member.
-     *  
-     *  col_v<&Object::member> -> column_pointer<Label, ice_t<&Object::member>>
-     */
-    template<class Label, class O, class F, F O::*m>
-    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer<Label, internal::ice_t<m>> col_of_v<Label, m>{};
-
-    /**
-     *  Refer to a CTE column by mapped alias.
-     *  
-     *  The alias type must have a static `Alias::get()` function.
-     *
-     *  als_v<Alias> -> column_pointer<Label, alias_holder<Alias>>
+    /** 
+     *  A special table alias that is both, a storage lookup type (mapping type) and an alias.
      */
-    template<class Label, class Alias>
-    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer<Label, internal::alias_holder<Alias>>
-        als_of_v<Label, Alias, polyfill::void_t<internal::get_fn_t<Alias>>>{};
-
-    template<class Label>
-    struct cte_label_interface {
-        /**
-         *  Refer to a CTE column by mapped object member.
-         *  
-         *  col_v<&Object::member> -> column_pointer<Label, ice_t<&Object::member>>
-         */
-        template<auto c>
-        static constexpr auto col_v = col_of_v<Label, c>;
-
-        /**
-         *  Refer to a CTE column by mapped alias.
-         *  
-         *  The alias type must have a static `Alias::get()` function.
-         *
-         *  als_v<Alias> -> column_pointer<Label, alias_holder<Alias>>
-         */
-        template<class Alias>
-        static constexpr auto als_v = als_of_v<Label, Alias>;
-    };
-
-    template<char C, char... Chars>
-    struct cte_label : cte_label_interface<cte_label<C, Chars...>> {
-        // Optional label classification tag
-        using label_tag = cte_label_tag;
-
-        static constexpr char str[] = {C, Chars..., '\0'};
-
-        static constexpr const char* label() {
-            return str;
-        }
-
-        // CTE derives from a label, hence provide a string conversion operator
-        explicit operator std::string() const {
-            return cte_label::label();
-        }
-    };
-
-    using cte_1 = cte_label<'c', 't', 'e', '_', '1'>;
-    using cte_2 = cte_label<'c', 't', 'e', '_', '2'>;
-    using cte_3 = cte_label<'c', 't', 'e', '_', '3'>;
-    using cte_4 = cte_label<'c', 't', 'e', '_', '4'>;
-    using cte_5 = cte_label<'c', 't', 'e', '_', '5'>;
-    using cte_6 = cte_label<'c', 't', 'e', '_', '6'>;
-    using cte_7 = cte_label<'c', 't', 'e', '_', '7'>;
-    using cte_8 = cte_label<'c', 't', 'e', '_', '8'>;
-    using cte_9 = cte_label<'c', 't', 'e', '_', '9'>;
+    template<char C>
+    struct cte_alias
+        : internal::table_alias<cte_alias<C> /* refer to self, since a label is both, an alias and a lookup type */,
+                                C> {};
+
+    using cte_1 = cte_alias<'1'>;
+    using cte_2 = cte_alias<'2'>;
+    using cte_3 = cte_alias<'3'>;
+    using cte_4 = cte_alias<'4'>;
+    using cte_5 = cte_alias<'5'>;
+    using cte_6 = cte_alias<'6'>;
+    using cte_7 = cte_alias<'7'>;
+    using cte_8 = cte_alias<'8'>;
+    using cte_9 = cte_alias<'9'>;
 
 #if __cplusplus >= 201703L  // use of C++17 or higher
     namespace internal {

From 089ea5ae4c8520702804288e41108aabbd00221a Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 11 Apr 2022 21:10:40 +0300
Subject: [PATCH 052/161] Simplifications, fully leveraging alias mechanism for
 CTEs

---
 dev/alias.h                                   | 145 ++-
 dev/column.h                                  |  55 +-
 dev/column_expression.h                       |  11 +-
 dev/column_names_getter.h                     |   4 +-
 dev/column_result.h                           |  59 +-
 dev/conditions.h                              |  28 +
 dev/cte.h                                     | 106 +-
 dev/cte_column_names_collector.h              |  12 +-
 dev/cte_storage.h                             | 191 +++-
 dev/cte_types.h                               |  50 +-
 dev/mapped_type_proxy.h                       |   2 +-
 dev/member_traits/field_member_traits.h       |   2 +-
 dev/member_traits/is_field_member_pointer.h   |   6 +-
 dev/select_constraints.h                      |  23 +-
 dev/statement_binder.h                        |  29 +-
 dev/statement_serializer.h                    |   3 -
 dev/storage_impl.h                            |  90 +-
 dev/storage_traits.h                          |   6 +-
 dev/table.h                                   |  25 +-
 dev/table_type.h                              |  12 +-
 dev/tuple_helper/tuple_helper.h               |  45 +
 dev/tuple_helper/tuple_transformer.h          |   4 +
 dev/type_traits.h                             |  27 +-
 examples/common_table_expressions.cpp         | 227 +++-
 include/sqlite_orm/sqlite_orm.h               | 968 +++++++++++-------
 tests/static_tests/column_expression_type.cpp |  33 +-
 tests/static_tests/column_result_t.cpp        |  31 +-
 tests/static_tests/tuple_filter.cpp           |  28 +
 tests/static_tests/tuple_filter_single.cpp    |  79 --
 29 files changed, 1377 insertions(+), 924 deletions(-)
 create mode 100644 tests/static_tests/tuple_filter.cpp
 delete mode 100644 tests/static_tests/tuple_filter_single.cpp

diff --git a/dev/alias.h b/dev/alias.h
index 5e1d2066d..eb1956c92 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -4,6 +4,7 @@
 #include <sstream>  //  std::stringstream
 #include <string>  //  std::string
 
+#include "cxx_polyfill.h"
 #include "static_magic.h"
 
 namespace sqlite_orm {
@@ -14,18 +15,65 @@ namespace sqlite_orm {
      */
     struct alias_tag {};
 
+    namespace internal {
+
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_column_alias_v = std::is_base_of<alias_tag, A>::value;
+
+        template<class A>
+        using is_column_alias = polyfill::bool_constant<is_column_alias_v<A>>;
+
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_table_alias_v =
+            polyfill::conjunction_v<std::is_base_of<alias_tag, A>, polyfill::is_detected<type_t, A>>;
+
+        template<class A>
+        using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
+
+        /** 
+         *  A CTE alias is a specialization of a table alias, which is both, a storage lookup type (mapping type) and an alias.
+         */
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_cte_alias_v =
+            polyfill::conjunction_v<std::is_base_of<alias_tag, A>, std::is_same<polyfill::detected_t<type_t, A>, A>>;
+
+        template<class A>
+        using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
+
+#if __cplusplus >= 202002L  // C++20 and later
+        /*  
+         *  Helper class to facilitate user-defined string literal operator template
+         */
+        template<size_t N>
+        struct string_identifier_template {
+            static constexpr size_t size() {
+                return N - 1;
+            }
+
+            constexpr string_identifier_template(const char (&id)[N]) : id{id} {}
+
+            const char (&id)[N];
+        };
+
+        template<template<char...> class Alias, string_identifier_template t, size_t... Idx>
+        SQLITE_ORM_CONSTEVAL auto to_alias(std::index_sequence<Idx...>) {
+            return Alias<t.id[Idx]...>{};
+        }
+#endif
+    }
+
     namespace internal {
 
         /**
          *  This is a common built-in class used for custom single character table aliases.
-         *  For convenience there exist type aliases `alias_a`, `alias_b`, ...
+         *  For convenience there exist public type aliases `alias_a`, `alias_b`, ...
          */
-        template<class T, char A>
+        template<class T, char A, char... X>
         struct table_alias : alias_tag {
             using type = T;
 
-            constexpr static char get() {
-                return A;
+            constexpr static std::string get() {
+                return {A, X...};
             }
         };
 
@@ -45,13 +93,17 @@ namespace sqlite_orm {
         };
 
         template<class T, class SFINAE = void>
-        struct alias_extractor;
+        struct alias_extractor {
+            static std::string extract() {
+                return {};
+            }
+        };
 
         template<class A>
         struct alias_extractor<A, match_if<std::is_base_of, alias_tag, A>> {
-            template<bool always = !std::is_same<polyfill::detected_t<type_t, A>, A>::value>
-            static std::string extract(polyfill::bool_constant<always> = {}) {
-                return static_if<always>(
+            template<bool yes = !is_cte_alias_v<A>>
+            static std::string extract(polyfill::bool_constant<yes> = {}) {
+                return static_if<yes>(
                     []() {
                         std::stringstream ss;
                         ss << A::get();
@@ -63,13 +115,6 @@ namespace sqlite_orm {
             }
         };
 
-        template<class T>
-        struct alias_extractor<T, match_if_not<std::is_base_of, alias_tag, T>> {
-            static std::string extract() {
-                return {};
-            }
-        };
-
         /**
          * Used to store alias for expression
          */
@@ -85,17 +130,28 @@ namespace sqlite_orm {
          *  This is a common built-in class used for custom single-character column aliases.
          *  For convenience there exist type aliases `colalias_a`, `colalias_b`, ...
          */
-        template<char A>
+        template<char A, char... X>
         struct column_alias : alias_tag {
             static std::string get() {
-                return std::string(1u, A);
+                return {A, X...};
             }
         };
 
         template<class T>
         struct alias_holder {
             using type = T;
+            using alias_type = type;
         };
+
+        template<size_t n, char... C>
+        SQLITE_ORM_CONSTEVAL auto n_to_colalias() {
+            constexpr column_alias<'1' + n % 10, C...> colalias{};
+            if constexpr(n > 10) {
+                return n_to_colalias<n / 10, '1' + n % 10, C...>();
+            } else {
+                return colalias;
+            }
+        }
     }
 
     /**
@@ -109,8 +165,34 @@ namespace sqlite_orm {
         return {c};
     }
 
-    template<class T, class E>
-    internal::as_t<T, E> as(E expression) {
+    /** 
+     *  Alias a column expression.
+     */
+    template<class A, class E>
+    internal::as_t<A, E> as(E expression) {
+        return {std::move(expression)};
+    }
+
+#if __cplusplus >= 202002L  // C++20 and later
+    template<auto als, class E>
+    internal::as_t<decltype(als), E> as(E expression) {
+        return {std::move(expression)};
+    }
+#endif
+
+    /** 
+     *  Alias a column expression.
+     */
+    template<class A, class E, internal::satisfies<internal::is_column_alias, A> = true>
+    internal::as_t<A, E> operator>>=(E expression, const A&) {
+        return {std::move(expression)};
+    }
+
+    /** 
+     *  Alias a column expression.
+     */
+    template<class A, class E, internal::satisfies<internal::is_column_alias, A> = true>
+    internal::as_t<A, E> operator|=(E expression, const A&) {
         return {std::move(expression)};
     }
 
@@ -181,4 +263,29 @@ namespace sqlite_orm {
     using colalias_g = internal::column_alias<'g'>;
     using colalias_h = internal::column_alias<'h'>;
     using colalias_i = internal::column_alias<'i'>;
+
+#if __cplusplus >= 201703L  // use of C++17 or higher
+    /**
+     *  column_alias<'1'[, ...]> from a numeric literal.
+     *  E.g. 1_colalias, 2_colalias
+     */
+    template<char... Chars>
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _colalias() {
+        // numeric identifiers are used for automatically assigning implicit aliases to unaliased column expressions,
+        // which start at "1".
+        static_assert(std::array{Chars...}[0] > '0');
+        return internal::column_alias<Chars...>{};
+    }
+
+#if __cplusplus >= 202002L  // C++20 and later
+    /**
+     *  column_alias<'a'[, ...]> from a string literal.
+     *  E.g. "a"_col, "b"_col
+     */
+    template<internal::string_identifier_template t>
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _col() {
+        return internal::to_alias<internal::column_alias, t>(std::make_index_sequence<t.size()>{});
+    }
+#endif
+#endif
 }
diff --git a/dev/column.h b/dev/column.h
index 5eb48e359..3bcb4733f 100644
--- a/dev/column.h
+++ b/dev/column.h
@@ -10,19 +10,13 @@
 #include "type_is_nullable.h"
 #include "tuple_helper/tuple_helper.h"
 #include "constraints.h"
+#include "member_traits/is_field_member_pointer.h"
 #include "member_traits/member_traits.h"
-#include "member_traits/field_member_traits.h"
 
 namespace sqlite_orm {
 
     namespace internal {
 
-        /**
-         *  typename T::value_type if is_integral_constant_v<T>
-         */
-        template<typename T>
-        using ice_value_type_t = std::enable_if_t<is_integral_constant_v<T>, value_type_t<T>>;
-
         struct basic_column {
 
             /**
@@ -40,14 +34,7 @@ namespace sqlite_orm {
         template<class O, class T, class G /* = const T& (O::*)() const*/, class S /* = void (O::*)(T)*/, class... Op>
         struct column_t : basic_column {
             using object_type = O;
-            // the passed in type is either `integral_constant<F O::*member>` or the return type
-            using _ice_or_field_type = T;
-            // `F O::*` from `integral_constant<F O::*member>` or `T`
-            using _member_pointer_or_field_type = polyfill::detected_or_t<T, ice_value_type_t, T>;
-            // `F` from `F O::*` or `T`
-            using field_type = polyfill::detected_or_t<_member_pointer_or_field_type,
-                                                       field_type_t,
-                                                       field_member_traits<_member_pointer_or_field_type>>;
+            using field_type = T;
             using constraints_type = std::tuple<Op...>;
             using member_pointer_t = field_type object_type::*;
             using getter_type = G;
@@ -59,7 +46,7 @@ namespace sqlite_orm {
             member_pointer_t member_pointer /* = nullptr*/;
 
             /**
-             *  Getter member function pointer to get a value. If member_pointer is null than
+             *  Getter member function pointer to get a value. If member_pointer is null then
              *  `getter` and `setter` must be not null
              */
             getter_type getter /* = nullptr*/;
@@ -198,14 +185,10 @@ namespace sqlite_orm {
         };
 
         template<class O, class T, class... Op>
-        struct column_field_expression<column_t<O, T, Op...>, match_if_not<is_integral_constant, T>> {
+        struct column_field_expression<column_t<O, T, Op...>, void> {
             using type = typename column_t<O, T, Op...>::member_pointer_t;
         };
 
-        // match `F O::*member`
-        template<class O, class F, F O::*m, class... Op>
-        struct column_field_expression<column_t<O, ice_t<m>, Op...>, void> : ice_t<m> {};
-
         template<class T>
         struct column_constraints_type {
             using type = std::tuple<>;
@@ -221,10 +204,7 @@ namespace sqlite_orm {
     /**
      *  Column builder function. You should use it to create columns instead of constructor
      */
-    template<class O,
-             class T,
-             typename = typename std::enable_if<!std::is_member_function_pointer<T O::*>::value>::type,
-             class... Op>
+    template<class O, class T, internal::satisfies<internal::is_field_member_pointer, T O::*> = true, class... Op>
     internal::column_t<O, T, const T& (O::*)() const, void (O::*)(T), Op...>
     make_column(const std::string& name, T O::*m, Op... constraints) {
         static_assert(internal::template constraints_size<Op...>::value == std::tuple_size<std::tuple<Op...>>::value,
@@ -234,30 +214,13 @@ namespace sqlite_orm {
         return {name, m, nullptr, nullptr, std::make_tuple(constraints...)};
     }
 
-    /**
-     *  Column builder function. You should use it to create columns instead of constructor
-     */
-    template<class T,
-             T m,
-             class O = typename internal::field_member_traits<T>::object_type,
-             class F = typename internal::field_member_traits<T>::field_type,
-             class... Op>
-    internal::column_t<O, std::integral_constant<T, m>, const F& (O::*)() const, void (O::*)(F), Op...>
-    make_column(const std::string& name, std::integral_constant<T, m>, Op... constraints) {
-        static_assert(internal::template constraints_size<Op...>::value == std::tuple_size<std::tuple<Op...>>::value,
-                      "Incorrect constraints pack");
-        static_assert(internal::is_field_member_pointer<T>::value,
-                      "second argument expected as a member field pointer, not member function pointer");
-        return {name, m, nullptr, nullptr, std::make_tuple(constraints...)};
-    }
-
     /**
      *  Column builder function with setter and getter. You should use it to create columns instead of constructor
      */
     template<class G,
              class S,
-             typename = typename std::enable_if<internal::is_getter<G>::value>::type,
-             typename = typename std::enable_if<internal::is_setter<S>::value>::type,
+             internal::satisfies<internal::is_getter, G> = true,
+             internal::satisfies<internal::is_setter, S> = true,
              class... Op>
     internal::column_t<typename internal::setter_traits<S>::object_type,
                        typename internal::setter_traits<S>::field_type,
@@ -279,8 +242,8 @@ namespace sqlite_orm {
      */
     template<class G,
              class S,
-             typename = typename std::enable_if<internal::is_getter<G>::value>::type,
-             typename = typename std::enable_if<internal::is_setter<S>::value>::type,
+             internal::satisfies<internal::is_getter, G> = true,
+             internal::satisfies<internal::is_setter, S> = true,
              class... Op>
     internal::column_t<typename internal::setter_traits<S>::object_type,
                        typename internal::setter_traits<S>::field_type,
diff --git a/dev/column_expression.h b/dev/column_expression.h
index 07212fabc..ba31fd6df 100644
--- a/dev/column_expression.h
+++ b/dev/column_expression.h
@@ -60,7 +60,7 @@ namespace sqlite_orm {
          *  asterisk_t<O> -> tuple<ColExpr...>
          */
         template<class St, class E>
-        struct column_expression_type<St, asterisk_t<E>, match_if_not<std::is_base_of, alias_tag, E>>
+        struct column_expression_type<St, asterisk_t<E>, match_if_not<is_column_alias, E>>
             : storage_traits::storage_mapped_column_expressions<St, E> {};
 
         template<class A>
@@ -75,17 +75,10 @@ namespace sqlite_orm {
          *  asterisk_t<Alias> -> tuple<alias_column_t<Alias, ColExpr>...>
          */
         template<class St, class A>
-        struct column_expression_type<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>>
+        struct column_expression_type<St, asterisk_t<A>, match_if<is_column_alias, A>>
             : tuple_transformer<typename storage_traits::storage_mapped_column_expressions<St, type_t<A>>::type,
                                 add_column_alias<A>::template apply> {};
 
-        /**
-         *  Resolve member pointer constant (actually covered by identity matcher above).
-         *  F O::*member -> F O::*member
-         */
-        template<class St, class O, class F, F O::*m>
-        struct column_expression_type<St, ice_t<m>, void> : ice_t<m> {};
-
         /**
          *  Resolve multiple columns.
          *  columns_t<C...> -> tuple<ColExpr...>
diff --git a/dev/column_names_getter.h b/dev/column_names_getter.h
index 9e08b2020..7fbe794f4 100644
--- a/dev/column_names_getter.h
+++ b/dev/column_names_getter.h
@@ -51,7 +51,7 @@ namespace sqlite_orm {
         };
 
         template<class T>
-        struct column_names_getter<asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>> {
+        struct column_names_getter<asterisk_t<T>, match_if_not<is_column_alias, T>> {
             using expression_type = asterisk_t<T>;
 
             template<class Ctx>
@@ -61,7 +61,7 @@ namespace sqlite_orm {
         };
 
         template<class A>
-        struct column_names_getter<asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>> {
+        struct column_names_getter<asterisk_t<A>, match_if<is_column_alias, A>> {
             using expression_type = asterisk_t<A>;
 
             template<class Ctx>
diff --git a/dev/column_result.h b/dev/column_result.h
index 64019b3b4..821b1552f 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -6,6 +6,7 @@
 
 #include "cxx_polyfill.h"
 #include "type_traits.h"
+#include "member_traits/is_field_member_pointer.h"
 #include "core_functions.h"
 #include "select_constraints.h"
 #include "operators.h"
@@ -51,15 +52,7 @@ namespace sqlite_orm {
 #endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
 
         template<class St, class O, class F>
-        struct column_result_t<St,
-                               F O::*,
-                               std::enable_if_t<std::is_member_pointer<F O::*>::value &&
-                                                !std::is_member_function_pointer<F O::*>::value>> {
-            using type = F;
-        };
-
-        template<class St, class O, class F, F O::*m>
-        struct column_result_t<St, ice_t<m>, void> {
+        struct column_result_t<St, F O::*, match_if<is_field_member_pointer, F O::*>> {
             using type = F;
         };
 
@@ -230,48 +223,20 @@ namespace sqlite_orm {
         template<class St, class T, class F>
         struct column_result_t<St, column_pointer<T, F>, void> : column_result_t<St, F> {};
 
-        template<class St, class Label, size_t I>
-        struct column_result_t<St, column_pointer<Label, polyfill::index_constant<I>>, void>
-            : column_result_t<St, cte_getter_t<storage_object_type_t<storage_pick_impl_t<St, Label>>, I>> {};
-
-        /**
-         *  Obtain result type from member pointer constant mapped into a CTE.
-         * 
-         *  Note: Even though we actually know the member's type we don't assume anything
-         *  and perform a lookup, such that we ensure that the member pointer has been mapped.
-         */
-        template<class St, class Label, class O, class F, F O::*m>
-        struct column_result_t<St, column_pointer<Label, ice_t<m>>, void> {
+        template<class St, class Label, class ColAlias>
+        struct column_result_t<St, column_pointer<Label, alias_holder<ColAlias>>, void> {
             using timpl_type = storage_pick_impl_t<St, Label>;
             using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
 
-            // lookup index in expressions_tuple by member pointer constant
-            static constexpr auto I = tuple_index_of_v<ice_t<m>, typename cte_mapper_type::expressions_tuple>;
-            static_assert(I != -1, "No such column mapped into the CTE.");
-
-            using type = column_result_of_t<St, cte_getter_t<storage_object_type_t<timpl_type>, I>>;
-        };
-
-        // as_t::alias_type or nonesuch
-        template<class T>
-        using alias_type_or_none = polyfill::detected<alias_type_t, T>;
-
-        /**
-         *  Obtain result type from aliased column mapped into a CTE.
-         */
-        template<class St, class Label, class Alias>
-        struct column_result_t<St, column_pointer<Label, alias_holder<Alias>>, void> {
-            using timpl_type = storage_pick_impl_t<St, Label>;
-            using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
-            // filter all column alias expressions [`as_t<A>`]
+            // filter all column references [`alias_holder<>`]
             using alias_types_tuple =
-                typename tuple_transformer<typename cte_mapper_type::expressions_tuple, alias_type_or_none>::type;
+                transform_tuple_t<typename cte_mapper_type::colref_expressions_tuple, alias_type_or_none>;
 
-            // lookup index in alias_types_tuple by Alias
-            static constexpr auto I = tuple_index_of_v<Alias, alias_types_tuple>;
-            static_assert(I != -1, "No such column mapped into the CTE.");
+            // lookup index of ColAlias in alias_types_tuple
+            static constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
+            static_assert(ColIdx != -1, "No such column mapped into the CTE.");
 
-            using type = column_result_of_t<St, cte_getter_t<storage_object_type_t<timpl_type>, I>>;
+            using type = std::tuple_element_t<ColIdx, typename cte_mapper_type::fields_type>;
         };
 
         template<class St, class... Args>
@@ -323,12 +288,12 @@ namespace sqlite_orm {
         struct column_result_t<St, as_t<T, E>, void> : column_result_t<St, std::decay_t<E>> {};
 
         template<class St, class T>
-        struct column_result_t<St, asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>> {
+        struct column_result_t<St, asterisk_t<T>, match_if_not<is_column_alias, T>> {
             using type = typename storage_traits::storage_mapped_columns<St, T>::type;
         };
 
         template<class St, class A>
-        struct column_result_t<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>> {
+        struct column_result_t<St, asterisk_t<A>, match_if<is_column_alias, A>> {
             using type = typename storage_traits::storage_mapped_columns<St, type_t<A>>::type;
         };
 
diff --git a/dev/conditions.h b/dev/conditions.h
index 5c07e9f34..5002b3aca 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -1008,21 +1008,49 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
+#if __cplusplus >= 202002L  // C++20 and later
+    template<auto als, class O>
+    internal::left_join_t<decltype(als), O> left_join(O o) {
+        return {std::move(o)};
+    }
+#endif
+
     template<class T, class O>
     internal::join_t<T, O> join(O o) {
         return {std::move(o)};
     }
 
+#if __cplusplus >= 202002L  // C++20 and later
+    template<auto als, class O>
+    internal::join_t<decltype(als), O> join(O o) {
+        return {std::move(o)};
+    }
+#endif
+
     template<class T, class O>
     internal::left_outer_join_t<T, O> left_outer_join(O o) {
         return {std::move(o)};
     }
 
+#if __cplusplus >= 202002L  // C++20 and later
+    template<auto als, class O>
+    internal::left_outer_join_t<decltype(als), O> left_outer_join(O o) {
+        return {std::move(o)};
+    }
+#endif
+
     template<class T, class O>
     internal::inner_join_t<T, O> inner_join(O o) {
         return {std::move(o)};
     }
 
+#if __cplusplus >= 202002L  // C++20 and later
+    template<auto als, class O>
+    internal::inner_join_t<decltype(als), O> inner_join(O o) {
+        return {std::move(o)};
+    }
+#endif
+
     template<class T>
     internal::offset_t<T> offset(T off) {
         return {std::move(off)};
diff --git a/dev/cte.h b/dev/cte.h
index 04a6ee3ba..135645346 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -5,28 +5,19 @@
 
 #include "cxx_polyfill.h"
 #include "alias.h"
-#include "select_constraints.h"
-#include "cte_types.h"
 
 namespace sqlite_orm {
 
-    /** 
-     *  A special table alias that is both, a storage lookup type (mapping type) and an alias.
-     */
-    template<char C>
-    struct cte_alias
-        : internal::table_alias<cte_alias<C> /* refer to self, since a label is both, an alias and a lookup type */,
-                                C> {};
-
-    using cte_1 = cte_alias<'1'>;
-    using cte_2 = cte_alias<'2'>;
-    using cte_3 = cte_alias<'3'>;
-    using cte_4 = cte_alias<'4'>;
-    using cte_5 = cte_alias<'5'>;
-    using cte_6 = cte_alias<'6'>;
-    using cte_7 = cte_alias<'7'>;
-    using cte_8 = cte_alias<'8'>;
-    using cte_9 = cte_alias<'9'>;
+    namespace internal {
+        /** 
+         *  A special table alias that is both, a storage lookup type (mapping type) and an alias.
+         */
+        template<char C, char... X>
+        struct cte_alias
+            : table_alias<cte_alias<C, X...> /* refer to self, since a label is both, an alias and a lookup type */,
+                          C,
+                          X...> {};
+    }
 
 #if __cplusplus >= 201703L  // use of C++17 or higher
     namespace internal {
@@ -46,10 +37,10 @@ namespace sqlite_orm {
 
     /**
      *  index_constant<> from numeric literal.
-     *  E.g. 0_col, 1_col
+     *  E.g. 0_colidx, 1_colidx
      */
     template<char... Chars>
-    [[nodiscard]] constexpr decltype(auto) operator"" _col() {
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL decltype(auto) operator"" _colidx() {
         return polyfill::index_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{},
                                                                  Chars...)>{};
     }
@@ -59,32 +50,55 @@ namespace sqlite_orm {
      *  E.g. 1_nth_col, 2_nth_col
      */
     template<char... Chars>
-    [[nodiscard]] constexpr decltype(auto) operator"" _nth_col() {
-        static_assert(((Chars != '0') && ...));
-        return internal::nth_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{},
-                                                               Chars...)>{};
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL decltype(auto) operator"" _nth_col() {
+        constexpr auto n =
+            internal::nth_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{}, Chars...)>{};
+        static_assert(n > 0);
+        return n;
     }
-#else
-    constexpr polyfill::index_constant<0> _0_col{};
-    constexpr polyfill::index_constant<1> _1_col{};
-    constexpr polyfill::index_constant<2> _2_col{};
-    constexpr polyfill::index_constant<3> _3_col{};
-    constexpr polyfill::index_constant<4> _4_col{};
-    constexpr polyfill::index_constant<5> _5_col{};
-    constexpr polyfill::index_constant<6> _6_col{};
-    constexpr polyfill::index_constant<7> _7_col{};
-    constexpr polyfill::index_constant<8> _8_col{};
-    constexpr polyfill::index_constant<9> _9_col{};
 
-    constexpr internal::nth_constant<1> _1_nth_col{};
-    constexpr internal::nth_constant<2> _2_nth_col{};
-    constexpr internal::nth_constant<3> _3_nth_col{};
-    constexpr internal::nth_constant<4> _4_nth_col{};
-    constexpr internal::nth_constant<5> _5_nth_col{};
-    constexpr internal::nth_constant<6> _6_nth_col{};
-    constexpr internal::nth_constant<7> _7_nth_col{};
-    constexpr internal::nth_constant<8> _8_nth_col{};
-    constexpr internal::nth_constant<9> _9_nth_col{};
-    constexpr internal::nth_constant<10> _10_nth_col{};
+    /**
+     *  cte_alias<'n'> from a numeric literal.
+     *  E.g. 1_ctealias, 2_ctealias
+     */
+    template<char... Chars>
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
+        return internal::cte_alias<Chars...>{};
+    }
+#if __cplusplus >= 202002L  // C++20 or later
+    /**
+     *  cte_alias<'1'[, ...]> from a string literal.
+     *  E.g. "1"_cte, "2"_cte
+     */
+    template<internal::string_identifier_template t>
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _cte() {
+        static_assert(t.size() != 1 || ((t.id[0] < 'A' || 'Z' < t.id[0]) && (t.id[0] < 'a' || 'z' < t.id[0])),
+                      "CTE alias identifiers consisting of a single alphabetic character should be avoided, in order "
+                      "to evade clashes with the built-in table aliases.");
+        return internal::to_alias<internal::cte_alias, t>(std::make_index_sequence<t.size()>{});
+    }
+#endif
+
+#if __cplusplus >= 202002L  // C++20 or later
+    using cte_1 = decltype("1"_cte);
+    using cte_2 = decltype("2"_cte);
+    using cte_3 = decltype("3"_cte);
+    using cte_4 = decltype("4"_cte);
+    using cte_5 = decltype("5"_cte);
+    using cte_6 = decltype("6"_cte);
+    using cte_7 = decltype("7"_cte);
+    using cte_8 = decltype("8"_cte);
+    using cte_9 = decltype("9"_cte);
+#else
+    using cte_1 = decltype(1_ctealias);
+    using cte_2 = decltype(2_ctealias);
+    using cte_3 = decltype(3_ctealias);
+    using cte_4 = decltype(4_ctealias);
+    using cte_5 = decltype(5_ctealias);
+    using cte_6 = decltype(6_ctealias);
+    using cte_7 = decltype(7_ctealias);
+    using cte_8 = decltype(8_ctealias);
+    using cte_9 = decltype(9_ctealias);
+#endif
 #endif
 }
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index 16eee1f34..f5c24607a 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -149,7 +149,13 @@ namespace sqlite_orm {
                 }
             };
             for(std::string& name: columnNames) {
-                unquote(name);
+                constexpr char quoteChar = '"';
+                if(name.front() == quoteChar) {
+                    unquote(name);
+                } else {
+                    // unaliased expression - see 3. below
+                    name.clear();
+                }
             }
 
             // 2. override column names from cte expression
@@ -164,11 +170,11 @@ namespace sqlite_orm {
                     }
                 }
             }
-            // 3. fill in blanks with numerical column names
+            // 3. fill in blanks with numerical column identifiers
             {
                 for(size_t i = 0, n = columnNames.size(); i < n; ++i) {
                     if(columnNames[i].empty()) {
-                        columnNames[i] = std::to_string(i);
+                        columnNames[i] = std::to_string(i + 1);
                     }
                 }
             }
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 62677ef68..06d6828d0 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -18,34 +18,65 @@ namespace sqlite_orm {
     namespace internal {
 
         // F = field_type
-        template<typename Label, typename Expression, typename F>
+        template<typename Label, typename Expression, typename RefExpressions, typename F>
         struct create_cte_mapper {
-            using type = subselect_mapper<Label, Expression, F>;
+            using type = subselect_mapper<Label, Expression, RefExpressions, F>;
         };
 
-        template<typename Label, typename Expression, typename... Fs>
-        struct create_cte_mapper<Label, Expression, std::tuple<Fs...>> {
-            using type = subselect_mapper<Label, Expression, Fs...>;
+        template<typename Label, typename Expression, typename RefExpressions, typename... Fs>
+        struct create_cte_mapper<Label, Expression, RefExpressions, std::tuple<Fs...>> {
+            using type = subselect_mapper<Label, Expression, RefExpressions, Fs...>;
         };
 
-        template<typename Label, typename Expression, typename... Fs>
-        using create_cte_mapper_t = typename create_cte_mapper<Label, Expression, Fs...>::type;
+        template<typename Label, typename Expression, typename RefExpressions, typename... Fs>
+        using create_cte_mapper_t = typename create_cte_mapper<Label, Expression, RefExpressions, Fs...>::type;
 
-        template<typename O, size_t CI>
+        // aliased column expressions, explicit or implicitly numbered
+        template<typename Mapper, size_t CI, typename SFINAE = void>
         struct create_cte_column {
-            using cte_object_type = O;
-            using field_type = std::tuple_element_t<CI, typename O::fields_type>;
-            using getter_type = cte_getter_t<O, CI>;
-            using setter_type = cte_setter_t<O, CI>;
+            using As = std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>;
+            using field_type = std::tuple_element_t<CI, typename Mapper::fields_type>;
+            using object_type = aliased_field<alias_type_t<As>, field_type>;
 
-            using type = column_t<cte_object_type, field_type, getter_type, setter_type>;
+            using type = column_t<object_type,
+                                  field_type,
+                                  const field_type& (object_type::*)() const,
+                                  void (object_type::*)(field_type)>;
+
+            template<typename Tpl>
+            static type make_column(std::string name, const Tpl& /*colRefs*/) {
+                return sqlite_orm::make_column<>(move(name), &object_type::field);
+            }
+        };
+
+        // F O::*
+        template<typename Mapper, size_t CI>
+        struct create_cte_column<
+            Mapper,
+            CI,
+            std::enable_if_t<polyfill::disjunction_v<
+                is_field_member_pointer<std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>>,
+                is_getter<std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>>>>> {
+            using F = std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>;
+            using object_type = typename field_member_traits<F>::object_type;
+            using field_type = typename field_member_traits<F>::field_type;
+
+            using type = column_t<object_type,
+                                  field_type,
+                                  const field_type& (object_type::*)() const,
+                                  void (object_type::*)(field_type)>;
+
+            template<typename Tpl>
+            static type make_column(std::string name, const Tpl& colRefs) {
+                return sqlite_orm::make_column<>(move(name), get<CI>(colRefs));
+            }
         };
 
         /**
          *  Metafunction to create a CTE column_t type.
          */
-        template<typename O, size_t CI>
-        using create_cte_column_t = typename create_cte_column<O, CI>::type;
+        template<typename Mapper, size_t CI>
+        using create_cte_column_t = typename create_cte_column<Mapper, CI>::type;
 
         template<typename Mapper, typename IdxSeq>
         struct create_cte_table;
@@ -53,8 +84,7 @@ namespace sqlite_orm {
         template<typename Label, typename Expression, typename... Fs, size_t... CIs>
         struct create_cte_table<subselect_mapper<Label, Expression, Fs...>, std::index_sequence<CIs...>> {
             using cte_mapper_type = subselect_mapper<Label, Expression, Fs...>;
-            using table_type =
-                table_t<cte_mapper_type, true, create_cte_column_t<cte_object_type_t<cte_mapper_type>, CIs>...>;
+            using table_type = table_t<cte_mapper_type, true, create_cte_column_t<cte_mapper_type, CIs>...>;
 
             using type = table_type;
         };
@@ -108,42 +138,123 @@ namespace sqlite_orm {
         using cte_driving_subselect_t =
             polyfill::remove_cvref_t<decltype(get_cte_driving_subselect(std::declval<Select>()))>;
 
+        template<class C, size_t... Idx>
+        auto get_fields_of_columns(const C& coldef, std::index_sequence<Idx...>) {
+            return std::make_tuple(get<Idx>(coldef).member_pointer...);
+        }
+
+        // any expression -> numeric column alias
+        template<class S, class E, size_t Idx = 0>
+        auto extract_colref_expressions(const S& /*impl*/, const E& /*col*/, std::index_sequence<Idx> = {})
+            -> std::tuple<alias_holder<decltype(n_to_colalias<Idx>())>> {
+            return {};
+        }
+
+        // expression_t<>
+        template<class S, class E, size_t Idx = 0>
+        auto extract_colref_expressions(const S& impl, const expression_t<E>& col, std::index_sequence<Idx> s = {}) {
+            return extract_colref_expressions(impl, col.value, s);
+        }
+
+        // F O::* (field) -> field
+        template<class S, class F, class O, size_t Idx = 0>
+        auto extract_colref_expressions(const S& /*impl*/, F O::*col, std::index_sequence<Idx> = {}) {
+            return std::make_tuple(col);
+        }
+
+        // as_t<> (aliased expression) -> alias_holder
+        template<class S, class A, class E, size_t Idx = 0>
+        std::tuple<alias_holder<A>>
+        extract_colref_expressions(const S& /*impl*/, const as_t<A, E>& /*col*/, std::index_sequence<Idx> = {}) {
+            return {};
+        }
+
+        // alias_holder<> (colref) -> alias_holder
+        template<class S, class A, size_t Idx = 0>
+        std::tuple<alias_holder<A>>
+        extract_colref_expressions(const S& /*impl*/, const alias_holder<A>& /*col*/, std::index_sequence<Idx> = {}) {
+            return {};
+        }
+
+        // column_pointer<>
+        template<class S, class Label, class F, size_t Idx = 0>
+        auto extract_colref_expressions(const S& impl,
+                                        const column_pointer<Label, F>& col,
+                                        std::index_sequence<Idx> s = {}) {
+            return extract_colref_expressions(impl, col.field, s);
+        }
+
+        // column expression tuple
+        template<class S, class... Args, size_t... Idx>
+        auto extract_colref_expressions(const S& impl, const std::tuple<Args...>& cols, std::index_sequence<Idx...>) {
+            return std::tuple_cat(extract_colref_expressions(impl, get<Idx>(cols), std::index_sequence<Idx>{})...);
+        }
+
+        // columns_t<>
+        template<class S, class... Args>
+        auto extract_colref_expressions(const S& impl, const columns_t<Args...>& cols) {
+            return extract_colref_expressions(impl, cols.columns, std::index_sequence_for<Args...>{});
+        }
+
+        // asterisk_t<> -> fields
+        template<class S, class O>
+        auto extract_colref_expressions(const S& impl, const asterisk_t<O>& /*col*/) {
+            using timpl_type = storage_pick_impl_t<S, O>;
+            using elements_t = typename timpl_type::table_type::elements_type;
+            using column_idxs = filter_tuple_sequence_t<elements_t, is_column>;
+
+            auto& tImpl = pick_impl<O>(impl);
+            return get_fields_of_columns(tImpl.table.elements, column_idxs{});
+        }
+
+        template<class S, class E, class... Args>
+        decltype(auto) extract_colref_expressions(const S& /*impl*/,
+                                                  const select_t<E, Args...>& /*subSelect*/) = delete;
+
+        template<typename S, typename SubSelect>
+        using extracted_colref_expressions_t =
+            polyfill::remove_cvref_t<decltype(extract_colref_expressions(std::declval<S>(),
+                                                                         std::declval<SubSelect>().col))>;
+
         template<typename Mapper, typename S, typename CTE, size_t... CIs>
         create_cte_table_t<Mapper, typename Mapper::index_sequence>
         make_cte_table_using_column_indices(const S& impl, const CTE& cte, std::index_sequence<CIs...>) {
-            using O = cte_object_type_t<Mapper>;
             using context_type = serializer_context<S>;
-            context_type context{impl};
+            using cte_type = CTE;
 
+            context_type context{impl};
+            std::string tableName = alias_extractor<cte_label_type_t<cte_type>>::extract(std::true_type{});
+            auto subSelect = get_cte_driving_subselect(cte.subselect);
+            auto colRefs = extract_colref_expressions(impl, subSelect.col);
             std::vector<std::string> columnNames =
-                collect_cte_column_names(get_cte_driving_subselect(cte.subselect), cte.explicitColumnNames, context);
+                collect_cte_column_names(subSelect, cte.explicitColumnNames, context);
 
             return create_cte_table_t<Mapper, typename Mapper::index_sequence>{
-                alias_extractor<cte_label_type_t<CTE>>::extract(std::true_type{}),
-                std::make_tuple(
-                    make_column<>(move(columnNames.at(CIs)), cte_getter_v<O, CIs>, cte_setter_v<O, CIs>)...)};
+                move(tableName),
+                std::make_tuple(create_cte_column<Mapper, CIs>::make_column(move(columnNames.at(CIs)), colRefs)...)};
         }
 
-        template<typename Mapper, typename S, typename CTE>
-        create_cte_table_t<Mapper, typename Mapper::index_sequence> make_cte_table(const S& impl, const CTE& cte) {
-            return make_cte_table_using_column_indices<Mapper>(impl, cte, typename Mapper::index_sequence{});
-        }
-
-        template<typename S, typename... CTEs, size_t Ii>
-        decltype(auto) make_recursive_cte_storage_using_table_indices(const S& impl,
-                                                                      const common_table_expressions<CTEs...>& cte,
-                                                                      std::index_sequence<Ii>) {
-            using cte_type = std::tuple_element_t<Ii, common_table_expressions<CTEs...>>;
+        template<typename S, typename CTE>
+        auto make_cte_table(const S& impl, const CTE& cte) {
+            using cte_type = CTE;
             using subselect_type = cte_driving_subselect_t<expression_type_t<cte_type>>;
             using mapper_type = create_cte_mapper_t<cte_label_type_t<cte_type>,
                                                     column_expression_of_t<S, subselect_type>,
+                                                    extracted_colref_expressions_t<S, subselect_type>,
                                                     column_result_of_t<S, subselect_type>>;
             static_assert(cte_type::explicit_column_count == 0 ||
                               cte_type::explicit_column_count == mapper_type::index_sequence::size(),
                           "Number of explicit columns of common table expression doesn't match the number of columns "
                           "in the subselect.");
 
-            auto tbl = make_cte_table<mapper_type>(impl, get<Ii>(cte));
+            return make_cte_table_using_column_indices<mapper_type>(impl, cte, typename mapper_type::index_sequence{});
+        }
+
+        template<typename S, typename... CTEs, size_t Ii>
+        decltype(auto) make_recursive_cte_storage_using_table_indices(const S& impl,
+                                                                      const common_table_expressions<CTEs...>& cte,
+                                                                      std::index_sequence<Ii>) {
+            auto tbl = make_cte_table(impl, get<Ii>(cte));
 
             return storage_impl_cat(impl, std::move(tbl));
         }
@@ -152,17 +263,7 @@ namespace sqlite_orm {
         decltype(auto) make_recursive_cte_storage_using_table_indices(const S& impl,
                                                                       const common_table_expressions<CTEs...>& cte,
                                                                       std::index_sequence<Ii, Ij, In...>) {
-            using cte_type = std::tuple_element_t<Ii, common_table_expressions<CTEs...>>;
-            using subselect_type = cte_driving_subselect_t<expression_type_t<cte_type>>;
-            using mapper_type = create_cte_mapper_t<cte_label_type_t<cte_type>,
-                                                    column_expression_of_t<S, subselect_type>,
-                                                    column_result_of_t<S, subselect_type>>;
-            static_assert(cte_type::explicit_column_count == 0 ||
-                              cte_type::explicit_column_count == mapper_type::index_sequence::size(),
-                          "Number of explicit columns of common table expression doesn't match the number of columns "
-                          "in the subselect.");
-
-            auto tbl = make_cte_table<mapper_type>(impl, get<Ii>(cte));
+            auto tbl = make_cte_table(impl, get<Ii>(cte));
 
             return make_recursive_cte_storage_using_table_indices(
                 // Because CTEs can depend on their predecessor we recursively pass in a new storage object
diff --git a/dev/cte_types.h b/dev/cte_types.h
index 0e40814a5..5711c49e1 100644
--- a/dev/cte_types.h
+++ b/dev/cte_types.h
@@ -12,46 +12,40 @@ namespace sqlite_orm {
     namespace internal {
 
         /**
-         *  Tuple data structure for CTEs
+         *  Aliased column expression mapped into a CTE, stored as a field in a table column.
          */
-        template<typename Label, typename... Fs>
-        class column_results : fields_t<Fs...> {
-          public:
-            using fields_type = fields_t<Fs...>;
+        template<class A, class F>
+        struct aliased_field {
+            ~aliased_field() = delete;
+            aliased_field(const aliased_field&) = delete;
+            void operator=(const aliased_field&) = delete;
 
-            template<size_t I>
-            decltype(auto) cget() const noexcept {
-                return std::get<I>(polyfill::as_template_base<std::tuple>(*this));
-            }
-            template<size_t I>
-            void set(std::tuple_element_t<I, fields_type> v) noexcept {
-                std::get<I>(polyfill::as_template_base<std::tuple>(*this)) = std::move(v);
-            }
+            F field;
         };
 
         /**
-         *  This class maps an expression of a subselect (basically select_t<>::return_type) to
-         *  a tuple of fields (a column_results<Label, Fields>)
+         *  This class captures an expression of a subselect (basically select_t<>::return_type),
+         *  and is used as a proxy 
          */
-        template<typename Label, typename Expression, typename... Fs>
+        template<typename Label, typename Expression, typename RefExpressions, typename... Fs>
         class subselect_mapper {
           public:
+            subselect_mapper() = delete;
+
             using index_sequence = std::index_sequence_for<Fs...>;
             // this type name is used to detect the mapping from label to object
             using cte_label_type = Label;
-            // this type name is used to detect the mapping from label to object
-            using cte_object_type = column_results<Label, Fs...>;
+            using fields_type = fields_t<Fs...>;
+            // this type name is used to detect the mapping from label to object;
+            // it only exists to satisfy a table_t<>'s requirement to have a object_type typename
+            using cte_object_type = fields_t<Fs...>;
+            // this type captures the expressions forming the columns in a subselect;
+            // it is currently unused, however proves to be useful in compilation errors,
+            // as it simplifies recognizing errors in column expressions
             using expressions_tuple = tuplify_t<Expression>;
+            // this type captures column reference expressions;
+            // those are: member pointers, alias holders
+            using colref_expressions_tuple = tuplify_t<RefExpressions>;
         };
-
-        template<class O, size_t I>
-        SQLITE_ORM_INLINE_VAR auto cte_getter_v = &O::template cget<I>;
-        template<class O, size_t I>
-        SQLITE_ORM_INLINE_VAR auto cte_setter_v = &O::template set<I>;
-
-        template<class O, size_t I>
-        using cte_getter_t = decltype(cte_getter_v<O, I>);
-        template<class O, size_t I>
-        using cte_setter_t = decltype(cte_setter_v<O, I>);
     }
 }
diff --git a/dev/mapped_type_proxy.h b/dev/mapped_type_proxy.h
index 639f1b41b..7410bcd17 100644
--- a/dev/mapped_type_proxy.h
+++ b/dev/mapped_type_proxy.h
@@ -17,7 +17,7 @@ namespace sqlite_orm {
         };
 
         template<class T>
-        struct mapped_type_proxy<T, match_if<std::is_base_of, alias_tag, T>> {
+        struct mapped_type_proxy<T, match_if<is_table_alias, T>> {
             using type = type_t<T>;
         };
     }
diff --git a/dev/member_traits/field_member_traits.h b/dev/member_traits/field_member_traits.h
index 40ec9ca84..9059f3ae1 100644
--- a/dev/member_traits/field_member_traits.h
+++ b/dev/member_traits/field_member_traits.h
@@ -11,7 +11,7 @@ namespace sqlite_orm {
         struct field_member_traits;
 
         template<class O, class F>
-        struct field_member_traits<F O::*, typename std::enable_if<is_field_member_pointer<F O::*>::value>::type> {
+        struct field_member_traits<F O::*, std::enable_if_t<is_field_member_pointer<F O::*>::value>> {
             using object_type = O;
             using field_type = F;
         };
diff --git a/dev/member_traits/is_field_member_pointer.h b/dev/member_traits/is_field_member_pointer.h
index 75135ef65..9c525c449 100644
--- a/dev/member_traits/is_field_member_pointer.h
+++ b/dev/member_traits/is_field_member_pointer.h
@@ -9,9 +9,9 @@ namespace sqlite_orm {
         struct is_field_member_pointer : std::false_type {};
 
         template<class T>
-        struct is_field_member_pointer<T,
-                                       typename std::enable_if<std::is_member_pointer<T>::value &&
-                                                               !std::is_member_function_pointer<T>::value>::type>
+        struct is_field_member_pointer<
+            T,
+            std::enable_if_t<std::is_member_pointer<T>::value && !std::is_member_function_pointer<T>::value>>
             : std::true_type {};
     }
 }
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index ee1f92cfe..8730433cf 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -15,6 +15,7 @@
 #include "ast/where.h"
 #include "ast/group_by.h"
 #include "core_functions.h"
+#include "alias.h"
 
 namespace sqlite_orm {
 
@@ -148,7 +149,7 @@ namespace sqlite_orm {
 
         template<class A>
         struct column_pointer_builder<A, match_if<std::is_base_of, alias_tag, A>> {
-            static_assert(std::is_same<polyfill::detected_t<type_t, A>, A>::value, "`A' must be a mapped table alias");
+            static_assert(is_cte_alias_v<A>, "`A' must be a mapped table alias");
 
             using mapped_type = A;
 
@@ -164,12 +165,12 @@ namespace sqlite_orm {
              *  
              *  Example:
              *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(c_v<&Object::id>)));
+             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
              *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
              *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
              */
             template<class F, satisfies_not<std::is_base_of, alias_tag, F> = true>
-            column_pointer<mapped_type, F> operator()(F field) const {
+            constexpr column_pointer<mapped_type, F> operator()(F field) const {
                 return {std::move(field)};
             }
 
@@ -181,7 +182,7 @@ namespace sqlite_orm {
              *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
              */
             template<class ColAlias, satisfies<std::is_base_of, alias_tag, ColAlias> = true>
-            column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
+            constexpr column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
                 return {{}};
             }
 
@@ -547,7 +548,7 @@ namespace sqlite_orm {
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(cte_1{}->*&Object::id));
      */
     template<class A, class F, internal::satisfies<std::is_base_of, alias_tag, A> = true>
-    auto operator->*(const A& /*tableAlias*/, F field) {
+    constexpr auto operator->*(const A& /*tableAlias*/, F field) {
         return column<A>(std::move(field));
     }
 
@@ -559,7 +560,7 @@ namespace sqlite_orm {
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*0_col));
      */
     template<class A, class F, internal::satisfies<std::is_base_of, alias_tag, A> = true>
-    auto operator->*(const internal::column_pointer_builder<A>&, F field) {
+    constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
         return column<A>(std::move(field));
     }
 
@@ -615,6 +616,16 @@ namespace sqlite_orm {
         return {{std::move(explicitColumnNames)...}};
     }
 
+#if __cplusplus >= 202002L  // C++20 and later
+    template<auto label,
+             class... ColumnNames,
+             std::enable_if_t<polyfill::conjunction_v<std::is_convertible<ColumnNames, std::string>...>, bool> = true>
+    internal::cte_builder<decltype(label), polyfill::index_constant<sizeof...(ColumnNames)>>
+    cte(ColumnNames... explicitColumnNames) {
+        return {{std::move(explicitColumnNames)...}};
+    }
+#endif
+
     // tuple of CTEs
     template<class E, class... Labels, class... Selects, class... nExplicitCols>
     internal::with_t<E, internal::common_table_expression<Labels, Selects, nExplicitCols>...>
diff --git a/dev/statement_binder.h b/dev/statement_binder.h
index a8117ff06..4804f10c0 100644
--- a/dev/statement_binder.h
+++ b/dev/statement_binder.h
@@ -13,6 +13,7 @@
 
 #include "start_macros.h"
 #include "cxx_polyfill.h"
+#include "tuple_helper/tuple_helper.h"
 #include "is_std_ptr.h"
 #include "arithmetic_tag.h"
 #include "xdestroy_handling.h"
@@ -295,36 +296,10 @@ namespace sqlite_orm {
             }
         };
 
-        template<class T, template<class C> class F, class SFINAE = void>
-        struct tuple_filter_single;
-
-        template<class T, template<class C> class F>
-        struct tuple_filter_single<T, F, typename std::enable_if<F<T>::value>::type> {
-            using type = std::tuple<T>;
-        };
-
-        template<class T, template<class C> class F>
-        struct tuple_filter_single<T, F, typename std::enable_if<!F<T>::value>::type> {
-            using type = std::tuple<>;
-        };
-
-        template<class T, template<class C> class F>
-        struct tuple_filter;
-
-        template<class... Args, template<class C> class F>
-        struct tuple_filter<std::tuple<Args...>, F> {
-            using type = typename conc_tuple<typename tuple_filter_single<Args, F>::type...>::type;
-        };
-
-        template<class T>
-        struct bindable_filter_single : tuple_filter_single<T, is_bindable> {};
-
         template<class T>
         struct bindable_filter;
 
         template<class... Args>
-        struct bindable_filter<std::tuple<Args...>> {
-            using type = typename conc_tuple<typename bindable_filter_single<Args>::type...>::type;
-        };
+        struct bindable_filter<std::tuple<Args...>> : tuple_filter<std::tuple<Args...>, is_bindable> {};
     }
 }
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index 84768f8b5..e9256512a 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -786,9 +786,6 @@ namespace sqlite_orm {
             }
         };
 
-        template<class O, class F, F O::*m>
-        struct statement_serializer<ice_t<m>, void> : statement_serializer<typename ice_t<m>::value_type> {};
-
         template<class T, class F>
         struct statement_serializer<column_pointer<T, F>, void> {
             using statement_type = column_pointer<T, F>;
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index f1ac75aae..03b0eb162 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -179,6 +179,7 @@ namespace sqlite_orm {
         /**
          *  Materialize column pointer:
          *  1. by explicit object type and member pointer.
+         *  2. by label type and member pointer.
          */
         template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
         constexpr decltype(auto) materialize_column_pointer(const S&, const column_pointer<O, F>& cp) {
@@ -187,65 +188,80 @@ namespace sqlite_orm {
 
         /**
          *  Materialize column pointer:
-         *  2. by label type and index constant.
+         *  3. by label type and alias_holder<>.
          */
-        template<class Label, size_t I, class S, satisfies<is_storage_impl, S> = true>
+        template<class Label, class ColAlias, class S, satisfies<is_storage_impl, S> = true>
         constexpr decltype(auto) materialize_column_pointer(const S&,
-                                                            const column_pointer<Label, polyfill::index_constant<I>>&) {
+                                                            const column_pointer<Label, alias_holder<ColAlias>>&) {
             using timpl_type = storage_pick_impl_t<S, Label>;
+            using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
 
-            return cte_getter_v<storage_object_type_t<timpl_type>, I>;
+            // filter all column references [`alias_holder<>`]
+            using alias_types_tuple =
+                transform_tuple_t<typename cte_mapper_type::colref_expressions_tuple, alias_type_or_none>;
+
+            // lookup index in alias_types_tuple by Alias
+            constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
+            static_assert(ColIdx != -1, "No such column mapped into the CTE.");
+
+            return &aliased_field<ColAlias, std::tuple_element_t<ColIdx, cte_mapper_type::fields_type>>;
         }
 
         /**
-         *  Materialize column pointer:
-         *  3. by label type and member pointer constant.
+         *  Find column name by:
+         *  1. by explicit object type and member pointer.
+         *  2. by label type and member pointer.
          */
-        template<class Label, class O, class F, F O::*m, class S, satisfies<is_storage_impl, S> = true>
-        constexpr decltype(auto) materialize_column_pointer(const S&, const column_pointer<Label, ice_t<m>>&) {
-            using timpl_type = storage_pick_impl_t<S, Label>;
-            using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
-
-            // lookup index in column expressions tuple by member pointer constant
-            constexpr auto I = tuple_index_of_v<ice_t<m>, typename cte_mapper_type::expressions_tuple>;
-            static_assert(I != -1, "No such column mapped into the CTE.");
-            return cte_getter_v<cte_object_type_t<cte_mapper_type>, I>;
+        template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
+        const std::string* find_column_name(const S& strg, const column_pointer<O, F>& cp) {
+            auto field = materialize_column_pointer(strg, cp);
+            return pick_impl<O>(strg).table.find_column_name(field);
         }
 
-        // as_t::alias_type or nonesuch
-        template<class T>
-        using alias_type_or_none = polyfill::detected<alias_type_t, T>;
-
         /**
-         *  Materialize column pointer:
-         *  4. by label type and alias_holder<>.
+         *  Find column name by:
+         *  3. by label type and alias_holder<>.
          */
-        template<class Label, class Alias, class S, satisfies<is_storage_impl, S> = true>
-        constexpr decltype(auto) materialize_column_pointer(const S&,
-                                                            const column_pointer<Label, alias_holder<Alias>>&) {
+        template<class Label, class ColAlias, class S, satisfies<is_storage_impl, S> = true>
+        constexpr decltype(auto) find_column_name(const S& s, const column_pointer<Label, alias_holder<ColAlias>>&) {
             using timpl_type = storage_pick_impl_t<S, Label>;
             using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
-            // filter all column alias expressions [`as_t<A>`]
+            using elements_t = typename timpl_type::table_type::elements_type;
+            using column_idxs = filter_tuple_sequence_t<elements_t, is_column>;
+
+            // note: even though the columns contain the `[aliased_field<>::*` we perform the lookup using the column references.
+            // filter all column references [`alias_holder<>`]
             using alias_types_tuple =
-                typename tuple_transformer<typename cte_mapper_type::expressions_tuple, alias_type_or_none>::type;
+                transform_tuple_t<typename cte_mapper_type::colref_expressions_tuple, alias_type_or_none>;
 
-            // lookup index in alias_types_tuple by Alias
-            constexpr auto I = tuple_index_of_v<Alias, alias_types_tuple>;
+            // lookup index of ColAlias in alias_types_tuple
+            static constexpr auto I = tuple_index_of_v<ColAlias, alias_types_tuple>;
             static_assert(I != -1, "No such column mapped into the CTE.");
-            return cte_getter_v<cte_object_type_t<cte_mapper_type>, I>;
+
+            // note: we could "materialize" the alias to an `aliased_field<>::*` and use the regular `table_t<>::find_column_name()` mechanism;
+            //       however we have the column index already.
+            // lookup column in table_t<>'s elements
+            constexpr size_t ColIdx = index_sequence_value(I, column_idxs{});
+            auto& timpl = pick_impl<Label>(s);
+            return &std::get<ColIdx>(timpl.table.elements).name;
         }
 
         /**
          *  Find column name by:
-         *  1. by explicit object type and member pointer.
-         *  2. by label type and index constant.
-         *  3. by label type and member pointer constant.
-         *  4. by label type and alias_holder<>.
+         *  4. by label type and index constant.
          */
-        template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
-        const std::string* find_column_name(const S& strg, const column_pointer<O, F>& cp) {
-            auto field = materialize_column_pointer(strg, cp);
-            return pick_impl<O>(strg).table.find_column_name(field);
+        template<class Label, size_t I, class S, satisfies<is_storage_impl, S> = true>
+        constexpr decltype(auto) find_column_name(const S& s,
+                                                  const column_pointer<Label, polyfill::index_constant<I>>&) {
+            using timpl_type = storage_pick_impl_t<S, Label>;
+            using column_idxs = filter_tuple_sequence_t<typename timpl_type::table_type::elements_type, is_column>;
+
+            // lookup column in table_t<>'s elements
+            constexpr size_t ColIdx = index_sequence_value(I, column_idxs{});
+            static_assert(ColIdx < column_idxs{}.size(), "No such column mapped into the CTE.");
+
+            auto& timpl = pick_impl<Label>(s);
+            return &std::get<ColIdx>(timpl.table.elements).name;
         }
     }
 }
diff --git a/dev/storage_traits.h b/dev/storage_traits.h
index 1a5b4e7ff..4e3365a30 100644
--- a/dev/storage_traits.h
+++ b/dev/storage_traits.h
@@ -59,9 +59,9 @@ namespace sqlite_orm {
             template<class O, bool WithoutRowId, class... Args, template<class...> class TransformOp>
             struct table_types<table_t<O, WithoutRowId, Args...>, TransformOp> {
                 using args_tuple = std::tuple<Args...>;
-                using columns_tuple = typename tuple_filter<args_tuple, is_column>::type;
+                using columns_tuple = filter_tuple_t<args_tuple, is_column>;
 
-                using type = typename tuple_transformer<columns_tuple, TransformOp>::type;
+                using type = transform_tuple_t<columns_tuple, TransformOp>;
             };
 
             /**
@@ -165,7 +165,7 @@ namespace sqlite_orm {
             template<class H, class... Ts, class O>
             struct storage_foreign_keys_count_impl<storage_impl<H, Ts...>, O> {
                 static constexpr int value = table_foreign_keys_count<H, O>::value +
-                                                   storage_foreign_keys_count_impl<storage_impl<Ts...>, O>::value;
+                                             storage_foreign_keys_count_impl<storage_impl<Ts...>, O>::value;
             };
 
             /**
diff --git a/dev/table.h b/dev/table.h
index d72716b59..9fd9947bd 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -7,6 +7,7 @@
 
 #include "cxx_polyfill.h"
 #include "type_traits.h"
+#include "member_traits/is_field_member_pointer.h"
 #include "static_magic.h"
 #include "typed_comparator.h"
 #include "tuple_helper/tuple_helper.h"
@@ -193,14 +194,12 @@ namespace sqlite_orm {
              *  Searches column name by class member pointer passed as the first argument.
              *  @return column name or empty string if nothing found.
              */
-            template<class F,
-                     class C,
-                     typename = typename std::enable_if<std::is_member_pointer<F C::*>::value &&
-                                                        !std::is_member_function_pointer<F C::*>::value>::type>
+            template<class F, class C, satisfies<is_field_member_pointer, F C::*> = true>
             const std::string* find_column_name(F C::*m) const {
                 const std::string* res = nullptr;
                 this->template for_each_column_with_field_type<F>([&res, m](auto& c) {
-                    if(c.member_pointer == m) {
+                    // note: need to use compare_any because CTEs map all kind of column references into a column_t
+                    if(compare_any(c.member_pointer, m)) {
                         res = &c.name;
                     }
                 });
@@ -211,9 +210,8 @@ namespace sqlite_orm {
              *  Searches column name by class getter function member pointer passed as first argument.
              *  @return column name or empty string if nothing found.
              */
-            template<class G>
-            const std::string* find_column_name(G getter,
-                                                typename std::enable_if<is_getter<G>::value>::type* = nullptr) const {
+            template<class G, satisfies<is_getter, G> = true>
+            const std::string* find_column_name(G getter) const {
                 const std::string* res = nullptr;
                 using field_type = typename getter_traits<G>::field_type;
                 this->template for_each_column_with_field_type<field_type>([&res, getter](auto& c) {
@@ -228,9 +226,8 @@ namespace sqlite_orm {
              *  Searches column name by class setter function member pointer passed as first argument.
              *  @return column name or empty string if nothing found.
              */
-            template<class S>
-            const std::string* find_column_name(S setter,
-                                                typename std::enable_if<is_setter<S>::value>::type* = nullptr) const {
+            template<class S, satisfies<is_setter, S> = true>
+            const std::string* find_column_name(S setter) const {
                 const std::string* res = nullptr;
                 using field_type = typename setter_traits<S>::field_type;
                 this->template for_each_column_with_field_type<field_type>([&res, setter](auto& c) {
@@ -258,11 +255,7 @@ namespace sqlite_orm {
              *  Counts and returns amount of columns. Skips constraints.
              */
             int count_columns_amount() const {
-                auto res = 0;
-                this->for_each_column([&res](auto&) {
-                    ++res;
-                });
-                return res;
+                return filter_tuple_sequence_t<elements_type, is_column>::size();
             }
 
             /**
diff --git a/dev/table_type.h b/dev/table_type.h
index 0c1e35042..c98cdc9e3 100644
--- a/dev/table_type.h
+++ b/dev/table_type.h
@@ -1,11 +1,11 @@
 #pragma once
 
-#include <type_traits>  //  std::enable_if, std::is_member_pointer, std::is_member_function_pointer
-
+#include "type_traits.h"
 #include "member_traits/getter_traits.h"
 #include "member_traits/setter_traits.h"
 #include "member_traits/is_getter.h"
 #include "member_traits/is_setter.h"
+#include "member_traits/is_field_member_pointer.h"
 
 namespace sqlite_orm {
 
@@ -27,19 +27,17 @@ namespace sqlite_orm {
         struct table_type;
 
         template<class O, class F>
-        struct table_type<F O::*,
-                          typename std::enable_if<std::is_member_pointer<F O::*>::value &&
-                                                  !std::is_member_function_pointer<F O::*>::value>::type> {
+        struct table_type<F O::*, match_if<is_field_member_pointer, F O::*>> {
             using type = O;
         };
 
         template<class T>
-        struct table_type<T, typename std::enable_if<is_getter<T>::value>::type> {
+        struct table_type<T, match_if<is_getter, T>> {
             using type = typename getter_traits<T>::object_type;
         };
 
         template<class T>
-        struct table_type<T, typename std::enable_if<is_setter<T>::value>::type> {
+        struct table_type<T, match_if<is_setter, T>> {
             using type = typename setter_traits<T>::object_type;
         };
 
diff --git a/dev/tuple_helper/tuple_helper.h b/dev/tuple_helper/tuple_helper.h
index b2be8b499..0b88c4563 100644
--- a/dev/tuple_helper/tuple_helper.h
+++ b/dev/tuple_helper/tuple_helper.h
@@ -3,6 +3,7 @@
 #include <cstddef>
 #include <type_traits>  //  std::false_type, std::true_type
 #include <tuple>  //  std::tuple, std::get, std::tuple_element, std::tuple_size
+#include <array>
 
 #include "../static_magic.h"
 
@@ -184,5 +185,49 @@ namespace sqlite_orm {
         struct conc_tuple {
             using type = tuple_cat_t<Args...>;
         };
+
+        template<class T, template<class C> class F>
+        struct tuple_filter;
+
+        template<class... Args, template<class C> class F>
+        struct tuple_filter<std::tuple<Args...>, F>
+            : conc_tuple<std::conditional_t<F<Args>::value, std::tuple<Args>, std::tuple<>>...> {};
+
+        template<class Tpl, template<class C> class F>
+        using filter_tuple_t = typename tuple_filter<Tpl, F>::type;
+
+        /** 
+         *  Get the value of an index_sequence at a specific position.
+         */
+        template<size_t... Idx>
+        SQLITE_ORM_CONSTEVAL size_t index_sequence_value(size_t pos, std::index_sequence<Idx...>) {
+            constexpr std::array<size_t, sizeof...(Idx)> values{Idx...};
+            return values[pos];
+        }
+
+        template<class... Seq>
+        struct concat_idx_seq;
+
+        template<size_t... Idx>
+        struct concat_idx_seq<std::index_sequence<Idx...>> {
+            using type = std::index_sequence<Idx...>;
+        };
+
+        template<size_t... As, size_t... Bs, class... Seq>
+        struct concat_idx_seq<std::index_sequence<As...>, std::index_sequence<Bs...>, Seq...>
+            : concat_idx_seq<std::index_sequence<As..., Bs...>, Seq...> {};
+
+        template<class Tpl, template<class...> class F, class Seq>
+        struct filter_tuple_sequence;
+
+        template<class Tpl, template<class...> class F, size_t... Idx>
+        struct filter_tuple_sequence<Tpl, F, std::index_sequence<Idx...>>
+            : concat_idx_seq<std::conditional_t<F<std::tuple_element_t<Idx, Tpl>>::value,
+                                                std::index_sequence<Idx>,
+                                                std::index_sequence<>>...> {};
+
+        template<class Tpl, template<class...> class F>
+        using filter_tuple_sequence_t =
+            typename filter_tuple_sequence<Tpl, F, std::make_index_sequence<std::tuple_size<Tpl>::value>>::type;
     }
 }
diff --git a/dev/tuple_helper/tuple_transformer.h b/dev/tuple_helper/tuple_transformer.h
index 75a1a6173..a73c4b604 100644
--- a/dev/tuple_helper/tuple_transformer.h
+++ b/dev/tuple_helper/tuple_transformer.h
@@ -18,5 +18,9 @@ namespace sqlite_orm {
         struct tuple_transformer<std::tuple<Args...>, F> {
             using type = std::tuple<typename F<Args>::type...>;
         };
+
+        template<class T, template<class...> class F>
+        using transform_tuple_t = typename tuple_transformer<T, F>::type;
+
     }
 }
diff --git a/dev/type_traits.h b/dev/type_traits.h
index 078bf95b0..45c7271cc 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -33,18 +33,6 @@ namespace sqlite_orm {
         using satisfies_is_specialization_of = std::enable_if_t<polyfill::is_specialization_of_v<T, Primary>, bool>;
     }
 
-    // type traits not quite polyfill, however used throughout the program
-    namespace internal {
-        template<typename T>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_integral_constant_v = false;
-
-        template<typename T, T N>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_integral_constant_v<std::integral_constant<T, N>> = true;
-
-        template<typename T>
-        struct is_integral_constant : polyfill::bool_constant<is_integral_constant_v<T>> {};
-    }
-
     // type name template aliases for syntactic sugar
     namespace internal {
         template<typename T>
@@ -82,6 +70,10 @@ namespace sqlite_orm {
 
         template<class As>
         using alias_type_t = typename As::alias_type;
+
+        // T::alias_type or nonesuch
+        template<class T>
+        using alias_type_or_none = polyfill::detected<alias_type_t, T>;
     }
 
     namespace internal {
@@ -92,9 +84,6 @@ namespace sqlite_orm {
         using fields_t = std::tuple<Fs...>;
 
 #if __cplusplus >= 201703L  // use of C++17 or higher
-        template<auto c>
-        using ice_t = std::integral_constant<decltype(c), c>;
-
         // cudos to OznOg https://stackoverflow.com/a/64606884/279251
         template<class X, class Tuple>
         struct tuple_index_of;
@@ -124,12 +113,4 @@ namespace sqlite_orm {
         template<typename T>
         using tuplify_t = typename tuplify<T>::type;
     }
-
-#if __cplusplus >= 201703L  // use of C++17 or higher
-    /**
-     *  Capture a compile-time value as an integral constant.
-     */
-    template<auto c>
-    inline constexpr internal::ice_t<c> c_v{};
-#endif
 }
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 9f1a09655..37aa9c4c0 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -26,10 +26,17 @@ void all_integers_between(int from, int end) {
         //WITH RECURSIVE
         //    cnt(x) AS(VALUES(1) UNION ALL SELECT x + 1 FROM cnt WHERE x < 1000000)
         //    SELECT x FROM cnt;
-        auto ast = with(cte<cte_1>()(union_all(
-                            select(as<colalias_f>(from)),
-                            select(column<cte_1>->*colalias_f{} + c(1), where(column<cte_1>->*colalias_f{} < end)))),
-                        select(column<cte_1>->*colalias_f{}));
+        auto ast =
+            with(cte<cte_1>()(union_all(select(from),
+                                        select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < end)))),
+                 select(1_ctealias->*1_colalias));
+// alternative
+#if 0
+        auto ast = with(
+            cte<cte_1>()(union_all(select(from >>= colalias_f{}),
+                                   select(1_ctealias->*colalias_f{} + c(1), where(1_ctealias->*colalias_f{} < end)))),
+            select(1_ctealias->*colalias_f{}));
+#endif
 
         string sql = storage.dump(ast);
 
@@ -81,6 +88,7 @@ void all_integers_between(int from, int end) {
         }
         cout << endl;
     }
+
     cout << endl;
 }
 
@@ -104,8 +112,8 @@ void supervisor_chain() {
 
     auto storage = make_storage("",
                                 make_table<Org>("org",
-                                                make_column("name", c_v<&Org::name>, primary_key()),
-                                                make_column("boss", c_v<&Org::boss>),
+                                                make_column("name", &Org::name, primary_key()),
+                                                make_column("boss", &Org::boss),
                                                 foreign_key(&Org::boss).references(&Org::name)));
     storage.sync_schema();
 
@@ -127,11 +135,19 @@ void supervisor_chain() {
         //        WHERE parent.name = chain.boss
         //    )
         //    SELECT name FROM chain;
-        auto ast = with(cte<cte_1>()(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
-                                               select(asterisk<alias_a<Org>>(),
-                                                      where(c(alias_column<alias_a<Org>>(&Org::name)) ==
-                                                            column<cte_1>(c_v<&Org::boss>))))),
-                        select(column<cte_1>(c_v<&Org::name>)));
+#if __cplusplus >= 202002L  // C++20 or later
+        auto ast = with(cte<"chain"_cte>()(union_all(
+                            select(asterisk<Org>(), where(&Org::name == c("Fred"))),
+                            select(asterisk<alias_a<Org>>(),
+                                   where(c(alias_column<alias_a<Org>>(&Org::name)) == "chain"_cte->*&Org::boss)))),
+                        select("chain"_cte->*&Org::name));
+#else
+        auto ast = with(cte<cte_1>()(union_all(
+                            select(asterisk<Org>(), where(&Org::name == c("Fred"))),
+                            select(asterisk<alias_a<Org>>(),
+                                   where(c(alias_column<alias_a<Org>>(&Org::name)) == column<cte_1>->*&Org::boss)))),
+                        select(column<cte_1>->*&Org::name));
+#endif
         string sql = storage.dump(ast);
 
         auto stmt = storage.prepare(ast);
@@ -185,9 +201,18 @@ void works_for_alice() {
         //    )
         //    SELECT avg(height) FROM org
         //    WHERE org.name IN works_for_alice;
-        auto ast = with(
-            cte<cte_1>("n")(union_(select("Alice"), select(&Org::name, where(c(&Org::boss) == column<cte_1>->*0_col)))),
-            select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<cte_1>->*0_col)))));
+#if __cplusplus >= 202002L  // C++20 or later
+        constexpr auto works_for_alice = "works_for_alice"_cte;
+        auto ast =
+            with(cte<works_for_alice>("n")(
+                     union_(select("Alice"), select(&Org::name, where(c(&Org::boss) == works_for_alice->*1_colalias)))),
+                 select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(works_for_alice->*1_colalias)))));
+#else
+        auto ast =
+            with(cte<cte_1>("n")(
+                     union_(select("Alice"), select(&Org::name, where(c(&Org::boss) == column<cte_1>->*1_colalias)))),
+                 select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<cte_1>->*1_colalias)))));
+#endif
 
         //WITH cte_1("n")
         //    AS(
@@ -261,15 +286,30 @@ void family_tree() {
     //    WHERE ancestor_of_alice.name = family.name
     //    AND died IS NULL
     //    ORDER BY born;
-    auto ast =
-        with(make_tuple(cte<cte_1>("name", "parent")(union_(select(columns(c_v<&Family::name>, &Family::mom)),
-                                                            select(columns(&Family::name, &Family::dad)))),
-                        cte<cte_2>("name")(union_all(
-                            select(column<cte_1>->*1_col, where(column<cte_1>(c_v<&Family::name>) == "Alice")),
-                            select(column<cte_1>->*1_col, join<cte_2>(using_(column<cte_1>(c_v<&Family::name>))))))),
-             select(&Family::name,
-                    where(is_equal(column<cte_2>->*0_col, &Family::name) && is_null(&Family::died)),
-                    order_by(&Family::born)));
+#if __cplusplus >= 202002L  // C++20 or later
+    constexpr auto parent_of = "parent_of"_cte;
+    constexpr auto ancestor_of_alice = "ancestor_of_alice"_cte;
+    constexpr auto parent_col = "parent"_col;
+    auto ast = with(
+        make_tuple(cte<parent_of>("name", "parent")(union_(select(columns(&Family::name, &Family::mom >>= parent_col)),
+                                                           select(columns(&Family::name, &Family::dad)))),
+                   cte<ancestor_of_alice>("name")(union_all(
+                       select(parent_of->*parent_col, where(parent_of->*&Family::name == "Alice")),
+                       select(parent_of->*parent_col, join<ancestor_of_alice>(using_(parent_of->*&Family::name)))))),
+        select(&Family::name,
+               where(is_equal(ancestor_of_alice->*parent_col, &Family::name) && is_null(&Family::died)),
+               order_by(&Family::born)));
+#else
+    auto ast = with(
+        make_tuple(cte<cte_1>("name", "parent")(union_(select(columns(&Family::name, &Family::mom >>= colalias_h{})),
+                                                       select(columns(&Family::name, &Family::dad)))),
+                   cte<cte_2>("name")(union_all(
+                       select(column<cte_1>->*colalias_h{}, where(column<cte_1>->*&Family::name == "Alice")),
+                       select(column<cte_1>->*colalias_h{}, join<cte_2>(using_(column<cte_1>->*&Family::name)))))),
+        select(&Family::name,
+               where(is_equal(column<cte_2>->*colalias_h{}, &Family::name) && is_null(&Family::died)),
+               order_by(&Family::born)));
+#endif
 
     //WITH cte_1("name", "parent")
     //    AS(
@@ -363,12 +403,23 @@ void depth_or_breadth_first() {
         //        ORDER BY 2
         //    )
         //    SELECT substr('..........', 1, level * 3) || name FROM under_alice;
+#if __cplusplus >= 202002L  // C++20 or later
+        constexpr auto under_alice = "under_alice"_cte;
+        auto ast =
+            with(cte<under_alice>("name", "level")(
+                     union_all(select(columns("Alice", 0)),
+                               select(columns(&Org::name, under_alice->*2_colalias + c(1)),
+                                      join<under_alice>(on(under_alice->*1_colalias == &Org::boss)),
+                                      order_by(2)))),
+                 select(substr("..........", 1, under_alice->*2_colalias * c(3)) || c(under_alice->*1_colalias)));
+#else
         auto ast =
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
-                                                       select(columns(&Org::name, column<cte_1>->*1_col + c(1)),
-                                                              join<cte_1>(on(c(&Org::boss) == column<cte_1>->*0_col)),
+                                                       select(columns(&Org::name, column<cte_1>->*2_colalias + c(1)),
+                                                              join<cte_1>(on(column<cte_1>->*1_colalias == &Org::boss)),
                                                               order_by(2)))),
-                 select(substr("..........", 1, column<cte_1>->*1_col * c(3)) || c(column<cte_1>->*0_col)));
+                 select(substr("..........", 1, column<cte_1>->*2_colalias * c(3)) || c(column<cte_1>->*1_colalias)));
+#endif
 
         string sql = storage.dump(ast);
 
@@ -393,12 +444,23 @@ void depth_or_breadth_first() {
         //        ORDER BY 2
         //    )
         //    SELECT substr('..........', 1, level * 3) || name FROM under_alice;
+#if __cplusplus >= 202002L  // C++20 or later
+        constexpr auto under_alice = "under_alice"_cte;
+        auto ast =
+            with(cte<under_alice>("name", "level")(
+                     union_all(select(columns("Alice", 0)),
+                               select(columns(&Org::name, under_alice->*2_colalias + c(1)),
+                                      join<under_alice>(on(under_alice->*1_colalias == &Org::boss)),
+                                      order_by(2).desc()))),
+                 select(substr("..........", 1, under_alice->*2_colalias * c(3)) || c(under_alice->*1_colalias)));
+#else
         auto ast =
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
-                                                       select(columns(&Org::name, column<cte_1>->*1_col + c(1)),
-                                                              join<cte_1>(on(c(&Org::boss) == column<cte_1>->*0_col)),
+                                                       select(columns(&Org::name, column<cte_1>->*2_colalias + c(1)),
+                                                              join<cte_1>(on(column<cte_1>->*1_colalias == &Org::boss)),
                                                               order_by(2).desc()))),
-                 select(substr("..........", 1, column<cte_1>->*1_col * c(3)) || c(column<cte_1>->*0_col)));
+                 select(substr("..........", 1, column<cte_1>->*2_colalias * c(3)) || c(column<cte_1>->*1_colalias)));
+#endif
 
         string sql = storage.dump(ast);
 
@@ -415,6 +477,7 @@ void depth_or_breadth_first() {
 }
 
 void apfelmaennchen() {
+#if __cplusplus >= 201703L  // use of C++17 or higher
     auto storage = make_storage("");
 
     //WITH RECURSIVE
@@ -434,33 +497,83 @@ void apfelmaennchen() {
     //        FROM m2 GROUP BY cy
     //    )
     //    SELECT group_concat(rtrim(t), x'0a') FROM a;
-    using cte_xaxis = cte_alias<'x'>;
-    using cte_yaxis = cte_alias<'y'>;
-    using cte_m = cte_alias<'i'>;
-    using cte_m2 = cte_alias<'m'>;
-    using cte_a = cte_alias<'a'>;
+#if __cplusplus >= 202002L  // C++20 or later
+    constexpr auto xaxis = "xaxis"_cte;
+    constexpr auto yaxis = "yaxis"_cte;
+    constexpr auto m = "mi"_cte;
+    constexpr auto m2 = "maxi"_cte;
+    constexpr auto a = "string"_cte;
+    constexpr auto x_col = "x"_col;
+    constexpr auto y_col = "y"_col;
+    constexpr auto iter_col = "iter"_col;
+    constexpr auto cx_col = "cx"_col;
+    constexpr auto cy_col = "cy"_col;
+    constexpr auto t_col = "t"_col;
+    auto ast = with(
+        make_tuple(
+            cte<xaxis>("x")(
+                union_all(select(-2.0 >>= x_col), select(xaxis->*x_col + c(0.05), where(xaxis->*x_col < 1.2)))),
+            cte<yaxis>("y")(
+                union_all(select(-1.0 >>= y_col), select(yaxis->*y_col + c(0.1), where(yaxis->*y_col < 1.0)))),
+            cte<m>("iter", "cx", "cy", "x", "y")(union_all(
+                select(columns(0 >>= iter_col,
+                               xaxis->*x_col >>= cx_col,
+                               yaxis->*y_col >>= cy_col,
+                               0.0 >>= x_col,
+                               0.0 >>= y_col)),
+                select(columns(m->*iter_col + c(1),
+                               m->*cx_col,
+                               m->*cy_col,
+                               m->*x_col * c(m->*x_col) - m->*y_col * c(m->*y_col) + m->*cx_col,
+                               c(2.0) * m->*x_col * m->*y_col + m->*cy_col),
+                       where((m->*x_col * c(m->*x_col) + m->*y_col * c(m->*y_col)) < c(4.0) && m->*iter_col < 28)))),
+            cte<m2>("iter", "cx", "cy")(select(columns(max<>(m->*iter_col) >>= iter_col, m->*cx_col, m->*cy_col),
+                                               group_by(m->*cx_col, m->*cy_col))),
+            cte<a>("t")(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter_col / c(7.0), 4.0), 1), "") >>= t_col,
+                               group_by(m2->*cy_col)))),
+        select(group_concat(rtrim(a->*t_col), "\n")));
+#elif __cplusplus >= 201703L  // C++17 or later
+    using cte_xaxis = decltype(1_ctealias);
+    using cte_yaxis = decltype(2_ctealias);
+    using cte_m = decltype(3_ctealias);
+    using cte_m2 = decltype(4_ctealias);
+    using cte_a = decltype(5_ctealias);
     constexpr cte_xaxis xaxis{};
     constexpr cte_yaxis yaxis{};
     constexpr cte_m m{};
     constexpr cte_m2 m2{};
     constexpr cte_a a{};
+    constexpr internal::column_alias<'x'> x_col;
+    constexpr internal::column_alias<'y'> y_col;
+    constexpr internal::column_alias<'i', 't', 'e', 'r'> iter_col;
+    constexpr internal::column_alias<'c', 'x'> cx_col;
+    constexpr internal::column_alias<'c', 'y'> cy_col;
+    constexpr internal::column_alias<'t'> t_col;
     auto ast = with(
         make_tuple(
-            cte<cte_xaxis>("x")(union_all(select(-2.0), select(xaxis->*0_col + c(0.05), where(xaxis->*0_col < 1.2)))),
-            cte<cte_yaxis>("y")(union_all(select(-1.0), select(yaxis->*0_col + c(0.1), where(yaxis->*0_col < 1.0)))),
+            cte<cte_xaxis>("x")(
+                union_all(select(-2.0 >>= x_col), select(xaxis->*x_col + c(0.05), where(xaxis->*x_col < 1.2)))),
+            cte<cte_yaxis>("y")(
+                union_all(select(-1.0 >>= y_col), select(yaxis->*y_col + c(0.1), where(yaxis->*y_col < 1.0)))),
             cte<cte_m>("iter", "cx", "cy", "x", "y")(union_all(
-                select(columns(0, xaxis->*0_col, yaxis->*0_col, 0.0, 0.0)),
-                select(columns(m->*0_col + c(1),
-                               m->*1_col,
-                               m->*2_col,
-                               m->*3_col * c(m->*3_col) - m->*4_col * c(m->*4_col) + m->*1_col,
-                               c(2.0) * m->*3_col * m->*4_col + m->*2_col),
-                       where((m->*3_col * c(m->*3_col) + m->*4_col * c(m->*4_col)) < c(4.0) && m->*0_col < 28)))),
-            cte<cte_m2>("iter", "cx", "cy")(
-                select(columns(max<>(m->*0_col), m->*1_col, m->*2_col), group_by(m->*1_col, m->*2_col))),
-            cte<cte_a>("t")(select(group_concat(substr(" .+*#", 1 + min<>(m2->*0_col / c(7.0), 4.0), 1), ""),
-                                   group_by(m2->*2_col)))),
-        select(group_concat(rtrim(a->*0_col), "\n")));
+                select(columns(0 >>= iter_col,
+                               xaxis->*x_col >>= cx_col,
+                               yaxis->*y_col >>= cy_col,
+                               0.0 >>= x_col,
+                               0.0 >>= y_col)),
+                select(columns(m->*iter_col + c(1),
+                               m->*cx_col,
+                               m->*cy_col,
+                               m->*x_col * c(m->*x_col) - m->*y_col * c(m->*y_col) + m->*cx_col,
+                               c(2.0) * m->*x_col * m->*y_col + m->*cy_col),
+                       where((m->*x_col * c(m->*x_col) + m->*y_col * c(m->*y_col)) < c(4.0) && m->*iter_col < 28)))),
+            cte<cte_m2>("iter", "cx", "cy")(select(columns(max<>(m->*iter_col) >>= iter_col, m->*cx_col, m->*cy_col),
+                                                   group_by(m->*cx_col, m->*cy_col))),
+            cte<cte_a>("t")(
+                select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter_col / c(7.0), 4.0), 1), "") >>= t_col,
+                       group_by(m2->*cy_col)))),
+        select(group_concat(rtrim(a->*t_col), "\n")));
+#endif
 
     string sql = storage.dump(ast);
 
@@ -472,6 +585,7 @@ void apfelmaennchen() {
         cout << rowString << endl;
     }
     cout << endl;
+#endif
 }
 
 void show_mapping_and_backreferencing() {
@@ -487,6 +601,16 @@ void show_mapping_and_backreferencing() {
     };
 
     auto storage = make_storage("", make_table("object", make_column("id", &Object::id)));
+    storage.sync_schema();
+
+    // map column via integral pointer-to-member into cte,
+    // back-reference via `column_pointer<cte_1, ice_t<>>`
+    {
+        auto ast = with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*&Object::id));
+
+        string sql = storage.dump(ast);
+        auto stmt = storage.prepare(ast);
+    }
 
     // map column via alias_holder into cte,
     // back-reference via `column_pointer<cte_1, alias_holder>`
@@ -530,9 +654,10 @@ void show_mapping_and_backreferencing() {
     // map column via integral pointer-to-member into cte,
     // back-reference via `column_pointer<cte_1, ice_t<>>`
     {
-        auto ast = with(cte<cte_1>("x")(union_all(select(c_v<&Object::id>),
-                                                  select(column<cte_1>(c_v<&Object::id>) + c(1), limit(10)))),
-                        select(column<cte_1>(c_v<&Object::id>)));
+        //auto ast = with(cte<cte_1>("x")(union_all(select(&Object::id),
+        //                                          select(column<cte_1>(&Object::id) + c(1), limit(10)))),
+        //                select(column<cte_1>(&Object::id)));
+        auto ast = with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
 
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index d889e6da1..70a78a5b8 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -221,18 +221,6 @@ namespace sqlite_orm {
         using satisfies_is_specialization_of = std::enable_if_t<polyfill::is_specialization_of_v<T, Primary>, bool>;
     }
 
-    // type traits not quite polyfill, however used throughout the program
-    namespace internal {
-        template<typename T>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_integral_constant_v = false;
-
-        template<typename T, T N>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_integral_constant_v<std::integral_constant<T, N>> = true;
-
-        template<typename T>
-        struct is_integral_constant : polyfill::bool_constant<is_integral_constant_v<T>> {};
-    }
-
     // type name template aliases for syntactic sugar
     namespace internal {
         template<typename T>
@@ -270,6 +258,10 @@ namespace sqlite_orm {
 
         template<class As>
         using alias_type_t = typename As::alias_type;
+
+        // T::alias_type or nonesuch
+        template<class T>
+        using alias_type_or_none = polyfill::detected<alias_type_t, T>;
     }
 
     namespace internal {
@@ -280,9 +272,6 @@ namespace sqlite_orm {
         using fields_t = std::tuple<Fs...>;
 
 #if __cplusplus >= 201703L  // use of C++17 or higher
-        template<auto c>
-        using ice_t = std::integral_constant<decltype(c), c>;
-
         // cudos to OznOg https://stackoverflow.com/a/64606884/279251
         template<class X, class Tuple>
         struct tuple_index_of;
@@ -312,14 +301,6 @@ namespace sqlite_orm {
         template<typename T>
         using tuplify_t = typename tuplify<T>::type;
     }
-
-#if __cplusplus >= 201703L  // use of C++17 or higher
-    /**
-     *  Capture a compile-time value as an integral constant.
-     */
-    template<auto c>
-    inline constexpr internal::ice_t<c> c_v{};
-#endif
 }
 #pragma once
 
@@ -491,6 +472,7 @@ namespace sqlite_orm {
 #include <cstddef>
 #include <type_traits>  //  std::false_type, std::true_type
 #include <tuple>  //  std::tuple, std::get, std::tuple_element, std::tuple_size
+#include <array>
 
 // #include "../static_magic.h"
 
@@ -711,6 +693,50 @@ namespace sqlite_orm {
         struct conc_tuple {
             using type = tuple_cat_t<Args...>;
         };
+
+        template<class T, template<class C> class F>
+        struct tuple_filter;
+
+        template<class... Args, template<class C> class F>
+        struct tuple_filter<std::tuple<Args...>, F>
+            : conc_tuple<std::conditional_t<F<Args>::value, std::tuple<Args>, std::tuple<>>...> {};
+
+        template<class Tpl, template<class C> class F>
+        using filter_tuple_t = typename tuple_filter<Tpl, F>::type;
+
+        /** 
+         *  Get the value of an index_sequence at a specific position.
+         */
+        template<size_t... Idx>
+        SQLITE_ORM_CONSTEVAL size_t index_sequence_value(size_t pos, std::index_sequence<Idx...>) {
+            constexpr std::array<size_t, sizeof...(Idx)> values{Idx...};
+            return values[pos];
+        }
+
+        template<class... Seq>
+        struct concat_idx_seq;
+
+        template<size_t... Idx>
+        struct concat_idx_seq<std::index_sequence<Idx...>> {
+            using type = std::index_sequence<Idx...>;
+        };
+
+        template<size_t... As, size_t... Bs, class... Seq>
+        struct concat_idx_seq<std::index_sequence<As...>, std::index_sequence<Bs...>, Seq...>
+            : concat_idx_seq<std::index_sequence<As..., Bs...>, Seq...> {};
+
+        template<class Tpl, template<class...> class F, class Seq>
+        struct filter_tuple_sequence;
+
+        template<class Tpl, template<class...> class F, size_t... Idx>
+        struct filter_tuple_sequence<Tpl, F, std::index_sequence<Idx...>>
+            : concat_idx_seq<std::conditional_t<F<std::tuple_element_t<Idx, Tpl>>::value,
+                                                std::index_sequence<Idx>,
+                                                std::index_sequence<>>...> {};
+
+        template<class Tpl, template<class...> class F>
+        using filter_tuple_sequence_t =
+            typename filter_tuple_sequence<Tpl, F, std::make_index_sequence<std::tuple_size<Tpl>::value>>::type;
     }
 }
 #pragma once
@@ -760,6 +786,10 @@ namespace sqlite_orm {
         struct tuple_transformer<std::tuple<Args...>, F> {
             using type = std::tuple<typename F<Args>::type...>;
         };
+
+        template<class T, template<class...> class F>
+        using transform_tuple_t = typename tuple_transformer<T, F>::type;
+
     }
 }
 #pragma once
@@ -951,7 +981,7 @@ namespace sqlite_orm {
 
 // #include "table_type.h"
 
-#include <type_traits>  //  std::enable_if, std::is_member_pointer, std::is_member_function_pointer
+// #include "type_traits.h"
 
 // #include "member_traits/getter_traits.h"
 
@@ -1261,6 +1291,24 @@ namespace sqlite_orm {
     }
 }
 
+// #include "member_traits/is_field_member_pointer.h"
+
+#include <type_traits>  //  std::false_type, std::true_type, std::is_member_pointer, std::is_member_function_pointer
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T, class SFINAE = void>
+        struct is_field_member_pointer : std::false_type {};
+
+        template<class T>
+        struct is_field_member_pointer<
+            T,
+            std::enable_if_t<std::is_member_pointer<T>::value && !std::is_member_function_pointer<T>::value>>
+            : std::true_type {};
+    }
+}
+
 namespace sqlite_orm {
 
     namespace internal {
@@ -1281,19 +1329,17 @@ namespace sqlite_orm {
         struct table_type;
 
         template<class O, class F>
-        struct table_type<F O::*,
-                          typename std::enable_if<std::is_member_pointer<F O::*>::value &&
-                                                  !std::is_member_function_pointer<F O::*>::value>::type> {
+        struct table_type<F O::*, match_if<is_field_member_pointer, F O::*>> {
             using type = O;
         };
 
         template<class T>
-        struct table_type<T, typename std::enable_if<is_getter<T>::value>::type> {
+        struct table_type<T, match_if<is_getter, T>> {
             using type = typename getter_traits<T>::object_type;
         };
 
         template<class T>
-        struct table_type<T, typename std::enable_if<is_setter<T>::value>::type> {
+        struct table_type<T, match_if<is_setter, T>> {
             using type = typename setter_traits<T>::object_type;
         };
 
@@ -2206,28 +2252,14 @@ namespace sqlite_orm {
 
 // #include "constraints.h"
 
+// #include "member_traits/is_field_member_pointer.h"
+
 // #include "member_traits/member_traits.h"
 
 #include <type_traits>  //  std::enable_if
 
 // #include "is_field_member_pointer.h"
 
-#include <type_traits>  //  std::false_type, std::true_type, std::is_member_pointer, std::is_member_function_pointer
-
-namespace sqlite_orm {
-    namespace internal {
-
-        template<class T, class SFINAE = void>
-        struct is_field_member_pointer : std::false_type {};
-
-        template<class T>
-        struct is_field_member_pointer<T,
-                                       typename std::enable_if<std::is_member_pointer<T>::value &&
-                                                               !std::is_member_function_pointer<T>::value>::type>
-            : std::true_type {};
-    }
-}
-
 // #include "is_getter.h"
 
 // #include "field_member_traits.h"
@@ -2243,7 +2275,7 @@ namespace sqlite_orm {
         struct field_member_traits;
 
         template<class O, class F>
-        struct field_member_traits<F O::*, typename std::enable_if<is_field_member_pointer<F O::*>::value>::type> {
+        struct field_member_traits<F O::*, std::enable_if_t<is_field_member_pointer<F O::*>::value>> {
             using object_type = O;
             using field_type = F;
         };
@@ -2282,18 +2314,10 @@ namespace sqlite_orm {
     }
 }
 
-// #include "member_traits/field_member_traits.h"
-
 namespace sqlite_orm {
 
     namespace internal {
 
-        /**
-         *  typename T::value_type if is_integral_constant_v<T>
-         */
-        template<typename T>
-        using ice_value_type_t = std::enable_if_t<is_integral_constant_v<T>, value_type_t<T>>;
-
         struct basic_column {
 
             /**
@@ -2311,14 +2335,7 @@ namespace sqlite_orm {
         template<class O, class T, class G /* = const T& (O::*)() const*/, class S /* = void (O::*)(T)*/, class... Op>
         struct column_t : basic_column {
             using object_type = O;
-            // the passed in type is either `integral_constant<F O::*member>` or the return type
-            using _ice_or_field_type = T;
-            // `F O::*` from `integral_constant<F O::*member>` or `T`
-            using _member_pointer_or_field_type = polyfill::detected_or_t<T, ice_value_type_t, T>;
-            // `F` from `F O::*` or `T`
-            using field_type = polyfill::detected_or_t<_member_pointer_or_field_type,
-                                                       field_type_t,
-                                                       field_member_traits<_member_pointer_or_field_type>>;
+            using field_type = T;
             using constraints_type = std::tuple<Op...>;
             using member_pointer_t = field_type object_type::*;
             using getter_type = G;
@@ -2330,7 +2347,7 @@ namespace sqlite_orm {
             member_pointer_t member_pointer /* = nullptr*/;
 
             /**
-             *  Getter member function pointer to get a value. If member_pointer is null than
+             *  Getter member function pointer to get a value. If member_pointer is null then
              *  `getter` and `setter` must be not null
              */
             getter_type getter /* = nullptr*/;
@@ -2469,14 +2486,10 @@ namespace sqlite_orm {
         };
 
         template<class O, class T, class... Op>
-        struct column_field_expression<column_t<O, T, Op...>, match_if_not<is_integral_constant, T>> {
+        struct column_field_expression<column_t<O, T, Op...>, void> {
             using type = typename column_t<O, T, Op...>::member_pointer_t;
         };
 
-        // match `F O::*member`
-        template<class O, class F, F O::*m, class... Op>
-        struct column_field_expression<column_t<O, ice_t<m>, Op...>, void> : ice_t<m> {};
-
         template<class T>
         struct column_constraints_type {
             using type = std::tuple<>;
@@ -2492,10 +2505,7 @@ namespace sqlite_orm {
     /**
      *  Column builder function. You should use it to create columns instead of constructor
      */
-    template<class O,
-             class T,
-             typename = typename std::enable_if<!std::is_member_function_pointer<T O::*>::value>::type,
-             class... Op>
+    template<class O, class T, internal::satisfies<internal::is_field_member_pointer, T O::*> = true, class... Op>
     internal::column_t<O, T, const T& (O::*)() const, void (O::*)(T), Op...>
     make_column(const std::string& name, T O::*m, Op... constraints) {
         static_assert(internal::template constraints_size<Op...>::value == std::tuple_size<std::tuple<Op...>>::value,
@@ -2505,30 +2515,13 @@ namespace sqlite_orm {
         return {name, m, nullptr, nullptr, std::make_tuple(constraints...)};
     }
 
-    /**
-     *  Column builder function. You should use it to create columns instead of constructor
-     */
-    template<class T,
-             T m,
-             class O = typename internal::field_member_traits<T>::object_type,
-             class F = typename internal::field_member_traits<T>::field_type,
-             class... Op>
-    internal::column_t<O, std::integral_constant<T, m>, const F& (O::*)() const, void (O::*)(F), Op...>
-    make_column(const std::string& name, std::integral_constant<T, m>, Op... constraints) {
-        static_assert(internal::template constraints_size<Op...>::value == std::tuple_size<std::tuple<Op...>>::value,
-                      "Incorrect constraints pack");
-        static_assert(internal::is_field_member_pointer<T>::value,
-                      "second argument expected as a member field pointer, not member function pointer");
-        return {name, m, nullptr, nullptr, std::make_tuple(constraints...)};
-    }
-
     /**
      *  Column builder function with setter and getter. You should use it to create columns instead of constructor
      */
     template<class G,
              class S,
-             typename = typename std::enable_if<internal::is_getter<G>::value>::type,
-             typename = typename std::enable_if<internal::is_setter<S>::value>::type,
+             internal::satisfies<internal::is_getter, G> = true,
+             internal::satisfies<internal::is_setter, S> = true,
              class... Op>
     internal::column_t<typename internal::setter_traits<S>::object_type,
                        typename internal::setter_traits<S>::field_type,
@@ -2550,8 +2543,8 @@ namespace sqlite_orm {
      */
     template<class G,
              class S,
-             typename = typename std::enable_if<internal::is_getter<G>::value>::type,
-             typename = typename std::enable_if<internal::is_setter<S>::value>::type,
+             internal::satisfies<internal::is_getter, G> = true,
+             internal::satisfies<internal::is_setter, S> = true,
              class... Op>
     internal::column_t<typename internal::setter_traits<S>::object_type,
                        typename internal::setter_traits<S>::field_type,
@@ -3942,21 +3935,49 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
+#if __cplusplus >= 202002L  // C++20 and later
+    template<auto als, class O>
+    internal::left_join_t<decltype(als), O> left_join(O o) {
+        return {std::move(o)};
+    }
+#endif
+
     template<class T, class O>
     internal::join_t<T, O> join(O o) {
         return {std::move(o)};
     }
 
+#if __cplusplus >= 202002L  // C++20 and later
+    template<auto als, class O>
+    internal::join_t<decltype(als), O> join(O o) {
+        return {std::move(o)};
+    }
+#endif
+
     template<class T, class O>
     internal::left_outer_join_t<T, O> left_outer_join(O o) {
         return {std::move(o)};
     }
 
+#if __cplusplus >= 202002L  // C++20 and later
+    template<auto als, class O>
+    internal::left_outer_join_t<decltype(als), O> left_outer_join(O o) {
+        return {std::move(o)};
+    }
+#endif
+
     template<class T, class O>
     internal::inner_join_t<T, O> inner_join(O o) {
         return {std::move(o)};
     }
 
+#if __cplusplus >= 202002L  // C++20 and later
+    template<auto als, class O>
+    internal::inner_join_t<decltype(als), O> inner_join(O o) {
+        return {std::move(o)};
+    }
+#endif
+
     template<class T>
     internal::offset_t<T> offset(T off) {
         return {std::move(off)};
@@ -4210,6 +4231,8 @@ namespace sqlite_orm {
 #include <sstream>  //  std::stringstream
 #include <string>  //  std::string
 
+// #include "cxx_polyfill.h"
+
 // #include "static_magic.h"
 
 namespace sqlite_orm {
@@ -4220,18 +4243,65 @@ namespace sqlite_orm {
      */
     struct alias_tag {};
 
+    namespace internal {
+
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_column_alias_v = std::is_base_of<alias_tag, A>::value;
+
+        template<class A>
+        using is_column_alias = polyfill::bool_constant<is_column_alias_v<A>>;
+
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_table_alias_v =
+            polyfill::conjunction_v<std::is_base_of<alias_tag, A>, polyfill::is_detected<type_t, A>>;
+
+        template<class A>
+        using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
+
+        /** 
+         *  A CTE alias is a specialization of a table alias, which is both, a storage lookup type (mapping type) and an alias.
+         */
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_cte_alias_v =
+            polyfill::conjunction_v<std::is_base_of<alias_tag, A>, std::is_same<polyfill::detected_t<type_t, A>, A>>;
+
+        template<class A>
+        using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
+
+#if __cplusplus >= 202002L  // C++20 and later
+        /*  
+         *  Helper class to facilitate user-defined string literal operator template
+         */
+        template<size_t N>
+        struct string_identifier_template {
+            static constexpr size_t size() {
+                return N - 1;
+            }
+
+            constexpr string_identifier_template(const char (&id)[N]) : id{id} {}
+
+            const char (&id)[N];
+        };
+
+        template<template<char...> class Alias, string_identifier_template t, size_t... Idx>
+        SQLITE_ORM_CONSTEVAL auto to_alias(std::index_sequence<Idx...>) {
+            return Alias<t.id[Idx]...>{};
+        }
+#endif
+    }
+
     namespace internal {
 
         /**
          *  This is a common built-in class used for custom single character table aliases.
-         *  For convenience there exist type aliases `alias_a`, `alias_b`, ...
+         *  For convenience there exist public type aliases `alias_a`, `alias_b`, ...
          */
-        template<class T, char A>
+        template<class T, char A, char... X>
         struct table_alias : alias_tag {
             using type = T;
 
-            constexpr static char get() {
-                return A;
+            constexpr static std::string get() {
+                return {A, X...};
             }
         };
 
@@ -4251,13 +4321,17 @@ namespace sqlite_orm {
         };
 
         template<class T, class SFINAE = void>
-        struct alias_extractor;
+        struct alias_extractor {
+            static std::string extract() {
+                return {};
+            }
+        };
 
         template<class A>
         struct alias_extractor<A, match_if<std::is_base_of, alias_tag, A>> {
-            template<bool always = !std::is_same<polyfill::detected_t<type_t, A>, A>::value>
-            static std::string extract(polyfill::bool_constant<always> = {}) {
-                return static_if<always>(
+            template<bool yes = !is_cte_alias_v<A>>
+            static std::string extract(polyfill::bool_constant<yes> = {}) {
+                return static_if<yes>(
                     []() {
                         std::stringstream ss;
                         ss << A::get();
@@ -4269,13 +4343,6 @@ namespace sqlite_orm {
             }
         };
 
-        template<class T>
-        struct alias_extractor<T, match_if_not<std::is_base_of, alias_tag, T>> {
-            static std::string extract() {
-                return {};
-            }
-        };
-
         /**
          * Used to store alias for expression
          */
@@ -4291,17 +4358,28 @@ namespace sqlite_orm {
          *  This is a common built-in class used for custom single-character column aliases.
          *  For convenience there exist type aliases `colalias_a`, `colalias_b`, ...
          */
-        template<char A>
+        template<char A, char... X>
         struct column_alias : alias_tag {
             static std::string get() {
-                return std::string(1u, A);
+                return {A, X...};
             }
         };
 
         template<class T>
         struct alias_holder {
             using type = T;
+            using alias_type = type;
         };
+
+        template<size_t n, char... C>
+        SQLITE_ORM_CONSTEVAL auto n_to_colalias() {
+            constexpr column_alias<'1' + n % 10, C...> colalias{};
+            if constexpr(n > 10) {
+                return n_to_colalias<n / 10, '1' + n % 10, C...>();
+            } else {
+                return colalias;
+            }
+        }
     }
 
     /**
@@ -4315,8 +4393,34 @@ namespace sqlite_orm {
         return {c};
     }
 
-    template<class T, class E>
-    internal::as_t<T, E> as(E expression) {
+    /** 
+     *  Alias a column expression.
+     */
+    template<class A, class E>
+    internal::as_t<A, E> as(E expression) {
+        return {std::move(expression)};
+    }
+
+#if __cplusplus >= 202002L  // C++20 and later
+    template<auto als, class E>
+    internal::as_t<decltype(als), E> as(E expression) {
+        return {std::move(expression)};
+    }
+#endif
+
+    /** 
+     *  Alias a column expression.
+     */
+    template<class A, class E, internal::satisfies<internal::is_column_alias, A> = true>
+    internal::as_t<A, E> operator>>=(E expression, const A&) {
+        return {std::move(expression)};
+    }
+
+    /** 
+     *  Alias a column expression.
+     */
+    template<class A, class E, internal::satisfies<internal::is_column_alias, A> = true>
+    internal::as_t<A, E> operator|=(E expression, const A&) {
         return {std::move(expression)};
     }
 
@@ -4387,6 +4491,31 @@ namespace sqlite_orm {
     using colalias_g = internal::column_alias<'g'>;
     using colalias_h = internal::column_alias<'h'>;
     using colalias_i = internal::column_alias<'i'>;
+
+#if __cplusplus >= 201703L  // use of C++17 or higher
+    /**
+     *  column_alias<'1'[, ...]> from a numeric literal.
+     *  E.g. 1_colalias, 2_colalias
+     */
+    template<char... Chars>
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _colalias() {
+        // numeric identifiers are used for automatically assigning implicit aliases to unaliased column expressions,
+        // which start at "1".
+        static_assert(std::array{Chars...}[0] > '0');
+        return internal::column_alias<Chars...>{};
+    }
+
+#if __cplusplus >= 202002L  // C++20 and later
+    /**
+     *  column_alias<'a'[, ...]> from a string literal.
+     *  E.g. "a"_col, "b"_col
+     */
+    template<internal::string_identifier_template t>
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _col() {
+        return internal::to_alias<internal::column_alias, t>(std::make_index_sequence<t.size()>{});
+    }
+#endif
+#endif
 }
 #pragma once
 
@@ -6762,6 +6891,8 @@ namespace sqlite_orm {
 
 // #include "core_functions.h"
 
+// #include "alias.h"
+
 namespace sqlite_orm {
 
     namespace internal {
@@ -6894,7 +7025,7 @@ namespace sqlite_orm {
 
         template<class A>
         struct column_pointer_builder<A, match_if<std::is_base_of, alias_tag, A>> {
-            static_assert(std::is_same<polyfill::detected_t<type_t, A>, A>::value, "`A' must be a mapped table alias");
+            static_assert(is_cte_alias_v<A>, "`A' must be a mapped table alias");
 
             using mapped_type = A;
 
@@ -6910,12 +7041,12 @@ namespace sqlite_orm {
              *  
              *  Example:
              *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(c_v<&Object::id>)));
+             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
              *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
              *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
              */
             template<class F, satisfies_not<std::is_base_of, alias_tag, F> = true>
-            column_pointer<mapped_type, F> operator()(F field) const {
+            constexpr column_pointer<mapped_type, F> operator()(F field) const {
                 return {std::move(field)};
             }
 
@@ -6927,7 +7058,7 @@ namespace sqlite_orm {
              *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
              */
             template<class ColAlias, satisfies<std::is_base_of, alias_tag, ColAlias> = true>
-            column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
+            constexpr column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
                 return {{}};
             }
 
@@ -7293,7 +7424,7 @@ namespace sqlite_orm {
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(cte_1{}->*&Object::id));
      */
     template<class A, class F, internal::satisfies<std::is_base_of, alias_tag, A> = true>
-    auto operator->*(const A& /*tableAlias*/, F field) {
+    constexpr auto operator->*(const A& /*tableAlias*/, F field) {
         return column<A>(std::move(field));
     }
 
@@ -7305,7 +7436,7 @@ namespace sqlite_orm {
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*0_col));
      */
     template<class A, class F, internal::satisfies<std::is_base_of, alias_tag, A> = true>
-    auto operator->*(const internal::column_pointer_builder<A>&, F field) {
+    constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
         return column<A>(std::move(field));
     }
 
@@ -7361,6 +7492,16 @@ namespace sqlite_orm {
         return {{std::move(explicitColumnNames)...}};
     }
 
+#if __cplusplus >= 202002L  // C++20 and later
+    template<auto label,
+             class... ColumnNames,
+             std::enable_if_t<polyfill::conjunction_v<std::is_convertible<ColumnNames, std::string>...>, bool> = true>
+    internal::cte_builder<decltype(label), polyfill::index_constant<sizeof...(ColumnNames)>>
+    cte(ColumnNames... explicitColumnNames) {
+        return {{std::move(explicitColumnNames)...}};
+    }
+#endif
+
     // tuple of CTEs
     template<class E, class... Labels, class... Selects, class... nExplicitCols>
     internal::with_t<E, internal::common_table_expression<Labels, Selects, nExplicitCols>...>
@@ -8186,6 +8327,8 @@ namespace sqlite_orm {
 
 // #include "cxx_polyfill.h"
 
+// #include "tuple_helper/tuple_helper.h"
+
 // #include "is_std_ptr.h"
 
 // #include "arithmetic_tag.h"
@@ -8471,37 +8614,11 @@ namespace sqlite_orm {
             }
         };
 
-        template<class T, template<class C> class F, class SFINAE = void>
-        struct tuple_filter_single;
-
-        template<class T, template<class C> class F>
-        struct tuple_filter_single<T, F, typename std::enable_if<F<T>::value>::type> {
-            using type = std::tuple<T>;
-        };
-
-        template<class T, template<class C> class F>
-        struct tuple_filter_single<T, F, typename std::enable_if<!F<T>::value>::type> {
-            using type = std::tuple<>;
-        };
-
-        template<class T, template<class C> class F>
-        struct tuple_filter;
-
-        template<class... Args, template<class C> class F>
-        struct tuple_filter<std::tuple<Args...>, F> {
-            using type = typename conc_tuple<typename tuple_filter_single<Args, F>::type...>::type;
-        };
-
-        template<class T>
-        struct bindable_filter_single : tuple_filter_single<T, is_bindable> {};
-
         template<class T>
         struct bindable_filter;
 
         template<class... Args>
-        struct bindable_filter<std::tuple<Args...>> {
-            using type = typename conc_tuple<typename bindable_filter_single<Args>::type...>::type;
-        };
+        struct bindable_filter<std::tuple<Args...>> : tuple_filter<std::tuple<Args...>, is_bindable> {};
     }
 }
 #pragma once
@@ -9209,7 +9326,7 @@ namespace sqlite_orm {
         };
 
         template<class T>
-        struct mapped_type_proxy<T, match_if<std::is_base_of, alias_tag, T>> {
+        struct mapped_type_proxy<T, match_if<is_table_alias, T>> {
             using type = type_t<T>;
         };
     }
@@ -9293,6 +9410,8 @@ namespace sqlite_orm {
 
 // #include "type_traits.h"
 
+// #include "member_traits/is_field_member_pointer.h"
+
 // #include "core_functions.h"
 
 // #include "select_constraints.h"
@@ -9319,47 +9438,41 @@ namespace sqlite_orm {
     namespace internal {
 
         /**
-         *  Tuple data structure for CTEs
+         *  Aliased column expression mapped into a CTE, stored as a field in a table column.
          */
-        template<typename Label, typename... Fs>
-        class column_results : fields_t<Fs...> {
-          public:
-            using fields_type = fields_t<Fs...>;
+        template<class A, class F>
+        struct aliased_field {
+            ~aliased_field() = delete;
+            aliased_field(const aliased_field&) = delete;
+            void operator=(const aliased_field&) = delete;
 
-            template<size_t I>
-            decltype(auto) cget() const noexcept {
-                return std::get<I>(polyfill::as_template_base<std::tuple>(*this));
-            }
-            template<size_t I>
-            void set(std::tuple_element_t<I, fields_type> v) noexcept {
-                std::get<I>(polyfill::as_template_base<std::tuple>(*this)) = std::move(v);
-            }
+            F field;
         };
 
         /**
-         *  This class maps an expression of a subselect (basically select_t<>::return_type) to
-         *  a tuple of fields (a column_results<Label, Fields>)
+         *  This class captures an expression of a subselect (basically select_t<>::return_type),
+         *  and is used as a proxy 
          */
-        template<typename Label, typename Expression, typename... Fs>
+        template<typename Label, typename Expression, typename RefExpressions, typename... Fs>
         class subselect_mapper {
           public:
+            subselect_mapper() = delete;
+
             using index_sequence = std::index_sequence_for<Fs...>;
             // this type name is used to detect the mapping from label to object
             using cte_label_type = Label;
-            // this type name is used to detect the mapping from label to object
-            using cte_object_type = column_results<Label, Fs...>;
+            using fields_type = fields_t<Fs...>;
+            // this type name is used to detect the mapping from label to object;
+            // it only exists to satisfy a table_t<>'s requirement to have a object_type typename
+            using cte_object_type = fields_t<Fs...>;
+            // this type captures the expressions forming the columns in a subselect;
+            // it is currently unused, however proves to be useful in compilation errors,
+            // as it simplifies recognizing errors in column expressions
             using expressions_tuple = tuplify_t<Expression>;
+            // this type captures column reference expressions;
+            // those are: member pointers, alias holders
+            using colref_expressions_tuple = tuplify_t<RefExpressions>;
         };
-
-        template<class O, size_t I>
-        SQLITE_ORM_INLINE_VAR auto cte_getter_v = &O::template cget<I>;
-        template<class O, size_t I>
-        SQLITE_ORM_INLINE_VAR auto cte_setter_v = &O::template set<I>;
-
-        template<class O, size_t I>
-        using cte_getter_t = decltype(cte_getter_v<O, I>);
-        template<class O, size_t I>
-        using cte_setter_t = decltype(cte_setter_v<O, I>);
     }
 }
 
@@ -9640,9 +9753,9 @@ namespace sqlite_orm {
             template<class O, bool WithoutRowId, class... Args, template<class...> class TransformOp>
             struct table_types<table_t<O, WithoutRowId, Args...>, TransformOp> {
                 using args_tuple = std::tuple<Args...>;
-                using columns_tuple = typename tuple_filter<args_tuple, is_column>::type;
+                using columns_tuple = filter_tuple_t<args_tuple, is_column>;
 
-                using type = typename tuple_transformer<columns_tuple, TransformOp>::type;
+                using type = transform_tuple_t<columns_tuple, TransformOp>;
             };
 
             /**
@@ -10235,15 +10348,7 @@ namespace sqlite_orm {
 #endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
 
         template<class St, class O, class F>
-        struct column_result_t<St,
-                               F O::*,
-                               std::enable_if_t<std::is_member_pointer<F O::*>::value &&
-                                                !std::is_member_function_pointer<F O::*>::value>> {
-            using type = F;
-        };
-
-        template<class St, class O, class F, F O::*m>
-        struct column_result_t<St, ice_t<m>, void> {
+        struct column_result_t<St, F O::*, match_if<is_field_member_pointer, F O::*>> {
             using type = F;
         };
 
@@ -10414,48 +10519,20 @@ namespace sqlite_orm {
         template<class St, class T, class F>
         struct column_result_t<St, column_pointer<T, F>, void> : column_result_t<St, F> {};
 
-        template<class St, class Label, size_t I>
-        struct column_result_t<St, column_pointer<Label, polyfill::index_constant<I>>, void>
-            : column_result_t<St, cte_getter_t<storage_object_type_t<storage_pick_impl_t<St, Label>>, I>> {};
-
-        /**
-         *  Obtain result type from member pointer constant mapped into a CTE.
-         * 
-         *  Note: Even though we actually know the member's type we don't assume anything
-         *  and perform a lookup, such that we ensure that the member pointer has been mapped.
-         */
-        template<class St, class Label, class O, class F, F O::*m>
-        struct column_result_t<St, column_pointer<Label, ice_t<m>>, void> {
+        template<class St, class Label, class ColAlias>
+        struct column_result_t<St, column_pointer<Label, alias_holder<ColAlias>>, void> {
             using timpl_type = storage_pick_impl_t<St, Label>;
             using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
 
-            // lookup index in expressions_tuple by member pointer constant
-            static constexpr auto I = tuple_index_of_v<ice_t<m>, typename cte_mapper_type::expressions_tuple>;
-            static_assert(I != -1, "No such column mapped into the CTE.");
-
-            using type = column_result_of_t<St, cte_getter_t<storage_object_type_t<timpl_type>, I>>;
-        };
-
-        // as_t::alias_type or nonesuch
-        template<class T>
-        using alias_type_or_none = polyfill::detected<alias_type_t, T>;
-
-        /**
-         *  Obtain result type from aliased column mapped into a CTE.
-         */
-        template<class St, class Label, class Alias>
-        struct column_result_t<St, column_pointer<Label, alias_holder<Alias>>, void> {
-            using timpl_type = storage_pick_impl_t<St, Label>;
-            using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
-            // filter all column alias expressions [`as_t<A>`]
+            // filter all column references [`alias_holder<>`]
             using alias_types_tuple =
-                typename tuple_transformer<typename cte_mapper_type::expressions_tuple, alias_type_or_none>::type;
+                transform_tuple_t<typename cte_mapper_type::colref_expressions_tuple, alias_type_or_none>;
 
-            // lookup index in alias_types_tuple by Alias
-            static constexpr auto I = tuple_index_of_v<Alias, alias_types_tuple>;
-            static_assert(I != -1, "No such column mapped into the CTE.");
+            // lookup index of ColAlias in alias_types_tuple
+            static constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
+            static_assert(ColIdx != -1, "No such column mapped into the CTE.");
 
-            using type = column_result_of_t<St, cte_getter_t<storage_object_type_t<timpl_type>, I>>;
+            using type = std::tuple_element_t<ColIdx, typename cte_mapper_type::fields_type>;
         };
 
         template<class St, class... Args>
@@ -10507,12 +10584,12 @@ namespace sqlite_orm {
         struct column_result_t<St, as_t<T, E>, void> : column_result_t<St, std::decay_t<E>> {};
 
         template<class St, class T>
-        struct column_result_t<St, asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>> {
+        struct column_result_t<St, asterisk_t<T>, match_if_not<is_column_alias, T>> {
             using type = typename storage_traits::storage_mapped_columns<St, T>::type;
         };
 
         template<class St, class A>
-        struct column_result_t<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>> {
+        struct column_result_t<St, asterisk_t<A>, match_if<is_column_alias, A>> {
             using type = typename storage_traits::storage_mapped_columns<St, type_t<A>>::type;
         };
 
@@ -10561,6 +10638,8 @@ namespace sqlite_orm {
 
 // #include "type_traits.h"
 
+// #include "member_traits/is_field_member_pointer.h"
+
 // #include "static_magic.h"
 
 // #include "typed_comparator.h"
@@ -10752,14 +10831,12 @@ namespace sqlite_orm {
              *  Searches column name by class member pointer passed as the first argument.
              *  @return column name or empty string if nothing found.
              */
-            template<class F,
-                     class C,
-                     typename = typename std::enable_if<std::is_member_pointer<F C::*>::value &&
-                                                        !std::is_member_function_pointer<F C::*>::value>::type>
+            template<class F, class C, satisfies<is_field_member_pointer, F C::*> = true>
             const std::string* find_column_name(F C::*m) const {
                 const std::string* res = nullptr;
                 this->template for_each_column_with_field_type<F>([&res, m](auto& c) {
-                    if(c.member_pointer == m) {
+                    // note: need to use compare_any because CTEs map all kind of column references into a column_t
+                    if(compare_any(c.member_pointer, m)) {
                         res = &c.name;
                     }
                 });
@@ -10770,9 +10847,8 @@ namespace sqlite_orm {
              *  Searches column name by class getter function member pointer passed as first argument.
              *  @return column name or empty string if nothing found.
              */
-            template<class G>
-            const std::string* find_column_name(G getter,
-                                                typename std::enable_if<is_getter<G>::value>::type* = nullptr) const {
+            template<class G, satisfies<is_getter, G> = true>
+            const std::string* find_column_name(G getter) const {
                 const std::string* res = nullptr;
                 using field_type = typename getter_traits<G>::field_type;
                 this->template for_each_column_with_field_type<field_type>([&res, getter](auto& c) {
@@ -10787,9 +10863,8 @@ namespace sqlite_orm {
              *  Searches column name by class setter function member pointer passed as first argument.
              *  @return column name or empty string if nothing found.
              */
-            template<class S>
-            const std::string* find_column_name(S setter,
-                                                typename std::enable_if<is_setter<S>::value>::type* = nullptr) const {
+            template<class S, satisfies<is_setter, S> = true>
+            const std::string* find_column_name(S setter) const {
                 const std::string* res = nullptr;
                 using field_type = typename setter_traits<S>::field_type;
                 this->template for_each_column_with_field_type<field_type>([&res, setter](auto& c) {
@@ -10817,11 +10892,7 @@ namespace sqlite_orm {
              *  Counts and returns amount of columns. Skips constraints.
              */
             int count_columns_amount() const {
-                auto res = 0;
-                this->for_each_column([&res](auto&) {
-                    ++res;
-                });
-                return res;
+                return filter_tuple_sequence_t<elements_type, is_column>::size();
             }
 
             /**
@@ -11077,6 +11148,7 @@ namespace sqlite_orm {
         /**
          *  Materialize column pointer:
          *  1. by explicit object type and member pointer.
+         *  2. by label type and member pointer.
          */
         template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
         constexpr decltype(auto) materialize_column_pointer(const S&, const column_pointer<O, F>& cp) {
@@ -11085,65 +11157,80 @@ namespace sqlite_orm {
 
         /**
          *  Materialize column pointer:
-         *  2. by label type and index constant.
+         *  3. by label type and alias_holder<>.
          */
-        template<class Label, size_t I, class S, satisfies<is_storage_impl, S> = true>
+        template<class Label, class ColAlias, class S, satisfies<is_storage_impl, S> = true>
         constexpr decltype(auto) materialize_column_pointer(const S&,
-                                                            const column_pointer<Label, polyfill::index_constant<I>>&) {
+                                                            const column_pointer<Label, alias_holder<ColAlias>>&) {
             using timpl_type = storage_pick_impl_t<S, Label>;
+            using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
+
+            // filter all column references [`alias_holder<>`]
+            using alias_types_tuple =
+                transform_tuple_t<typename cte_mapper_type::colref_expressions_tuple, alias_type_or_none>;
 
-            return cte_getter_v<storage_object_type_t<timpl_type>, I>;
+            // lookup index in alias_types_tuple by Alias
+            constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
+            static_assert(ColIdx != -1, "No such column mapped into the CTE.");
+
+            return &aliased_field<ColAlias, std::tuple_element_t<ColIdx, cte_mapper_type::fields_type>>;
         }
 
         /**
-         *  Materialize column pointer:
-         *  3. by label type and member pointer constant.
+         *  Find column name by:
+         *  1. by explicit object type and member pointer.
+         *  2. by label type and member pointer.
          */
-        template<class Label, class O, class F, F O::*m, class S, satisfies<is_storage_impl, S> = true>
-        constexpr decltype(auto) materialize_column_pointer(const S&, const column_pointer<Label, ice_t<m>>&) {
-            using timpl_type = storage_pick_impl_t<S, Label>;
-            using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
-
-            // lookup index in column expressions tuple by member pointer constant
-            constexpr auto I = tuple_index_of_v<ice_t<m>, typename cte_mapper_type::expressions_tuple>;
-            static_assert(I != -1, "No such column mapped into the CTE.");
-            return cte_getter_v<cte_object_type_t<cte_mapper_type>, I>;
+        template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
+        const std::string* find_column_name(const S& strg, const column_pointer<O, F>& cp) {
+            auto field = materialize_column_pointer(strg, cp);
+            return pick_impl<O>(strg).table.find_column_name(field);
         }
 
-        // as_t::alias_type or nonesuch
-        template<class T>
-        using alias_type_or_none = polyfill::detected<alias_type_t, T>;
-
         /**
-         *  Materialize column pointer:
-         *  4. by label type and alias_holder<>.
+         *  Find column name by:
+         *  3. by label type and alias_holder<>.
          */
-        template<class Label, class Alias, class S, satisfies<is_storage_impl, S> = true>
-        constexpr decltype(auto) materialize_column_pointer(const S&,
-                                                            const column_pointer<Label, alias_holder<Alias>>&) {
+        template<class Label, class ColAlias, class S, satisfies<is_storage_impl, S> = true>
+        constexpr decltype(auto) find_column_name(const S& s, const column_pointer<Label, alias_holder<ColAlias>>&) {
             using timpl_type = storage_pick_impl_t<S, Label>;
             using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
-            // filter all column alias expressions [`as_t<A>`]
+            using elements_t = typename timpl_type::table_type::elements_type;
+            using column_idxs = filter_tuple_sequence_t<elements_t, is_column>;
+
+            // note: even though the columns contain the `[aliased_field<>::*` we perform the lookup using the column references.
+            // filter all column references [`alias_holder<>`]
             using alias_types_tuple =
-                typename tuple_transformer<typename cte_mapper_type::expressions_tuple, alias_type_or_none>::type;
+                transform_tuple_t<typename cte_mapper_type::colref_expressions_tuple, alias_type_or_none>;
 
-            // lookup index in alias_types_tuple by Alias
-            constexpr auto I = tuple_index_of_v<Alias, alias_types_tuple>;
+            // lookup index of ColAlias in alias_types_tuple
+            static constexpr auto I = tuple_index_of_v<ColAlias, alias_types_tuple>;
             static_assert(I != -1, "No such column mapped into the CTE.");
-            return cte_getter_v<cte_object_type_t<cte_mapper_type>, I>;
+
+            // note: we could "materialize" the alias to an `aliased_field<>::*` and use the regular `table_t<>::find_column_name()` mechanism;
+            //       however we have the column index already.
+            // lookup column in table_t<>'s elements
+            constexpr size_t ColIdx = index_sequence_value(I, column_idxs{});
+            auto& timpl = pick_impl<Label>(s);
+            return &std::get<ColIdx>(timpl.table.elements).name;
         }
 
         /**
          *  Find column name by:
-         *  1. by explicit object type and member pointer.
-         *  2. by label type and index constant.
-         *  3. by label type and member pointer constant.
-         *  4. by label type and alias_holder<>.
+         *  4. by label type and index constant.
          */
-        template<class O, class F, class S, satisfies<is_storage_impl, S> = true>
-        const std::string* find_column_name(const S& strg, const column_pointer<O, F>& cp) {
-            auto field = materialize_column_pointer(strg, cp);
-            return pick_impl<O>(strg).table.find_column_name(field);
+        template<class Label, size_t I, class S, satisfies<is_storage_impl, S> = true>
+        constexpr decltype(auto) find_column_name(const S& s,
+                                                  const column_pointer<Label, polyfill::index_constant<I>>&) {
+            using timpl_type = storage_pick_impl_t<S, Label>;
+            using column_idxs = filter_tuple_sequence_t<typename timpl_type::table_type::elements_type, is_column>;
+
+            // lookup column in table_t<>'s elements
+            constexpr size_t ColIdx = index_sequence_value(I, column_idxs{});
+            static_assert(ColIdx < column_idxs{}.size(), "No such column mapped into the CTE.");
+
+            auto& timpl = pick_impl<Label>(s);
+            return &std::get<ColIdx>(timpl.table.elements).name;
         }
     }
 }
@@ -15115,7 +15202,7 @@ namespace sqlite_orm {
         };
 
         template<class T>
-        struct column_names_getter<asterisk_t<T>, match_if_not<std::is_base_of, alias_tag, T>> {
+        struct column_names_getter<asterisk_t<T>, match_if_not<is_column_alias, T>> {
             using expression_type = asterisk_t<T>;
 
             template<class Ctx>
@@ -15125,7 +15212,7 @@ namespace sqlite_orm {
         };
 
         template<class A>
-        struct column_names_getter<asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>> {
+        struct column_names_getter<asterisk_t<A>, match_if<is_column_alias, A>> {
             using expression_type = asterisk_t<A>;
 
             template<class Ctx>
@@ -15325,7 +15412,13 @@ namespace sqlite_orm {
                 }
             };
             for(std::string& name: columnNames) {
-                unquote(name);
+                constexpr char quoteChar = '"';
+                if(name.front() == quoteChar) {
+                    unquote(name);
+                } else {
+                    // unaliased expression - see 3. below
+                    name.clear();
+                }
             }
 
             // 2. override column names from cte expression
@@ -15340,11 +15433,11 @@ namespace sqlite_orm {
                     }
                 }
             }
-            // 3. fill in blanks with numerical column names
+            // 3. fill in blanks with numerical column identifiers
             {
                 for(size_t i = 0, n = columnNames.size(); i < n; ++i) {
                     if(columnNames[i].empty()) {
-                        columnNames[i] = std::to_string(i);
+                        columnNames[i] = std::to_string(i + 1);
                     }
                 }
             }
@@ -16196,9 +16289,6 @@ namespace sqlite_orm {
             }
         };
 
-        template<class O, class F, F O::*m>
-        struct statement_serializer<ice_t<m>, void> : statement_serializer<typename ice_t<m>::value_type> {};
-
         template<class T, class F>
         struct statement_serializer<column_pointer<T, F>, void> {
             using statement_type = column_pointer<T, F>;
@@ -17991,7 +18081,7 @@ namespace sqlite_orm {
          *  asterisk_t<O> -> tuple<ColExpr...>
          */
         template<class St, class E>
-        struct column_expression_type<St, asterisk_t<E>, match_if_not<std::is_base_of, alias_tag, E>>
+        struct column_expression_type<St, asterisk_t<E>, match_if_not<is_column_alias, E>>
             : storage_traits::storage_mapped_column_expressions<St, E> {};
 
         template<class A>
@@ -18006,17 +18096,10 @@ namespace sqlite_orm {
          *  asterisk_t<Alias> -> tuple<alias_column_t<Alias, ColExpr>...>
          */
         template<class St, class A>
-        struct column_expression_type<St, asterisk_t<A>, match_if<std::is_base_of, alias_tag, A>>
+        struct column_expression_type<St, asterisk_t<A>, match_if<is_column_alias, A>>
             : tuple_transformer<typename storage_traits::storage_mapped_column_expressions<St, type_t<A>>::type,
                                 add_column_alias<A>::template apply> {};
 
-        /**
-         *  Resolve member pointer constant (actually covered by identity matcher above).
-         *  F O::*member -> F O::*member
-         */
-        template<class St, class O, class F, F O::*m>
-        struct column_expression_type<St, ice_t<m>, void> : ice_t<m> {};
-
         /**
          *  Resolve multiple columns.
          *  columns_t<C...> -> tuple<ColExpr...>
@@ -18051,34 +18134,65 @@ namespace sqlite_orm {
     namespace internal {
 
         // F = field_type
-        template<typename Label, typename Expression, typename F>
+        template<typename Label, typename Expression, typename RefExpressions, typename F>
         struct create_cte_mapper {
-            using type = subselect_mapper<Label, Expression, F>;
+            using type = subselect_mapper<Label, Expression, RefExpressions, F>;
         };
 
-        template<typename Label, typename Expression, typename... Fs>
-        struct create_cte_mapper<Label, Expression, std::tuple<Fs...>> {
-            using type = subselect_mapper<Label, Expression, Fs...>;
+        template<typename Label, typename Expression, typename RefExpressions, typename... Fs>
+        struct create_cte_mapper<Label, Expression, RefExpressions, std::tuple<Fs...>> {
+            using type = subselect_mapper<Label, Expression, RefExpressions, Fs...>;
         };
 
-        template<typename Label, typename Expression, typename... Fs>
-        using create_cte_mapper_t = typename create_cte_mapper<Label, Expression, Fs...>::type;
+        template<typename Label, typename Expression, typename RefExpressions, typename... Fs>
+        using create_cte_mapper_t = typename create_cte_mapper<Label, Expression, RefExpressions, Fs...>::type;
 
-        template<typename O, size_t CI>
+        // aliased column expressions, explicit or implicitly numbered
+        template<typename Mapper, size_t CI, typename SFINAE = void>
         struct create_cte_column {
-            using cte_object_type = O;
-            using field_type = std::tuple_element_t<CI, typename O::fields_type>;
-            using getter_type = cte_getter_t<O, CI>;
-            using setter_type = cte_setter_t<O, CI>;
+            using As = std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>;
+            using field_type = std::tuple_element_t<CI, typename Mapper::fields_type>;
+            using object_type = aliased_field<alias_type_t<As>, field_type>;
+
+            using type = column_t<object_type,
+                                  field_type,
+                                  const field_type& (object_type::*)() const,
+                                  void (object_type::*)(field_type)>;
 
-            using type = column_t<cte_object_type, field_type, getter_type, setter_type>;
+            template<typename Tpl>
+            static type make_column(std::string name, const Tpl& /*colRefs*/) {
+                return sqlite_orm::make_column<>(move(name), &object_type::field);
+            }
+        };
+
+        // F O::*
+        template<typename Mapper, size_t CI>
+        struct create_cte_column<
+            Mapper,
+            CI,
+            std::enable_if_t<polyfill::disjunction_v<
+                is_field_member_pointer<std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>>,
+                is_getter<std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>>>>> {
+            using F = std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>;
+            using object_type = typename field_member_traits<F>::object_type;
+            using field_type = typename field_member_traits<F>::field_type;
+
+            using type = column_t<object_type,
+                                  field_type,
+                                  const field_type& (object_type::*)() const,
+                                  void (object_type::*)(field_type)>;
+
+            template<typename Tpl>
+            static type make_column(std::string name, const Tpl& colRefs) {
+                return sqlite_orm::make_column<>(move(name), get<CI>(colRefs));
+            }
         };
 
         /**
          *  Metafunction to create a CTE column_t type.
          */
-        template<typename O, size_t CI>
-        using create_cte_column_t = typename create_cte_column<O, CI>::type;
+        template<typename Mapper, size_t CI>
+        using create_cte_column_t = typename create_cte_column<Mapper, CI>::type;
 
         template<typename Mapper, typename IdxSeq>
         struct create_cte_table;
@@ -18086,8 +18200,7 @@ namespace sqlite_orm {
         template<typename Label, typename Expression, typename... Fs, size_t... CIs>
         struct create_cte_table<subselect_mapper<Label, Expression, Fs...>, std::index_sequence<CIs...>> {
             using cte_mapper_type = subselect_mapper<Label, Expression, Fs...>;
-            using table_type =
-                table_t<cte_mapper_type, true, create_cte_column_t<cte_object_type_t<cte_mapper_type>, CIs>...>;
+            using table_type = table_t<cte_mapper_type, true, create_cte_column_t<cte_mapper_type, CIs>...>;
 
             using type = table_type;
         };
@@ -18141,42 +18254,123 @@ namespace sqlite_orm {
         using cte_driving_subselect_t =
             polyfill::remove_cvref_t<decltype(get_cte_driving_subselect(std::declval<Select>()))>;
 
+        template<class C, size_t... Idx>
+        auto get_fields_of_columns(const C& coldef, std::index_sequence<Idx...>) {
+            return std::make_tuple(get<Idx>(coldef).member_pointer...);
+        }
+
+        // any expression -> numeric column alias
+        template<class S, class E, size_t Idx = 0>
+        auto extract_colref_expressions(const S& /*impl*/, const E& /*col*/, std::index_sequence<Idx> = {})
+            -> std::tuple<alias_holder<decltype(n_to_colalias<Idx>())>> {
+            return {};
+        }
+
+        // expression_t<>
+        template<class S, class E, size_t Idx = 0>
+        auto extract_colref_expressions(const S& impl, const expression_t<E>& col, std::index_sequence<Idx> s = {}) {
+            return extract_colref_expressions(impl, col.value, s);
+        }
+
+        // F O::* (field) -> field
+        template<class S, class F, class O, size_t Idx = 0>
+        auto extract_colref_expressions(const S& /*impl*/, F O::*col, std::index_sequence<Idx> = {}) {
+            return std::make_tuple(col);
+        }
+
+        // as_t<> (aliased expression) -> alias_holder
+        template<class S, class A, class E, size_t Idx = 0>
+        std::tuple<alias_holder<A>>
+        extract_colref_expressions(const S& /*impl*/, const as_t<A, E>& /*col*/, std::index_sequence<Idx> = {}) {
+            return {};
+        }
+
+        // alias_holder<> (colref) -> alias_holder
+        template<class S, class A, size_t Idx = 0>
+        std::tuple<alias_holder<A>>
+        extract_colref_expressions(const S& /*impl*/, const alias_holder<A>& /*col*/, std::index_sequence<Idx> = {}) {
+            return {};
+        }
+
+        // column_pointer<>
+        template<class S, class Label, class F, size_t Idx = 0>
+        auto extract_colref_expressions(const S& impl,
+                                        const column_pointer<Label, F>& col,
+                                        std::index_sequence<Idx> s = {}) {
+            return extract_colref_expressions(impl, col.field, s);
+        }
+
+        // column expression tuple
+        template<class S, class... Args, size_t... Idx>
+        auto extract_colref_expressions(const S& impl, const std::tuple<Args...>& cols, std::index_sequence<Idx...>) {
+            return std::tuple_cat(extract_colref_expressions(impl, get<Idx>(cols), std::index_sequence<Idx>{})...);
+        }
+
+        // columns_t<>
+        template<class S, class... Args>
+        auto extract_colref_expressions(const S& impl, const columns_t<Args...>& cols) {
+            return extract_colref_expressions(impl, cols.columns, std::index_sequence_for<Args...>{});
+        }
+
+        // asterisk_t<> -> fields
+        template<class S, class O>
+        auto extract_colref_expressions(const S& impl, const asterisk_t<O>& /*col*/) {
+            using timpl_type = storage_pick_impl_t<S, O>;
+            using elements_t = typename timpl_type::table_type::elements_type;
+            using column_idxs = filter_tuple_sequence_t<elements_t, is_column>;
+
+            auto& tImpl = pick_impl<O>(impl);
+            return get_fields_of_columns(tImpl.table.elements, column_idxs{});
+        }
+
+        template<class S, class E, class... Args>
+        decltype(auto) extract_colref_expressions(const S& /*impl*/,
+                                                  const select_t<E, Args...>& /*subSelect*/) = delete;
+
+        template<typename S, typename SubSelect>
+        using extracted_colref_expressions_t =
+            polyfill::remove_cvref_t<decltype(extract_colref_expressions(std::declval<S>(),
+                                                                         std::declval<SubSelect>().col))>;
+
         template<typename Mapper, typename S, typename CTE, size_t... CIs>
         create_cte_table_t<Mapper, typename Mapper::index_sequence>
         make_cte_table_using_column_indices(const S& impl, const CTE& cte, std::index_sequence<CIs...>) {
-            using O = cte_object_type_t<Mapper>;
             using context_type = serializer_context<S>;
-            context_type context{impl};
+            using cte_type = CTE;
 
+            context_type context{impl};
+            std::string tableName = alias_extractor<cte_label_type_t<cte_type>>::extract(std::true_type{});
+            auto subSelect = get_cte_driving_subselect(cte.subselect);
+            auto colRefs = extract_colref_expressions(impl, subSelect.col);
             std::vector<std::string> columnNames =
-                collect_cte_column_names(get_cte_driving_subselect(cte.subselect), cte.explicitColumnNames, context);
+                collect_cte_column_names(subSelect, cte.explicitColumnNames, context);
 
             return create_cte_table_t<Mapper, typename Mapper::index_sequence>{
-                alias_extractor<cte_label_type_t<CTE>>::extract(std::true_type{}),
-                std::make_tuple(
-                    make_column<>(move(columnNames.at(CIs)), cte_getter_v<O, CIs>, cte_setter_v<O, CIs>)...)};
-        }
-
-        template<typename Mapper, typename S, typename CTE>
-        create_cte_table_t<Mapper, typename Mapper::index_sequence> make_cte_table(const S& impl, const CTE& cte) {
-            return make_cte_table_using_column_indices<Mapper>(impl, cte, typename Mapper::index_sequence{});
+                move(tableName),
+                std::make_tuple(create_cte_column<Mapper, CIs>::make_column(move(columnNames.at(CIs)), colRefs)...)};
         }
 
-        template<typename S, typename... CTEs, size_t Ii>
-        decltype(auto) make_recursive_cte_storage_using_table_indices(const S& impl,
-                                                                      const common_table_expressions<CTEs...>& cte,
-                                                                      std::index_sequence<Ii>) {
-            using cte_type = std::tuple_element_t<Ii, common_table_expressions<CTEs...>>;
+        template<typename S, typename CTE>
+        auto make_cte_table(const S& impl, const CTE& cte) {
+            using cte_type = CTE;
             using subselect_type = cte_driving_subselect_t<expression_type_t<cte_type>>;
             using mapper_type = create_cte_mapper_t<cte_label_type_t<cte_type>,
                                                     column_expression_of_t<S, subselect_type>,
+                                                    extracted_colref_expressions_t<S, subselect_type>,
                                                     column_result_of_t<S, subselect_type>>;
             static_assert(cte_type::explicit_column_count == 0 ||
                               cte_type::explicit_column_count == mapper_type::index_sequence::size(),
                           "Number of explicit columns of common table expression doesn't match the number of columns "
                           "in the subselect.");
 
-            auto tbl = make_cte_table<mapper_type>(impl, get<Ii>(cte));
+            return make_cte_table_using_column_indices<mapper_type>(impl, cte, typename mapper_type::index_sequence{});
+        }
+
+        template<typename S, typename... CTEs, size_t Ii>
+        decltype(auto) make_recursive_cte_storage_using_table_indices(const S& impl,
+                                                                      const common_table_expressions<CTEs...>& cte,
+                                                                      std::index_sequence<Ii>) {
+            auto tbl = make_cte_table(impl, get<Ii>(cte));
 
             return storage_impl_cat(impl, std::move(tbl));
         }
@@ -18185,17 +18379,7 @@ namespace sqlite_orm {
         decltype(auto) make_recursive_cte_storage_using_table_indices(const S& impl,
                                                                       const common_table_expressions<CTEs...>& cte,
                                                                       std::index_sequence<Ii, Ij, In...>) {
-            using cte_type = std::tuple_element_t<Ii, common_table_expressions<CTEs...>>;
-            using subselect_type = cte_driving_subselect_t<expression_type_t<cte_type>>;
-            using mapper_type = create_cte_mapper_t<cte_label_type_t<cte_type>,
-                                                    column_expression_of_t<S, subselect_type>,
-                                                    column_result_of_t<S, subselect_type>>;
-            static_assert(cte_type::explicit_column_count == 0 ||
-                              cte_type::explicit_column_count == mapper_type::index_sequence::size(),
-                          "Number of explicit columns of common table expression doesn't match the number of columns "
-                          "in the subselect.");
-
-            auto tbl = make_cte_table<mapper_type>(impl, get<Ii>(cte));
+            auto tbl = make_cte_table(impl, get<Ii>(cte));
 
             return make_recursive_cte_storage_using_table_indices(
                 // Because CTEs can depend on their predecessor we recursively pass in a new storage object
@@ -19929,29 +20113,18 @@ namespace sqlite_orm {
 
 // #include "alias.h"
 
-// #include "select_constraints.h"
-
-// #include "cte_types.h"
-
 namespace sqlite_orm {
 
-    /** 
-     *  A special table alias that is both, a storage lookup type (mapping type) and an alias.
-     */
-    template<char C>
-    struct cte_alias
-        : internal::table_alias<cte_alias<C> /* refer to self, since a label is both, an alias and a lookup type */,
-                                C> {};
-
-    using cte_1 = cte_alias<'1'>;
-    using cte_2 = cte_alias<'2'>;
-    using cte_3 = cte_alias<'3'>;
-    using cte_4 = cte_alias<'4'>;
-    using cte_5 = cte_alias<'5'>;
-    using cte_6 = cte_alias<'6'>;
-    using cte_7 = cte_alias<'7'>;
-    using cte_8 = cte_alias<'8'>;
-    using cte_9 = cte_alias<'9'>;
+    namespace internal {
+        /** 
+         *  A special table alias that is both, a storage lookup type (mapping type) and an alias.
+         */
+        template<char C, char... X>
+        struct cte_alias
+            : table_alias<cte_alias<C, X...> /* refer to self, since a label is both, an alias and a lookup type */,
+                          C,
+                          X...> {};
+    }
 
 #if __cplusplus >= 201703L  // use of C++17 or higher
     namespace internal {
@@ -19971,10 +20144,10 @@ namespace sqlite_orm {
 
     /**
      *  index_constant<> from numeric literal.
-     *  E.g. 0_col, 1_col
+     *  E.g. 0_colidx, 1_colidx
      */
     template<char... Chars>
-    [[nodiscard]] constexpr decltype(auto) operator"" _col() {
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL decltype(auto) operator"" _colidx() {
         return polyfill::index_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{},
                                                                  Chars...)>{};
     }
@@ -19984,33 +20157,56 @@ namespace sqlite_orm {
      *  E.g. 1_nth_col, 2_nth_col
      */
     template<char... Chars>
-    [[nodiscard]] constexpr decltype(auto) operator"" _nth_col() {
-        static_assert(((Chars != '0') && ...));
-        return internal::nth_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{},
-                                                               Chars...)>{};
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL decltype(auto) operator"" _nth_col() {
+        constexpr auto n =
+            internal::nth_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{}, Chars...)>{};
+        static_assert(n > 0);
+        return n;
+    }
+
+    /**
+     *  cte_alias<'n'> from a numeric literal.
+     *  E.g. 1_ctealias, 2_ctealias
+     */
+    template<char... Chars>
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
+        return internal::cte_alias<Chars...>{};
     }
+#if __cplusplus >= 202002L  // C++20 or later
+    /**
+     *  cte_alias<'1'[, ...]> from a string literal.
+     *  E.g. "1"_cte, "2"_cte
+     */
+    template<internal::string_identifier_template t>
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _cte() {
+        static_assert(t.size() != 1 || ((t.id[0] < 'A' || 'Z' < t.id[0]) && (t.id[0] < 'a' || 'z' < t.id[0])),
+                      "CTE alias identifiers consisting of a single alphabetic character should be avoided, in order "
+                      "to evade clashes with the built-in table aliases.");
+        return internal::to_alias<internal::cte_alias, t>(std::make_index_sequence<t.size()>{});
+    }
+#endif
+
+#if __cplusplus >= 202002L  // C++20 or later
+    using cte_1 = decltype("1"_cte);
+    using cte_2 = decltype("2"_cte);
+    using cte_3 = decltype("3"_cte);
+    using cte_4 = decltype("4"_cte);
+    using cte_5 = decltype("5"_cte);
+    using cte_6 = decltype("6"_cte);
+    using cte_7 = decltype("7"_cte);
+    using cte_8 = decltype("8"_cte);
+    using cte_9 = decltype("9"_cte);
 #else
-        constexpr polyfill::index_constant<0> _0_col{};
-        constexpr polyfill::index_constant<1> _1_col{};
-        constexpr polyfill::index_constant<2> _2_col{};
-        constexpr polyfill::index_constant<3> _3_col{};
-        constexpr polyfill::index_constant<4> _4_col{};
-        constexpr polyfill::index_constant<5> _5_col{};
-        constexpr polyfill::index_constant<6> _6_col{};
-        constexpr polyfill::index_constant<7> _7_col{};
-        constexpr polyfill::index_constant<8> _8_col{};
-        constexpr polyfill::index_constant<9> _9_col{};
-
-        constexpr internal::nth_constant<1> _1_nth_col{};
-        constexpr internal::nth_constant<2> _2_nth_col{};
-        constexpr internal::nth_constant<3> _3_nth_col{};
-        constexpr internal::nth_constant<4> _4_nth_col{};
-        constexpr internal::nth_constant<5> _5_nth_col{};
-        constexpr internal::nth_constant<6> _6_nth_col{};
-        constexpr internal::nth_constant<7> _7_nth_col{};
-        constexpr internal::nth_constant<8> _8_nth_col{};
-        constexpr internal::nth_constant<9> _9_nth_col{};
-        constexpr internal::nth_constant<10> _10_nth_col{};
+    using cte_1 = decltype(1_ctealias);
+    using cte_2 = decltype(2_ctealias);
+    using cte_3 = decltype(3_ctealias);
+    using cte_4 = decltype(4_ctealias);
+    using cte_5 = decltype(5_ctealias);
+    using cte_6 = decltype(6_ctealias);
+    using cte_7 = decltype(7_ctealias);
+    using cte_8 = decltype(8_ctealias);
+    using cte_9 = decltype(9_ctealias);
+#endif
 #endif
 }
 #pragma once
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index 945f49ac2..99ae6a6dd 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -3,6 +3,8 @@
 #include <catch2/catch.hpp>
 
 using namespace sqlite_orm;
+using internal::alias_holder;
+using internal::column_pointer;
 
 template<class St, class E, class V>
 void runTest(V value) {
@@ -21,8 +23,8 @@ TEST_CASE("column_expression_of_t") {
 
     auto storage = make_storage(
         "",
-        make_table("org", make_column("id", c_v<&Org::id>), make_column("boss", &Org::boss)),
-        make_table<Derived>("derived", make_column("id", c_v<&Derived::id>), make_column("boss", &Derived::boss)));
+        make_table("org", make_column("id", &Org::id), make_column("boss", &Org::boss)),
+        make_table<Derived>("derived", make_column("id", &Derived::id), make_column("boss", &Derived::boss)));
     using storage_type = decltype(storage);
 
     runTest<storage_type, int>(1);
@@ -33,20 +35,25 @@ TEST_CASE("column_expression_of_t") {
         const int64 x = 42;
         runTest<storage_type, const int64&>(std::ref(x));
     }
-    runTest<storage_type, std::integral_constant<int64 Org::*, &Org::id>>(internal::ice_t<&Org::id>{});
-    runTest<storage_type, internal::ice_t<&Org::id>>(c_v<&Org::id>);
-    runTest<storage_type, std::tuple<internal::ice_t<&Org::id>, int64 Org::*>>(columns(c_v<&Org::id>, &Org::boss));
-    runTest<storage_type, std::tuple<int64 Org::*, internal::ice_t<&Org::boss>>>(columns(&Org::id, c_v<&Org::boss>));
-    runTest<storage_type, std::tuple<internal::ice_t<&Org::id>, int64 Org::*>>(asterisk<Org>());
+    runTest<storage_type, std::tuple<int64 Org::*>>(columns(&Org::boss));
+    runTest<storage_type, std::tuple<int64 Org::*, int64 Org::*>>(asterisk<Org>());
     runTest<storage_type,
-            std::tuple<internal::alias_column_t<alias_a<Org>, internal::ice_t<&Org::id>>,
+            std::tuple<internal::alias_column_t<alias_a<Org>, int64 Org::*>,
                        internal::alias_column_t<alias_a<Org>, int64 Org::*>>>(asterisk<alias_a<Org>>());
     // object_t not allowed
     //runTest<storage_type, Org>(object<Org>());
+    runTest<storage_type, internal::as_t<colalias_a, int>>(as<colalias_a>(1));
 
-    // just like other types, column pointer isn't explicitly handled by column_expression_of_t;
-    // assert expectation nevertheless
-    runTest<storage_type, internal::column_pointer<Derived, int64 Org::*>>(column<Derived>(&Org::id));
-    runTest<storage_type, internal::column_pointer<cte_1, internal::ice_t<&Org::id>>>(column<cte_1>(c_v<&Org::id>));
-    runTest<storage_type, internal::column_pointer<cte_1, polyfill::index_constant<0u>>>(column<cte_1>(0_col));
+    runTest<storage_type, column_pointer<Derived, int64 Org::*>>(column<Derived>(&Org::id));
+    runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>(&Org::id));
+    runTest<storage_type, column_pointer<cte_1, polyfill::index_constant<0u>>>(column<cte_1>(0_colidx));
+    runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>()->*&Org::id);
+    runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>->*&Org::id);
+    runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>->*&Org::id);
+    runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>->*&Org::id);
+    runTest<storage_type, column_pointer<cte_1, alias_holder<internal::column_alias<'1'>>>>(column<cte_1>(1_colalias));
+    runTest<storage_type, column_pointer<cte_1, alias_holder<colalias_c>>>(1_ctealias->*colalias_c{});
+#if __cplusplus >= 202002L  // C++20 or later
+    runTest<storage_type, column_pointer<cte_1, alias_holder<colalias_c>>>("1"_cte->*"c"_col);
+#endif
 }
diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
index 226378e6a..0a94927e0 100644
--- a/tests/static_tests/column_result_t.cpp
+++ b/tests/static_tests/column_result_t.cpp
@@ -10,7 +10,7 @@ void runTest(V /*value*/) {
     STATIC_REQUIRE(std::is_same<Type, E>::value);
 }
 
-TEST_CASE("column_result_of_t 1") {
+TEST_CASE("column_result_of_t") {
     struct User {
         int id = 0;
         std::string name;
@@ -111,26 +111,11 @@ TEST_CASE("column_result_of_t 1") {
     runTest<Storage, std::tuple<int, std::string>>(columns(&User::id, &User::name));
     runTest<Storage, int>(column<User>(&User::id));
     runTest<Storage, User>(object<User>());
-}
-
-TEST_CASE("column_result_of_t 2") {
-    struct Org {
-        // compile-time mapped (via c_v<>)
-        int64 id = 0;
-        // not compile-time mapped
-        int64 boss = 0;
-    };
-    struct Derived : Org {};
-
-    auto storage = make_storage(
-        "",
-        make_table("org", make_column("id", c_v<&Org::id>), make_column("boss", &Org::boss)),
-        make_table<Derived>("derived", make_column("id", c_v<&Derived::id>), make_column("boss", &Derived::boss)));
-    using storage_type = decltype(storage);
-
-    runTest<storage_type, int64>(c_v<&Org::id>);
-    runTest<storage_type, std::tuple<int64, int64>>(columns(c_v<&Org::id>, &Org::boss));
-    // these need a 'CTE' expression storage
-    //runTest<storage_type, int64>(column<cte_1>(c_v<&Org::id>));
-    //runTest<storage_type, int64>(column<cte_1>(0_col));
+    runTest<Storage, int>(column<cte_1>(&User::id));
+    runTest<Storage, int>(column<cte_1>()->*&User::id);
+    runTest<Storage, int>(column<cte_1>->*&User::id);
+    runTest<Storage, int>(1_ctealias->*&User::id);
+#if __cplusplus >= 202002L  // C++20 or later
+    runTest<Storage, int>("1"_cte->*&User::id);
+#endif
 }
diff --git a/tests/static_tests/tuple_filter.cpp b/tests/static_tests/tuple_filter.cpp
new file mode 100644
index 000000000..5a868af85
--- /dev/null
+++ b/tests/static_tests/tuple_filter.cpp
@@ -0,0 +1,28 @@
+#include <sqlite_orm/sqlite_orm.h>
+#include <catch2/catch.hpp>
+#include <type_traits>  //  std::is_same
+
+using namespace sqlite_orm;
+using internal::filter_tuple_t;
+
+TEST_CASE("tuple_filter") {
+    struct User {
+        int id = 0;
+    };
+    SECTION("is_bindable") {
+        using Arg = std::tuple<int, std::string, internal::where_t<bool>, internal::order_by_t<decltype(&User::id)>>;
+        using Expected = std::tuple<int, std::string>;
+        using ResultType = filter_tuple_t<Arg, internal::is_bindable>;
+        STATIC_REQUIRE(std::is_same<ResultType, Expected>::value);
+    }
+    SECTION("is_column") {
+        auto column = make_column({}, &User::id);
+        using Column = decltype(column);
+        using OrderBy = internal::order_by_t<decltype(&User::id)>;
+        using Unique = decltype(unique(&User::id));
+        using Arg = std::tuple<Column, OrderBy, Unique>;
+        using Expected = std::tuple<Column>;
+        using ResultType = filter_tuple_t<Arg, internal::is_column>;
+        STATIC_REQUIRE(std::is_same<ResultType, Expected>::value);
+    }
+}
diff --git a/tests/static_tests/tuple_filter_single.cpp b/tests/static_tests/tuple_filter_single.cpp
deleted file mode 100644
index 069cadd0e..000000000
--- a/tests/static_tests/tuple_filter_single.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#include <sqlite_orm/sqlite_orm.h>
-#include <catch2/catch.hpp>
-#include <type_traits>  //  std::is_same
-
-using namespace sqlite_orm;
-
-TEST_CASE("tuple_filter") {
-    struct User {
-        int id = 0;
-    };
-    SECTION("single") {
-        SECTION("is_bindable") {
-            SECTION("int") {
-                using Arg = int;
-                using Expected = std::tuple<int>;
-                using ResultType = internal::tuple_filter_single<Arg, internal::is_bindable>::type;
-                STATIC_REQUIRE(std::is_same<ResultType, Expected>::value);
-            }
-            SECTION("std::string") {
-                using Arg = std::string;
-                using Expected = std::tuple<std::string>;
-                using ResultType = internal::tuple_filter_single<Arg, internal::is_bindable>::type;
-                STATIC_REQUIRE(std::is_same<ResultType, Expected>::value);
-            }
-            SECTION("where_t") {
-                using Arg = internal::where_t<bool>;
-                using Expected = std::tuple<>;
-                using ResultType = internal::tuple_filter_single<Arg, internal::is_bindable>::type;
-                STATIC_REQUIRE(std::is_same<ResultType, Expected>::value);
-            }
-            SECTION("order_by_t") {
-                using Arg = internal::order_by_t<decltype(&User::id)>;
-                using Expected = std::tuple<>;
-                using ResultType = internal::tuple_filter_single<Arg, internal::is_bindable>::type;
-                STATIC_REQUIRE(std::is_same<ResultType, Expected>::value);
-            }
-        }
-        SECTION("is_column") {
-            SECTION("column_t") {
-                auto column = make_column({}, &User::id);
-                using Arg = decltype(column);
-                using Expected = std::tuple<Arg>;
-                using ResultType = internal::tuple_filter_single<Arg, internal::is_column>::type;
-                STATIC_REQUIRE(std::is_same<ResultType, Expected>::value);
-            }
-            SECTION("order_by_t") {
-                using Arg = internal::order_by_t<decltype(&User::id)>;
-                using Expected = std::tuple<>;
-                using ResultType = internal::tuple_filter_single<Arg, internal::is_column>::type;
-                STATIC_REQUIRE(std::is_same<ResultType, Expected>::value);
-            }
-            SECTION("unique_t") {
-                using Arg = decltype(unique(&User::id));
-                using Expected = std::tuple<>;
-                using ResultType = internal::tuple_filter_single<Arg, internal::is_column>::type;
-                STATIC_REQUIRE(std::is_same<ResultType, Expected>::value);
-            }
-        }
-    }
-    SECTION("multiple") {
-        SECTION("is_bindable") {
-            using Arg =
-                std::tuple<int, std::string, internal::where_t<bool>, internal::order_by_t<decltype(&User::id)>>;
-            using Expected = std::tuple<int, std::string>;
-            using ResultType = internal::tuple_filter<Arg, internal::is_bindable>::type;
-            STATIC_REQUIRE(std::is_same<ResultType, Expected>::value);
-        }
-        SECTION("is_column") {
-            auto column = make_column({}, &User::id);
-            using Column = decltype(column);
-            using OrderBy = internal::order_by_t<decltype(&User::id)>;
-            using Unique = decltype(unique(&User::id));
-            using Arg = std::tuple<Column, OrderBy, Unique>;
-            using Expected = std::tuple<Column>;
-            using ResultType = internal::tuple_filter<Arg, internal::is_column>::type;
-            STATIC_REQUIRE(std::is_same<ResultType, Expected>::value);
-        }
-    }
-}

From 78ae7413bb8b2c2c9494067d7c7fac5fc4e9fbfb Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Wed, 13 Apr 2022 20:48:54 +0300
Subject: [PATCH 053/161] Fully implemented explicit CTE columns

---
 dev/alias.h                                 |  23 +-
 dev/column_result.h                         |   4 +-
 dev/cte.h                                   |   4 +-
 dev/cte_column_names_collector.h            |  98 ++--
 dev/cte_storage.h                           | 208 ++++----
 dev/cte_types.h                             |  20 +-
 dev/member_traits/is_field_member_pointer.h |  10 +-
 dev/member_traits/member_traits.h           |   6 +-
 dev/select_constraints.h                    | 124 +++--
 dev/statement_serializer.h                  |  12 +-
 dev/storage.h                               |  14 +-
 dev/storage_impl.h                          |   6 +-
 dev/table.h                                 |  10 +-
 dev/tuple_helper/tuple_helper.h             |   1 +
 dev/type_traits.h                           |   2 +-
 examples/common_table_expressions.cpp       |  99 ++--
 include/sqlite_orm/sqlite_orm.h             | 551 ++++++++++++--------
 17 files changed, 706 insertions(+), 486 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index eb1956c92..23926c3b9 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -40,7 +40,7 @@ namespace sqlite_orm {
         template<class A>
         using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cpp_nontype_template_args >= 201911
         /*  
          *  Helper class to facilitate user-defined string literal operator template
          */
@@ -50,13 +50,21 @@ namespace sqlite_orm {
                 return N - 1;
             }
 
+#ifdef _MSC_VER
             constexpr string_identifier_template(const char (&id)[N]) : id{id} {}
 
             const char (&id)[N];
+#else
+            constexpr string_identifier_template(const char (&id)[N]) {
+                std::copy_n(id, N, this->id);
+            }
+
+            char id[N];
+#endif
         };
 
         template<template<char...> class Alias, string_identifier_template t, size_t... Idx>
-        SQLITE_ORM_CONSTEVAL auto to_alias(std::index_sequence<Idx...>) {
+        consteval auto to_alias(std::index_sequence<Idx...>) {
             return Alias<t.id[Idx]...>{};
         }
 #endif
@@ -72,7 +80,7 @@ namespace sqlite_orm {
         struct table_alias : alias_tag {
             using type = T;
 
-            constexpr static std::string get() {
+            static std::string get() {
                 return {A, X...};
             }
         };
@@ -140,7 +148,10 @@ namespace sqlite_orm {
         template<class T>
         struct alias_holder {
             using type = T;
-            using alias_type = type;
+
+            alias_holder() = default;
+            // CTE feature needs it to implicitly convert a column alias to an alias_holder; see `cte()` factory function
+            alias_holder(const T&) noexcept {}
         };
 
         template<size_t n, char... C>
@@ -277,13 +288,13 @@ namespace sqlite_orm {
         return internal::column_alias<Chars...>{};
     }
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cpp_nontype_template_args >= 201911
     /**
      *  column_alias<'a'[, ...]> from a string literal.
      *  E.g. "a"_col, "b"_col
      */
     template<internal::string_identifier_template t>
-    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _col() {
+    [[nodiscard]] consteval auto operator"" _col() {
         return internal::to_alias<internal::column_alias, t>(std::make_index_sequence<t.size()>{});
     }
 #endif
diff --git a/dev/column_result.h b/dev/column_result.h
index 821b1552f..8bf7ae714 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -228,9 +228,9 @@ namespace sqlite_orm {
             using timpl_type = storage_pick_impl_t<St, Label>;
             using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
 
-            // filter all column references [`alias_holder<>`]
+            // filter all column references being `alias_holder<>`
             using alias_types_tuple =
-                transform_tuple_t<typename cte_mapper_type::colref_expressions_tuple, alias_type_or_none>;
+                transform_tuple_t<typename cte_mapper_type::final_colrefs_tuple, alias_holder_type_or_none>;
 
             // lookup index of ColAlias in alias_types_tuple
             static constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
diff --git a/dev/cte.h b/dev/cte.h
index 135645346..3e861c2bf 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -65,13 +65,13 @@ namespace sqlite_orm {
     [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
         return internal::cte_alias<Chars...>{};
     }
-#if __cplusplus >= 202002L  // C++20 or later
+#if __cpp_nontype_template_args >= 201911
     /**
      *  cte_alias<'1'[, ...]> from a string literal.
      *  E.g. "1"_cte, "2"_cte
      */
     template<internal::string_identifier_template t>
-    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _cte() {
+    [[nodiscard]] consteval auto operator"" _cte() {
         static_assert(t.size() != 1 || ((t.id[0] < 'A' || 'Z' < t.id[0]) && (t.id[0] < 'a' || 'z' < t.id[0])),
                       "CTE alias identifiers consisting of a single alphabetic character should be avoided, in order "
                       "to evade clashes with the built-in table aliases.");
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index f5c24607a..fe0a801da 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -7,6 +7,7 @@
 
 #include "cxx_polyfill.h"
 #include "type_traits.h"
+#include "member_traits/field_member_traits.h"
 #include "error_code.h"
 #include "alias.h"
 #include "select_constraints.h"
@@ -18,6 +19,28 @@ namespace sqlite_orm {
         template<class T, class I>
         std::string serialize(const T& t, const serializer_context<I>& context);
 
+        inline void unquote_identifier(std::string& identifier) {
+            if(!identifier.empty()) {
+                constexpr char quoteChar = '"';
+                constexpr char sqlEscaped[] = {quoteChar, quoteChar};
+                identifier.erase(identifier.end() - 1);
+                identifier.erase(identifier.begin());
+                for(size_t pos = 0; (pos = identifier.find(sqlEscaped, pos, 2)) != identifier.npos; ++pos) {
+                    identifier.erase(pos, 1);
+                }
+            }
+        }
+
+        inline void unquote_or_erase(std::string& name) {
+            constexpr char quoteChar = '"';
+            if(name.front() == quoteChar) {
+                unquote_identifier(name);
+            } else {
+                // unaliased expression - see 3. below
+                name.clear();
+            }
+        }
+
         template<class T, class SFINAE = void>
         struct cte_column_names_collector {
             using expression_type = T;
@@ -28,8 +51,9 @@ namespace sqlite_orm {
                 newContext.skip_table_name = true;
                 std::string columnName = serialize(t, newContext);
                 if(columnName.empty()) {
-                    throw std::system_error(orm_error_code::column_not_found);
+                    throw std::system_error{orm_error_code::column_not_found};
                 }
+                unquote_or_erase(columnName);
                 return {move(columnName)};
             }
         };
@@ -121,55 +145,57 @@ namespace sqlite_orm {
                     if(!columnName.empty()) {
                         columnNames.push_back(move(columnName));
                     } else {
-                        throw std::system_error(orm_error_code::column_not_found);
+                        throw std::system_error{orm_error_code::column_not_found};
                     }
+                    unquote_or_erase(columnNames.back());
                 });
                 return columnNames;
             }
         };
 
-        template<typename Ctx, typename E, satisfies_is_specialization_of<E, select_t> = true>
-        std::vector<std::string> collect_cte_column_names(const E& sel,
-                                                          const std::vector<std::string>& explicitColumnNames,
-                                                          const Ctx& context) {
+        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) {
             // 1. determine column names from subselect
-
             std::vector<std::string> columnNames = get_cte_column_names(sel.col, context);
 
-            // unquote column names
-            constexpr auto unquote = [](std::string& identifier) {
-                if(!identifier.empty()) {
-                    constexpr char quoteChar = '"';
-                    constexpr char sqlEscaped[] = {quoteChar, quoteChar};
-                    identifier.erase(identifier.end() - 1);
-                    identifier.erase(identifier.begin());
-                    for(size_t pos = 0; (pos = identifier.find(sqlEscaped, pos, 2)) != identifier.npos; ++pos) {
-                        identifier.erase(pos, 1);
-                    }
-                }
-            };
-            for(std::string& name: columnNames) {
-                constexpr char quoteChar = '"';
-                if(name.front() == quoteChar) {
-                    unquote(name);
-                } else {
-                    // unaliased expression - see 3. below
-                    name.clear();
-                }
-            }
-
             // 2. override column names from cte expression
-            if(!explicitColumnNames.empty()) {
-                if(explicitColumnNames.size() != columnNames.size()) {
-                    throw std::system_error(orm_error_code::column_not_found);
+            if(size_t n = std::tuple_size_v<ExplicitColRefs>) {
+                if(n != columnNames.size()) {
+                    throw std::system_error{orm_error_code::column_not_found};
                 }
 
-                for(size_t i = 0, n = explicitColumnNames.size(); i < n; ++i) {
-                    if(!explicitColumnNames[i].empty()) {
-                        columnNames[i] = explicitColumnNames[i];
+                size_t idx = 0;
+                iterate_tuple(explicitColRefs, [&idx, &columnNames, &context](auto& colRef) {
+                    using ColRef = polyfill::remove_cvref_t<decltype(colRef)>;
+
+                    if constexpr(polyfill::is_specialization_of_v<ColRef, alias_holder>) {
+                        columnNames[idx] = alias_extractor<type_t<ColRef>>::extract();
+                    } else if constexpr(is_field_member_pointer<ColRef>::value) {
+                        using O = typename field_member_traits<ColRef>::object_type;
+                        if(auto* columnName = find_column_name<O>(context.impl, colRef)) {
+                            columnNames[idx] = *columnName;
+                        } else {
+                            // relaxed: allow any member pointer as column reference
+                            columnNames[idx] = typeid(ColRef).name();
+                        }
+                    } else if constexpr(polyfill::is_specialization_of_v<ColRef, column_t>) {
+                        columnNames[idx] = colRef.name;
+                    } else if constexpr(std::is_same_v<ColRef, std::string>) {
+                        if(std::string name = colRef; !name.empty()) {
+                            columnNames[idx] = move(name);
+                        }
+                    } else if constexpr(std::is_same_v<ColRef, polyfill::remove_cvref_t<decltype(std::ignore)>>) {
+                        if(columnNames[idx].empty()) {
+                            columnNames[idx] = std::to_string(idx + 1);
+                        }
+                    } else {
+                        static_assert(polyfill::always_false_v<ColRef>, "Invalid explicit column reference specified");
                     }
-                }
+                    ++idx;
+                });
             }
+
             // 3. fill in blanks with numerical column identifiers
             {
                 for(size_t i = 0, n = columnNames.size(); i < n; ++i) {
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 06d6828d0..9131fbbe1 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -18,82 +18,56 @@ namespace sqlite_orm {
     namespace internal {
 
         // F = field_type
-        template<typename Label, typename Expression, typename RefExpressions, typename F>
+        template<typename Label,
+                 typename ExplicitColRefs,
+                 typename Expression,
+                 typename SubselectColRefs,
+                 typename FinalColRefs,
+                 typename F>
         struct create_cte_mapper {
-            using type = subselect_mapper<Label, Expression, RefExpressions, F>;
+            using type = subselect_mapper<Label, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, F>;
         };
 
-        template<typename Label, typename Expression, typename RefExpressions, typename... Fs>
-        struct create_cte_mapper<Label, Expression, RefExpressions, std::tuple<Fs...>> {
-            using type = subselect_mapper<Label, Expression, RefExpressions, Fs...>;
+        // std::tuple<Fs...>
+        template<typename Label,
+                 typename ExplicitColRefs,
+                 typename Expression,
+                 typename SubselectColRefs,
+                 typename FinalColRefs,
+                 typename... Fs>
+        struct create_cte_mapper<Label,
+                                 ExplicitColRefs,
+                                 Expression,
+                                 SubselectColRefs,
+                                 FinalColRefs,
+                                 std::tuple<Fs...>> {
+            using type = subselect_mapper<Label, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Fs...>;
         };
 
-        template<typename Label, typename Expression, typename RefExpressions, typename... Fs>
-        using create_cte_mapper_t = typename create_cte_mapper<Label, Expression, RefExpressions, Fs...>::type;
+        template<typename Label,
+                 typename ExplicitColRefs,
+                 typename Expression,
+                 typename SubselectColRefs,
+                 typename FinalColRefs,
+                 typename Result>
+        using create_cte_mapper_t =
+            typename create_cte_mapper<Label, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Result>::
+                type;
 
         // aliased column expressions, explicit or implicitly numbered
-        template<typename Mapper, size_t CI, typename SFINAE = void>
-        struct create_cte_column {
-            using As = std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>;
-            using field_type = std::tuple_element_t<CI, typename Mapper::fields_type>;
-            using object_type = aliased_field<alias_type_t<As>, field_type>;
-
-            using type = column_t<object_type,
-                                  field_type,
-                                  const field_type& (object_type::*)() const,
-                                  void (object_type::*)(field_type)>;
-
-            template<typename Tpl>
-            static type make_column(std::string name, const Tpl& /*colRefs*/) {
-                return sqlite_orm::make_column<>(move(name), &object_type::field);
-            }
-        };
+        template<typename F, typename ColRef, satisfies_is_specialization_of<ColRef, alias_holder> = true>
+        static auto make_cte_column(std::string name, const ColRef& /*finalColRef*/) {
+            using object_type = aliased_field<type_t<ColRef>, F>;
+            return sqlite_orm::make_column<>(move(name), &object_type::field);
+        }
 
         // F O::*
-        template<typename Mapper, size_t CI>
-        struct create_cte_column<
-            Mapper,
-            CI,
-            std::enable_if_t<polyfill::disjunction_v<
-                is_field_member_pointer<std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>>,
-                is_getter<std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>>>>> {
-            using F = std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>;
-            using object_type = typename field_member_traits<F>::object_type;
-            using field_type = typename field_member_traits<F>::field_type;
-
-            using type = column_t<object_type,
-                                  field_type,
-                                  const field_type& (object_type::*)() const,
-                                  void (object_type::*)(field_type)>;
-
-            template<typename Tpl>
-            static type make_column(std::string name, const Tpl& colRefs) {
-                return sqlite_orm::make_column<>(move(name), get<CI>(colRefs));
-            }
-        };
-
-        /**
-         *  Metafunction to create a CTE column_t type.
-         */
-        template<typename Mapper, size_t CI>
-        using create_cte_column_t = typename create_cte_column<Mapper, CI>::type;
-
-        template<typename Mapper, typename IdxSeq>
-        struct create_cte_table;
-
-        template<typename Label, typename Expression, typename... Fs, size_t... CIs>
-        struct create_cte_table<subselect_mapper<Label, Expression, Fs...>, std::index_sequence<CIs...>> {
-            using cte_mapper_type = subselect_mapper<Label, Expression, Fs...>;
-            using table_type = table_t<cte_mapper_type, true, create_cte_column_t<cte_mapper_type, CIs>...>;
-
-            using type = table_type;
-        };
-
-        /**
-         *  Metafunction to create a CTE table_t type.
-         */
-        template<typename Mapper, typename IdxSeq>
-        using create_cte_table_t = typename create_cte_table<Mapper, IdxSeq>::type;
+        template<typename F,
+                 typename ColRef,
+                 std::enable_if_t<polyfill::disjunction_v<is_field_member_pointer<ColRef>>, bool> = true>
+        static auto make_cte_column(std::string name, const ColRef& finalColRef) {
+            return sqlite_orm::make_column<>(move(name), finalColRef);
+        }
 
         /**
          *  Concatenate newly created tables with those from an existing storage implementation,
@@ -134,10 +108,6 @@ namespace sqlite_orm {
             return subSelect.col.left;
         }
 
-        template<typename Select>
-        using cte_driving_subselect_t =
-            polyfill::remove_cvref_t<decltype(get_cte_driving_subselect(std::declval<Select>()))>;
-
         template<class C, size_t... Idx>
         auto get_fields_of_columns(const C& coldef, std::index_sequence<Idx...>) {
             return std::make_tuple(get<Idx>(coldef).member_pointer...);
@@ -211,43 +181,87 @@ namespace sqlite_orm {
         decltype(auto) extract_colref_expressions(const S& /*impl*/,
                                                   const select_t<E, Args...>& /*subSelect*/) = delete;
 
-        template<typename S, typename SubSelect>
-        using extracted_colref_expressions_t =
-            polyfill::remove_cvref_t<decltype(extract_colref_expressions(std::declval<S>(),
-                                                                         std::declval<SubSelect>().col))>;
-
-        template<typename Mapper, typename S, typename CTE, size_t... CIs>
-        create_cte_table_t<Mapper, typename Mapper::index_sequence>
-        make_cte_table_using_column_indices(const S& impl, const CTE& cte, std::index_sequence<CIs...>) {
-            using context_type = serializer_context<S>;
-            using cte_type = CTE;
+        /*
+         *  Depending on ExplicitColRef's type returns either the explicit column reference
+         *  or the expression's column reference otherwise.
+         */
+        template<typename S, typename SubselectColRef, typename ExplicitColRef>
+        auto determine_cte_colref(const S& /*impl*/,
+                                  const SubselectColRef& subselectColRef,
+                                  const ExplicitColRef& explicitColRef) {
+            if constexpr(polyfill::is_specialization_of_v<ExplicitColRef, alias_holder>) {
+                return explicitColRef;
+            } else if constexpr(is_field_member_pointer<ExplicitColRef>::value) {
+                return explicitColRef;
+            } else if constexpr(std::is_base_of_v<basic_column, ExplicitColRef>) {
+                return explicitColRef.member_pointer;
+            } else if constexpr(std::is_same_v<ExplicitColRef, std::string>) {
+                return subselectColRef;
+            } else if constexpr(std::is_same_v<ExplicitColRef, polyfill::remove_cvref_t<decltype(std::ignore)>>) {
+                return subselectColRef;
+            } else {
+                static_assert(polyfill::always_false_v<ExplicitColRef>, "Invalid explicit column reference specified");
+            }
+        }
 
-            context_type context{impl};
-            std::string tableName = alias_extractor<cte_label_type_t<cte_type>>::extract(std::true_type{});
-            auto subSelect = get_cte_driving_subselect(cte.subselect);
-            auto colRefs = extract_colref_expressions(impl, subSelect.col);
-            std::vector<std::string> columnNames =
-                collect_cte_column_names(subSelect, cte.explicitColumnNames, context);
+        template<typename S, typename SubselectColRefs, typename ExplicitColRefs, size_t... Idx>
+        auto determine_cte_colrefs(const S& impl,
+                                   const SubselectColRefs& subselectColRefs,
+                                   const ExplicitColRefs& explicitColRefs,
+                                   std::index_sequence<Idx...>) {
+            if constexpr(std::tuple_size_v < ExplicitColRefs >> 0) {
+                return std::tuple{determine_cte_colref(impl, get<Idx>(subselectColRefs), get<Idx>(explicitColRefs))...};
+            } else {
+                return subselectColRefs;
+            }
+        }
 
-            return create_cte_table_t<Mapper, typename Mapper::index_sequence>{
+        template<typename Mapper, typename S, typename ColRefs, size_t... CIs>
+        auto make_cte_table_using_column_indices(const S& impl,
+                                                 std::string tableName,
+                                                 std::vector<std::string> columnNames,
+                                                 const ColRefs& finalColRefs,
+                                                 std::index_sequence<CIs...>) {
+            return make_table<Mapper>(
                 move(tableName),
-                std::make_tuple(create_cte_column<Mapper, CIs>::make_column(move(columnNames.at(CIs)), colRefs)...)};
+                make_cte_column<std::tuple_element_t<CIs, typename Mapper::fields_type>>(move(columnNames.at(CIs)),
+                                                                                         get<CIs>(finalColRefs))...);
         }
 
         template<typename S, typename CTE>
         auto make_cte_table(const S& impl, const CTE& cte) {
             using cte_type = CTE;
-            using subselect_type = cte_driving_subselect_t<expression_type_t<cte_type>>;
-            using mapper_type = create_cte_mapper_t<cte_label_type_t<cte_type>,
-                                                    column_expression_of_t<S, subselect_type>,
-                                                    extracted_colref_expressions_t<S, subselect_type>,
-                                                    column_result_of_t<S, subselect_type>>;
-            static_assert(cte_type::explicit_column_count == 0 ||
-                              cte_type::explicit_column_count == mapper_type::index_sequence::size(),
+
+            auto subSelect = get_cte_driving_subselect(cte.subselect);
+
+            using subselect_type = decltype(subSelect);
+            using column_results = column_result_of_t<S, subselect_type>;
+            using index_sequence = std::make_index_sequence<std::tuple_size_v<tuplify_t<column_results>>>;
+            static_assert(cte_type::explicit_colref_count == 0 ||
+                              cte_type::explicit_colref_count == index_sequence::size(),
                           "Number of explicit columns of common table expression doesn't match the number of columns "
                           "in the subselect.");
 
-            return make_cte_table_using_column_indices<mapper_type>(impl, cte, typename mapper_type::index_sequence{});
+            using context_type = serializer_context<S>;
+
+            std::string tableName = alias_extractor<cte_label_type_t<cte_type>>::extract(std::true_type{});
+            auto subselectColRefs = extract_colref_expressions(impl, subSelect.col);
+            const auto& finalColRefs =
+                determine_cte_colrefs(impl, subselectColRefs, cte.explicitColumns, index_sequence{});
+            context_type context{impl};
+            std::vector<std::string> columnNames = collect_cte_column_names(subSelect, cte.explicitColumns, context);
+
+            using mapper_type = create_cte_mapper_t<cte_label_type_t<cte_type>,
+                                                    typename cte_type::explicit_colrefs_tuple,
+                                                    column_expression_of_t<S, subselect_type>,
+                                                    decltype(subselectColRefs),
+                                                    polyfill::remove_cvref_t<decltype(finalColRefs)>,
+                                                    column_results>;
+            return make_cte_table_using_column_indices<mapper_type>(impl,
+                                                                    move(tableName),
+                                                                    move(columnNames),
+                                                                    finalColRefs,
+                                                                    index_sequence{});
         }
 
         template<typename S, typename... CTEs, size_t Ii>
diff --git a/dev/cte_types.h b/dev/cte_types.h
index 5711c49e1..3c27d1dcd 100644
--- a/dev/cte_types.h
+++ b/dev/cte_types.h
@@ -24,10 +24,15 @@ namespace sqlite_orm {
         };
 
         /**
-         *  This class captures an expression of a subselect (basically select_t<>::return_type),
-         *  and is used as a proxy 
+         *  This class captures various properties and aspects of a subselect's column expression,
+         *  and is used as a proxy in table_t<>.
          */
-        template<typename Label, typename Expression, typename RefExpressions, typename... Fs>
+        template<typename Label,
+                 typename ExplicitColRefs,
+                 typename Expression,
+                 typename SubselectColRefs,
+                 typename FinalColRefs,
+                 typename... Fs>
         class subselect_mapper {
           public:
             subselect_mapper() = delete;
@@ -43,9 +48,14 @@ namespace sqlite_orm {
             // it is currently unused, however proves to be useful in compilation errors,
             // as it simplifies recognizing errors in column expressions
             using expressions_tuple = tuplify_t<Expression>;
-            // this type captures column reference expressions;
+            // this type captures column reference expressions specified at CTE construction;
             // those are: member pointers, alias holders
-            using colref_expressions_tuple = tuplify_t<RefExpressions>;
+            using explicit_colrefs_tuple = ExplicitColRefs;
+            // this type captures column reference expressions from the subselect;
+            // those are: member pointers, alias holders
+            using subselect_colrefs_tuple = SubselectColRefs;
+            // this type captures column reference expressions merged from SubselectColRefs and ExplicitColRefs
+            using final_colrefs_tuple = FinalColRefs;
         };
     }
 }
diff --git a/dev/member_traits/is_field_member_pointer.h b/dev/member_traits/is_field_member_pointer.h
index 9c525c449..213b19473 100644
--- a/dev/member_traits/is_field_member_pointer.h
+++ b/dev/member_traits/is_field_member_pointer.h
@@ -1,17 +1,11 @@
 #pragma once
 
-#include <type_traits>  //  std::false_type, std::true_type, std::is_member_pointer, std::is_member_function_pointer
+#include <type_traits>  //  std::is_member_object_pointer
 
 namespace sqlite_orm {
     namespace internal {
 
-        template<class T, class SFINAE = void>
-        struct is_field_member_pointer : std::false_type {};
-
         template<class T>
-        struct is_field_member_pointer<
-            T,
-            std::enable_if_t<std::is_member_pointer<T>::value && !std::is_member_function_pointer<T>::value>>
-            : std::true_type {};
+        using is_field_member_pointer = std::is_member_object_pointer<T>;
     }
 }
diff --git a/dev/member_traits/member_traits.h b/dev/member_traits/member_traits.h
index d02ab87cc..054dd1077 100644
--- a/dev/member_traits/member_traits.h
+++ b/dev/member_traits/member_traits.h
@@ -16,19 +16,19 @@ namespace sqlite_orm {
         struct member_traits;
 
         template<class T>
-        struct member_traits<T, typename std::enable_if<is_field_member_pointer<T>::value>::type> {
+        struct member_traits<T, std::enable_if_t<is_field_member_pointer<T>::value>> {
             using object_type = typename field_member_traits<T>::object_type;
             using field_type = typename field_member_traits<T>::field_type;
         };
 
         template<class T>
-        struct member_traits<T, typename std::enable_if<is_getter<T>::value>::type> {
+        struct member_traits<T, std::enable_if_t<is_getter<T>::value>> {
             using object_type = typename getter_traits<T>::object_type;
             using field_type = typename getter_traits<T>::field_type;
         };
 
         template<class T>
-        struct member_traits<T, typename std::enable_if<is_setter<T>::value>::type> {
+        struct member_traits<T, std::enable_if_t<is_setter<T>::value>> {
             using object_type = typename setter_traits<T>::object_type;
             using field_type = typename setter_traits<T>::field_type;
         };
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 8730433cf..81dd852fe 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -298,79 +298,100 @@ namespace sqlite_orm {
             }
         };
 
+        /*
+         *  Turn explicit columns for a CTE into types that the CTE backend understands
+         */
+        template<class T, class SFINAE = void>
+        struct decay_explicit_column {
+            using type = T;
+        };
+        template<class T>
+        struct decay_explicit_column<T, match_if<is_column_alias, T>> {
+            using type = alias_holder<T>;
+        };
+        template<class T>
+        struct decay_explicit_column<T, match_if<std::is_convertible, T, std::string>> {
+            using type = std::string;
+        };
+
         /**
          *  Labeled (aliased) CTE expression.
          */
-        template<class Label, class Select, class nExplicitCols>
+        template<class Label, class Select, class ExplicitCols, class nExplicitCols>
         struct common_table_expression {
             using cte_label_type = Label;
             using expression_type = Select;
-            static constexpr size_t explicit_column_count = nExplicitCols::value;
+            using explicit_colrefs_tuple = ExplicitCols;
+            static constexpr size_t explicit_colref_count = std::tuple_size_v<ExplicitCols>;
 
-            std::vector<std::string> explicitColumnNames;
+            explicit_colrefs_tuple explicitColumns;
             expression_type subselect;
 
-            common_table_expression(std::vector<std::string> explicitColumnNames, expression_type subselect) :
-                explicitColumnNames{move(explicitColumnNames)}, subselect{std::move(subselect)} {
+            common_table_expression(explicit_colrefs_tuple explicitColumns, expression_type subselect) :
+                explicitColumns{move(explicitColumns)}, subselect{std::move(subselect)} {
                 this->subselect.highest_level = true;
             }
         };
         template<class... CTEs>
         using common_table_expressions = std::tuple<CTEs...>;
 
-        template<typename Label, class nExplicitCols>
+        template<typename Label, class ExplicitCols, class nExplicitCols>
         struct cte_builder {
-            std::vector<std::string> explicitColumnNames;
+            ExplicitCols explicitColumns;
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, nExplicitCols>
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
             operator()(select_t<T, Args...> sel) && {
-                return {move(this->explicitColumnNames), std::move(sel)};
+                return {move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, nExplicitCols> operator()(Compound sel) && {
-                return {move(this->explicitColumnNames), {std::move(sel)}};
+            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols>
+            operator()(Compound sel) && {
+                return {move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, nExplicitCols> as(select_t<T, Args...> sel) && {
-                return {move(this->explicitColumnNames), std::move(sel)};
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
+            as(select_t<T, Args...> sel) && {
+                return {move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, nExplicitCols> as(Compound sel) && {
-                return {move(this->explicitColumnNames), {std::move(sel)}};
+            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols> as(Compound sel) && {
+                return {move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, nExplicitCols>
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
             materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumnNames), std::move(sel)};
+                return {move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, nExplicitCols> materialized(Compound sel) && {
+            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols>
+            materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumnNames), {std::move(sel)}};
+                return {move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, nExplicitCols>
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
             not_materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumnNames), std::move(sel)};
+                return {move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, nExplicitCols> not_materialized(Compound sel) && {
+            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols>
+            not_materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumnNames), {std::move(sel)}};
+                return {move(this->explicitColumns), {std::move(sel)}};
             }
         };
 
@@ -601,44 +622,65 @@ namespace sqlite_orm {
 
     /**
      *  Example : cte<cte_1>()(select(&Object::id));
-     *  The list of column names is optional;
+     *  The list of explicit columns is optional;
      *  if provided the number of columns must match the number of columns of the subselect.
      *  The column names will be merged with the subselect:
      *  1. column names of subselect
      *  2. explicit columns
-     *  3. fill in empty column names with stringified column index
+     *  3. fill in empty column names with column index
      */
     template<class Label,
-             class... ColumnNames,
-             std::enable_if_t<polyfill::conjunction_v<std::is_convertible<ColumnNames, std::string>...>, bool> = true>
-    internal::cte_builder<Label, polyfill::index_constant<sizeof...(ColumnNames)>>
-    cte(ColumnNames... explicitColumnNames) {
-        return {{std::move(explicitColumnNames)...}};
+             class... ExplicitCols,
+             std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
+                                  internal::is_column_alias<ExplicitCols>,
+                                  internal::is_field_member_pointer<ExplicitCols>,
+                                  internal::is_column<ExplicitCols>,
+                                  std::is_same<ExplicitCols, polyfill::remove_cvref_t<decltype(std::ignore)>>,
+                                  std::is_convertible<ExplicitCols, std::string>>...>,
+                              bool> = true>
+    auto cte(ExplicitCols... explicitColumns) {
+        static_assert(internal::is_cte_alias_v<Label>, "Label must be a CTE alias");
+        using builder_type = internal::cte_builder<
+            Label,
+            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column>,
+            polyfill::index_constant<sizeof...(ExplicitCols)>>;
+        return builder_type{{std::move(explicitColumns)...}};
     }
 
 #if __cplusplus >= 202002L  // C++20 and later
     template<auto label,
-             class... ColumnNames,
-             std::enable_if_t<polyfill::conjunction_v<std::is_convertible<ColumnNames, std::string>...>, bool> = true>
-    internal::cte_builder<decltype(label), polyfill::index_constant<sizeof...(ColumnNames)>>
-    cte(ColumnNames... explicitColumnNames) {
-        return {{std::move(explicitColumnNames)...}};
+             class... ExplicitCols,
+             std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
+                                  internal::is_column_alias<ExplicitCols>,
+                                  internal::is_field_member_pointer<ExplicitCols>,
+                                  internal::is_column<ExplicitCols>,
+                                  std::is_same<ExplicitCols, std::remove_cvref_t<decltype(std::ignore)>>,
+                                  std::is_convertible<ExplicitCols, std::string>>...>,
+                              bool> = true>
+    auto cte(ExplicitCols... explicitColumns) {
+        static_assert(internal::is_cte_alias_v<decltype(label)>, "Label must be a CTE alias");
+        using builder_type = internal::cte_builder<
+            decltype(label),
+            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column>,
+            polyfill::index_constant<sizeof...(ExplicitCols)>>;
+        return builder_type{{std::move(explicitColumns)...}};
     }
 #endif
 
     // tuple of CTEs
-    template<class E, class... Labels, class... Selects, class... nExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Labels, Selects, nExplicitCols>...>
-    with(std::tuple<internal::common_table_expression<Labels, Selects, nExplicitCols>...> cte, E expression) {
+    template<class E, class... Labels, class... Selects, class... ExplicitCols, class... nExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Labels, Selects, ExplicitCols, nExplicitCols>...>
+    with(std::tuple<internal::common_table_expression<Labels, Selects, ExplicitCols, nExplicitCols>...> cte,
+         E expression) {
         return {move(cte), std::move(expression)};
     }
 
     /** A single CTE.
      *  Example : with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
      */
-    template<class E, class Label, class Select, class nExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Label, Select, nExplicitCols>>
-    with(internal::common_table_expression<Label, Select, nExplicitCols> cte, E expression) {
+    template<class E, class Label, class Select, class ExplicitCols, class nExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Label, Select, ExplicitCols, nExplicitCols>>
+    with(internal::common_table_expression<Label, Select, ExplicitCols, nExplicitCols> cte, E expression) {
         return {std::make_tuple(move(cte)), std::move(expression)};
     }
 
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index e9256512a..88bf6a98c 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -791,12 +791,12 @@ namespace sqlite_orm {
             using statement_type = column_pointer<T, F>;
 
             template<class Ctx>
-            std::string operator()(const statement_type& c, const Ctx& context) const {
+            std::string operator()(const statement_type& cp, const Ctx& context) const {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
                     ss << streaming_identifier(lookup_table_name<T>(context.impl)) << ".";
                 }
-                if(auto* columnName = find_column_name(context.impl, c)) {
+                if(auto* columnName = find_column_name(context.impl, cp)) {
                     ss << streaming_identifier(*columnName);
                 } else {
                     throw std::system_error{orm_error_code::column_not_found};
@@ -823,7 +823,7 @@ namespace sqlite_orm {
             using statement_type = CTE;
 
             template<class Ctx>
-            std::string operator()(const statement_type& c, const Ctx& context) const {
+            std::string operator()(const statement_type& cte, const Ctx& context) const {
                 // A CTE always starts a new 'highest level' context
                 Ctx cteContext = context;
                 cteContext.use_parentheses = false;
@@ -832,12 +832,12 @@ namespace sqlite_orm {
                 ss << streaming_identifier(alias_extractor<cte_label_type_t<CTE>>::extract(std::true_type{}));
                 {
                     std::vector<std::string> columnNames =
-                        collect_cte_column_names(get_cte_driving_subselect(c.subselect),
-                                                 c.explicitColumnNames,
+                        collect_cte_column_names(get_cte_driving_subselect(cte.subselect),
+                                                 cte.explicitColumns,
                                                  context);
                     ss << '(' << streaming_identifiers(columnNames) << ')';
                 }
-                ss << " AS " << '(' << serialize(c.subselect, cteContext) << ')';
+                ss << " AS " << '(' << serialize(cte.subselect, cteContext) << ')';
                 return ss.str();
             }
         };
diff --git a/dev/storage.h b/dev/storage.h
index 7ec2e5263..e97fe9924 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -578,9 +578,9 @@ namespace sqlite_orm {
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class Label, class Select, class nExplicitCols, class T, class... Args>
-            auto with(common_table_expression<Label, Select, nExplicitCols> cte, select_t<T, Args...> sel) {
-                auto statement = this->prepare(sqlite_orm::with(move(cte), std::move(sel)));
+            template<class CTE, class T, class... Args>
+            auto with(CTE cte, select_t<T, Args...> sel) {
+                auto statement = this->prepare(sqlite_orm::with(std::move(cte), std::move(sel)));
                 return this->execute(statement);
             }
 
@@ -596,13 +596,11 @@ namespace sqlite_orm {
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class Label,
-                     class Select,
-                     class nExplicitCols,
+            template<class CTE,
                      class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            auto with(common_table_expression<Label, Select, nExplicitCols> cte, Compound sel) {
-                auto statement = this->prepare(sqlite_orm::with(move(cte), sqlite_orm::select(std::move(sel))));
+            auto with(CTE cte, Compound sel) {
+                auto statement = this->prepare(sqlite_orm::with(std::move(cte), sqlite_orm::select(std::move(sel))));
                 return this->execute(statement);
             }
 
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 03b0eb162..2085f8c58 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -198,7 +198,7 @@ namespace sqlite_orm {
 
             // filter all column references [`alias_holder<>`]
             using alias_types_tuple =
-                transform_tuple_t<typename cte_mapper_type::colref_expressions_tuple, alias_type_or_none>;
+                transform_tuple_t<typename cte_mapper_type::final_colrefs_tuple, alias_holder_type_or_none>;
 
             // lookup index in alias_types_tuple by Alias
             constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
@@ -229,10 +229,10 @@ namespace sqlite_orm {
             using elements_t = typename timpl_type::table_type::elements_type;
             using column_idxs = filter_tuple_sequence_t<elements_t, is_column>;
 
-            // note: even though the columns contain the `[aliased_field<>::*` we perform the lookup using the column references.
+            // note: even though the columns contain the [`aliased_field<>::*`] we perform the lookup using the column references.
             // filter all column references [`alias_holder<>`]
             using alias_types_tuple =
-                transform_tuple_t<typename cte_mapper_type::colref_expressions_tuple, alias_type_or_none>;
+                transform_tuple_t<typename cte_mapper_type::final_colrefs_tuple, alias_holder_type_or_none>;
 
             // lookup index of ColAlias in alias_types_tuple
             static constexpr auto I = tuple_index_of_v<ColAlias, alias_types_tuple>;
diff --git a/dev/table.h b/dev/table.h
index 9fd9947bd..786f0fc8c 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -132,7 +132,7 @@ namespace sqlite_orm {
             template<class L>
             void for_each_primary_key(const L& lambda) const {
                 iterate_tuple(this->elements, [&lambda](auto& element) {
-                    using element_type = typename std::decay<decltype(element)>::type;
+                    using element_type = std::decay_t<decltype(element)>;
                     static_if<is_primary_key<element_type>{}>(lambda)(element);
                 });
             }
@@ -268,7 +268,7 @@ namespace sqlite_orm {
             template<class L>
             void for_each_column(const L& lambda) const {
                 iterate_tuple(this->elements, [&lambda](auto& element) {
-                    using element_type = typename std::decay<decltype(element)>::type;
+                    using element_type = std::decay_t<decltype(element)>;
                     static_if<is_column<element_type>{}>(lambda)(element);
                 });
             }
@@ -276,7 +276,7 @@ namespace sqlite_orm {
             template<class L>
             void for_each_foreign_key(const L& lambda) const {
                 iterate_tuple(this->elements, [&lambda](auto& element) {
-                    using element_type = typename std::decay<decltype(element)>::type;
+                    using element_type = std::decay_t<decltype(element)>;
                     static_if<is_foreign_key<element_type>{}>(lambda)(element);
                 });
             }
@@ -284,7 +284,7 @@ namespace sqlite_orm {
             template<class F, class L>
             void for_each_column_with_field_type(const L& lambda) const {
                 this->for_each_column([&lambda](auto& column) {
-                    using column_type = typename std::decay<decltype(column)>::type;
+                    using column_type = std::decay_t<decltype(column)>;
                     using field_type = typename column_field_type<column_type>::type;
                     static_if<std::is_same<F, field_type>{}>(lambda)(column);
                 });
@@ -300,7 +300,7 @@ namespace sqlite_orm {
             void for_each_column_with(const L& lambda) const {
                 this->for_each_column([&lambda](auto& column) {
                     using tuple_helper::tuple_contains_type;
-                    using column_type = typename std::decay<decltype(column)>::type;
+                    using column_type = std::decay_t<decltype(column)>;
                     using constraints_type = typename column_constraints_type<column_type>::type;
                     static_if<tuple_contains_type<Op, constraints_type>{}>(lambda)(column);
                 });
diff --git a/dev/tuple_helper/tuple_helper.h b/dev/tuple_helper/tuple_helper.h
index 0b88c4563..cd6912c45 100644
--- a/dev/tuple_helper/tuple_helper.h
+++ b/dev/tuple_helper/tuple_helper.h
@@ -202,6 +202,7 @@ namespace sqlite_orm {
         template<size_t... Idx>
         SQLITE_ORM_CONSTEVAL size_t index_sequence_value(size_t pos, std::index_sequence<Idx...>) {
             constexpr std::array<size_t, sizeof...(Idx)> values{Idx...};
+            static_assert(values.size() > 0, "");
             return values[pos];
         }
 
diff --git a/dev/type_traits.h b/dev/type_traits.h
index 45c7271cc..ae17717ac 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -73,7 +73,7 @@ namespace sqlite_orm {
 
         // T::alias_type or nonesuch
         template<class T>
-        using alias_type_or_none = polyfill::detected<alias_type_t, T>;
+        using alias_holder_type_or_none = polyfill::detected<type_t, T>;
     }
 
     namespace internal {
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 37aa9c4c0..d6a0cc8b4 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -26,10 +26,18 @@ void all_integers_between(int from, int end) {
         //WITH RECURSIVE
         //    cnt(x) AS(VALUES(1) UNION ALL SELECT x + 1 FROM cnt WHERE x < 1000000)
         //    SELECT x FROM cnt;
+#if __cpp_nontype_template_args >= 201911
+        constexpr auto cnt_cte = "cnt"_cte;
+        auto ast =
+            with(cte<cnt_cte>()(
+                     union_all(select(from), select(cnt_cte->*1_colalias + c(1), where(cnt_cte->*1_colalias < end)))),
+                 select(cnt_cte->*1_colalias));
+#else
         auto ast =
             with(cte<cte_1>()(union_all(select(from),
                                         select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < end)))),
                  select(1_ctealias->*1_colalias));
+#endif
 // alternative
 #if 0
         auto ast = with(
@@ -60,9 +68,15 @@ void all_integers_between(int from, int end) {
         //        LIMIT 1000000
         //    )
         //    SELECT x FROM cnt;
+#if __cpp_nontype_template_args >= 201911
+        auto ast = with(cte<"cnt"_cte>("y"_col)(
+                            union_all(select(from >>= "x"_col), select("cnt"_cte->*"y"_col + c(1), limit(end)))),
+                        select("cnt"_cte->*"y"_col));
+#else
         auto ast = with(cte<cte_1>()(union_all(select(as<colalias_f>(from)),
                                                select(column<cte_1>->*colalias_f{} + c(1), limit(end)))),
                         select(column<cte_1>->*colalias_f{}));
+#endif
 
         string sql = storage.dump(ast);
 
@@ -135,7 +149,7 @@ void supervisor_chain() {
         //        WHERE parent.name = chain.boss
         //    )
         //    SELECT name FROM chain;
-#if __cplusplus >= 202002L  // C++20 or later
+#if __cpp_nontype_template_args >= 201911
         auto ast = with(cte<"chain"_cte>()(union_all(
                             select(asterisk<Org>(), where(&Org::name == c("Fred"))),
                             select(asterisk<alias_a<Org>>(),
@@ -201,15 +215,15 @@ void works_for_alice() {
         //    )
         //    SELECT avg(height) FROM org
         //    WHERE org.name IN works_for_alice;
-#if __cplusplus >= 202002L  // C++20 or later
+#if __cpp_nontype_template_args >= 201911
         constexpr auto works_for_alice = "works_for_alice"_cte;
         auto ast =
-            with(cte<works_for_alice>("n")(
-                     union_(select("Alice"), select(&Org::name, where(c(&Org::boss) == works_for_alice->*1_colalias)))),
-                 select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(works_for_alice->*1_colalias)))));
+            with(cte<works_for_alice>("n"_col)(
+                     union_(select("Alice"), select(&Org::name, where(c(&Org::boss) == works_for_alice->*"n"_col)))),
+                 select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(works_for_alice->*"n"_col)))));
 #else
         auto ast =
-            with(cte<cte_1>("n")(
+            with(cte<cte_1>()(
                      union_(select("Alice"), select(&Org::name, where(c(&Org::boss) == column<cte_1>->*1_colalias)))),
                  select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<cte_1>->*1_colalias)))));
 #endif
@@ -286,18 +300,19 @@ void family_tree() {
     //    WHERE ancestor_of_alice.name = family.name
     //    AND died IS NULL
     //    ORDER BY born;
-#if __cplusplus >= 202002L  // C++20 or later
+#if __cpp_nontype_template_args >= 201911
     constexpr auto parent_of = "parent_of"_cte;
     constexpr auto ancestor_of_alice = "ancestor_of_alice"_cte;
     constexpr auto parent_col = "parent"_col;
+    constexpr auto name_col = "name"_col;
     auto ast = with(
-        make_tuple(cte<parent_of>("name", "parent")(union_(select(columns(&Family::name, &Family::mom >>= parent_col)),
-                                                           select(columns(&Family::name, &Family::dad)))),
-                   cte<ancestor_of_alice>("name")(union_all(
+        make_tuple(cte<parent_of>(&Family::name, parent_col)(union_(select(columns(&Family::name, &Family::mom)),
+                                                                    select(columns(&Family::name, &Family::dad)))),
+                   cte<ancestor_of_alice>(name_col)(union_all(
                        select(parent_of->*parent_col, where(parent_of->*&Family::name == "Alice")),
                        select(parent_of->*parent_col, join<ancestor_of_alice>(using_(parent_of->*&Family::name)))))),
         select(&Family::name,
-               where(is_equal(ancestor_of_alice->*parent_col, &Family::name) && is_null(&Family::died)),
+               where(is_equal(ancestor_of_alice->*name_col, &Family::name) && is_null(&Family::died)),
                order_by(&Family::born)));
 #else
     auto ast = with(
@@ -403,15 +418,15 @@ void depth_or_breadth_first() {
         //        ORDER BY 2
         //    )
         //    SELECT substr('..........', 1, level * 3) || name FROM under_alice;
-#if __cplusplus >= 202002L  // C++20 or later
+#if __cpp_nontype_template_args >= 201911
         constexpr auto under_alice = "under_alice"_cte;
-        auto ast =
-            with(cte<under_alice>("name", "level")(
-                     union_all(select(columns("Alice", 0)),
-                               select(columns(&Org::name, under_alice->*2_colalias + c(1)),
-                                      join<under_alice>(on(under_alice->*1_colalias == &Org::boss)),
-                                      order_by(2)))),
-                 select(substr("..........", 1, under_alice->*2_colalias * c(3)) || c(under_alice->*1_colalias)));
+        constexpr auto level_col = "level"_col;
+        auto ast = with(cte<under_alice>(&Org::name, level_col)(
+                            union_all(select(columns("Alice", 0)),
+                                      select(columns(&Org::name, under_alice->*level_col + c(1)),
+                                             join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
+                                             order_by(2)))),
+                        select(substr("..........", 1, under_alice->*level_col * c(3)) || c(under_alice->*&Org::name)));
 #else
         auto ast =
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
@@ -444,15 +459,15 @@ void depth_or_breadth_first() {
         //        ORDER BY 2
         //    )
         //    SELECT substr('..........', 1, level * 3) || name FROM under_alice;
-#if __cplusplus >= 202002L  // C++20 or later
+#if __cpp_nontype_template_args >= 201911
         constexpr auto under_alice = "under_alice"_cte;
-        auto ast =
-            with(cte<under_alice>("name", "level")(
-                     union_all(select(columns("Alice", 0)),
-                               select(columns(&Org::name, under_alice->*2_colalias + c(1)),
-                                      join<under_alice>(on(under_alice->*1_colalias == &Org::boss)),
-                                      order_by(2).desc()))),
-                 select(substr("..........", 1, under_alice->*2_colalias * c(3)) || c(under_alice->*1_colalias)));
+        constexpr auto level_col = "level"_col;
+        auto ast = with(cte<under_alice>(&Org::name, level_col)(
+                            union_all(select(columns("Alice", 0)),
+                                      select(columns(&Org::name, under_alice->*level_col + c(1)),
+                                             join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
+                                             order_by(2).desc()))),
+                        select(substr("..........", 1, under_alice->*level_col * c(3)) || c(under_alice->*&Org::name)));
 #else
         auto ast =
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
@@ -497,7 +512,7 @@ void apfelmaennchen() {
     //        FROM m2 GROUP BY cy
     //    )
     //    SELECT group_concat(rtrim(t), x'0a') FROM a;
-#if __cplusplus >= 202002L  // C++20 or later
+#if __cpp_nontype_template_args >= 201911
     constexpr auto xaxis = "xaxis"_cte;
     constexpr auto yaxis = "yaxis"_cte;
     constexpr auto m = "mi"_cte;
@@ -603,8 +618,7 @@ void show_mapping_and_backreferencing() {
     auto storage = make_storage("", make_table("object", make_column("id", &Object::id)));
     storage.sync_schema();
 
-    // map column via integral pointer-to-member into cte,
-    // back-reference via `column_pointer<cte_1, ice_t<>>`
+    // back-reference via `column_pointer<cte_1, F O::*>`
     {
         auto ast = with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*&Object::id));
 
@@ -651,13 +665,26 @@ void show_mapping_and_backreferencing() {
         auto stmt = storage.prepare(ast);
     }
 
-    // map column via integral pointer-to-member into cte,
-    // back-reference via `column_pointer<cte_1, ice_t<>>`
+    // explicitly state that column name should be taken from subselect
     {
-        //auto ast = with(cte<cte_1>("x")(union_all(select(&Object::id),
-        //                                          select(column<cte_1>(&Object::id) + c(1), limit(10)))),
-        //                select(column<cte_1>(&Object::id)));
-        auto ast = with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
+        auto ast = with(cte<cte_1>(std::ignore)(select(&Object::id)), select(column<cte_1>(&Object::id)));
+
+        string sql = storage.dump(ast);
+        auto stmt = storage.prepare(ast);
+    }
+
+    // explicitly state that column name should be taken from subselect
+    {
+        struct CTEObject : alias_tag {
+            using type = CTEObject;
+            static std::string get() {
+                return "CTEObj";
+            }
+
+            int64 xyz;
+        };
+        auto ast =
+            with(cte<CTEObject>(make_column("xyz", &CTEObject::xyz))(select(&Object::id)), select(&CTEObject::xyz));
 
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 70a78a5b8..d722a96d1 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -261,7 +261,7 @@ namespace sqlite_orm {
 
         // T::alias_type or nonesuch
         template<class T>
-        using alias_type_or_none = polyfill::detected<alias_type_t, T>;
+        using alias_holder_type_or_none = polyfill::detected<type_t, T>;
     }
 
     namespace internal {
@@ -710,6 +710,7 @@ namespace sqlite_orm {
         template<size_t... Idx>
         SQLITE_ORM_CONSTEVAL size_t index_sequence_value(size_t pos, std::index_sequence<Idx...>) {
             constexpr std::array<size_t, sizeof...(Idx)> values{Idx...};
+            static_assert(values.size() > 0, "");
             return values[pos];
         }
 
@@ -1293,19 +1294,13 @@ namespace sqlite_orm {
 
 // #include "member_traits/is_field_member_pointer.h"
 
-#include <type_traits>  //  std::false_type, std::true_type, std::is_member_pointer, std::is_member_function_pointer
+#include <type_traits>  //  std::is_member_object_pointer
 
 namespace sqlite_orm {
     namespace internal {
 
-        template<class T, class SFINAE = void>
-        struct is_field_member_pointer : std::false_type {};
-
         template<class T>
-        struct is_field_member_pointer<
-            T,
-            std::enable_if_t<std::is_member_pointer<T>::value && !std::is_member_function_pointer<T>::value>>
-            : std::true_type {};
+        using is_field_member_pointer = std::is_member_object_pointer<T>;
     }
 }
 
@@ -2295,19 +2290,19 @@ namespace sqlite_orm {
         struct member_traits;
 
         template<class T>
-        struct member_traits<T, typename std::enable_if<is_field_member_pointer<T>::value>::type> {
+        struct member_traits<T, std::enable_if_t<is_field_member_pointer<T>::value>> {
             using object_type = typename field_member_traits<T>::object_type;
             using field_type = typename field_member_traits<T>::field_type;
         };
 
         template<class T>
-        struct member_traits<T, typename std::enable_if<is_getter<T>::value>::type> {
+        struct member_traits<T, std::enable_if_t<is_getter<T>::value>> {
             using object_type = typename getter_traits<T>::object_type;
             using field_type = typename getter_traits<T>::field_type;
         };
 
         template<class T>
-        struct member_traits<T, typename std::enable_if<is_setter<T>::value>::type> {
+        struct member_traits<T, std::enable_if_t<is_setter<T>::value>> {
             using object_type = typename setter_traits<T>::object_type;
             using field_type = typename setter_traits<T>::field_type;
         };
@@ -4268,7 +4263,7 @@ namespace sqlite_orm {
         template<class A>
         using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cpp_nontype_template_args >= 201911
         /*  
          *  Helper class to facilitate user-defined string literal operator template
          */
@@ -4278,13 +4273,21 @@ namespace sqlite_orm {
                 return N - 1;
             }
 
+#ifdef _MSC_VER
             constexpr string_identifier_template(const char (&id)[N]) : id{id} {}
 
             const char (&id)[N];
+#else
+            constexpr string_identifier_template(const char (&id)[N]) {
+                std::copy_n(id, N, this->id);
+            }
+
+            char id[N];
+#endif
         };
 
         template<template<char...> class Alias, string_identifier_template t, size_t... Idx>
-        SQLITE_ORM_CONSTEVAL auto to_alias(std::index_sequence<Idx...>) {
+        consteval auto to_alias(std::index_sequence<Idx...>) {
             return Alias<t.id[Idx]...>{};
         }
 #endif
@@ -4300,7 +4303,7 @@ namespace sqlite_orm {
         struct table_alias : alias_tag {
             using type = T;
 
-            constexpr static std::string get() {
+            static std::string get() {
                 return {A, X...};
             }
         };
@@ -4368,7 +4371,10 @@ namespace sqlite_orm {
         template<class T>
         struct alias_holder {
             using type = T;
-            using alias_type = type;
+
+            alias_holder() = default;
+            // CTE feature needs it to implicitly convert a column alias to an alias_holder; see `cte()` factory function
+            alias_holder(const T&) noexcept {}
         };
 
         template<size_t n, char... C>
@@ -4505,13 +4511,13 @@ namespace sqlite_orm {
         return internal::column_alias<Chars...>{};
     }
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cpp_nontype_template_args >= 201911
     /**
      *  column_alias<'a'[, ...]> from a string literal.
      *  E.g. "a"_col, "b"_col
      */
     template<internal::string_identifier_template t>
-    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _col() {
+    [[nodiscard]] consteval auto operator"" _col() {
         return internal::to_alias<internal::column_alias, t>(std::make_index_sequence<t.size()>{});
     }
 #endif
@@ -7174,79 +7180,100 @@ namespace sqlite_orm {
             }
         };
 
+        /*
+         *  Turn explicit columns for a CTE into types that the CTE backend understands
+         */
+        template<class T, class SFINAE = void>
+        struct decay_explicit_column {
+            using type = T;
+        };
+        template<class T>
+        struct decay_explicit_column<T, match_if<is_column_alias, T>> {
+            using type = alias_holder<T>;
+        };
+        template<class T>
+        struct decay_explicit_column<T, match_if<std::is_convertible, T, std::string>> {
+            using type = std::string;
+        };
+
         /**
          *  Labeled (aliased) CTE expression.
          */
-        template<class Label, class Select, class nExplicitCols>
+        template<class Label, class Select, class ExplicitCols, class nExplicitCols>
         struct common_table_expression {
             using cte_label_type = Label;
             using expression_type = Select;
-            static constexpr size_t explicit_column_count = nExplicitCols::value;
+            using explicit_colrefs_tuple = ExplicitCols;
+            static constexpr size_t explicit_colref_count = std::tuple_size_v<ExplicitCols>;
 
-            std::vector<std::string> explicitColumnNames;
+            explicit_colrefs_tuple explicitColumns;
             expression_type subselect;
 
-            common_table_expression(std::vector<std::string> explicitColumnNames, expression_type subselect) :
-                explicitColumnNames{move(explicitColumnNames)}, subselect{std::move(subselect)} {
+            common_table_expression(explicit_colrefs_tuple explicitColumns, expression_type subselect) :
+                explicitColumns{move(explicitColumns)}, subselect{std::move(subselect)} {
                 this->subselect.highest_level = true;
             }
         };
         template<class... CTEs>
         using common_table_expressions = std::tuple<CTEs...>;
 
-        template<typename Label, class nExplicitCols>
+        template<typename Label, class ExplicitCols, class nExplicitCols>
         struct cte_builder {
-            std::vector<std::string> explicitColumnNames;
+            ExplicitCols explicitColumns;
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, nExplicitCols>
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
             operator()(select_t<T, Args...> sel) && {
-                return {move(this->explicitColumnNames), std::move(sel)};
+                return {move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, nExplicitCols> operator()(Compound sel) && {
-                return {move(this->explicitColumnNames), {std::move(sel)}};
+            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols>
+            operator()(Compound sel) && {
+                return {move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, nExplicitCols> as(select_t<T, Args...> sel) && {
-                return {move(this->explicitColumnNames), std::move(sel)};
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
+            as(select_t<T, Args...> sel) && {
+                return {move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, nExplicitCols> as(Compound sel) && {
-                return {move(this->explicitColumnNames), {std::move(sel)}};
+            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols> as(Compound sel) && {
+                return {move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, nExplicitCols>
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
             materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumnNames), std::move(sel)};
+                return {move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, nExplicitCols> materialized(Compound sel) && {
+            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols>
+            materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumnNames), {std::move(sel)}};
+                return {move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, nExplicitCols>
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
             not_materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumnNames), std::move(sel)};
+                return {move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, nExplicitCols> not_materialized(Compound sel) && {
+            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols>
+            not_materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumnNames), {std::move(sel)}};
+                return {move(this->explicitColumns), {std::move(sel)}};
             }
         };
 
@@ -7477,44 +7504,65 @@ namespace sqlite_orm {
 
     /**
      *  Example : cte<cte_1>()(select(&Object::id));
-     *  The list of column names is optional;
+     *  The list of explicit columns is optional;
      *  if provided the number of columns must match the number of columns of the subselect.
      *  The column names will be merged with the subselect:
      *  1. column names of subselect
      *  2. explicit columns
-     *  3. fill in empty column names with stringified column index
+     *  3. fill in empty column names with column index
      */
     template<class Label,
-             class... ColumnNames,
-             std::enable_if_t<polyfill::conjunction_v<std::is_convertible<ColumnNames, std::string>...>, bool> = true>
-    internal::cte_builder<Label, polyfill::index_constant<sizeof...(ColumnNames)>>
-    cte(ColumnNames... explicitColumnNames) {
-        return {{std::move(explicitColumnNames)...}};
+             class... ExplicitCols,
+             std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
+                                  internal::is_column_alias<ExplicitCols>,
+                                  internal::is_field_member_pointer<ExplicitCols>,
+                                  internal::is_column<ExplicitCols>,
+                                  std::is_same<ExplicitCols, polyfill::remove_cvref_t<decltype(std::ignore)>>,
+                                  std::is_convertible<ExplicitCols, std::string>>...>,
+                              bool> = true>
+    auto cte(ExplicitCols... explicitColumns) {
+        static_assert(internal::is_cte_alias_v<Label>, "Label must be a CTE alias");
+        using builder_type = internal::cte_builder<
+            Label,
+            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column>,
+            polyfill::index_constant<sizeof...(ExplicitCols)>>;
+        return builder_type{{std::move(explicitColumns)...}};
     }
 
 #if __cplusplus >= 202002L  // C++20 and later
     template<auto label,
-             class... ColumnNames,
-             std::enable_if_t<polyfill::conjunction_v<std::is_convertible<ColumnNames, std::string>...>, bool> = true>
-    internal::cte_builder<decltype(label), polyfill::index_constant<sizeof...(ColumnNames)>>
-    cte(ColumnNames... explicitColumnNames) {
-        return {{std::move(explicitColumnNames)...}};
+             class... ExplicitCols,
+             std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
+                                  internal::is_column_alias<ExplicitCols>,
+                                  internal::is_field_member_pointer<ExplicitCols>,
+                                  internal::is_column<ExplicitCols>,
+                                  std::is_same<ExplicitCols, std::remove_cvref_t<decltype(std::ignore)>>,
+                                  std::is_convertible<ExplicitCols, std::string>>...>,
+                              bool> = true>
+    auto cte(ExplicitCols... explicitColumns) {
+        static_assert(internal::is_cte_alias_v<decltype(label)>, "Label must be a CTE alias");
+        using builder_type = internal::cte_builder<
+            decltype(label),
+            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column>,
+            polyfill::index_constant<sizeof...(ExplicitCols)>>;
+        return builder_type{{std::move(explicitColumns)...}};
     }
 #endif
 
     // tuple of CTEs
-    template<class E, class... Labels, class... Selects, class... nExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Labels, Selects, nExplicitCols>...>
-    with(std::tuple<internal::common_table_expression<Labels, Selects, nExplicitCols>...> cte, E expression) {
+    template<class E, class... Labels, class... Selects, class... ExplicitCols, class... nExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Labels, Selects, ExplicitCols, nExplicitCols>...>
+    with(std::tuple<internal::common_table_expression<Labels, Selects, ExplicitCols, nExplicitCols>...> cte,
+         E expression) {
         return {move(cte), std::move(expression)};
     }
 
     /** A single CTE.
      *  Example : with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
      */
-    template<class E, class Label, class Select, class nExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Label, Select, nExplicitCols>>
-    with(internal::common_table_expression<Label, Select, nExplicitCols> cte, E expression) {
+    template<class E, class Label, class Select, class ExplicitCols, class nExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Label, Select, ExplicitCols, nExplicitCols>>
+    with(internal::common_table_expression<Label, Select, ExplicitCols, nExplicitCols> cte, E expression) {
         return {std::make_tuple(move(cte)), std::move(expression)};
     }
 
@@ -9450,10 +9498,15 @@ namespace sqlite_orm {
         };
 
         /**
-         *  This class captures an expression of a subselect (basically select_t<>::return_type),
-         *  and is used as a proxy 
+         *  This class captures various properties and aspects of a subselect's column expression,
+         *  and is used as a proxy in table_t<>.
          */
-        template<typename Label, typename Expression, typename RefExpressions, typename... Fs>
+        template<typename Label,
+                 typename ExplicitColRefs,
+                 typename Expression,
+                 typename SubselectColRefs,
+                 typename FinalColRefs,
+                 typename... Fs>
         class subselect_mapper {
           public:
             subselect_mapper() = delete;
@@ -9469,9 +9522,14 @@ namespace sqlite_orm {
             // it is currently unused, however proves to be useful in compilation errors,
             // as it simplifies recognizing errors in column expressions
             using expressions_tuple = tuplify_t<Expression>;
-            // this type captures column reference expressions;
+            // this type captures column reference expressions specified at CTE construction;
             // those are: member pointers, alias holders
-            using colref_expressions_tuple = tuplify_t<RefExpressions>;
+            using explicit_colrefs_tuple = ExplicitColRefs;
+            // this type captures column reference expressions from the subselect;
+            // those are: member pointers, alias holders
+            using subselect_colrefs_tuple = SubselectColRefs;
+            // this type captures column reference expressions merged from SubselectColRefs and ExplicitColRefs
+            using final_colrefs_tuple = FinalColRefs;
         };
     }
 }
@@ -10524,9 +10582,9 @@ namespace sqlite_orm {
             using timpl_type = storage_pick_impl_t<St, Label>;
             using cte_mapper_type = storage_cte_mapper_type_t<timpl_type>;
 
-            // filter all column references [`alias_holder<>`]
+            // filter all column references being `alias_holder<>`
             using alias_types_tuple =
-                transform_tuple_t<typename cte_mapper_type::colref_expressions_tuple, alias_type_or_none>;
+                transform_tuple_t<typename cte_mapper_type::final_colrefs_tuple, alias_holder_type_or_none>;
 
             // lookup index of ColAlias in alias_types_tuple
             static constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
@@ -10769,7 +10827,7 @@ namespace sqlite_orm {
             template<class L>
             void for_each_primary_key(const L& lambda) const {
                 iterate_tuple(this->elements, [&lambda](auto& element) {
-                    using element_type = typename std::decay<decltype(element)>::type;
+                    using element_type = std::decay_t<decltype(element)>;
                     static_if<is_primary_key<element_type>{}>(lambda)(element);
                 });
             }
@@ -10905,7 +10963,7 @@ namespace sqlite_orm {
             template<class L>
             void for_each_column(const L& lambda) const {
                 iterate_tuple(this->elements, [&lambda](auto& element) {
-                    using element_type = typename std::decay<decltype(element)>::type;
+                    using element_type = std::decay_t<decltype(element)>;
                     static_if<is_column<element_type>{}>(lambda)(element);
                 });
             }
@@ -10913,7 +10971,7 @@ namespace sqlite_orm {
             template<class L>
             void for_each_foreign_key(const L& lambda) const {
                 iterate_tuple(this->elements, [&lambda](auto& element) {
-                    using element_type = typename std::decay<decltype(element)>::type;
+                    using element_type = std::decay_t<decltype(element)>;
                     static_if<is_foreign_key<element_type>{}>(lambda)(element);
                 });
             }
@@ -10921,7 +10979,7 @@ namespace sqlite_orm {
             template<class F, class L>
             void for_each_column_with_field_type(const L& lambda) const {
                 this->for_each_column([&lambda](auto& column) {
-                    using column_type = typename std::decay<decltype(column)>::type;
+                    using column_type = std::decay_t<decltype(column)>;
                     using field_type = typename column_field_type<column_type>::type;
                     static_if<std::is_same<F, field_type>{}>(lambda)(column);
                 });
@@ -10937,7 +10995,7 @@ namespace sqlite_orm {
             void for_each_column_with(const L& lambda) const {
                 this->for_each_column([&lambda](auto& column) {
                     using tuple_helper::tuple_contains_type;
-                    using column_type = typename std::decay<decltype(column)>::type;
+                    using column_type = std::decay_t<decltype(column)>;
                     using constraints_type = typename column_constraints_type<column_type>::type;
                     static_if<tuple_contains_type<Op, constraints_type>{}>(lambda)(column);
                 });
@@ -11167,7 +11225,7 @@ namespace sqlite_orm {
 
             // filter all column references [`alias_holder<>`]
             using alias_types_tuple =
-                transform_tuple_t<typename cte_mapper_type::colref_expressions_tuple, alias_type_or_none>;
+                transform_tuple_t<typename cte_mapper_type::final_colrefs_tuple, alias_holder_type_or_none>;
 
             // lookup index in alias_types_tuple by Alias
             constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
@@ -11198,10 +11256,10 @@ namespace sqlite_orm {
             using elements_t = typename timpl_type::table_type::elements_type;
             using column_idxs = filter_tuple_sequence_t<elements_t, is_column>;
 
-            // note: even though the columns contain the `[aliased_field<>::*` we perform the lookup using the column references.
+            // note: even though the columns contain the [`aliased_field<>::*`] we perform the lookup using the column references.
             // filter all column references [`alias_holder<>`]
             using alias_types_tuple =
-                transform_tuple_t<typename cte_mapper_type::colref_expressions_tuple, alias_type_or_none>;
+                transform_tuple_t<typename cte_mapper_type::final_colrefs_tuple, alias_holder_type_or_none>;
 
             // lookup index of ColAlias in alias_types_tuple
             static constexpr auto I = tuple_index_of_v<ColAlias, alias_types_tuple>;
@@ -15267,6 +15325,8 @@ namespace sqlite_orm {
 
 // #include "type_traits.h"
 
+// #include "member_traits/field_member_traits.h"
+
 // #include "error_code.h"
 
 // #include "alias.h"
@@ -15281,6 +15341,28 @@ namespace sqlite_orm {
         template<class T, class I>
         std::string serialize(const T& t, const serializer_context<I>& context);
 
+        inline void unquote_identifier(std::string& identifier) {
+            if(!identifier.empty()) {
+                constexpr char quoteChar = '"';
+                constexpr char sqlEscaped[] = {quoteChar, quoteChar};
+                identifier.erase(identifier.end() - 1);
+                identifier.erase(identifier.begin());
+                for(size_t pos = 0; (pos = identifier.find(sqlEscaped, pos, 2)) != identifier.npos; ++pos) {
+                    identifier.erase(pos, 1);
+                }
+            }
+        }
+
+        inline void unquote_or_erase(std::string& name) {
+            constexpr char quoteChar = '"';
+            if(name.front() == quoteChar) {
+                unquote_identifier(name);
+            } else {
+                // unaliased expression - see 3. below
+                name.clear();
+            }
+        }
+
         template<class T, class SFINAE = void>
         struct cte_column_names_collector {
             using expression_type = T;
@@ -15291,8 +15373,9 @@ namespace sqlite_orm {
                 newContext.skip_table_name = true;
                 std::string columnName = serialize(t, newContext);
                 if(columnName.empty()) {
-                    throw std::system_error(orm_error_code::column_not_found);
+                    throw std::system_error{orm_error_code::column_not_found};
                 }
+                unquote_or_erase(columnName);
                 return {move(columnName)};
             }
         };
@@ -15384,55 +15467,57 @@ namespace sqlite_orm {
                     if(!columnName.empty()) {
                         columnNames.push_back(move(columnName));
                     } else {
-                        throw std::system_error(orm_error_code::column_not_found);
+                        throw std::system_error{orm_error_code::column_not_found};
                     }
+                    unquote_or_erase(columnNames.back());
                 });
                 return columnNames;
             }
         };
 
-        template<typename Ctx, typename E, satisfies_is_specialization_of<E, select_t> = true>
-        std::vector<std::string> collect_cte_column_names(const E& sel,
-                                                          const std::vector<std::string>& explicitColumnNames,
-                                                          const Ctx& context) {
+        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) {
             // 1. determine column names from subselect
-
             std::vector<std::string> columnNames = get_cte_column_names(sel.col, context);
 
-            // unquote column names
-            constexpr auto unquote = [](std::string& identifier) {
-                if(!identifier.empty()) {
-                    constexpr char quoteChar = '"';
-                    constexpr char sqlEscaped[] = {quoteChar, quoteChar};
-                    identifier.erase(identifier.end() - 1);
-                    identifier.erase(identifier.begin());
-                    for(size_t pos = 0; (pos = identifier.find(sqlEscaped, pos, 2)) != identifier.npos; ++pos) {
-                        identifier.erase(pos, 1);
-                    }
-                }
-            };
-            for(std::string& name: columnNames) {
-                constexpr char quoteChar = '"';
-                if(name.front() == quoteChar) {
-                    unquote(name);
-                } else {
-                    // unaliased expression - see 3. below
-                    name.clear();
-                }
-            }
-
             // 2. override column names from cte expression
-            if(!explicitColumnNames.empty()) {
-                if(explicitColumnNames.size() != columnNames.size()) {
-                    throw std::system_error(orm_error_code::column_not_found);
+            if(size_t n = std::tuple_size_v<ExplicitColRefs>) {
+                if(n != columnNames.size()) {
+                    throw std::system_error{orm_error_code::column_not_found};
                 }
 
-                for(size_t i = 0, n = explicitColumnNames.size(); i < n; ++i) {
-                    if(!explicitColumnNames[i].empty()) {
-                        columnNames[i] = explicitColumnNames[i];
+                size_t idx = 0;
+                iterate_tuple(explicitColRefs, [&idx, &columnNames, &context](auto& colRef) {
+                    using ColRef = polyfill::remove_cvref_t<decltype(colRef)>;
+
+                    if constexpr(polyfill::is_specialization_of_v<ColRef, alias_holder>) {
+                        columnNames[idx] = alias_extractor<type_t<ColRef>>::extract();
+                    } else if constexpr(is_field_member_pointer<ColRef>::value) {
+                        using O = typename field_member_traits<ColRef>::object_type;
+                        if(auto* columnName = find_column_name<O>(context.impl, colRef)) {
+                            columnNames[idx] = *columnName;
+                        } else {
+                            // relaxed: allow any member pointer as column reference
+                            columnNames[idx] = typeid(ColRef).name();
+                        }
+                    } else if constexpr(polyfill::is_specialization_of_v<ColRef, column_t>) {
+                        columnNames[idx] = colRef.name;
+                    } else if constexpr(std::is_same_v<ColRef, std::string>) {
+                        if(std::string name = colRef; !name.empty()) {
+                            columnNames[idx] = move(name);
+                        }
+                    } else if constexpr(std::is_same_v<ColRef, polyfill::remove_cvref_t<decltype(std::ignore)>>) {
+                        if(columnNames[idx].empty()) {
+                            columnNames[idx] = std::to_string(idx + 1);
+                        }
+                    } else {
+                        static_assert(polyfill::always_false_v<ColRef>, "Invalid explicit column reference specified");
                     }
-                }
+                    ++idx;
+                });
             }
+
             // 3. fill in blanks with numerical column identifiers
             {
                 for(size_t i = 0, n = columnNames.size(); i < n; ++i) {
@@ -16294,12 +16379,12 @@ namespace sqlite_orm {
             using statement_type = column_pointer<T, F>;
 
             template<class Ctx>
-            std::string operator()(const statement_type& c, const Ctx& context) const {
+            std::string operator()(const statement_type& cp, const Ctx& context) const {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
                     ss << streaming_identifier(lookup_table_name<T>(context.impl)) << ".";
                 }
-                if(auto* columnName = find_column_name(context.impl, c)) {
+                if(auto* columnName = find_column_name(context.impl, cp)) {
                     ss << streaming_identifier(*columnName);
                 } else {
                     throw std::system_error{orm_error_code::column_not_found};
@@ -16326,7 +16411,7 @@ namespace sqlite_orm {
             using statement_type = CTE;
 
             template<class Ctx>
-            std::string operator()(const statement_type& c, const Ctx& context) const {
+            std::string operator()(const statement_type& cte, const Ctx& context) const {
                 // A CTE always starts a new 'highest level' context
                 Ctx cteContext = context;
                 cteContext.use_parentheses = false;
@@ -16335,12 +16420,12 @@ namespace sqlite_orm {
                 ss << streaming_identifier(alias_extractor<cte_label_type_t<CTE>>::extract(std::true_type{}));
                 {
                     std::vector<std::string> columnNames =
-                        collect_cte_column_names(get_cte_driving_subselect(c.subselect),
-                                                 c.explicitColumnNames,
+                        collect_cte_column_names(get_cte_driving_subselect(cte.subselect),
+                                                 cte.explicitColumns,
                                                  context);
                     ss << '(' << streaming_identifiers(columnNames) << ')';
                 }
-                ss << " AS " << '(' << serialize(c.subselect, cteContext) << ')';
+                ss << " AS " << '(' << serialize(cte.subselect, cteContext) << ')';
                 return ss.str();
             }
         };
@@ -18134,82 +18219,56 @@ namespace sqlite_orm {
     namespace internal {
 
         // F = field_type
-        template<typename Label, typename Expression, typename RefExpressions, typename F>
+        template<typename Label,
+                 typename ExplicitColRefs,
+                 typename Expression,
+                 typename SubselectColRefs,
+                 typename FinalColRefs,
+                 typename F>
         struct create_cte_mapper {
-            using type = subselect_mapper<Label, Expression, RefExpressions, F>;
-        };
-
-        template<typename Label, typename Expression, typename RefExpressions, typename... Fs>
-        struct create_cte_mapper<Label, Expression, RefExpressions, std::tuple<Fs...>> {
-            using type = subselect_mapper<Label, Expression, RefExpressions, Fs...>;
-        };
-
-        template<typename Label, typename Expression, typename RefExpressions, typename... Fs>
-        using create_cte_mapper_t = typename create_cte_mapper<Label, Expression, RefExpressions, Fs...>::type;
+            using type = subselect_mapper<Label, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, F>;
+        };
+
+        // std::tuple<Fs...>
+        template<typename Label,
+                 typename ExplicitColRefs,
+                 typename Expression,
+                 typename SubselectColRefs,
+                 typename FinalColRefs,
+                 typename... Fs>
+        struct create_cte_mapper<Label,
+                                 ExplicitColRefs,
+                                 Expression,
+                                 SubselectColRefs,
+                                 FinalColRefs,
+                                 std::tuple<Fs...>> {
+            using type = subselect_mapper<Label, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Fs...>;
+        };
+
+        template<typename Label,
+                 typename ExplicitColRefs,
+                 typename Expression,
+                 typename SubselectColRefs,
+                 typename FinalColRefs,
+                 typename Result>
+        using create_cte_mapper_t =
+            typename create_cte_mapper<Label, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Result>::
+                type;
 
         // aliased column expressions, explicit or implicitly numbered
-        template<typename Mapper, size_t CI, typename SFINAE = void>
-        struct create_cte_column {
-            using As = std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>;
-            using field_type = std::tuple_element_t<CI, typename Mapper::fields_type>;
-            using object_type = aliased_field<alias_type_t<As>, field_type>;
-
-            using type = column_t<object_type,
-                                  field_type,
-                                  const field_type& (object_type::*)() const,
-                                  void (object_type::*)(field_type)>;
-
-            template<typename Tpl>
-            static type make_column(std::string name, const Tpl& /*colRefs*/) {
-                return sqlite_orm::make_column<>(move(name), &object_type::field);
-            }
-        };
+        template<typename F, typename ColRef, satisfies_is_specialization_of<ColRef, alias_holder> = true>
+        static auto make_cte_column(std::string name, const ColRef& /*finalColRef*/) {
+            using object_type = aliased_field<type_t<ColRef>, F>;
+            return sqlite_orm::make_column<>(move(name), &object_type::field);
+        }
 
         // F O::*
-        template<typename Mapper, size_t CI>
-        struct create_cte_column<
-            Mapper,
-            CI,
-            std::enable_if_t<polyfill::disjunction_v<
-                is_field_member_pointer<std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>>,
-                is_getter<std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>>>>> {
-            using F = std::tuple_element_t<CI, typename Mapper::colref_expressions_tuple>;
-            using object_type = typename field_member_traits<F>::object_type;
-            using field_type = typename field_member_traits<F>::field_type;
-
-            using type = column_t<object_type,
-                                  field_type,
-                                  const field_type& (object_type::*)() const,
-                                  void (object_type::*)(field_type)>;
-
-            template<typename Tpl>
-            static type make_column(std::string name, const Tpl& colRefs) {
-                return sqlite_orm::make_column<>(move(name), get<CI>(colRefs));
-            }
-        };
-
-        /**
-         *  Metafunction to create a CTE column_t type.
-         */
-        template<typename Mapper, size_t CI>
-        using create_cte_column_t = typename create_cte_column<Mapper, CI>::type;
-
-        template<typename Mapper, typename IdxSeq>
-        struct create_cte_table;
-
-        template<typename Label, typename Expression, typename... Fs, size_t... CIs>
-        struct create_cte_table<subselect_mapper<Label, Expression, Fs...>, std::index_sequence<CIs...>> {
-            using cte_mapper_type = subselect_mapper<Label, Expression, Fs...>;
-            using table_type = table_t<cte_mapper_type, true, create_cte_column_t<cte_mapper_type, CIs>...>;
-
-            using type = table_type;
-        };
-
-        /**
-         *  Metafunction to create a CTE table_t type.
-         */
-        template<typename Mapper, typename IdxSeq>
-        using create_cte_table_t = typename create_cte_table<Mapper, IdxSeq>::type;
+        template<typename F,
+                 typename ColRef,
+                 std::enable_if_t<polyfill::disjunction_v<is_field_member_pointer<ColRef>>, bool> = true>
+        static auto make_cte_column(std::string name, const ColRef& finalColRef) {
+            return sqlite_orm::make_column<>(move(name), finalColRef);
+        }
 
         /**
          *  Concatenate newly created tables with those from an existing storage implementation,
@@ -18250,10 +18309,6 @@ namespace sqlite_orm {
             return subSelect.col.left;
         }
 
-        template<typename Select>
-        using cte_driving_subselect_t =
-            polyfill::remove_cvref_t<decltype(get_cte_driving_subselect(std::declval<Select>()))>;
-
         template<class C, size_t... Idx>
         auto get_fields_of_columns(const C& coldef, std::index_sequence<Idx...>) {
             return std::make_tuple(get<Idx>(coldef).member_pointer...);
@@ -18327,43 +18382,87 @@ namespace sqlite_orm {
         decltype(auto) extract_colref_expressions(const S& /*impl*/,
                                                   const select_t<E, Args...>& /*subSelect*/) = delete;
 
-        template<typename S, typename SubSelect>
-        using extracted_colref_expressions_t =
-            polyfill::remove_cvref_t<decltype(extract_colref_expressions(std::declval<S>(),
-                                                                         std::declval<SubSelect>().col))>;
-
-        template<typename Mapper, typename S, typename CTE, size_t... CIs>
-        create_cte_table_t<Mapper, typename Mapper::index_sequence>
-        make_cte_table_using_column_indices(const S& impl, const CTE& cte, std::index_sequence<CIs...>) {
-            using context_type = serializer_context<S>;
-            using cte_type = CTE;
+        /*
+         *  Depending on ExplicitColRef's type returns either the explicit column reference
+         *  or the expression's column reference otherwise.
+         */
+        template<typename S, typename SubselectColRef, typename ExplicitColRef>
+        auto determine_cte_colref(const S& /*impl*/,
+                                  const SubselectColRef& subselectColRef,
+                                  const ExplicitColRef& explicitColRef) {
+            if constexpr(polyfill::is_specialization_of_v<ExplicitColRef, alias_holder>) {
+                return explicitColRef;
+            } else if constexpr(is_field_member_pointer<ExplicitColRef>::value) {
+                return explicitColRef;
+            } else if constexpr(std::is_base_of_v<basic_column, ExplicitColRef>) {
+                return explicitColRef.member_pointer;
+            } else if constexpr(std::is_same_v<ExplicitColRef, std::string>) {
+                return subselectColRef;
+            } else if constexpr(std::is_same_v<ExplicitColRef, polyfill::remove_cvref_t<decltype(std::ignore)>>) {
+                return subselectColRef;
+            } else {
+                static_assert(polyfill::always_false_v<ExplicitColRef>, "Invalid explicit column reference specified");
+            }
+        }
 
-            context_type context{impl};
-            std::string tableName = alias_extractor<cte_label_type_t<cte_type>>::extract(std::true_type{});
-            auto subSelect = get_cte_driving_subselect(cte.subselect);
-            auto colRefs = extract_colref_expressions(impl, subSelect.col);
-            std::vector<std::string> columnNames =
-                collect_cte_column_names(subSelect, cte.explicitColumnNames, context);
+        template<typename S, typename SubselectColRefs, typename ExplicitColRefs, size_t... Idx>
+        auto determine_cte_colrefs(const S& impl,
+                                   const SubselectColRefs& subselectColRefs,
+                                   const ExplicitColRefs& explicitColRefs,
+                                   std::index_sequence<Idx...>) {
+            if constexpr(std::tuple_size_v < ExplicitColRefs >> 0) {
+                return std::tuple{determine_cte_colref(impl, get<Idx>(subselectColRefs), get<Idx>(explicitColRefs))...};
+            } else {
+                return subselectColRefs;
+            }
+        }
 
-            return create_cte_table_t<Mapper, typename Mapper::index_sequence>{
+        template<typename Mapper, typename S, typename ColRefs, size_t... CIs>
+        auto make_cte_table_using_column_indices(const S& impl,
+                                                 std::string tableName,
+                                                 std::vector<std::string> columnNames,
+                                                 const ColRefs& finalColRefs,
+                                                 std::index_sequence<CIs...>) {
+            return make_table<Mapper>(
                 move(tableName),
-                std::make_tuple(create_cte_column<Mapper, CIs>::make_column(move(columnNames.at(CIs)), colRefs)...)};
+                make_cte_column<std::tuple_element_t<CIs, typename Mapper::fields_type>>(move(columnNames.at(CIs)),
+                                                                                         get<CIs>(finalColRefs))...);
         }
 
         template<typename S, typename CTE>
         auto make_cte_table(const S& impl, const CTE& cte) {
             using cte_type = CTE;
-            using subselect_type = cte_driving_subselect_t<expression_type_t<cte_type>>;
-            using mapper_type = create_cte_mapper_t<cte_label_type_t<cte_type>,
-                                                    column_expression_of_t<S, subselect_type>,
-                                                    extracted_colref_expressions_t<S, subselect_type>,
-                                                    column_result_of_t<S, subselect_type>>;
-            static_assert(cte_type::explicit_column_count == 0 ||
-                              cte_type::explicit_column_count == mapper_type::index_sequence::size(),
+
+            auto subSelect = get_cte_driving_subselect(cte.subselect);
+
+            using subselect_type = decltype(subSelect);
+            using column_results = column_result_of_t<S, subselect_type>;
+            using index_sequence = std::make_index_sequence<std::tuple_size_v<tuplify_t<column_results>>>;
+            static_assert(cte_type::explicit_colref_count == 0 ||
+                              cte_type::explicit_colref_count == index_sequence::size(),
                           "Number of explicit columns of common table expression doesn't match the number of columns "
                           "in the subselect.");
 
-            return make_cte_table_using_column_indices<mapper_type>(impl, cte, typename mapper_type::index_sequence{});
+            using context_type = serializer_context<S>;
+
+            std::string tableName = alias_extractor<cte_label_type_t<cte_type>>::extract(std::true_type{});
+            auto subselectColRefs = extract_colref_expressions(impl, subSelect.col);
+            const auto& finalColRefs =
+                determine_cte_colrefs(impl, subselectColRefs, cte.explicitColumns, index_sequence{});
+            context_type context{impl};
+            std::vector<std::string> columnNames = collect_cte_column_names(subSelect, cte.explicitColumns, context);
+
+            using mapper_type = create_cte_mapper_t<cte_label_type_t<cte_type>,
+                                                    typename cte_type::explicit_colrefs_tuple,
+                                                    column_expression_of_t<S, subselect_type>,
+                                                    decltype(subselectColRefs),
+                                                    polyfill::remove_cvref_t<decltype(finalColRefs)>,
+                                                    column_results>;
+            return make_cte_table_using_column_indices<mapper_type>(impl,
+                                                                    move(tableName),
+                                                                    move(columnNames),
+                                                                    finalColRefs,
+                                                                    index_sequence{});
         }
 
         template<typename S, typename... CTEs, size_t Ii>
@@ -18933,9 +19032,9 @@ namespace sqlite_orm {
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class Label, class Select, class nExplicitCols, class T, class... Args>
-            auto with(common_table_expression<Label, Select, nExplicitCols> cte, select_t<T, Args...> sel) {
-                auto statement = this->prepare(sqlite_orm::with(move(cte), std::move(sel)));
+            template<class CTE, class T, class... Args>
+            auto with(CTE cte, select_t<T, Args...> sel) {
+                auto statement = this->prepare(sqlite_orm::with(std::move(cte), std::move(sel)));
                 return this->execute(statement);
             }
 
@@ -18951,13 +19050,11 @@ namespace sqlite_orm {
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class Label,
-                     class Select,
-                     class nExplicitCols,
+            template<class CTE,
                      class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            auto with(common_table_expression<Label, Select, nExplicitCols> cte, Compound sel) {
-                auto statement = this->prepare(sqlite_orm::with(move(cte), sqlite_orm::select(std::move(sel))));
+            auto with(CTE cte, Compound sel) {
+                auto statement = this->prepare(sqlite_orm::with(std::move(cte), sqlite_orm::select(std::move(sel))));
                 return this->execute(statement);
             }
 
@@ -20172,13 +20269,13 @@ namespace sqlite_orm {
     [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
         return internal::cte_alias<Chars...>{};
     }
-#if __cplusplus >= 202002L  // C++20 or later
+#if __cpp_nontype_template_args >= 201911
     /**
      *  cte_alias<'1'[, ...]> from a string literal.
      *  E.g. "1"_cte, "2"_cte
      */
     template<internal::string_identifier_template t>
-    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _cte() {
+    [[nodiscard]] consteval auto operator"" _cte() {
         static_assert(t.size() != 1 || ((t.id[0] < 'A' || 'Z' < t.id[0]) && (t.id[0] < 'a' || 'z' < t.id[0])),
                       "CTE alias identifiers consisting of a single alphabetic character should be avoided, in order "
                       "to evade clashes with the built-in table aliases.");

From 0a891dafd0ae63c53545421dda284f0b150f0602 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 14 Apr 2022 17:18:14 +0300
Subject: [PATCH 054/161] Runner-up: Fully implemented explicit CTE columns

---
 dev/cte_storage.h                             |  1 +
 dev/select_constraints.h                      | 44 ++++++++-----------
 tests/CMakeLists.txt                          |  1 +
 tests/static_tests/column_expression_type.cpp |  7 +--
 4 files changed, 22 insertions(+), 31 deletions(-)

diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 9131fbbe1..91482567c 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -248,6 +248,7 @@ namespace sqlite_orm {
             auto subselectColRefs = extract_colref_expressions(impl, subSelect.col);
             const auto& finalColRefs =
                 determine_cte_colrefs(impl, subselectColRefs, cte.explicitColumns, index_sequence{});
+
             context_type context{impl};
             std::vector<std::string> columnNames = collect_cte_column_names(subSelect, cte.explicitColumns, context);
 
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 81dd852fe..4d6185bf7 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -317,7 +317,7 @@ namespace sqlite_orm {
         /**
          *  Labeled (aliased) CTE expression.
          */
-        template<class Label, class Select, class ExplicitCols, class nExplicitCols>
+        template<class Label, class Select, class ExplicitCols>
         struct common_table_expression {
             using cte_label_type = Label;
             using expression_type = Select;
@@ -335,37 +335,34 @@ namespace sqlite_orm {
         template<class... CTEs>
         using common_table_expressions = std::tuple<CTEs...>;
 
-        template<typename Label, class ExplicitCols, class nExplicitCols>
+        template<typename Label, class ExplicitCols>
         struct cte_builder {
             ExplicitCols explicitColumns;
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
-            operator()(select_t<T, Args...> sel) && {
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols> operator()(select_t<T, Args...> sel) && {
                 return {move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols>
-            operator()(Compound sel) && {
+            common_table_expression<Label, select_t<Compound>, ExplicitCols> operator()(Compound sel) && {
                 return {move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
-            as(select_t<T, Args...> sel) && {
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols> as(select_t<T, Args...> sel) && {
                 return {move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols> as(Compound sel) && {
+            common_table_expression<Label, select_t<Compound>, ExplicitCols> as(Compound sel) && {
                 return {move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols>
             materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS MATERIALIZED` is unimplemented");
                 return {move(this->explicitColumns), std::move(sel)};
@@ -373,14 +370,13 @@ namespace sqlite_orm {
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols>
-            materialized(Compound sel) && {
+            common_table_expression<Label, select_t<Compound>, ExplicitCols> materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS MATERIALIZED` is unimplemented");
                 return {move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols>
             not_materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
                 return {move(this->explicitColumns), std::move(sel)};
@@ -388,8 +384,7 @@ namespace sqlite_orm {
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols>
-            not_materialized(Compound sel) && {
+            common_table_expression<Label, select_t<Compound>, ExplicitCols> not_materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
                 return {move(this->explicitColumns), {std::move(sel)}};
             }
@@ -642,8 +637,7 @@ namespace sqlite_orm {
         static_assert(internal::is_cte_alias_v<Label>, "Label must be a CTE alias");
         using builder_type = internal::cte_builder<
             Label,
-            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column>,
-            polyfill::index_constant<sizeof...(ExplicitCols)>>;
+            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column>>;
         return builder_type{{std::move(explicitColumns)...}};
     }
 
@@ -661,26 +655,24 @@ namespace sqlite_orm {
         static_assert(internal::is_cte_alias_v<decltype(label)>, "Label must be a CTE alias");
         using builder_type = internal::cte_builder<
             decltype(label),
-            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column>,
-            polyfill::index_constant<sizeof...(ExplicitCols)>>;
+            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column>>;
         return builder_type{{std::move(explicitColumns)...}};
     }
 #endif
 
     // tuple of CTEs
-    template<class E, class... Labels, class... Selects, class... ExplicitCols, class... nExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Labels, Selects, ExplicitCols, nExplicitCols>...>
-    with(std::tuple<internal::common_table_expression<Labels, Selects, ExplicitCols, nExplicitCols>...> cte,
-         E expression) {
+    template<class E, class... Labels, class... Selects, class... ExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Labels, Selects, ExplicitCols>...>
+    with(std::tuple<internal::common_table_expression<Labels, Selects, ExplicitCols>...> cte, E expression) {
         return {move(cte), std::move(expression)};
     }
 
     /** A single CTE.
      *  Example : with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
      */
-    template<class E, class Label, class Select, class ExplicitCols, class nExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Label, Select, ExplicitCols, nExplicitCols>>
-    with(internal::common_table_expression<Label, Select, ExplicitCols, nExplicitCols> cte, E expression) {
+    template<class E, class Label, class Select, class ExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Label, Select, ExplicitCols>>
+    with(internal::common_table_expression<Label, Select, ExplicitCols> cte, E expression) {
         return {std::make_tuple(move(cte)), std::move(expression)};
     }
 
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index da8fde5eb..6540efe71 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -62,6 +62,7 @@ add_executable(unit_tests
     static_tests/tuple_helper.cpp
     static_tests/function_static_tests.cpp
     static_tests/aggregate_function_return_types.cpp
+    static_tests/column_expression_type.cpp
     static_tests/column_result_t.cpp
     static_tests/has_some_type.cpp
     static_tests/is_primary_key_insertable.cpp
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index 99ae6a6dd..79eb7002d 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -14,9 +14,7 @@ void runTest(V value) {
 
 TEST_CASE("column_expression_of_t") {
     struct Org {
-        // compile-time mapped (via c_v<>)
         int64 id = 0;
-        // not compile-time mapped
         int64 boss = 0;
     };
     struct Derived : Org {};
@@ -49,11 +47,10 @@ TEST_CASE("column_expression_of_t") {
     runTest<storage_type, column_pointer<cte_1, polyfill::index_constant<0u>>>(column<cte_1>(0_colidx));
     runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>()->*&Org::id);
     runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>->*&Org::id);
-    runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>->*&Org::id);
-    runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>->*&Org::id);
+    runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(cte_1{}->*&Org::id);
     runTest<storage_type, column_pointer<cte_1, alias_holder<internal::column_alias<'1'>>>>(column<cte_1>(1_colalias));
     runTest<storage_type, column_pointer<cte_1, alias_holder<colalias_c>>>(1_ctealias->*colalias_c{});
-#if __cplusplus >= 202002L  // C++20 or later
+#if __cpp_nontype_template_args >= 201911
     runTest<storage_type, column_pointer<cte_1, alias_holder<colalias_c>>>("1"_cte->*"c"_col);
 #endif
 }

From 93ecf5581e280984679e70fcbb3c1589c455ba49 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 14 Apr 2022 17:25:16 +0300
Subject: [PATCH 055/161] Unit tests for explicit CTE column references

---
 tests/CMakeLists.txt       |  1 +
 tests/static_tests/cte.cpp | 38 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 39 insertions(+)
 create mode 100644 tests/static_tests/cte.cpp

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 6540efe71..881231a33 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -64,6 +64,7 @@ add_executable(unit_tests
     static_tests/aggregate_function_return_types.cpp
     static_tests/column_expression_type.cpp
     static_tests/column_result_t.cpp
+    static_tests/cte.cpp
     static_tests/has_some_type.cpp
     static_tests/is_primary_key_insertable.cpp
     static_tests/is_column_with_insertable_primary_key.cpp
diff --git a/tests/static_tests/cte.cpp b/tests/static_tests/cte.cpp
new file mode 100644
index 000000000..95ef7a02a
--- /dev/null
+++ b/tests/static_tests/cte.cpp
@@ -0,0 +1,38 @@
+#include <type_traits>  //  std::is_same, std::is_constructible
+#include <sqlite_orm/sqlite_orm.h>
+#include <catch2/catch.hpp>
+
+using namespace sqlite_orm;
+using internal::alias_holder;
+using internal::column_alias;
+using internal::column_t;
+using std::tuple;
+
+template<class ColRefs, class E>
+void do_assert() {
+    STATIC_REQUIRE(std::is_same<ColRefs, E>::value);
+}
+
+template<class E, class ColRef>
+void runTest(ColRef colRef) {
+    do_assert<internal::transform_tuple_t<tuple<ColRef>, internal::decay_explicit_column>, E>();
+}
+
+TEST_CASE("CTE type traits") {
+    SECTION("decay_explicit_column") {
+        struct Org {
+            int64 id = 0;
+        };
+
+        STATIC_REQUIRE(std::is_constructible<alias_holder<column_alias<'c'>>, column_alias<'c'>>::value);
+        runTest<tuple<decltype(&Org::id)>>(&Org::id);
+        runTest<tuple<alias_holder<column_alias<'1'>>>>(1_colalias);
+#if __cpp_nontype_template_args >= 201911
+        runTest<tuple<alias_holder<column_alias<'c'>>>>("a"_col);
+#endif
+        runTest<tuple<column_t<Org, int64, const int64& (Org::*)() const, void (Org::*)(int64)>>>(
+            make_column("id", &Org::id));
+        runTest<tuple<polyfill::remove_cvref_t<decltype(std::ignore)>>>(std::ignore);
+        runTest<tuple<std::string>>("");
+    }
+}

From a9e13904e8c4a9cbcf9e6c7bd0393820fbb89a00 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 14 Apr 2022 17:29:31 +0300
Subject: [PATCH 056/161] Confined using numeric column aliases within a single
 CTE

---
 dev/alias.h              | 7 +++++++
 dev/cte_storage.h        | 5 +++++
 dev/select_constraints.h | 8 ++++++++
 dev/type_traits.h        | 3 +++
 4 files changed, 23 insertions(+)

diff --git a/dev/alias.h b/dev/alias.h
index 23926c3b9..f397252fb 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -276,6 +276,13 @@ namespace sqlite_orm {
     using colalias_i = internal::column_alias<'i'>;
 
 #if __cplusplus >= 201703L  // use of C++17 or higher
+    namespace internal {
+        template<class T>
+        inline constexpr bool is_builtin_numeric_column_alias_v = false;
+        template<char... C>
+        inline constexpr bool is_builtin_numeric_column_alias_v<column_alias<C...>> = ((C >= '0' && C <= '9') && ...);
+    }
+
     /**
      *  column_alias<'1'[, ...]> from a numeric literal.
      *  E.g. 1_colalias, 2_colalias
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 91482567c..b2322d352 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -212,6 +212,11 @@ namespace sqlite_orm {
             if constexpr(std::tuple_size_v < ExplicitColRefs >> 0) {
                 return std::tuple{determine_cte_colref(impl, get<Idx>(subselectColRefs), get<Idx>(explicitColRefs))...};
             } else {
+                static_assert(
+                    (!internal::is_builtin_numeric_column_alias_v<
+                         alias_holder_type_or_none_t<std::tuple_element_t<Idx, SubselectColRefs>>> &&
+                     ...),
+                    "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
                 return subselectColRefs;
             }
         }
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 4d6185bf7..7e2fcaf62 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -635,6 +635,11 @@ namespace sqlite_orm {
                               bool> = true>
     auto cte(ExplicitCols... explicitColumns) {
         static_assert(internal::is_cte_alias_v<Label>, "Label must be a CTE alias");
+#if __cplusplus >= 201703L  // C++17 or later
+        static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
+                      "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
+#endif
+
         using builder_type = internal::cte_builder<
             Label,
             internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column>>;
@@ -653,6 +658,9 @@ namespace sqlite_orm {
                               bool> = true>
     auto cte(ExplicitCols... explicitColumns) {
         static_assert(internal::is_cte_alias_v<decltype(label)>, "Label must be a CTE alias");
+        static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
+                      "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
+
         using builder_type = internal::cte_builder<
             decltype(label),
             internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column>>;
diff --git a/dev/type_traits.h b/dev/type_traits.h
index ae17717ac..8bb7a7b7e 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -74,6 +74,9 @@ namespace sqlite_orm {
         // T::alias_type or nonesuch
         template<class T>
         using alias_holder_type_or_none = polyfill::detected<type_t, T>;
+
+        template<class T>
+        using alias_holder_type_or_none_t = typename alias_holder_type_or_none<T>::type;
     }
 
     namespace internal {

From 865611d427361dfc114c94d6e69e9f740c9f8394 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 14 Apr 2022 17:30:25 +0300
Subject: [PATCH 057/161] Same wording for "C++nm or later"

---
 dev/alias.h              | 4 ++--
 dev/conditions.h         | 8 ++++----
 dev/cte.h                | 2 +-
 dev/function.h           | 2 +-
 dev/select_constraints.h | 2 +-
 dev/type_traits.h        | 2 +-
 6 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index f397252fb..de38c4cc7 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -184,7 +184,7 @@ namespace sqlite_orm {
         return {std::move(expression)};
     }
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cplusplus >= 202002L  // C++20 or later
     template<auto als, class E>
     internal::as_t<decltype(als), E> as(E expression) {
         return {std::move(expression)};
@@ -275,7 +275,7 @@ namespace sqlite_orm {
     using colalias_h = internal::column_alias<'h'>;
     using colalias_i = internal::column_alias<'i'>;
 
-#if __cplusplus >= 201703L  // use of C++17 or higher
+#if __cplusplus >= 201703L  // C++17 or later
     namespace internal {
         template<class T>
         inline constexpr bool is_builtin_numeric_column_alias_v = false;
diff --git a/dev/conditions.h b/dev/conditions.h
index 5002b3aca..9e5e9f9e8 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -1008,7 +1008,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cplusplus >= 202002L  // C++20 or later
     template<auto als, class O>
     internal::left_join_t<decltype(als), O> left_join(O o) {
         return {std::move(o)};
@@ -1020,7 +1020,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cplusplus >= 202002L  // C++20 or later
     template<auto als, class O>
     internal::join_t<decltype(als), O> join(O o) {
         return {std::move(o)};
@@ -1032,7 +1032,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cplusplus >= 202002L  // C++20 or later
     template<auto als, class O>
     internal::left_outer_join_t<decltype(als), O> left_outer_join(O o) {
         return {std::move(o)};
@@ -1044,7 +1044,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cplusplus >= 202002L  // C++20 or later
     template<auto als, class O>
     internal::inner_join_t<decltype(als), O> inner_join(O o) {
         return {std::move(o)};
diff --git a/dev/cte.h b/dev/cte.h
index 3e861c2bf..4a3f36a0b 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -19,7 +19,7 @@ namespace sqlite_orm {
                           X...> {};
     }
 
-#if __cplusplus >= 201703L  // use of C++17 or higher
+#if __cplusplus >= 201703L  // C++17 or later
     namespace internal {
         constexpr size_t _10_pow(size_t n) {
             if(n == 0) {
diff --git a/dev/function.h b/dev/function.h
index 1e1184e81..e74024e37 100644
--- a/dev/function.h
+++ b/dev/function.h
@@ -198,7 +198,7 @@ namespace sqlite_orm {
         SQLITE_ORM_INLINE_VAR constexpr bool
             is_same_pvt_v<I, PointerArg, std::nullptr_t, polyfill::void_t<typename PointerArg::tag>> = true;
 
-#if __cplusplus >= 201703L  // using C++17 or higher
+#if __cplusplus >= 201703L  // C++17 or later
         template<size_t I, const char *PointerArg, const char *Binding>
         SQLITE_ORM_CONSTEVAL bool assert_same_pointer_type() {
             constexpr bool valid = Binding == PointerArg;
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 7e2fcaf62..9088f7fd2 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -646,7 +646,7 @@ namespace sqlite_orm {
         return builder_type{{std::move(explicitColumns)...}};
     }
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cplusplus >= 202002L  // C++20 or later
     template<auto label,
              class... ExplicitCols,
              std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
diff --git a/dev/type_traits.h b/dev/type_traits.h
index 8bb7a7b7e..055004b33 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -86,7 +86,7 @@ namespace sqlite_orm {
         template<typename... Fs>
         using fields_t = std::tuple<Fs...>;
 
-#if __cplusplus >= 201703L  // use of C++17 or higher
+#if __cplusplus >= 201703L  // C++17 or later
         // cudos to OznOg https://stackoverflow.com/a/64606884/279251
         template<class X, class Tuple>
         struct tuple_index_of;

From 059be69178048cb9752068c0c468c40eba048123 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 14 Apr 2022 17:30:50 +0300
Subject: [PATCH 058/161] Updated sqlite_orm.h

---
 include/sqlite_orm/sqlite_orm.h | 88 +++++++++++++++++++--------------
 1 file changed, 52 insertions(+), 36 deletions(-)

diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index d722a96d1..e9b797076 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -262,6 +262,9 @@ namespace sqlite_orm {
         // T::alias_type or nonesuch
         template<class T>
         using alias_holder_type_or_none = polyfill::detected<type_t, T>;
+
+        template<class T>
+        using alias_holder_type_or_none_t = typename alias_holder_type_or_none<T>::type;
     }
 
     namespace internal {
@@ -271,7 +274,7 @@ namespace sqlite_orm {
         template<typename... Fs>
         using fields_t = std::tuple<Fs...>;
 
-#if __cplusplus >= 201703L  // use of C++17 or higher
+#if __cplusplus >= 201703L  // C++17 or later
         // cudos to OznOg https://stackoverflow.com/a/64606884/279251
         template<class X, class Tuple>
         struct tuple_index_of;
@@ -3930,7 +3933,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cplusplus >= 202002L  // C++20 or later
     template<auto als, class O>
     internal::left_join_t<decltype(als), O> left_join(O o) {
         return {std::move(o)};
@@ -3942,7 +3945,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cplusplus >= 202002L  // C++20 or later
     template<auto als, class O>
     internal::join_t<decltype(als), O> join(O o) {
         return {std::move(o)};
@@ -3954,7 +3957,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cplusplus >= 202002L  // C++20 or later
     template<auto als, class O>
     internal::left_outer_join_t<decltype(als), O> left_outer_join(O o) {
         return {std::move(o)};
@@ -3966,7 +3969,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cplusplus >= 202002L  // C++20 or later
     template<auto als, class O>
     internal::inner_join_t<decltype(als), O> inner_join(O o) {
         return {std::move(o)};
@@ -4407,7 +4410,7 @@ namespace sqlite_orm {
         return {std::move(expression)};
     }
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cplusplus >= 202002L  // C++20 or later
     template<auto als, class E>
     internal::as_t<decltype(als), E> as(E expression) {
         return {std::move(expression)};
@@ -4498,7 +4501,14 @@ namespace sqlite_orm {
     using colalias_h = internal::column_alias<'h'>;
     using colalias_i = internal::column_alias<'i'>;
 
-#if __cplusplus >= 201703L  // use of C++17 or higher
+#if __cplusplus >= 201703L  // C++17 or later
+    namespace internal {
+        template<class T>
+        inline constexpr bool is_builtin_numeric_column_alias_v = false;
+        template<char... C>
+        inline constexpr bool is_builtin_numeric_column_alias_v<column_alias<C...>> = ((C >= '0' && C <= '9') && ...);
+    }
+
     /**
      *  column_alias<'1'[, ...]> from a numeric literal.
      *  E.g. 1_colalias, 2_colalias
@@ -7199,7 +7209,7 @@ namespace sqlite_orm {
         /**
          *  Labeled (aliased) CTE expression.
          */
-        template<class Label, class Select, class ExplicitCols, class nExplicitCols>
+        template<class Label, class Select, class ExplicitCols>
         struct common_table_expression {
             using cte_label_type = Label;
             using expression_type = Select;
@@ -7217,37 +7227,34 @@ namespace sqlite_orm {
         template<class... CTEs>
         using common_table_expressions = std::tuple<CTEs...>;
 
-        template<typename Label, class ExplicitCols, class nExplicitCols>
+        template<typename Label, class ExplicitCols>
         struct cte_builder {
             ExplicitCols explicitColumns;
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
-            operator()(select_t<T, Args...> sel) && {
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols> operator()(select_t<T, Args...> sel) && {
                 return {move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols>
-            operator()(Compound sel) && {
+            common_table_expression<Label, select_t<Compound>, ExplicitCols> operator()(Compound sel) && {
                 return {move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
-            as(select_t<T, Args...> sel) && {
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols> as(select_t<T, Args...> sel) && {
                 return {move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols> as(Compound sel) && {
+            common_table_expression<Label, select_t<Compound>, ExplicitCols> as(Compound sel) && {
                 return {move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols>
             materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS MATERIALIZED` is unimplemented");
                 return {move(this->explicitColumns), std::move(sel)};
@@ -7255,14 +7262,13 @@ namespace sqlite_orm {
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols>
-            materialized(Compound sel) && {
+            common_table_expression<Label, select_t<Compound>, ExplicitCols> materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS MATERIALIZED` is unimplemented");
                 return {move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols, nExplicitCols>
+            common_table_expression<Label, select_t<T, Args...>, ExplicitCols>
             not_materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
                 return {move(this->explicitColumns), std::move(sel)};
@@ -7270,8 +7276,7 @@ namespace sqlite_orm {
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols, nExplicitCols>
-            not_materialized(Compound sel) && {
+            common_table_expression<Label, select_t<Compound>, ExplicitCols> not_materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
                 return {move(this->explicitColumns), {std::move(sel)}};
             }
@@ -7522,14 +7527,18 @@ namespace sqlite_orm {
                               bool> = true>
     auto cte(ExplicitCols... explicitColumns) {
         static_assert(internal::is_cte_alias_v<Label>, "Label must be a CTE alias");
+#if __cplusplus >= 201703L  // C++17 or later
+        static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
+                      "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
+#endif
+
         using builder_type = internal::cte_builder<
             Label,
-            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column>,
-            polyfill::index_constant<sizeof...(ExplicitCols)>>;
+            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column>>;
         return builder_type{{std::move(explicitColumns)...}};
     }
 
-#if __cplusplus >= 202002L  // C++20 and later
+#if __cplusplus >= 202002L  // C++20 or later
     template<auto label,
              class... ExplicitCols,
              std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
@@ -7541,28 +7550,29 @@ namespace sqlite_orm {
                               bool> = true>
     auto cte(ExplicitCols... explicitColumns) {
         static_assert(internal::is_cte_alias_v<decltype(label)>, "Label must be a CTE alias");
+        static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
+                      "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
+
         using builder_type = internal::cte_builder<
             decltype(label),
-            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column>,
-            polyfill::index_constant<sizeof...(ExplicitCols)>>;
+            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column>>;
         return builder_type{{std::move(explicitColumns)...}};
     }
 #endif
 
     // tuple of CTEs
-    template<class E, class... Labels, class... Selects, class... ExplicitCols, class... nExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Labels, Selects, ExplicitCols, nExplicitCols>...>
-    with(std::tuple<internal::common_table_expression<Labels, Selects, ExplicitCols, nExplicitCols>...> cte,
-         E expression) {
+    template<class E, class... Labels, class... Selects, class... ExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Labels, Selects, ExplicitCols>...>
+    with(std::tuple<internal::common_table_expression<Labels, Selects, ExplicitCols>...> cte, E expression) {
         return {move(cte), std::move(expression)};
     }
 
     /** A single CTE.
      *  Example : with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
      */
-    template<class E, class Label, class Select, class ExplicitCols, class nExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Label, Select, ExplicitCols, nExplicitCols>>
-    with(internal::common_table_expression<Label, Select, ExplicitCols, nExplicitCols> cte, E expression) {
+    template<class E, class Label, class Select, class ExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Label, Select, ExplicitCols>>
+    with(internal::common_table_expression<Label, Select, ExplicitCols> cte, E expression) {
         return {std::make_tuple(move(cte)), std::move(expression)};
     }
 
@@ -10295,7 +10305,7 @@ namespace sqlite_orm {
         SQLITE_ORM_INLINE_VAR constexpr bool
             is_same_pvt_v<I, PointerArg, std::nullptr_t, polyfill::void_t<typename PointerArg::tag>> = true;
 
-#if __cplusplus >= 201703L  // using C++17 or higher
+#if __cplusplus >= 201703L  // C++17 or later
         template<size_t I, const char* PointerArg, const char* Binding>
         SQLITE_ORM_CONSTEVAL bool assert_same_pointer_type() {
             constexpr bool valid = Binding == PointerArg;
@@ -18413,6 +18423,11 @@ namespace sqlite_orm {
             if constexpr(std::tuple_size_v < ExplicitColRefs >> 0) {
                 return std::tuple{determine_cte_colref(impl, get<Idx>(subselectColRefs), get<Idx>(explicitColRefs))...};
             } else {
+                static_assert(
+                    (!internal::is_builtin_numeric_column_alias_v<
+                         alias_holder_type_or_none_t<std::tuple_element_t<Idx, SubselectColRefs>>> &&
+                     ...),
+                    "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
                 return subselectColRefs;
             }
         }
@@ -18449,6 +18464,7 @@ namespace sqlite_orm {
             auto subselectColRefs = extract_colref_expressions(impl, subSelect.col);
             const auto& finalColRefs =
                 determine_cte_colrefs(impl, subselectColRefs, cte.explicitColumns, index_sequence{});
+
             context_type context{impl};
             std::vector<std::string> columnNames = collect_cte_column_names(subSelect, cte.explicitColumns, context);
 
@@ -20223,7 +20239,7 @@ namespace sqlite_orm {
                           X...> {};
     }
 
-#if __cplusplus >= 201703L  // use of C++17 or higher
+#if __cplusplus >= 201703L  // C++17 or later
     namespace internal {
         constexpr size_t _10_pow(size_t n) {
             if(n == 0) {

From 2414ea72063468f964fa70b7a8e960fb237f6dd8 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 14 Apr 2022 21:37:51 +0300
Subject: [PATCH 059/161] Updated apfelmaennchen C++20 select statement

---
 examples/common_table_expressions.cpp | 24 +++++++++---------------
 1 file changed, 9 insertions(+), 15 deletions(-)

diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index d6a0cc8b4..83a32e59f 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -526,26 +526,20 @@ void apfelmaennchen() {
     constexpr auto t_col = "t"_col;
     auto ast = with(
         make_tuple(
-            cte<xaxis>("x")(
-                union_all(select(-2.0 >>= x_col), select(xaxis->*x_col + c(0.05), where(xaxis->*x_col < 1.2)))),
-            cte<yaxis>("y")(
-                union_all(select(-1.0 >>= y_col), select(yaxis->*y_col + c(0.1), where(yaxis->*y_col < 1.0)))),
-            cte<m>("iter", "cx", "cy", "x", "y")(union_all(
-                select(columns(0 >>= iter_col,
-                               xaxis->*x_col >>= cx_col,
-                               yaxis->*y_col >>= cy_col,
-                               0.0 >>= x_col,
-                               0.0 >>= y_col)),
+            cte<xaxis>(x_col)(union_all(select(-2.0), select(xaxis->*x_col + c(0.05), where(xaxis->*x_col < 1.2)))),
+            cte<yaxis>(y_col)(union_all(select(-1.0), select(yaxis->*y_col + c(0.10), where(yaxis->*y_col < 1.0)))),
+            cte<m>(iter_col, cx_col, cy_col, x_col, y_col)(union_all(
+                select(columns(0, xaxis->*x_col, yaxis->*y_col, 0.0, 0.0)),
                 select(columns(m->*iter_col + c(1),
                                m->*cx_col,
                                m->*cy_col,
                                m->*x_col * c(m->*x_col) - m->*y_col * c(m->*y_col) + m->*cx_col,
                                c(2.0) * m->*x_col * m->*y_col + m->*cy_col),
                        where((m->*x_col * c(m->*x_col) + m->*y_col * c(m->*y_col)) < c(4.0) && m->*iter_col < 28)))),
-            cte<m2>("iter", "cx", "cy")(select(columns(max<>(m->*iter_col) >>= iter_col, m->*cx_col, m->*cy_col),
-                                               group_by(m->*cx_col, m->*cy_col))),
-            cte<a>("t")(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter_col / c(7.0), 4.0), 1), "") >>= t_col,
-                               group_by(m2->*cy_col)))),
+            cte<m2>(iter_col, cx_col, cy_col)(
+                select(columns(max<>(m->*iter_col), m->*cx_col, m->*cy_col), group_by(m->*cx_col, m->*cy_col))),
+            cte<a>(t_col)(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter_col / c(7.0), 4.0), 1), ""),
+                                 group_by(m2->*cy_col)))),
         select(group_concat(rtrim(a->*t_col), "\n")));
 #elif __cplusplus >= 201703L  // C++17 or later
     using cte_xaxis = decltype(1_ctealias);
@@ -569,7 +563,7 @@ void apfelmaennchen() {
             cte<cte_xaxis>("x")(
                 union_all(select(-2.0 >>= x_col), select(xaxis->*x_col + c(0.05), where(xaxis->*x_col < 1.2)))),
             cte<cte_yaxis>("y")(
-                union_all(select(-1.0 >>= y_col), select(yaxis->*y_col + c(0.1), where(yaxis->*y_col < 1.0)))),
+                union_all(select(-1.0 >>= y_col), select(yaxis->*y_col + c(0.10), where(yaxis->*y_col < 1.0)))),
             cte<cte_m>("iter", "cx", "cy", "x", "y")(union_all(
                 select(columns(0 >>= iter_col,
                                xaxis->*x_col >>= cx_col,

From 14400e9cb96761597288b57d30c9b7a46cf7f84c Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 21 Apr 2022 17:12:41 +0300
Subject: [PATCH 060/161] Capture support for class types as non-type template
 parameters in macro

---
 dev/alias.h                                   |  4 ++--
 dev/cte.h                                     |  2 +-
 dev/start_macros.h                            |  4 ++++
 examples/common_table_expressions.cpp         | 16 ++++++++--------
 include/sqlite_orm/sqlite_orm.h               | 10 +++++++---
 tests/static_tests/column_expression_type.cpp |  2 +-
 tests/static_tests/cte.cpp                    |  2 +-
 7 files changed, 24 insertions(+), 16 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index de38c4cc7..b028fe8ce 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -40,7 +40,7 @@ namespace sqlite_orm {
         template<class A>
         using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
 
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
         /*  
          *  Helper class to facilitate user-defined string literal operator template
          */
@@ -295,7 +295,7 @@ namespace sqlite_orm {
         return internal::column_alias<Chars...>{};
     }
 
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     /**
      *  column_alias<'a'[, ...]> from a string literal.
      *  E.g. "a"_col, "b"_col
diff --git a/dev/cte.h b/dev/cte.h
index 4a3f36a0b..a35cd90b8 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -65,7 +65,7 @@ namespace sqlite_orm {
     [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
         return internal::cte_alias<Chars...>{};
     }
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     /**
      *  cte_alias<'1'[, ...]> from a string literal.
      *  E.g. "1"_cte, "2"_cte
diff --git a/dev/start_macros.h b/dev/start_macros.h
index 5b94379b5..f8b6a4e15 100644
--- a/dev/start_macros.h
+++ b/dev/start_macros.h
@@ -31,6 +31,10 @@ __pragma(push_macro("max"))
 #define SQLITE_ORM_CONSTEVAL constexpr
 #endif
 
+#if __cpp_nontype_template_args >= 201911
+#define SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#endif
+
 #if __cplusplus >= 201703L  // C++17 or later
 #if __has_include(<optional>)
 #define SQLITE_ORM_OPTIONAL_SUPPORTED
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 83a32e59f..25936bed6 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -26,7 +26,7 @@ void all_integers_between(int from, int end) {
         //WITH RECURSIVE
         //    cnt(x) AS(VALUES(1) UNION ALL SELECT x + 1 FROM cnt WHERE x < 1000000)
         //    SELECT x FROM cnt;
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
         constexpr auto cnt_cte = "cnt"_cte;
         auto ast =
             with(cte<cnt_cte>()(
@@ -68,7 +68,7 @@ void all_integers_between(int from, int end) {
         //        LIMIT 1000000
         //    )
         //    SELECT x FROM cnt;
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
         auto ast = with(cte<"cnt"_cte>("y"_col)(
                             union_all(select(from >>= "x"_col), select("cnt"_cte->*"y"_col + c(1), limit(end)))),
                         select("cnt"_cte->*"y"_col));
@@ -149,7 +149,7 @@ void supervisor_chain() {
         //        WHERE parent.name = chain.boss
         //    )
         //    SELECT name FROM chain;
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
         auto ast = with(cte<"chain"_cte>()(union_all(
                             select(asterisk<Org>(), where(&Org::name == c("Fred"))),
                             select(asterisk<alias_a<Org>>(),
@@ -215,7 +215,7 @@ void works_for_alice() {
         //    )
         //    SELECT avg(height) FROM org
         //    WHERE org.name IN works_for_alice;
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
         constexpr auto works_for_alice = "works_for_alice"_cte;
         auto ast =
             with(cte<works_for_alice>("n"_col)(
@@ -300,7 +300,7 @@ void family_tree() {
     //    WHERE ancestor_of_alice.name = family.name
     //    AND died IS NULL
     //    ORDER BY born;
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     constexpr auto parent_of = "parent_of"_cte;
     constexpr auto ancestor_of_alice = "ancestor_of_alice"_cte;
     constexpr auto parent_col = "parent"_col;
@@ -418,7 +418,7 @@ void depth_or_breadth_first() {
         //        ORDER BY 2
         //    )
         //    SELECT substr('..........', 1, level * 3) || name FROM under_alice;
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
         constexpr auto under_alice = "under_alice"_cte;
         constexpr auto level_col = "level"_col;
         auto ast = with(cte<under_alice>(&Org::name, level_col)(
@@ -459,7 +459,7 @@ void depth_or_breadth_first() {
         //        ORDER BY 2
         //    )
         //    SELECT substr('..........', 1, level * 3) || name FROM under_alice;
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
         constexpr auto under_alice = "under_alice"_cte;
         constexpr auto level_col = "level"_col;
         auto ast = with(cte<under_alice>(&Org::name, level_col)(
@@ -512,7 +512,7 @@ void apfelmaennchen() {
     //        FROM m2 GROUP BY cy
     //    )
     //    SELECT group_concat(rtrim(t), x'0a') FROM a;
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     constexpr auto xaxis = "xaxis"_cte;
     constexpr auto yaxis = "yaxis"_cte;
     constexpr auto m = "mi"_cte;
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index e41f90826..1a8aeb526 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -31,6 +31,10 @@ __pragma(push_macro("max"))
 #define SQLITE_ORM_CONSTEVAL constexpr
 #endif
 
+#if __cpp_nontype_template_args >= 201911
+#define SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#endif
+
 #if __cplusplus >= 201703L  // C++17 or later
 #if __has_include(<optional>)
 #define SQLITE_ORM_OPTIONAL_SUPPORTED
@@ -4250,7 +4254,7 @@ namespace sqlite_orm {
         template<class A>
         using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
 
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
         /*  
          *  Helper class to facilitate user-defined string literal operator template
          */
@@ -4505,7 +4509,7 @@ namespace sqlite_orm {
         return internal::column_alias<Chars...>{};
     }
 
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     /**
      *  column_alias<'a'[, ...]> from a string literal.
      *  E.g. "a"_col, "b"_col
@@ -20350,7 +20354,7 @@ namespace sqlite_orm {
     [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
         return internal::cte_alias<Chars...>{};
     }
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     /**
      *  cte_alias<'1'[, ...]> from a string literal.
      *  E.g. "1"_cte, "2"_cte
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index 79eb7002d..b298118fe 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -50,7 +50,7 @@ TEST_CASE("column_expression_of_t") {
     runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(cte_1{}->*&Org::id);
     runTest<storage_type, column_pointer<cte_1, alias_holder<internal::column_alias<'1'>>>>(column<cte_1>(1_colalias));
     runTest<storage_type, column_pointer<cte_1, alias_holder<colalias_c>>>(1_ctealias->*colalias_c{});
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     runTest<storage_type, column_pointer<cte_1, alias_holder<colalias_c>>>("1"_cte->*"c"_col);
 #endif
 }
diff --git a/tests/static_tests/cte.cpp b/tests/static_tests/cte.cpp
index d28ab5f84..330beee11 100644
--- a/tests/static_tests/cte.cpp
+++ b/tests/static_tests/cte.cpp
@@ -31,7 +31,7 @@ TEST_CASE("CTE type traits") {
         runTest<tuple<decltype(&Org::id)>>(&Org::id);
         runTest<tuple<decltype(&Org::getId)>>(&Org::getId);
         runTest<tuple<alias_holder<column_alias<'1'>>>>(1_colalias);
-#if __cpp_nontype_template_args >= 201911
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
         runTest<tuple<alias_holder<column_alias<'a'>>>>("a"_col);
 #endif
         runTest<tuple<column_t<Org, int64, int64 Org::*, internal::empty_setter>>>(make_column("id", &Org::id));

From f7de21ef20137eb546facc1e3a629587d03ac169 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 21 Apr 2022 17:47:09 +0300
Subject: [PATCH 061/161] Used 'support' macro for C++20 non-type template
 parameter features

---
 dev/alias.h                     |  4 ++--
 dev/conditions.h                |  8 ++++----
 dev/cte.h                       |  2 +-
 dev/select_constraints.h        |  2 +-
 include/sqlite_orm/sqlite_orm.h | 16 ++++++++--------
 5 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index b028fe8ce..ca9f2cf68 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -184,7 +184,7 @@ namespace sqlite_orm {
         return {std::move(expression)};
     }
 
-#if __cplusplus >= 202002L  // C++20 or later
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     template<auto als, class E>
     internal::as_t<decltype(als), E> as(E expression) {
         return {std::move(expression)};
@@ -294,6 +294,7 @@ namespace sqlite_orm {
         static_assert(std::array{Chars...}[0] > '0');
         return internal::column_alias<Chars...>{};
     }
+#endif
 
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     /**
@@ -305,5 +306,4 @@ namespace sqlite_orm {
         return internal::to_alias<internal::column_alias, t>(std::make_index_sequence<t.size()>{});
     }
 #endif
-#endif
 }
diff --git a/dev/conditions.h b/dev/conditions.h
index 9e5e9f9e8..c510bc7fd 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -1008,7 +1008,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 or later
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     template<auto als, class O>
     internal::left_join_t<decltype(als), O> left_join(O o) {
         return {std::move(o)};
@@ -1020,7 +1020,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 or later
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     template<auto als, class O>
     internal::join_t<decltype(als), O> join(O o) {
         return {std::move(o)};
@@ -1032,7 +1032,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 or later
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     template<auto als, class O>
     internal::left_outer_join_t<decltype(als), O> left_outer_join(O o) {
         return {std::move(o)};
@@ -1044,7 +1044,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 or later
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     template<auto als, class O>
     internal::inner_join_t<decltype(als), O> inner_join(O o) {
         return {std::move(o)};
diff --git a/dev/cte.h b/dev/cte.h
index a35cd90b8..9114e662f 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -79,7 +79,7 @@ namespace sqlite_orm {
     }
 #endif
 
-#if __cplusplus >= 202002L  // C++20 or later
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     using cte_1 = decltype("1"_cte);
     using cte_2 = decltype("2"_cte);
     using cte_3 = decltype("3"_cte);
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index d7af016d7..82131f829 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -646,7 +646,7 @@ namespace sqlite_orm {
         return builder_type{{std::move(explicitColumns)...}};
     }
 
-#if __cplusplus >= 202002L  // C++20 or later
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     template<auto label,
              class... ExplicitCols,
              std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 1a8aeb526..8bdeffe9b 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3921,7 +3921,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 or later
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     template<auto als, class O>
     internal::left_join_t<decltype(als), O> left_join(O o) {
         return {std::move(o)};
@@ -3933,7 +3933,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 or later
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     template<auto als, class O>
     internal::join_t<decltype(als), O> join(O o) {
         return {std::move(o)};
@@ -3945,7 +3945,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 or later
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     template<auto als, class O>
     internal::left_outer_join_t<decltype(als), O> left_outer_join(O o) {
         return {std::move(o)};
@@ -3957,7 +3957,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#if __cplusplus >= 202002L  // C++20 or later
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     template<auto als, class O>
     internal::inner_join_t<decltype(als), O> inner_join(O o) {
         return {std::move(o)};
@@ -4398,7 +4398,7 @@ namespace sqlite_orm {
         return {std::move(expression)};
     }
 
-#if __cplusplus >= 202002L  // C++20 or later
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     template<auto als, class E>
     internal::as_t<decltype(als), E> as(E expression) {
         return {std::move(expression)};
@@ -4508,6 +4508,7 @@ namespace sqlite_orm {
         static_assert(std::array{Chars...}[0] > '0');
         return internal::column_alias<Chars...>{};
     }
+#endif
 
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     /**
@@ -4519,7 +4520,6 @@ namespace sqlite_orm {
         return internal::to_alias<internal::column_alias, t>(std::make_index_sequence<t.size()>{});
     }
 #endif
-#endif
 }
 #pragma once
 
@@ -7580,7 +7580,7 @@ namespace sqlite_orm {
         return builder_type{{std::move(explicitColumns)...}};
     }
 
-#if __cplusplus >= 202002L  // C++20 or later
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     template<auto label,
              class... ExplicitCols,
              std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
@@ -20368,7 +20368,7 @@ namespace sqlite_orm {
     }
 #endif
 
-#if __cplusplus >= 202002L  // C++20 or later
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     using cte_1 = decltype("1"_cte);
     using cte_2 = decltype("2"_cte);
     using cte_3 = decltype("3"_cte);

From 08cadb2cb7e92b2da513486e31e43dca7f91a2ee Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 21 Apr 2022 19:08:46 +0300
Subject: [PATCH 062/161] Added 'node tuple' and 'ast iterator' unit tests for
 CTEs

---
 dev/ast_iterator.h                |  1 +
 dev/node_tuple.h                  | 24 +++++++++++++++---------
 include/sqlite_orm/sqlite_orm.h   | 27 ++++++++++++++++++---------
 tests/ast_iterator_tests.cpp      | 19 ++++++++++++++++++-
 tests/static_tests/node_tuple.cpp | 22 ++++++++++++++++++++--
 5 files changed, 72 insertions(+), 21 deletions(-)

diff --git a/dev/ast_iterator.h b/dev/ast_iterator.h
index 15e5f3e23..545797928 100644
--- a/dev/ast_iterator.h
+++ b/dev/ast_iterator.h
@@ -3,6 +3,7 @@
 #include <vector>  //  std::vector
 #include <functional>  //  std::reference_wrapper
 
+#include "type_traits.h"
 #include "conditions.h"
 #include "select_constraints.h"
 #include "operators.h"
diff --git a/dev/node_tuple.h b/dev/node_tuple.h
index ac18071b7..ad16c1d52 100644
--- a/dev/node_tuple.h
+++ b/dev/node_tuple.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <type_traits>  //  std::enable_if
 #include <tuple>  //  std::tuple
 #include <utility>  //  std::pair
 #include <functional>  //  std::reference_wrapper
@@ -7,6 +8,7 @@
 #include <optional>  // std::optional
 #endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
 
+#include "cxx_polyfill.h"
 #include "conditions.h"
 #include "operators.h"
 #include "select_constraints.h"
@@ -87,7 +89,7 @@ namespace sqlite_orm {
         struct node_tuple<order_by_t<E>, void> : node_tuple<E> {};
 
         template<class T>
-        struct node_tuple<T, typename std::enable_if<is_base_of_template<T, binary_condition>::value>::type> {
+        struct node_tuple<T, std::enable_if_t<is_base_of_template<T, binary_condition>::value>> {
             using node_type = T;
             using left_type = typename node_type::left_type;
             using right_type = typename node_type::right_type;
@@ -126,7 +128,7 @@ namespace sqlite_orm {
         };
 
         template<class T>
-        struct node_tuple<T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
+        struct node_tuple<T, std::enable_if_t<is_base_of_template<T, compound_operator>::value>> {
             using node_type = T;
             using left_type = typename node_type::left_type;
             using right_type = typename node_type::right_type;
@@ -135,13 +137,17 @@ namespace sqlite_orm {
             using type = typename conc_tuple<left_tuple, right_tuple>::type;
         };
 
-        template<class T>
-        struct node_tuple<T, typename std::enable_if<is_base_of_template<T, common_table_expression>::value>::type> {
-            using node_type = T;
-            using cte_type = typename node_type::cte_type;
-            using expression_type = typename node_type::expression_type;
-            using cte_tuple = node_tuple_t<cte_type>;
-            using expression_tuple = node_tuple_t<expression_type>;
+        template<class CTE>
+        struct node_tuple<CTE, std::enable_if_t<polyfill::is_specialization_of_v<CTE, common_table_expression>>> {
+            using node_type = CTE;
+            using type = node_tuple_t<typename node_type::expression_type>;
+        };
+
+        template<class With>
+        struct node_tuple<With, std::enable_if_t<polyfill::is_specialization_of_v<With, with_t>>> {
+            using node_type = With;
+            using cte_tuple = node_tuple_t<typename node_type::cte_type>;
+            using expression_tuple = node_tuple_t<typename node_type::expression_type>;
             using type = typename conc_tuple<cte_tuple, expression_tuple>::type;
         };
 
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 8bdeffe9b..6e99339f7 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -11722,6 +11722,8 @@ namespace sqlite_orm {
 #include <vector>  //  std::vector
 #include <functional>  //  std::reference_wrapper
 
+// #include "type_traits.h"
+
 // #include "conditions.h"
 
 // #include "select_constraints.h"
@@ -20393,6 +20395,7 @@ namespace sqlite_orm {
 }
 #pragma once
 
+#include <type_traits>  //  std::enable_if
 #include <tuple>  //  std::tuple
 #include <utility>  //  std::pair
 #include <functional>  //  std::reference_wrapper
@@ -20400,6 +20403,8 @@ namespace sqlite_orm {
 #include <optional>  // std::optional
 #endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
 
+// #include "cxx_polyfill.h"
+
 // #include "conditions.h"
 
 // #include "operators.h"
@@ -20491,7 +20496,7 @@ namespace sqlite_orm {
         struct node_tuple<order_by_t<E>, void> : node_tuple<E> {};
 
         template<class T>
-        struct node_tuple<T, typename std::enable_if<is_base_of_template<T, binary_condition>::value>::type> {
+        struct node_tuple<T, std::enable_if_t<is_base_of_template<T, binary_condition>::value>> {
             using node_type = T;
             using left_type = typename node_type::left_type;
             using right_type = typename node_type::right_type;
@@ -20530,7 +20535,7 @@ namespace sqlite_orm {
         };
 
         template<class T>
-        struct node_tuple<T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
+        struct node_tuple<T, std::enable_if_t<is_base_of_template<T, compound_operator>::value>> {
             using node_type = T;
             using left_type = typename node_type::left_type;
             using right_type = typename node_type::right_type;
@@ -20539,13 +20544,17 @@ namespace sqlite_orm {
             using type = typename conc_tuple<left_tuple, right_tuple>::type;
         };
 
-        template<class T>
-        struct node_tuple<T, typename std::enable_if<is_base_of_template<T, common_table_expression>::value>::type> {
-            using node_type = T;
-            using cte_type = typename node_type::cte_type;
-            using expression_type = typename node_type::expression_type;
-            using cte_tuple = node_tuple_t<cte_type>;
-            using expression_tuple = node_tuple_t<expression_type>;
+        template<class CTE>
+        struct node_tuple<CTE, std::enable_if_t<polyfill::is_specialization_of_v<CTE, common_table_expression>>> {
+            using node_type = CTE;
+            using type = node_tuple_t<typename node_type::expression_type>;
+        };
+
+        template<class With>
+        struct node_tuple<With, std::enable_if_t<polyfill::is_specialization_of_v<With, with_t>>> {
+            using node_type = With;
+            using cte_tuple = node_tuple_t<typename node_type::cte_type>;
+            using expression_tuple = node_tuple_t<typename node_type::expression_type>;
             using type = typename conc_tuple<cte_tuple, expression_tuple>::type;
         };
 
diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index 746cfd852..4ba490539 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -2,6 +2,10 @@
 #include <catch2/catch.hpp>
 
 using namespace sqlite_orm;
+using internal::alias_holder;
+using internal::column_alias;
+using internal::column_pointer;
+using internal::cte_alias;
 
 TEST_CASE("ast_iterator") {
     struct User {
@@ -152,7 +156,7 @@ TEST_CASE("ast_iterator") {
     }
     SECTION("using") {
         auto node = using_(&User::id);
-        expected.push_back(typeid(internal::column_pointer<User, decltype(&User::id)>{&User::id}));
+        expected.push_back(typeid(column_pointer<User, decltype(&User::id)>{&User::id}));
         internal::iterate_ast(node, lambda);
     }
     SECTION("exists") {
@@ -264,5 +268,18 @@ TEST_CASE("ast_iterator") {
         expected.push_back(typeid(&User::id));
         internal::iterate_ast(node, lambda);
     }
+    SECTION("with") {
+        auto expression =
+            with(cte<1_ctealias>()(
+                     union_all(select(1), select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < 10)))),
+                 select(1_ctealias->*1_colalias));
+        expected.push_back(typeid(int));
+        expected.push_back(typeid(column_pointer<cte_alias<49>, alias_holder<column_alias<49>>>));
+        expected.push_back(typeid(int));
+        expected.push_back(typeid(column_pointer<cte_alias<49>, alias_holder<column_alias<49>>>));
+        expected.push_back(typeid(int));
+        expected.push_back(typeid(column_pointer<cte_alias<49>, alias_holder<column_alias<49>>>));
+        internal::iterate_ast(expression, lambda);
+    }
     REQUIRE(typeIndexes == expected);
 }
diff --git a/tests/static_tests/node_tuple.cpp b/tests/static_tests/node_tuple.cpp
index 98c0a0ea2..8a24a3fe6 100644
--- a/tests/static_tests/node_tuple.cpp
+++ b/tests/static_tests/node_tuple.cpp
@@ -3,6 +3,10 @@
 #include <type_traits>  //  std::is_same
 
 using namespace sqlite_orm;
+using internal::alias_holder;
+using internal::column_alias;
+using internal::column_pointer;
+using internal::cte_alias;
 
 template<class T>
 struct is_pair : std::false_type {};
@@ -837,7 +841,7 @@ TEST_CASE("Node tuple") {
             auto j = join<User>(using_(&User::id));
             using Join = decltype(j);
             using Tuple = node_tuple_t<Join>;
-            using Expected = tuple<internal::column_pointer<User, decltype(&User::id)>>;
+            using Expected = tuple<column_pointer<User, decltype(&User::id)>>;
             static_assert(is_same<Tuple, Expected>::value, "join using");
         }
         SECTION("join using explicit column") {
@@ -845,7 +849,7 @@ TEST_CASE("Node tuple") {
             auto j = join<User>(using_(column<Derived>(&User::id)));
             using Join = decltype(j);
             using Tuple = node_tuple_t<Join>;
-            using Expected = tuple<internal::column_pointer<Derived, decltype(&User::id)>>;
+            using Expected = tuple<column_pointer<Derived, decltype(&User::id)>>;
             static_assert(is_same<Tuple, Expected>::value, "join using explicit column");
         }
         SECTION("left_outer_join") {
@@ -936,4 +940,18 @@ TEST_CASE("Node tuple") {
         using ExpectedTuple = tuple<decltype(&User::id)>;
         STATIC_REQUIRE(std::is_same<Tuple, ExpectedTuple>::value);
     }
+    SECTION("with") {
+        auto expression =
+            with(cte<1_ctealias>()(
+                     union_all(select(1), select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < 10)))),
+                 select(1_ctealias->*1_colalias));
+        using Tuple = node_tuple_t<decltype(expression)>;
+        using ExpectedTuple = tuple<int,
+                                    column_pointer<cte_alias<49>, alias_holder<column_alias<49>>>,
+                                    int,
+                                    column_pointer<cte_alias<49>, alias_holder<column_alias<49>>>,
+                                    int,
+                                    column_pointer<cte_alias<49>, alias_holder<column_alias<49>>>>;
+        STATIC_REQUIRE(std::is_same_v<Tuple, ExpectedTuple>);
+    }
 }

From e76c2d1446949fa46b1f5506772bc8a1fe1cc8be Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 22 Apr 2022 23:22:31 +0300
Subject: [PATCH 063/161] Made CTE column references work with getters

---
 dev/column_result.h                     | 14 ++++----------
 dev/cte_column_names_collector.h        | 20 +++++---------------
 dev/cte_storage.h                       | 24 +++++++++++++++++-------
 dev/is_base_of_template.h               |  3 +++
 dev/member_traits/field_member_traits.h |  4 +++-
 dev/table_type.h                        | 16 ----------------
 6 files changed, 32 insertions(+), 49 deletions(-)

diff --git a/dev/column_result.h b/dev/column_result.h
index 9534d9bbc..f9cf6f673 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -122,14 +122,10 @@ namespace sqlite_orm {
         };
 
         template<class St, class T>
-        struct column_result_t<St, distinct_t<T>, void> {
-            using type = typename column_result_t<St, T>::type;
-        };
+        struct column_result_t<St, distinct_t<T>, void> : column_result_t<St, T> {};
 
         template<class St, class T>
-        struct column_result_t<St, all_t<T>, void> {
-            using type = typename column_result_t<St, T>::type;
-        };
+        struct column_result_t<St, all_t<T>, void> : column_result_t<St, T> {};
 
         template<class St, class L, class R>
         struct column_result_t<St, conc_t<L, R>, void> {
@@ -248,10 +244,8 @@ namespace sqlite_orm {
 
         template<class St, class T>
         struct column_result_t<St, T, std::enable_if_t<is_base_of_template<T, compound_operator>::value>> {
-            using left_type = typename T::left_type;
-            using right_type = typename T::right_type;
-            using left_result = column_result_of_t<St, left_type>;
-            using right_result = column_result_of_t<St, right_type>;
+            using left_result = column_result_of_t<St, typename T::left_type>;
+            using right_result = column_result_of_t<St, typename T::right_type>;
             static_assert(std::is_same<left_result, right_result>::value,
                           "Compound subselect queries must return same types");
             using type = left_result;
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index f7fbcd08e..b87e05488 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -6,6 +6,7 @@
 #include <system_error>
 
 #include "cxx_polyfill.h"
+#include "is_base_of_template.h"
 #include "type_traits.h"
 #include "member_traits/field_member_traits.h"
 #include "error_code.h"
@@ -45,6 +46,9 @@ namespace sqlite_orm {
         struct cte_column_names_collector {
             using expression_type = T;
 
+            // Compound statements are never passed in by storage_for_expression()
+            static_assert(!is_base_of_template_v<T, compound_operator>);
+
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type& t, const Ctx& context) const {
                 auto newContext = context;
@@ -64,20 +68,6 @@ namespace sqlite_orm {
             return collector(t, context);
         }
 
-        // For compound statements we just need to collect the column alias names of the left expression
-        template<class Compound>
-        struct cte_column_names_collector<Compound,
-                                          std::enable_if_t<is_base_of_template<Compound, compound_operator>::value>> {
-            using expression_type = Compound;
-
-            template<class Ctx>
-            std::vector<std::string> operator()(const expression_type& t, const Ctx& context) const {
-                auto newContext = context;
-                newContext.skip_table_name = true;
-                return get_cte_column_names(t.left.col, context);
-            }
-        };
-
         template<class As>
         struct cte_column_names_collector<As, match_specialization_of<As, as_t>> {
             using expression_type = As;
@@ -172,7 +162,7 @@ namespace sqlite_orm {
                     if constexpr(polyfill::is_specialization_of_v<ColRef, alias_holder>) {
                         columnNames[idx] = alias_extractor<type_t<ColRef>>::extract();
                     } else if constexpr(std::is_member_pointer<ColRef>::value) {
-                        using O = typename field_member_traits<ColRef>::object_type;
+                        using O = typename table_type<ColRef>::object_type;
                         if(auto* columnName = find_column_name<O>(context.impl, colRef)) {
                             columnNames[idx] = *columnName;
                         } else {
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 340d56633..61e07ec2c 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -5,6 +5,8 @@
 #include <string>
 #include <vector>
 
+#include "is_base_of_template.h"
+#include "table_type.h"
 #include "column_result.h"
 #include "column_expression.h"
 #include "select_constraints.h"
@@ -58,15 +60,17 @@ namespace sqlite_orm {
         template<typename F, typename ColRef, satisfies_is_specialization_of<ColRef, alias_holder> = true>
         static auto make_cte_column(std::string name, const ColRef& /*finalColRef*/) {
             using object_type = aliased_field<type_t<ColRef>, F>;
+
             return sqlite_orm::make_column<>(move(name), &object_type::field);
         }
 
         // F O::*
-        template<typename F,
-                 typename ColRef,
-                 std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<ColRef>>, bool> = true>
+        template<typename F, typename ColRef, satisfies<std::is_member_pointer, ColRef> = true>
         static auto make_cte_column(std::string name, const ColRef& finalColRef) {
-            return sqlite_orm::make_column<>(move(name), finalColRef);
+            using object_type = typename table_type<ColRef>::type;
+            using column_type = column_t<object_type, F, ColRef, empty_setter>;
+
+            return column_type{move(name), finalColRef, empty_setter{}};
         }
 
         /**
@@ -108,6 +112,9 @@ namespace sqlite_orm {
             return subSelect.col.left;
         }
 
+        /**
+         *  Return a tuple of member pointers of all columns
+         */
         template<class C, size_t... Idx>
         auto get_fields_of_columns(const C& coldef, std::index_sequence<Idx...>) {
             return std::make_tuple(get<Idx>(coldef).member_pointer...);
@@ -126,7 +133,7 @@ namespace sqlite_orm {
             return extract_colref_expressions(impl, col.value, s);
         }
 
-        // F O::* (field) -> field
+        // F O::* (field/getter) -> field/getter
         template<class S, class F, class O, size_t Idx = 0>
         auto extract_colref_expressions(const S& /*impl*/, F O::*col, std::index_sequence<Idx> = {}) {
             return std::make_tuple(col);
@@ -178,8 +185,11 @@ namespace sqlite_orm {
         }
 
         template<class S, class E, class... Args>
-        decltype(auto) extract_colref_expressions(const S& /*impl*/,
-                                                  const select_t<E, Args...>& /*subSelect*/) = delete;
+        void extract_colref_expressions(const S& /*impl*/, const select_t<E, Args...>& /*subSelect*/) = delete;
+        template<class S,
+                 class Compound,
+                 std::enable_if_t<is_base_of_template_v<Compound, compound_operator>, bool> = true>
+        void extract_colref_expressions(const S& /*impl*/, const Compound& /*subSelect*/) = delete;
 
         /*
          *  Depending on ExplicitColRef's type returns either the explicit column reference
diff --git a/dev/is_base_of_template.h b/dev/is_base_of_template.h
index 0c388fe81..b0bbfee06 100644
--- a/dev/is_base_of_template.h
+++ b/dev/is_base_of_template.h
@@ -34,5 +34,8 @@ namespace sqlite_orm {
         template<typename T, template<typename...> class C>
         using is_base_of_template = decltype(is_base_of_template_impl<C>(std::declval<T*>()));
 #endif
+
+        template<typename T, template<typename...> class C>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_base_of_template_v = is_base_of_template<T, C>::value;
     }
 }
diff --git a/dev/member_traits/field_member_traits.h b/dev/member_traits/field_member_traits.h
index aefbcb2e6..e81bf63fa 100644
--- a/dev/member_traits/field_member_traits.h
+++ b/dev/member_traits/field_member_traits.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <type_traits>  //  std::enable_if, std::is_member_object_pointer
+
 namespace sqlite_orm {
     namespace internal {
 
@@ -7,7 +9,7 @@ namespace sqlite_orm {
         struct field_member_traits;
 
         template<class O, class F>
-        struct field_member_traits<F O::*, void> {
+        struct field_member_traits<F O::*, std::enable_if_t<std::is_member_object_pointer<F O::*>::value>> {
             using object_type = O;
             using field_type = F;
         };
diff --git a/dev/table_type.h b/dev/table_type.h
index 1949456f7..6ed2ffef5 100644
--- a/dev/table_type.h
+++ b/dev/table_type.h
@@ -1,11 +1,5 @@
 #pragma once
 
-#include "type_traits.h"
-#include "member_traits/getter_traits.h"
-#include "member_traits/setter_traits.h"
-#include "member_traits/is_getter.h"
-#include "member_traits/is_setter.h"
-
 namespace sqlite_orm {
 
     namespace internal {
@@ -30,16 +24,6 @@ namespace sqlite_orm {
             using type = O;
         };
 
-        template<class T>
-        struct table_type<T, match_if<is_getter, T>> {
-            using type = typename getter_traits<T>::object_type;
-        };
-
-        template<class T>
-        struct table_type<T, match_if<is_setter, T>> {
-            using type = typename setter_traits<T>::object_type;
-        };
-
         template<class T, class F>
         struct table_type<column_pointer<T, F>, void> {
             using type = T;

From 32bf564139b59b4fb23ba49293cbd79f4fcdcb95 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 24 Apr 2022 11:48:55 +0300
Subject: [PATCH 064/161] Fixed getting table_type's object

---
 dev/cte_column_names_collector.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index b87e05488..2b334a6e7 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -162,7 +162,7 @@ namespace sqlite_orm {
                     if constexpr(polyfill::is_specialization_of_v<ColRef, alias_holder>) {
                         columnNames[idx] = alias_extractor<type_t<ColRef>>::extract();
                     } else if constexpr(std::is_member_pointer<ColRef>::value) {
-                        using O = typename table_type<ColRef>::object_type;
+                        using O = typename table_type<ColRef>::type;
                         if(auto* columnName = find_column_name<O>(context.impl, colRef)) {
                             columnNames[idx] = *columnName;
                         } else {

From c7e58ed8110a985589bc54b09e1469f99e8b2bf3 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 24 Apr 2022 11:59:43 +0300
Subject: [PATCH 065/161] Added example selecting columns from a subquery,
 using an explicit CTE

---
 dev/alias.h                           | 17 ++++++---
 dev/column_expression.h               |  4 +--
 dev/column_names_getter.h             |  2 +-
 dev/column_result.h                   |  4 +--
 dev/cte_column_names_collector.h      |  2 +-
 dev/select_constraints.h              | 17 ++++++---
 dev/table_name_collector.h            |  4 +--
 examples/common_table_expressions.cpp | 52 ++++++++++++++++++++++++---
 include/sqlite_orm/sqlite_orm.h       | 52 +++++++++++++++++----------
 9 files changed, 115 insertions(+), 39 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index ca9f2cf68..ffffe890b 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -18,14 +18,23 @@ namespace sqlite_orm {
     namespace internal {
 
         template<class A>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_column_alias_v = std::is_base_of<alias_tag, A>::value;
+        SQLITE_ORM_INLINE_VAR constexpr bool is_alias_v = std::is_base_of<alias_tag, A>::value;
 
         template<class A>
-        using is_column_alias = polyfill::bool_constant<is_column_alias_v<A>>;
+        using is_alias = polyfill::bool_constant<is_alias_v<A>>;
+
+        /*
+         *  Note: Currently, there is no distinguishing property of a column alias other than that it is derived from "alias_tag".
+         */
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_column_alias_v = is_alias_v<A>;
+
+        template<class A>
+        using is_column_alias = is_alias<A>;
 
         template<class A>
         SQLITE_ORM_INLINE_VAR constexpr bool is_table_alias_v =
-            polyfill::conjunction_v<std::is_base_of<alias_tag, A>, polyfill::is_detected<type_t, A>>;
+            polyfill::conjunction_v<is_alias<A>, polyfill::is_detected<type_t, A>>;
 
         template<class A>
         using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
@@ -108,7 +117,7 @@ namespace sqlite_orm {
         };
 
         template<class A>
-        struct alias_extractor<A, match_if<std::is_base_of, alias_tag, A>> {
+        struct alias_extractor<A, match_if<is_alias, A>> {
             template<bool yes = !is_cte_alias_v<A>>
             static std::string extract(polyfill::bool_constant<yes> = {}) {
                 return static_if<yes>(
diff --git a/dev/column_expression.h b/dev/column_expression.h
index ba31fd6df..d64e87ff6 100644
--- a/dev/column_expression.h
+++ b/dev/column_expression.h
@@ -60,7 +60,7 @@ namespace sqlite_orm {
          *  asterisk_t<O> -> tuple<ColExpr...>
          */
         template<class St, class E>
-        struct column_expression_type<St, asterisk_t<E>, match_if_not<is_column_alias, E>>
+        struct column_expression_type<St, asterisk_t<E>, match_if_not<is_table_alias, E>>
             : storage_traits::storage_mapped_column_expressions<St, E> {};
 
         template<class A>
@@ -75,7 +75,7 @@ namespace sqlite_orm {
          *  asterisk_t<Alias> -> tuple<alias_column_t<Alias, ColExpr>...>
          */
         template<class St, class A>
-        struct column_expression_type<St, asterisk_t<A>, match_if<is_column_alias, A>>
+        struct column_expression_type<St, asterisk_t<A>, match_if<is_table_alias, A>>
             : tuple_transformer<typename storage_traits::storage_mapped_column_expressions<St, type_t<A>>::type,
                                 add_column_alias<A>::template apply> {};
 
diff --git a/dev/column_names_getter.h b/dev/column_names_getter.h
index 7fbe794f4..0df871a4c 100644
--- a/dev/column_names_getter.h
+++ b/dev/column_names_getter.h
@@ -66,7 +66,7 @@ namespace sqlite_orm {
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type&, const Ctx&) const {
-                return {quote_identifier(alias_extractor<A>::extract()) + ".*"};
+                return {quote_identifier(alias_extractor<A>::extract(std::true_type{})) + ".*"};
             }
         };
 
diff --git a/dev/column_result.h b/dev/column_result.h
index 0c622966b..f1c734294 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -281,12 +281,12 @@ namespace sqlite_orm {
         struct column_result_t<St, as_t<T, E>, void> : column_result_t<St, std::decay_t<E>> {};
 
         template<class St, class T>
-        struct column_result_t<St, asterisk_t<T>, match_if_not<is_column_alias, T>> {
+        struct column_result_t<St, asterisk_t<T>, match_if_not<is_table_alias, T>> {
             using type = typename storage_traits::storage_mapped_columns<St, T>::type;
         };
 
         template<class St, class A>
-        struct column_result_t<St, asterisk_t<A>, match_if<is_column_alias, A>> {
+        struct column_result_t<St, asterisk_t<A>, match_if<is_table_alias, A>> {
             using type = typename storage_traits::storage_mapped_columns<St, type_t<A>>::type;
         };
 
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index 2b334a6e7..29f48e3ac 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -128,7 +128,7 @@ namespace sqlite_orm {
 
                     std::string columnName;
                     if constexpr(polyfill::is_specialization_of_v<value_type, as_t>) {
-                        columnName = alias_extractor<typename value_type::alias_type>::extract();
+                        columnName = alias_extractor<alias_type_t<value_type>>::extract();
                     } else {
                         columnName = serialize(m, newContext);
                     }
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index ccd5eff16..df1979d27 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -149,7 +149,7 @@ namespace sqlite_orm {
         };
 
         template<class A>
-        struct column_pointer_builder<A, match_if<std::is_base_of, alias_tag, A>> {
+        struct column_pointer_builder<A, match_if<is_alias, A>> {
             static_assert(is_cte_alias_v<A>, "`A' must be a mapped table alias");
 
             using mapped_type = A;
@@ -170,7 +170,7 @@ namespace sqlite_orm {
              *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
              *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
              */
-            template<class F, satisfies_not<std::is_base_of, alias_tag, F> = true>
+            template<class F, satisfies_not<is_column_alias, F> = true>
             constexpr column_pointer<mapped_type, F> operator()(F field) const {
                 return {std::move(field)};
             }
@@ -182,7 +182,7 @@ namespace sqlite_orm {
              *  struct Object { ... };
              *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
              */
-            template<class ColAlias, satisfies<std::is_base_of, alias_tag, ColAlias> = true>
+            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
             constexpr column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
                 return {{}};
             }
@@ -564,7 +564,7 @@ namespace sqlite_orm {
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>()->*&Object::id));
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(cte_1{}->*&Object::id));
      */
-    template<class A, class F, internal::satisfies<std::is_base_of, alias_tag, A> = true>
+    template<class A, class F, internal::satisfies<internal::is_table_alias, A> = true>
     constexpr auto operator->*(const A& /*tableAlias*/, F field) {
         return column<A>(std::move(field));
     }
@@ -576,7 +576,7 @@ namespace sqlite_orm {
      *  struct Object { ... };
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*0_col));
      */
-    template<class A, class F, internal::satisfies<std::is_base_of, alias_tag, A> = true>
+    template<class A, class F, internal::satisfies<internal::is_table_alias, A> = true>
     constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
         return column<A>(std::move(field));
     }
@@ -707,6 +707,13 @@ namespace sqlite_orm {
         return {};
     }
 
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+    template<auto T, internal::satisfies<internal::is_table_alias, decltype(T)> = true>
+    internal::asterisk_t<decltype(T)> asterisk() {
+        return {};
+    }
+#endif
+
     /**
      * SELECT * FROM T function.
      * T is typed mapped to a storage.
diff --git a/dev/table_name_collector.h b/dev/table_name_collector.h
index 6b59dc8d8..97db33e06 100644
--- a/dev/table_name_collector.h
+++ b/dev/table_name_collector.h
@@ -54,12 +54,12 @@ namespace sqlite_orm {
                 }
             }
 
-            template<class T, satisfies_not<std::is_base_of, alias_tag, T> = true>
+            template<class T, satisfies_not<is_table_alias, T> = true>
             void operator()(const asterisk_t<T> &) const {
                 table_names.emplace(this->find_table_name(typeid(T)), "");
             }
 
-            template<class T, satisfies<std::is_base_of, alias_tag, T> = true>
+            template<class T, satisfies<is_table_alias, T> = true>
             void operator()(const asterisk_t<T> &) const {
                 // note: not all alias classes have a nested A::type
                 static_assert(polyfill::is_detected_v<type_t, T>,
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 25936bed6..519339873 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -361,7 +361,7 @@ void family_tree() {
 
     cout << "Living ancestor's of Alice:\n";
     for(const string& name: results) {
-        cout << name << endl;
+        cout << name << '\n';
     }
     cout << endl;
 #endif
@@ -443,7 +443,7 @@ void depth_or_breadth_first() {
 
         cout << "List of organization members, breadth-first:\n";
         for(const string& name: results) {
-            cout << name << endl;
+            cout << name << '\n';
         }
     }
     cout << endl;
@@ -484,13 +484,56 @@ void depth_or_breadth_first() {
 
         cout << "List of organization members, depth-first:\n";
         for(const string& name: results) {
-            cout << name << endl;
+            cout << name << '\n';
         }
     }
     cout << endl;
 #endif
 }
 
+void select_from_subselect() {
+    struct Employee {
+        int m_empno;
+        std::string m_ename;
+        double m_salary;
+        std::optional<double> m_commission;
+    };
+
+    auto storage = make_storage("",
+                                make_table("Emp",
+                                           make_column("empno", &Employee::m_empno, primary_key(), autoincrement()),
+                                           make_column("ename", &Employee::m_ename),
+                                           make_column("salary", &Employee::m_salary),
+                                           make_column("comm", &Employee::m_commission)));
+    storage.sync_schema();
+    storage.transaction([&storage]() {
+        storage.insert<Employee>({1, "Patel", 4000, nullopt});
+        storage.insert<Employee>({2, "Jariwala", 19300, nullopt});
+        return true;
+    });
+
+    // SELECT * FROM (SELECT salary, comm AS commmission FROM emp) WHERE salary < 5000
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+    constexpr auto sub = "sub"_cte;
+    auto expression = with(cte<sub>()(select(columns(&Employee::m_salary, &Employee::m_commission))),
+                           select(asterisk<sub>(), where(c(sub->*&Employee::m_salary) < 5000)));
+#else
+    auto expression = with(cte<cte_1>()(select(columns(&Employee::m_salary, &Employee::m_commission))),
+                           select(asterisk<cte_1>(), where(c(1_ctealias->*&Employee::m_salary) < 5000)));
+#endif
+
+    string sql = storage.dump(expression);
+
+    auto stmt = storage.prepare(expression);
+    auto results = storage.execute(stmt);
+
+    cout << "List of employees with a salary less than 5000:\n";
+    for(auto& result: results) {
+        cout << get<0>(result) << '\n';
+    }
+    cout << endl;
+}
+
 void apfelmaennchen() {
 #if __cplusplus >= 201703L  // use of C++17 or higher
     auto storage = make_storage("");
@@ -591,7 +634,7 @@ void apfelmaennchen() {
 
     cout << "Apfelmaennchen (Mandelbrot set):\n";
     for(const string& rowString: results) {
-        cout << rowString << endl;
+        cout << rowString << '\n';
     }
     cout << endl;
 #endif
@@ -692,6 +735,7 @@ int main() {
         works_for_alice();
         family_tree();
         depth_or_breadth_first();
+        select_from_subselect();
         apfelmaennchen();
         show_mapping_and_backreferencing();
     } catch(const system_error& e) {
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index b31204b7a..f4d953d92 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4094,14 +4094,23 @@ namespace sqlite_orm {
     namespace internal {
 
         template<class A>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_column_alias_v = std::is_base_of<alias_tag, A>::value;
+        SQLITE_ORM_INLINE_VAR constexpr bool is_alias_v = std::is_base_of<alias_tag, A>::value;
 
         template<class A>
-        using is_column_alias = polyfill::bool_constant<is_column_alias_v<A>>;
+        using is_alias = polyfill::bool_constant<is_alias_v<A>>;
+
+        /*
+         *  Note: Currently, there is no distinguishing property of a column alias other than that it is derived from "alias_tag".
+         */
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_column_alias_v = is_alias_v<A>;
+
+        template<class A>
+        using is_column_alias = is_alias<A>;
 
         template<class A>
         SQLITE_ORM_INLINE_VAR constexpr bool is_table_alias_v =
-            polyfill::conjunction_v<std::is_base_of<alias_tag, A>, polyfill::is_detected<type_t, A>>;
+            polyfill::conjunction_v<is_alias<A>, polyfill::is_detected<type_t, A>>;
 
         template<class A>
         using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
@@ -4184,7 +4193,7 @@ namespace sqlite_orm {
         };
 
         template<class A>
-        struct alias_extractor<A, match_if<std::is_base_of, alias_tag, A>> {
+        struct alias_extractor<A, match_if<is_alias, A>> {
             template<bool yes = !is_cte_alias_v<A>>
             static std::string extract(polyfill::bool_constant<yes> = {}) {
                 return static_if<yes>(
@@ -7045,7 +7054,7 @@ namespace sqlite_orm {
         };
 
         template<class A>
-        struct column_pointer_builder<A, match_if<std::is_base_of, alias_tag, A>> {
+        struct column_pointer_builder<A, match_if<is_alias, A>> {
             static_assert(is_cte_alias_v<A>, "`A' must be a mapped table alias");
 
             using mapped_type = A;
@@ -7066,7 +7075,7 @@ namespace sqlite_orm {
              *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
              *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
              */
-            template<class F, satisfies_not<std::is_base_of, alias_tag, F> = true>
+            template<class F, satisfies_not<is_column_alias, F> = true>
             constexpr column_pointer<mapped_type, F> operator()(F field) const {
                 return {std::move(field)};
             }
@@ -7078,7 +7087,7 @@ namespace sqlite_orm {
              *  struct Object { ... };
              *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
              */
-            template<class ColAlias, satisfies<std::is_base_of, alias_tag, ColAlias> = true>
+            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
             constexpr column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
                 return {{}};
             }
@@ -7460,7 +7469,7 @@ namespace sqlite_orm {
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>()->*&Object::id));
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(cte_1{}->*&Object::id));
      */
-    template<class A, class F, internal::satisfies<std::is_base_of, alias_tag, A> = true>
+    template<class A, class F, internal::satisfies<internal::is_table_alias, A> = true>
     constexpr auto operator->*(const A& /*tableAlias*/, F field) {
         return column<A>(std::move(field));
     }
@@ -7472,7 +7481,7 @@ namespace sqlite_orm {
      *  struct Object { ... };
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*0_col));
      */
-    template<class A, class F, internal::satisfies<std::is_base_of, alias_tag, A> = true>
+    template<class A, class F, internal::satisfies<internal::is_table_alias, A> = true>
     constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
         return column<A>(std::move(field));
     }
@@ -7603,6 +7612,13 @@ namespace sqlite_orm {
         return {};
     }
 
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+    template<auto T, internal::satisfies<internal::is_table_alias, decltype(T)> = true>
+    internal::asterisk_t<decltype(T)> asterisk() {
+        return {};
+    }
+#endif
+
     /**
      * SELECT * FROM T function.
      * T is typed mapped to a storage.
@@ -10666,12 +10682,12 @@ namespace sqlite_orm {
         struct column_result_t<St, as_t<T, E>, void> : column_result_t<St, std::decay_t<E>> {};
 
         template<class St, class T>
-        struct column_result_t<St, asterisk_t<T>, match_if_not<is_column_alias, T>> {
+        struct column_result_t<St, asterisk_t<T>, match_if_not<is_table_alias, T>> {
             using type = typename storage_traits::storage_mapped_columns<St, T>::type;
         };
 
         template<class St, class A>
-        struct column_result_t<St, asterisk_t<A>, match_if<is_column_alias, A>> {
+        struct column_result_t<St, asterisk_t<A>, match_if<is_table_alias, A>> {
             using type = typename storage_traits::storage_mapped_columns<St, type_t<A>>::type;
         };
 
@@ -15197,12 +15213,12 @@ namespace sqlite_orm {
                 }
             }
 
-            template<class T, satisfies_not<std::is_base_of, alias_tag, T> = true>
+            template<class T, satisfies_not<is_table_alias, T> = true>
             void operator()(const asterisk_t<T>&) const {
                 table_names.emplace(this->find_table_name(typeid(T)), "");
             }
 
-            template<class T, satisfies<std::is_base_of, alias_tag, T> = true>
+            template<class T, satisfies<is_table_alias, T> = true>
             void operator()(const asterisk_t<T>&) const {
                 // note: not all alias classes have a nested A::type
                 static_assert(polyfill::is_detected_v<type_t, T>,
@@ -15306,7 +15322,7 @@ namespace sqlite_orm {
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type&, const Ctx&) const {
-                return {quote_identifier(alias_extractor<A>::extract()) + ".*"};
+                return {quote_identifier(alias_extractor<A>::extract(std::true_type{})) + ".*"};
             }
         };
 
@@ -15482,7 +15498,7 @@ namespace sqlite_orm {
 
                     std::string columnName;
                     if constexpr(polyfill::is_specialization_of_v<value_type, as_t>) {
-                        columnName = alias_extractor<typename value_type::alias_type>::extract();
+                        columnName = alias_extractor<alias_type_t<value_type>>::extract();
                     } else {
                         columnName = serialize(m, newContext);
                     }
@@ -15516,7 +15532,7 @@ namespace sqlite_orm {
                     if constexpr(polyfill::is_specialization_of_v<ColRef, alias_holder>) {
                         columnNames[idx] = alias_extractor<type_t<ColRef>>::extract();
                     } else if constexpr(std::is_member_pointer<ColRef>::value) {
-                        using O = typename table_type<ColRef>::object_type;
+                        using O = typename table_type<ColRef>::type;
                         if(auto* columnName = find_column_name<O>(context.impl, colRef)) {
                             columnNames[idx] = *columnName;
                         } else {
@@ -18158,7 +18174,7 @@ namespace sqlite_orm {
          *  asterisk_t<O> -> tuple<ColExpr...>
          */
         template<class St, class E>
-        struct column_expression_type<St, asterisk_t<E>, match_if_not<is_column_alias, E>>
+        struct column_expression_type<St, asterisk_t<E>, match_if_not<is_table_alias, E>>
             : storage_traits::storage_mapped_column_expressions<St, E> {};
 
         template<class A>
@@ -18173,7 +18189,7 @@ namespace sqlite_orm {
          *  asterisk_t<Alias> -> tuple<alias_column_t<Alias, ColExpr>...>
          */
         template<class St, class A>
-        struct column_expression_type<St, asterisk_t<A>, match_if<is_column_alias, A>>
+        struct column_expression_type<St, asterisk_t<A>, match_if<is_table_alias, A>>
             : tuple_transformer<typename storage_traits::storage_mapped_column_expressions<St, type_t<A>>::type,
                                 add_column_alias<A>::template apply> {};
 

From ab3b0a1a22d9bbc9391bd95ee9ee9e233231aad4 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 24 Apr 2022 13:38:09 +0300
Subject: [PATCH 066/161] Use feature detection macros for polyfills

---
 dev/cxx_polyfill.h | 50 +++++++++++++++++++++++++++++-----------------
 dev/type_traits.h  |  2 +-
 2 files changed, 33 insertions(+), 19 deletions(-)

diff --git a/dev/cxx_polyfill.h b/dev/cxx_polyfill.h
index 04b560a4d..d462a8125 100644
--- a/dev/cxx_polyfill.h
+++ b/dev/cxx_polyfill.h
@@ -7,10 +7,25 @@
 namespace sqlite_orm {
     namespace internal {
         namespace polyfill {
-#if __cplusplus < 201703L  // C++14 or earlier
+#if __cpp_lib_void_t >= 201411L
+            using std::void_t;
+#else
+            template<class...>
+            using void_t = void;
+#endif
+
+#if __cpp_lib_bool_constant >= 201505L
+            using std::bool_constant;
+#else
             template<bool v>
             using bool_constant = std::integral_constant<bool, v>;
+#endif
 
+#if __cpp_lib_logical_traits >= 201510L && __cpp_lib_type_trait_variable_templates >= 201510L
+            using std::conjunction, std::conjunction_v;
+            using std::disjunction, std::disjunction_v;
+            using std::negation, std::negation_v;
+#else
             template<typename...>
             struct conjunction : std::true_type {};
             template<typename B1>
@@ -18,7 +33,7 @@ namespace sqlite_orm {
             template<typename B1, typename... Bn>
             struct conjunction<B1, Bn...> : std::conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};
             template<typename... Bs>
-            constexpr bool conjunction_v = conjunction<Bs...>::value;
+            SQLITE_ORM_INLINE_VAR constexpr bool conjunction_v = conjunction<Bs...>::value;
 
             template<typename...>
             struct disjunction : std::false_type {};
@@ -27,30 +42,22 @@ namespace sqlite_orm {
             template<typename B1, typename... Bn>
             struct disjunction<B1, Bn...> : std::conditional_t<bool(B1::value), B1, disjunction<Bn...>> {};
             template<typename... Bs>
-            constexpr bool disjunction_v = disjunction<Bs...>::value;
+            SQLITE_ORM_INLINE_VAR constexpr bool disjunction_v = disjunction<Bs...>::value;
 
-            template<class B>
+            template<typename B>
             struct negation : bool_constant<!bool(B::value)> {};
-
-            template<class...>
-            using void_t = void;
-#else
-            using std::bool_constant;
-            using std::conjunction, std::conjunction_v;
-            using std::disjunction, std::disjunction_v;
-            using std::negation, std::negation_v;
-            using std::void_t;
+            template<typename B>
+            SQLITE_ORM_INLINE_VAR constexpr bool negation_v = negation<B>::value;
 #endif
 
-#if __cplusplus < 202002L  // C++20 or earlier
+#if __cpp_lib_remove_cvref >= 201711L
+            using std::remove_cvref, std::remove_cvref_t;
+#else
             template<class T>
             struct remove_cvref : std::remove_cv<std::remove_reference_t<T>> {};
 
             template<class T>
             using remove_cvref_t = typename remove_cvref<T>::type;
-#else
-            using std::remove_cvref;
-            using std::remove_cvref_t;
 #endif
 
 #if 1  // proposed but not pursued                                                                                     \
@@ -70,7 +77,14 @@ namespace sqlite_orm {
 #else
             using std::is_specialization_of, std::is_specialization_of_t, std::is_specialization_of_v;
 #endif
-#if 1  // library fundamentals TS v2, [meta.detect]
+
+#if 0  // __cpp_lib_detect >= 0L  //  library fundamentals TS v2, [meta.detect]
+            using std::nonesuch;
+            using std::detector;
+            using std::is_detected, std::is_detected_v;
+            using std::detected, std::detected_t;
+            using std::detected_or, std::detected_or_t;
+#else
             struct nonesuch {
                 ~nonesuch() = delete;
                 nonesuch(const nonesuch&) = delete;
diff --git a/dev/type_traits.h b/dev/type_traits.h
index 055004b33..070cfeab1 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -14,7 +14,7 @@ namespace sqlite_orm {
 
         // enable_if for types
         template<template<typename...> class Op, class... Args>
-        using match_if_not = std::enable_if_t<polyfill::negation<Op<Args...>>::value>;
+        using match_if_not = std::enable_if_t<polyfill::negation_v<Op<Args...>>>;
 
         // enable_if for types
         template<class T, template<typename...> class Primary>

From f69701e56028766a550952a50f3992ce6954b4c8 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 25 Apr 2022 00:12:10 +0300
Subject: [PATCH 067/161] Context-sensitive alias extraction

---
 dev/alias.h                     |  41 +++++---
 dev/column_names_getter.h       |   2 +-
 dev/cte_storage.h               |   2 +-
 dev/mapped_type_proxy.h         |   3 +
 dev/statement_serializer.h      |  32 +++----
 dev/static_magic.h              |   3 -
 dev/storage.h                   |   2 +-
 dev/table_name_collector.h      |  20 ++--
 include/sqlite_orm/sqlite_orm.h | 160 +++++++++++++++++++-------------
 tests/static_if_tests.cpp       |   2 +-
 10 files changed, 152 insertions(+), 115 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index ffffe890b..8f9daf714 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -5,7 +5,6 @@
 #include <string>  //  std::string
 
 #include "cxx_polyfill.h"
-#include "static_magic.h"
 
 namespace sqlite_orm {
 
@@ -109,26 +108,44 @@ namespace sqlite_orm {
             alias_column_t(column_type column_) : column(std::move(column_)) {}
         };
 
+        /*
+         * Encapsulates extracting the alias identifier of a non-alias.
+         */
         template<class T, class SFINAE = void>
         struct alias_extractor {
             static std::string extract() {
                 return {};
             }
+
+            static std::string as_alias() {
+                return {};
+            }
         };
 
+        /*
+         * Encapsulates extracting the alias identifier of an alias.
+         * 
+         * `extract()` always returns the aliase identifier.
+         * `as_alias()` is used in contexts where a table is aliased.
+         *   In case of a CTE the alias is empty since the CTE identifier is already the alias itself.
+         */
         template<class A>
         struct alias_extractor<A, match_if<is_alias, A>> {
-            template<bool yes = !is_cte_alias_v<A>>
-            static std::string extract(polyfill::bool_constant<yes> = {}) {
-                return static_if<yes>(
-                    []() {
-                        std::stringstream ss;
-                        ss << A::get();
-                        return ss.str();
-                    },
-                    []() {
-                        return std::string{};
-                    })();
+            static std::string extract() {
+                std::stringstream ss;
+                ss << A::get();
+                return ss.str();
+            }
+
+            // for column and regular table aliases -> alias identifier
+            template<class T = A, satisfies_not<std::is_same, polyfill::detected_t<type_t, T>, A> = true>
+            static std::string as_alias() {
+                return alias_extractor::extract();
+            }
+            // for cte aliases -> empty
+            template<class T = A, satisfies<std::is_same, polyfill::detected_t<type_t, T>, A> = true>
+            static std::string as_alias() {
+                return {};
             }
         };
 
diff --git a/dev/column_names_getter.h b/dev/column_names_getter.h
index 0df871a4c..7fbe794f4 100644
--- a/dev/column_names_getter.h
+++ b/dev/column_names_getter.h
@@ -66,7 +66,7 @@ namespace sqlite_orm {
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type&, const Ctx&) const {
-                return {quote_identifier(alias_extractor<A>::extract(std::true_type{})) + ".*"};
+                return {quote_identifier(alias_extractor<A>::extract()) + ".*"};
             }
         };
 
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 61e07ec2c..794299053 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -259,7 +259,7 @@ namespace sqlite_orm {
 
             using context_type = serializer_context<S>;
 
-            std::string tableName = alias_extractor<cte_label_type_t<cte_type>>::extract(std::true_type{});
+            std::string tableName = alias_extractor<cte_label_type_t<cte_type>>::extract();
             auto subselectColRefs = extract_colref_expressions(impl, subSelect.col);
             const auto& finalColRefs =
                 determine_cte_colrefs(impl, subselectColRefs, cte.explicitColumns, index_sequence{});
diff --git a/dev/mapped_type_proxy.h b/dev/mapped_type_proxy.h
index 113325e83..58a23954d 100644
--- a/dev/mapped_type_proxy.h
+++ b/dev/mapped_type_proxy.h
@@ -20,5 +20,8 @@ namespace sqlite_orm {
         struct mapped_type_proxy<T, match_if<is_table_alias, T>> {
             using type = type_t<T>;
         };
+
+        template<class T>
+        using mapped_type_proxy_t = typename mapped_type_proxy<T>::type;
     }
 }
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index 9cee937be..a97672bf2 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -19,6 +19,7 @@
 #include "tuple_helper/tuple_filter.h"
 #include "member_traits/is_getter.h"
 #include "member_traits/is_setter.h"
+#include "mapped_type_proxy.h"
 #include "ast/upsert_clause.h"
 #include "ast/excluded.h"
 #include "ast/group_by.h"
@@ -454,7 +455,7 @@ namespace sqlite_orm {
          *  Serializer for literal values.
          */
         template<class T>
-        struct statement_serializer<T, internal::match_specialization_of<T, literal_holder>> {
+        struct statement_serializer<T, match_specialization_of<T, literal_holder>> {
             using statement_type = T;
 
             template<class Ctx>
@@ -829,7 +830,7 @@ namespace sqlite_orm {
                 cteContext.use_parentheses = false;
 
                 std::stringstream ss;
-                ss << streaming_identifier(alias_extractor<cte_label_type_t<CTE>>::extract(std::true_type{}));
+                ss << streaming_identifier(alias_extractor<cte_label_type_t<CTE>>::extract());
                 {
                     std::vector<std::string> columnNames =
                         collect_cte_column_names(get_cte_driving_subselect(cte.subselect),
@@ -1207,7 +1208,7 @@ namespace sqlite_orm {
                 {
                     using references_type_t = typename std::decay<decltype(fk)>::type::references_type;
                     using first_reference_t = std::tuple_element_t<0, references_type_t>;
-                    using first_reference_mapped_type = typename internal::table_type<first_reference_t>::type;
+                    using first_reference_mapped_type = typename table_type<first_reference_t>::type;
                     auto refTableName = lookup_table_name<first_reference_mapped_type>(context.impl);
                     ss << streaming_identifier(refTableName);
                 }
@@ -1870,9 +1871,9 @@ namespace sqlite_orm {
                     iterate_ast(sel.conditions, collector);
                     join_iterator<Args...>()([&collector, &context](const auto& c) {
                         using original_join_type = typename std::decay<decltype(c)>::type::join_type::type;
-                        using cross_join_type = typename internal::mapped_type_proxy<original_join_type>::type;
+                        using cross_join_type = mapped_type_proxy_t<original_join_type>;
                         auto crossJoinedTableName = lookup_table_name<cross_join_type>(context.impl);
-                        auto tableAliasString = alias_extractor<original_join_type>::extract();
+                        auto tableAliasString = alias_extractor<original_join_type>::as_alias();
                         std::pair<std::string, std::string> tableNameWithAlias{std::move(crossJoinedTableName),
                                                                                std::move(tableAliasString)};
                         collector.table_names.erase(tableNameWithAlias);
@@ -1973,9 +1974,8 @@ namespace sqlite_orm {
                     if(index > 0) {
                         ss << ", ";
                     }
-                    ss << streaming_identifier(
-                        lookup_table_name<typename mapped_type_proxy<from_type>::type>(context.impl),
-                        alias_extractor<from_type>::extract());
+                    ss << streaming_identifier(lookup_table_name<mapped_type_proxy_t<from_type>>(context.impl),
+                                               alias_extractor<from_type>::as_alias());
                     ++index;
                 });
                 return ss.str();
@@ -2222,8 +2222,8 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& l, const Ctx& context) const {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
-                   << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::extract())
+                   << streaming_identifier(lookup_table_name<mapped_type_proxy_t<T>>(context.impl),
+                                           alias_extractor<T>::as_alias())
                    << serialize(l.constraint, context);
                 return ss.str();
             }
@@ -2251,8 +2251,8 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& l, const Ctx& context) const {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
-                   << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::extract())
+                   << streaming_identifier(lookup_table_name<mapped_type_proxy_t<T>>(context.impl),
+                                           alias_extractor<T>::as_alias())
                    << " " << serialize(l.constraint, context);
                 return ss.str();
             }
@@ -2266,8 +2266,8 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& l, const Ctx& context) const {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
-                   << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::extract())
+                   << streaming_identifier(lookup_table_name<mapped_type_proxy_t<T>>(context.impl),
+                                           alias_extractor<T>::as_alias())
                    << " " << serialize(l.constraint, context);
                 return ss.str();
             }
@@ -2281,8 +2281,8 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& l, const Ctx& context) const {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
-                   << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::extract())
+                   << streaming_identifier(lookup_table_name<mapped_type_proxy_t<T>>(context.impl),
+                                           alias_extractor<T>::as_alias())
                    << " " << serialize(l.constraint, context);
                 return ss.str();
             }
diff --git a/dev/static_magic.h b/dev/static_magic.h
index 02dffd2a4..d14444f17 100644
--- a/dev/static_magic.h
+++ b/dev/static_magic.h
@@ -35,9 +35,6 @@ namespace sqlite_orm {
         decltype(auto) static_if(const T& t) {
             return static_if(std::integral_constant<bool, B>{}, t, empty_callable());
         }
-
-        template<typename T>
-        using static_not = std::integral_constant<bool, !T::value>;
     }
 
 }
diff --git a/dev/storage.h b/dev/storage.h
index e446dafab..c67f3ad84 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -418,7 +418,7 @@ namespace sqlite_orm {
              *  SELECT COUNT(*) https://www.sqlite.org/lang_aggfunc.html#count
              *  @return Number of O object in table.
              */
-            template<class O, class... Args, class R = typename mapped_type_proxy<O>::type>
+            template<class O, class... Args, class R = mapped_type_proxy_t<O>>
             int count(Args&&... args) {
                 this->assert_mapped_type<R>();
                 auto rows = this->select(sqlite_orm::count<R>(), std::forward<Args>(args)...);
diff --git a/dev/table_name_collector.h b/dev/table_name_collector.h
index 97db33e06..2db997a13 100644
--- a/dev/table_name_collector.h
+++ b/dev/table_name_collector.h
@@ -7,6 +7,7 @@
 
 #include "cxx_polyfill.h"
 #include "type_traits.h"
+#include "mapped_type_proxy.h"
 #include "select_constraints.h"
 #include "alias.h"
 #include "core_functions.h"
@@ -38,12 +39,13 @@ namespace sqlite_orm {
 
             template<class T, class F>
             void operator()(const column_pointer<T, F> &) const {
-                table_names.emplace(this->find_table_name(typeid(T)), "");
+                auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<T>));
+                table_names.emplace(move(tableName), alias_extractor<T>::as_alias());
             }
 
             template<class T, class C>
             void operator()(const alias_column_t<T, C> &a) const {
-                (*this)(a.column, alias_extractor<T>::extract());
+                (*this)(a.column, alias_extractor<T>::as_alias());
             }
 
             template<class T>
@@ -54,18 +56,10 @@ namespace sqlite_orm {
                 }
             }
 
-            template<class T, satisfies_not<is_table_alias, T> = true>
-            void operator()(const asterisk_t<T> &) const {
-                table_names.emplace(this->find_table_name(typeid(T)), "");
-            }
-
-            template<class T, satisfies<is_table_alias, T> = true>
+            template<class T>
             void operator()(const asterisk_t<T> &) const {
-                // note: not all alias classes have a nested A::type
-                static_assert(polyfill::is_detected_v<type_t, T>,
-                              "alias<O> must have a nested alias<O>::type typename");
-                auto tableName = this->find_table_name(typeid(type_t<T>));
-                table_names.emplace(move(tableName), alias_extractor<T>::extract());
+                auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<T>));
+                table_names.emplace(move(tableName), alias_extractor<T>::as_alias());
             }
 
             template<class T>
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index f4d953d92..5ffa2aed9 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -62,10 +62,25 @@ __pragma(push_macro("max"))
 namespace sqlite_orm {
     namespace internal {
         namespace polyfill {
-#if __cplusplus < 201703L  // C++14 or earlier
+#if __cpp_lib_void_t >= 201411L
+            using std::void_t;
+#else
+            template<class...>
+            using void_t = void;
+#endif
+
+#if __cpp_lib_bool_constant >= 201505L
+            using std::bool_constant;
+#else
             template<bool v>
             using bool_constant = std::integral_constant<bool, v>;
+#endif
 
+#if __cpp_lib_logical_traits >= 201510L && __cpp_lib_type_trait_variable_templates >= 201510L
+            using std::conjunction, std::conjunction_v;
+            using std::disjunction, std::disjunction_v;
+            using std::negation, std::negation_v;
+#else
             template<typename...>
             struct conjunction : std::true_type {};
             template<typename B1>
@@ -73,7 +88,7 @@ namespace sqlite_orm {
             template<typename B1, typename... Bn>
             struct conjunction<B1, Bn...> : std::conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};
             template<typename... Bs>
-            constexpr bool conjunction_v = conjunction<Bs...>::value;
+            SQLITE_ORM_INLINE_VAR constexpr bool conjunction_v = conjunction<Bs...>::value;
 
             template<typename...>
             struct disjunction : std::false_type {};
@@ -82,30 +97,22 @@ namespace sqlite_orm {
             template<typename B1, typename... Bn>
             struct disjunction<B1, Bn...> : std::conditional_t<bool(B1::value), B1, disjunction<Bn...>> {};
             template<typename... Bs>
-            constexpr bool disjunction_v = disjunction<Bs...>::value;
+            SQLITE_ORM_INLINE_VAR constexpr bool disjunction_v = disjunction<Bs...>::value;
 
-            template<class B>
+            template<typename B>
             struct negation : bool_constant<!bool(B::value)> {};
-
-            template<class...>
-            using void_t = void;
-#else
-            using std::bool_constant;
-            using std::conjunction, std::conjunction_v;
-            using std::disjunction, std::disjunction_v;
-            using std::negation, std::negation_v;
-            using std::void_t;
+            template<typename B>
+            SQLITE_ORM_INLINE_VAR constexpr bool negation_v = negation<B>::value;
 #endif
 
-#if __cplusplus < 202002L  // C++20 or earlier
+#if __cpp_lib_remove_cvref >= 201711L
+            using std::remove_cvref, std::remove_cvref_t;
+#else
             template<class T>
             struct remove_cvref : std::remove_cv<std::remove_reference_t<T>> {};
 
             template<class T>
             using remove_cvref_t = typename remove_cvref<T>::type;
-#else
-            using std::remove_cvref;
-            using std::remove_cvref_t;
 #endif
 
 #if 1  // proposed but not pursued                                                                                     \
@@ -125,7 +132,14 @@ namespace sqlite_orm {
 #else
             using std::is_specialization_of, std::is_specialization_of_t, std::is_specialization_of_v;
 #endif
-#if 1  // library fundamentals TS v2, [meta.detect]
+
+#if 0  // __cpp_lib_detect >= 0L  //  library fundamentals TS v2, [meta.detect]
+            using std::nonesuch;
+            using std::detector;
+            using std::is_detected, std::is_detected_v;
+            using std::detected, std::detected_t;
+            using std::detected_or, std::detected_or_t;
+#else
             struct nonesuch {
                 ~nonesuch() = delete;
                 nonesuch(const nonesuch&) = delete;
@@ -217,7 +231,7 @@ namespace sqlite_orm {
 
         // enable_if for types
         template<template<typename...> class Op, class... Args>
-        using match_if_not = std::enable_if_t<polyfill::negation<Op<Args...>>::value>;
+        using match_if_not = std::enable_if_t<polyfill::negation_v<Op<Args...>>>;
 
         // enable_if for types
         template<class T, template<typename...> class Primary>
@@ -729,9 +743,6 @@ namespace sqlite_orm {
         decltype(auto) static_if(const T& t) {
             return static_if(std::integral_constant<bool, B>{}, t, empty_callable());
         }
-
-        template<typename T>
-        using static_not = std::integral_constant<bool, !T::value>;
     }
 
 }
@@ -4081,8 +4092,6 @@ namespace sqlite_orm {
 
 // #include "cxx_polyfill.h"
 
-// #include "static_magic.h"
-
 namespace sqlite_orm {
 
     /**
@@ -4185,26 +4194,44 @@ namespace sqlite_orm {
             alias_column_t(column_type column_) : column(std::move(column_)) {}
         };
 
+        /*
+         * Encapsulates extracting the alias identifier of a non-alias.
+         */
         template<class T, class SFINAE = void>
         struct alias_extractor {
             static std::string extract() {
                 return {};
             }
+
+            static std::string as_alias() {
+                return {};
+            }
         };
 
+        /*
+         * Encapsulates extracting the alias identifier of an alias.
+         * 
+         * `extract()` always returns the aliase identifier.
+         * `as_alias()` is used in contexts where a table is aliased.
+         *   In case of a CTE the alias is empty since the CTE identifier is already the alias itself.
+         */
         template<class A>
         struct alias_extractor<A, match_if<is_alias, A>> {
-            template<bool yes = !is_cte_alias_v<A>>
-            static std::string extract(polyfill::bool_constant<yes> = {}) {
-                return static_if<yes>(
-                    []() {
-                        std::stringstream ss;
-                        ss << A::get();
-                        return ss.str();
-                    },
-                    []() {
-                        return std::string{};
-                    })();
+            static std::string extract() {
+                std::stringstream ss;
+                ss << A::get();
+                return ss.str();
+            }
+
+            // for column and regular table aliases -> alias identifier
+            template<class T = A, satisfies_not<std::is_same, polyfill::detected_t<type_t, T>, A> = true>
+            static std::string as_alias() {
+                return alias_extractor::extract();
+            }
+            // for cte aliases -> empty
+            template<class T = A, satisfies<std::is_same, polyfill::detected_t<type_t, T>, A> = true>
+            static std::string as_alias() {
+                return {};
             }
         };
 
@@ -9423,6 +9450,9 @@ namespace sqlite_orm {
         struct mapped_type_proxy<T, match_if<is_table_alias, T>> {
             using type = type_t<T>;
         };
+
+        template<class T>
+        using mapped_type_proxy_t = typename mapped_type_proxy<T>::type;
     }
 }
 #pragma once
@@ -15121,6 +15151,8 @@ namespace sqlite_orm {
 
 // #include "member_traits/is_setter.h"
 
+// #include "mapped_type_proxy.h"
+
 // #include "ast/upsert_clause.h"
 
 // #include "ast/excluded.h"
@@ -15164,6 +15196,8 @@ namespace sqlite_orm {
 
 // #include "type_traits.h"
 
+// #include "mapped_type_proxy.h"
+
 // #include "select_constraints.h"
 
 // #include "alias.h"
@@ -15197,12 +15231,13 @@ namespace sqlite_orm {
 
             template<class T, class F>
             void operator()(const column_pointer<T, F>&) const {
-                table_names.emplace(this->find_table_name(typeid(T)), "");
+                auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<T>));
+                table_names.emplace(move(tableName), alias_extractor<T>::as_alias());
             }
 
             template<class T, class C>
             void operator()(const alias_column_t<T, C>& a) const {
-                (*this)(a.column, alias_extractor<T>::extract());
+                (*this)(a.column, alias_extractor<T>::as_alias());
             }
 
             template<class T>
@@ -15213,18 +15248,10 @@ namespace sqlite_orm {
                 }
             }
 
-            template<class T, satisfies_not<is_table_alias, T> = true>
-            void operator()(const asterisk_t<T>&) const {
-                table_names.emplace(this->find_table_name(typeid(T)), "");
-            }
-
-            template<class T, satisfies<is_table_alias, T> = true>
+            template<class T>
             void operator()(const asterisk_t<T>&) const {
-                // note: not all alias classes have a nested A::type
-                static_assert(polyfill::is_detected_v<type_t, T>,
-                              "alias<O> must have a nested alias<O>::type typename");
-                auto tableName = this->find_table_name(typeid(type_t<T>));
-                table_names.emplace(move(tableName), alias_extractor<T>::extract());
+                auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<T>));
+                table_names.emplace(move(tableName), alias_extractor<T>::as_alias());
             }
 
             template<class T>
@@ -15322,7 +15349,7 @@ namespace sqlite_orm {
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type&, const Ctx&) const {
-                return {quote_identifier(alias_extractor<A>::extract(std::true_type{})) + ".*"};
+                return {quote_identifier(alias_extractor<A>::extract()) + ".*"};
             }
         };
 
@@ -16078,7 +16105,7 @@ namespace sqlite_orm {
          *  Serializer for literal values.
          */
         template<class T>
-        struct statement_serializer<T, internal::match_specialization_of<T, literal_holder>> {
+        struct statement_serializer<T, match_specialization_of<T, literal_holder>> {
             using statement_type = T;
 
             template<class Ctx>
@@ -16453,7 +16480,7 @@ namespace sqlite_orm {
                 cteContext.use_parentheses = false;
 
                 std::stringstream ss;
-                ss << streaming_identifier(alias_extractor<cte_label_type_t<CTE>>::extract(std::true_type{}));
+                ss << streaming_identifier(alias_extractor<cte_label_type_t<CTE>>::extract());
                 {
                     std::vector<std::string> columnNames =
                         collect_cte_column_names(get_cte_driving_subselect(cte.subselect),
@@ -16831,7 +16858,7 @@ namespace sqlite_orm {
                 {
                     using references_type_t = typename std::decay<decltype(fk)>::type::references_type;
                     using first_reference_t = std::tuple_element_t<0, references_type_t>;
-                    using first_reference_mapped_type = typename internal::table_type<first_reference_t>::type;
+                    using first_reference_mapped_type = typename table_type<first_reference_t>::type;
                     auto refTableName = lookup_table_name<first_reference_mapped_type>(context.impl);
                     ss << streaming_identifier(refTableName);
                 }
@@ -17494,9 +17521,9 @@ namespace sqlite_orm {
                     iterate_ast(sel.conditions, collector);
                     join_iterator<Args...>()([&collector, &context](const auto& c) {
                         using original_join_type = typename std::decay<decltype(c)>::type::join_type::type;
-                        using cross_join_type = typename internal::mapped_type_proxy<original_join_type>::type;
+                        using cross_join_type = mapped_type_proxy_t<original_join_type>;
                         auto crossJoinedTableName = lookup_table_name<cross_join_type>(context.impl);
-                        auto tableAliasString = alias_extractor<original_join_type>::extract();
+                        auto tableAliasString = alias_extractor<original_join_type>::as_alias();
                         std::pair<std::string, std::string> tableNameWithAlias{std::move(crossJoinedTableName),
                                                                                std::move(tableAliasString)};
                         collector.table_names.erase(tableNameWithAlias);
@@ -17597,9 +17624,8 @@ namespace sqlite_orm {
                     if(index > 0) {
                         ss << ", ";
                     }
-                    ss << streaming_identifier(
-                        lookup_table_name<typename mapped_type_proxy<from_type>::type>(context.impl),
-                        alias_extractor<from_type>::extract());
+                    ss << streaming_identifier(lookup_table_name<mapped_type_proxy_t<from_type>>(context.impl),
+                                               alias_extractor<from_type>::as_alias());
                     ++index;
                 });
                 return ss.str();
@@ -17846,8 +17872,8 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& l, const Ctx& context) const {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
-                   << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::extract())
+                   << streaming_identifier(lookup_table_name<mapped_type_proxy_t<T>>(context.impl),
+                                           alias_extractor<T>::as_alias())
                    << serialize(l.constraint, context);
                 return ss.str();
             }
@@ -17875,8 +17901,8 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& l, const Ctx& context) const {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
-                   << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::extract())
+                   << streaming_identifier(lookup_table_name<mapped_type_proxy_t<T>>(context.impl),
+                                           alias_extractor<T>::as_alias())
                    << " " << serialize(l.constraint, context);
                 return ss.str();
             }
@@ -17890,8 +17916,8 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& l, const Ctx& context) const {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
-                   << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::extract())
+                   << streaming_identifier(lookup_table_name<mapped_type_proxy_t<T>>(context.impl),
+                                           alias_extractor<T>::as_alias())
                    << " " << serialize(l.constraint, context);
                 return ss.str();
             }
@@ -17905,8 +17931,8 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& l, const Ctx& context) const {
                 std::stringstream ss;
                 ss << static_cast<std::string>(l) << " "
-                   << streaming_identifier(lookup_table_name<typename mapped_type_proxy<T>::type>(context.impl),
-                                           alias_extractor<T>::extract())
+                   << streaming_identifier(lookup_table_name<mapped_type_proxy_t<T>>(context.impl),
+                                           alias_extractor<T>::as_alias())
                    << " " << serialize(l.constraint, context);
                 return ss.str();
             }
@@ -18466,7 +18492,7 @@ namespace sqlite_orm {
 
             using context_type = serializer_context<S>;
 
-            std::string tableName = alias_extractor<cte_label_type_t<cte_type>>::extract(std::true_type{});
+            std::string tableName = alias_extractor<cte_label_type_t<cte_type>>::extract();
             auto subselectColRefs = extract_colref_expressions(impl, subSelect.col);
             const auto& finalColRefs =
                 determine_cte_colrefs(impl, subselectColRefs, cte.explicitColumns, index_sequence{});
@@ -18893,7 +18919,7 @@ namespace sqlite_orm {
              *  SELECT COUNT(*) https://www.sqlite.org/lang_aggfunc.html#count
              *  @return Number of O object in table.
              */
-            template<class O, class... Args, class R = typename mapped_type_proxy<O>::type>
+            template<class O, class... Args, class R = mapped_type_proxy_t<O>>
             int count(Args&&... args) {
                 this->assert_mapped_type<R>();
                 auto rows = this->select(sqlite_orm::count<R>(), std::forward<Args>(args)...);
diff --git a/tests/static_if_tests.cpp b/tests/static_if_tests.cpp
index 164d6c0ec..9a6cc8d41 100644
--- a/tests/static_if_tests.cpp
+++ b/tests/static_if_tests.cpp
@@ -39,7 +39,7 @@ TEST_CASE("static_if") {
     }
     {  //  tuple is not empty
         auto value = 0;
-        internal::static_if<internal::static_not<std::is_empty<std::tuple<>>>{}>(
+        internal::static_if<polyfill::negation_v<std::is_empty<std::tuple<>>>>(
             [&value] {
                 value = 1;
             },

From ca18031b24387288cb8ef1384872ceaad15449c0 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 25 Apr 2022 13:41:40 +0300
Subject: [PATCH 068/161] Added unit tests for alias extraction

---
 tests/CMakeLists.txt                          |  1 +
 .../alias_extractor.cpp                       | 26 +++++++++++++++++++
 2 files changed, 27 insertions(+)
 create mode 100644 tests/statement_serializer_tests/alias_extractor.cpp

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 14ae40bc3..966f45bb3 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -106,6 +106,7 @@ add_executable(unit_tests
     statement_serializer_tests/statements/remove.cpp
     statement_serializer_tests/statements/update_all.cpp
     statement_serializer_tests/aggregate_functions.cpp
+    statement_serializer_tests/alias_extractor.cpp
     storage_tests.cpp
     storage_non_crud_tests.cpp
 	unique_cases/get_all_with_two_tables.cpp
diff --git a/tests/statement_serializer_tests/alias_extractor.cpp b/tests/statement_serializer_tests/alias_extractor.cpp
new file mode 100644
index 000000000..3c742997c
--- /dev/null
+++ b/tests/statement_serializer_tests/alias_extractor.cpp
@@ -0,0 +1,26 @@
+#include <sqlite_orm/sqlite_orm.h>
+#include <catch2/catch.hpp>
+
+using namespace sqlite_orm;
+using internal::alias_extractor;
+
+TEST_CASE("alias extractor") {
+    struct User {};
+
+    SECTION("column alias") {
+        REQUIRE(alias_extractor<colalias_a>::extract() == "a");
+        REQUIRE(alias_extractor<colalias_a>::as_alias() == "a");
+    }
+    SECTION("table") {
+        REQUIRE(alias_extractor<User>::extract() == "");
+        REQUIRE(alias_extractor<User>::as_alias() == "");
+    }
+    SECTION("table alias") {
+        REQUIRE(alias_extractor<alias_a<User>>::extract() == "a");
+        REQUIRE(alias_extractor<alias_a<User>>::as_alias() == "a");
+    }
+    SECTION("cte table") {
+        REQUIRE(alias_extractor<cte_1>::extract() == "1");
+        REQUIRE(alias_extractor<cte_1>::as_alias() == "");
+    }
+}

From fa15bae067d15836caf3b08187a5aee42649be49 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Wed, 4 Jan 2023 21:16:04 +0200
Subject: [PATCH 069/161] Corrected CTE column referencing backend code

---
 dev/cte_storage.h               | 13 +++++++------
 include/sqlite_orm/sqlite_orm.h | 13 +++++++------
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index eba2798d1..e5b5c0691 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -125,7 +125,7 @@ namespace sqlite_orm {
         template<class DBOs, class E, size_t Idx = 0>
         auto extract_colref_expressions(const DBOs& /*dbObjects*/, const E& /*col*/, std::index_sequence<Idx> = {})
             -> std::tuple<alias_holder<decltype(n_to_colalias<Idx>())>> {
-            return;
+            return {};
         }
 
         // expression_t<>
@@ -221,19 +221,20 @@ namespace sqlite_orm {
         }
 
         template<typename DBOs, typename SubselectColRefs, typename ExplicitColRefs, size_t... Idx>
-        auto determine_cte_colrefs(const DBOs& dbObjects,
+        auto determine_cte_colrefs([[maybe_unused]] const DBOs& dbObjects,
                                    const SubselectColRefs& subselectColRefs,
-                                   const ExplicitColRefs& explicitColRefs,
+                                   [[maybe_unused]] const ExplicitColRefs& explicitColRefs,
                                    std::index_sequence<Idx...>) {
             if constexpr(std::tuple_size_v < ExplicitColRefs >> 0) {
-                return std::tuple{
-                    determine_cte_colref(dbObjects, get<Idx>(subselectColRefs), get<Idx>(explicitColRefs))...};
-            } else {
                 static_assert(
                     (!internal::is_builtin_numeric_column_alias_v<
                          alias_holder_type_or_none_t<std::tuple_element_t<Idx, ExplicitColRefs>>> &&
                      ...),
                     "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
+
+                return std::tuple{
+                    determine_cte_colref(dbObjects, get<Idx>(subselectColRefs), get<Idx>(explicitColRefs))...};
+            } else {
                 return subselectColRefs;
             }
         }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index bb37f2f35..1d4afd578 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -18442,7 +18442,7 @@ namespace sqlite_orm {
         template<class DBOs, class E, size_t Idx = 0>
         auto extract_colref_expressions(const DBOs& /*dbObjects*/, const E& /*col*/, std::index_sequence<Idx> = {})
             -> std::tuple<alias_holder<decltype(n_to_colalias<Idx>())>> {
-            return;
+            return {};
         }
 
         // expression_t<>
@@ -18538,19 +18538,20 @@ namespace sqlite_orm {
         }
 
         template<typename DBOs, typename SubselectColRefs, typename ExplicitColRefs, size_t... Idx>
-        auto determine_cte_colrefs(const DBOs& dbObjects,
+        auto determine_cte_colrefs([[maybe_unused]] const DBOs& dbObjects,
                                    const SubselectColRefs& subselectColRefs,
-                                   const ExplicitColRefs& explicitColRefs,
+                                   [[maybe_unused]] const ExplicitColRefs& explicitColRefs,
                                    std::index_sequence<Idx...>) {
             if constexpr(std::tuple_size_v < ExplicitColRefs >> 0) {
-                return std::tuple{
-                    determine_cte_colref(dbObjects, get<Idx>(subselectColRefs), get<Idx>(explicitColRefs))...};
-            } else {
                 static_assert(
                     (!internal::is_builtin_numeric_column_alias_v<
                          alias_holder_type_or_none_t<std::tuple_element_t<Idx, ExplicitColRefs>>> &&
                      ...),
                     "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
+
+                return std::tuple{
+                    determine_cte_colref(dbObjects, get<Idx>(subselectColRefs), get<Idx>(explicitColRefs))...};
+            } else {
                 return subselectColRefs;
             }
         }

From 0291bbf5ee6e93801253dea40b84dede8c320688 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Wed, 4 Jan 2023 23:25:42 +0200
Subject: [PATCH 070/161] Removed ability to reference columns by index

---
 dev/cte.h                                     | 22 --------
 dev/select_constraints.h                      |  8 ---
 dev/storage_impl.h                            | 18 -------
 dev/type_traits.h                             |  5 --
 include/sqlite_orm/sqlite_orm.h               | 53 -------------------
 tests/static_tests/column_expression_type.cpp |  1 -
 6 files changed, 107 deletions(-)

diff --git a/dev/cte.h b/dev/cte.h
index 5c62ccd62..b57fd7588 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -35,28 +35,6 @@ namespace sqlite_orm {
         }
     }
 
-    /**
-     *  index_constant<> from numeric literal.
-     *  E.g. 0_colidx, 1_colidx
-     */
-    template<char... Chars>
-    [[nodiscard]] SQLITE_ORM_CONSTEVAL decltype(auto) operator"" _colidx() {
-        return polyfill::index_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{},
-                                                                 Chars...)>{};
-    }
-
-    /**
-     *  integral_constant<unsigned int> from numeric literal.
-     *  E.g. 1_nth_col, 2_nth_col
-     */
-    template<char... Chars>
-    [[nodiscard]] SQLITE_ORM_CONSTEVAL decltype(auto) operator"" _nth_col() {
-        constexpr auto n =
-            internal::nth_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{}, Chars...)>{};
-        static_assert(n > 0);
-        return n;
-    }
-
     /**
      *  cte_alias<'n'> from a numeric literal.
      *  E.g. 1_ctealias, 2_ctealias
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 0e49f2cef..518cf950e 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -188,14 +188,6 @@ namespace sqlite_orm {
             constexpr column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
                 return {{}};
             }
-
-            /**
-             *  Turn 1_nth_col -> 0_col
-             */
-            template<unsigned int I>
-            auto operator()(internal::nth_constant<I>) const {
-                return (*this)(polyfill::index_constant<I - 1>{});
-            }
         };
 
         /**
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 8febde19a..d45d8ef96 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -137,23 +137,5 @@ namespace sqlite_orm {
             auto& table = pick_table<Label>(dboObjects);
             return &std::get<ColIdx>(table.elements).name;
         }
-
-        /**
-         *  Find column name by:
-         *  4. by label type and index constant.
-         */
-        template<class Label, size_t I, class DBOs, satisfies<is_db_objects, DBOs> = true>
-        constexpr decltype(auto) find_column_name(const DBOs& dboObjects,
-                                                  const column_pointer<Label, polyfill::index_constant<I>>&) {
-            using table_type = storage_pick_table_t<Label, DBOs>;
-            using column_idxs = filter_tuple_sequence_t<typename table_type::elements_type, is_column>;
-
-            // lookup column in table_t<>'s elements
-            constexpr size_t ColIdx = index_sequence_value(I, column_idxs{});
-            static_assert(ColIdx < column_idxs{}.size(), "No such column mapped into the CTE.");
-
-            auto& table = pick_table<Label>(dboObjects);
-            return &std::get<ColIdx>(table.elements).name;
-        }
     }
 }
diff --git a/dev/type_traits.h b/dev/type_traits.h
index 0d4b3a1cc..b105b75e3 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -83,9 +83,4 @@ namespace sqlite_orm {
         template<class T>
         using alias_holder_type_or_none_t = typename alias_holder_type_or_none<T>::type;
     }
-
-    namespace internal {
-        template<unsigned int N>
-        using nth_constant = std::integral_constant<unsigned int, N>;
-    }
 }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 1d4afd578..d641eb7ca 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -366,11 +366,6 @@ namespace sqlite_orm {
         template<class T>
         using alias_holder_type_or_none_t = typename alias_holder_type_or_none<T>::type;
     }
-
-    namespace internal {
-        template<unsigned int N>
-        using nth_constant = std::integral_constant<unsigned int, N>;
-    }
 }
 #pragma once
 
@@ -7078,14 +7073,6 @@ namespace sqlite_orm {
             constexpr column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
                 return {{}};
             }
-
-            /**
-             *  Turn 1_nth_col -> 0_col
-             */
-            template<unsigned int I>
-            auto operator()(internal::nth_constant<I>) const {
-                return (*this)(polyfill::index_constant<I - 1>{});
-            }
         };
 
         /**
@@ -11333,24 +11320,6 @@ namespace sqlite_orm {
             auto& table = pick_table<Label>(dboObjects);
             return &std::get<ColIdx>(table.elements).name;
         }
-
-        /**
-         *  Find column name by:
-         *  4. by label type and index constant.
-         */
-        template<class Label, size_t I, class DBOs, satisfies<is_db_objects, DBOs> = true>
-        constexpr decltype(auto) find_column_name(const DBOs& dboObjects,
-                                                  const column_pointer<Label, polyfill::index_constant<I>>&) {
-            using table_type = storage_pick_table_t<Label, DBOs>;
-            using column_idxs = filter_tuple_sequence_t<typename table_type::elements_type, is_column>;
-
-            // lookup column in table_t<>'s elements
-            constexpr size_t ColIdx = index_sequence_value(I, column_idxs{});
-            static_assert(ColIdx < column_idxs{}.size(), "No such column mapped into the CTE.");
-
-            auto& table = pick_table<Label>(dboObjects);
-            return &std::get<ColIdx>(table.elements).name;
-        }
     }
 }
 #pragma once
@@ -20181,28 +20150,6 @@ namespace sqlite_orm {
         }
     }
 
-    /**
-     *  index_constant<> from numeric literal.
-     *  E.g. 0_colidx, 1_colidx
-     */
-    template<char... Chars>
-    [[nodiscard]] SQLITE_ORM_CONSTEVAL decltype(auto) operator"" _colidx() {
-        return polyfill::index_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{},
-                                                                 Chars...)>{};
-    }
-
-    /**
-     *  integral_constant<unsigned int> from numeric literal.
-     *  E.g. 1_nth_col, 2_nth_col
-     */
-    template<char... Chars>
-    [[nodiscard]] SQLITE_ORM_CONSTEVAL decltype(auto) operator"" _nth_col() {
-        constexpr auto n =
-            internal::nth_constant<internal::n_from_literal(std::make_index_sequence<sizeof...(Chars)>{}, Chars...)>{};
-        static_assert(n > 0);
-        return n;
-    }
-
     /**
      *  cte_alias<'n'> from a numeric literal.
      *  E.g. 1_ctealias, 2_ctealias
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index b2c7aa494..c5e7cedc5 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -44,7 +44,6 @@ TEST_CASE("column_expression_of_t") {
 
     runTest<storage_type, column_pointer<Derived, int64 Org::*>>(column<Derived>(&Org::id));
     runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>(&Org::id));
-    runTest<storage_type, column_pointer<cte_1, polyfill::index_constant<0u>>>(column<cte_1>(0_colidx));
     runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>()->*&Org::id);
     runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>->*&Org::id);
     runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(cte_1{}->*&Org::id);

From 4449515aae7b957842afaab03b7d021829a1b134 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Wed, 4 Jan 2023 23:26:14 +0200
Subject: [PATCH 071/161] Simplified string identifier template

---
 dev/alias.h                     | 6 ------
 include/sqlite_orm/sqlite_orm.h | 6 ------
 2 files changed, 12 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 901d478b4..31418a71b 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -58,17 +58,11 @@ namespace sqlite_orm {
                 return N - 1;
             }
 
-#ifdef _MSC_VER
-            constexpr string_identifier_template(const char (&id)[N]) : id{id} {}
-
-            const char (&id)[N];
-#else
             constexpr string_identifier_template(const char (&id)[N]) {
                 std::copy_n(id, N, this->id);
             }
 
             char id[N];
-#endif
         };
 
         template<template<char...> class Alias, string_identifier_template t, size_t... Idx>
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index d641eb7ca..0b4ff2814 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4156,17 +4156,11 @@ namespace sqlite_orm {
                 return N - 1;
             }
 
-#ifdef _MSC_VER
-            constexpr string_identifier_template(const char (&id)[N]) : id{id} {}
-
-            const char (&id)[N];
-#else
             constexpr string_identifier_template(const char (&id)[N]) {
                 std::copy_n(id, N, this->id);
             }
 
             char id[N];
-#endif
         };
 
         template<template<char...> class Alias, string_identifier_template t, size_t... Idx>

From ac94ea4b66a63f7265fa1a9a624af475aad19bc2 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 5 Jan 2023 16:12:34 +0200
Subject: [PATCH 072/161] Cleanup CTE code

---
 dev/alias.h                                   |  4 +-
 dev/column_expression.h                       |  2 +-
 dev/cte.h                                     | 21 +----
 dev/cte_storage.h                             |  1 -
 dev/select_constraints.h                      | 35 +++++----
 dev/storage_lookup.h                          |  6 +-
 dev/tuple_helper/tuple_traits.h               |  2 +-
 examples/common_table_expressions.cpp         | 30 +++++---
 include/sqlite_orm/sqlite_orm.h               | 77 ++++++++-----------
 tests/static_tests/column_expression_type.cpp |  1 -
 tests/static_tests/column_result_t.cpp        |  1 -
 11 files changed, 78 insertions(+), 102 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 31418a71b..ef2ac991a 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -115,7 +115,7 @@ namespace sqlite_orm {
         /*
          * Encapsulates extracting the alias identifier of an alias.
          * 
-         * `extract()` always returns the aliase identifier.
+         * `extract()` always returns the alias identifier.
          * `as_alias()` is used in contexts where a table is aliased.
          *   In case of a CTE the alias is empty since the CTE identifier is already the alias itself.
          */
@@ -291,7 +291,7 @@ namespace sqlite_orm {
     using colalias_h = internal::column_alias<'h'>;
     using colalias_i = internal::column_alias<'i'>;
 
-#if __cplusplus >= 201703L  // C++17 or later
+#ifdef SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
     namespace internal {
         template<class T>
         inline constexpr bool is_builtin_numeric_column_alias_v = false;
diff --git a/dev/column_expression.h b/dev/column_expression.h
index c3a029985..df9cb9d9f 100644
--- a/dev/column_expression.h
+++ b/dev/column_expression.h
@@ -5,11 +5,11 @@
 #include <functional>  //  std::reference_wrapper
 
 #include "functional/cxx_type_traits_polyfill.h"
+#include "tuple_helper/tuple_transformer.h"
 #include "type_traits.h"
 #include "select_constraints.h"
 #include "alias.h"
 #include "storage_traits.h"
-#include "tuple_helper/tuple_transformer.h"
 
 namespace sqlite_orm {
 
diff --git a/dev/cte.h b/dev/cte.h
index b57fd7588..bf8613b0b 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -1,9 +1,7 @@
 #pragma once
 
-#include <type_traits>
-#include <string>
+#include <utility>  //  std::make_index_sequence
 
-#include "functional/cxx_type_traits_polyfill.h"
 #include "alias.h"
 
 namespace sqlite_orm {
@@ -19,22 +17,6 @@ namespace sqlite_orm {
                           X...> {};
     }
 
-#if __cplusplus >= 201703L  // C++17 or later
-    namespace internal {
-        constexpr size_t _10_pow(size_t n) {
-            if(n == 0) {
-                return 1;
-            } else {
-                return 10 * _10_pow(n - 1);
-            }
-        }
-
-        template<class... Chars, size_t... Is>
-        constexpr size_t n_from_literal(std::index_sequence<Is...>, Chars... chars) {
-            return (((chars - '0') * _10_pow(sizeof...(Is) - 1u - Is /*reversed index sequence*/)) + ...);
-        }
-    }
-
     /**
      *  cte_alias<'n'> from a numeric literal.
      *  E.g. 1_ctealias, 2_ctealias
@@ -78,5 +60,4 @@ namespace sqlite_orm {
     using cte_8 = decltype(8_ctealias);
     using cte_9 = decltype(9_ctealias);
 #endif
-#endif
 }
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index e5b5c0691..756fa0407 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -5,7 +5,6 @@
 #include <string>
 #include <vector>
 
-#include "tuple_helper/tuple_fy.h"
 #include "is_base_of_template.h"
 #include "table_type_of.h"
 #include "column_result.h"
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 518cf950e..94cae7ba9 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -156,21 +156,12 @@ namespace sqlite_orm {
 
             using mapped_type = A;
 
-            /** 
-             *  Instantiate table alias object A in order to use it with the overloaded pointer-to-member operator.
-             */
-            constexpr mapped_type operator()() const {
-                return mapped_type{};
-            }
-
             /**
              *  Explicitly refer to a column alias mapped into a CTE or subquery.
              *  
              *  Example:
              *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
-             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
-             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
+             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
              */
             template<class F, satisfies_not<is_column_alias, F> = true>
             constexpr column_pointer<mapped_type, F> operator()(F field) const {
@@ -182,12 +173,27 @@ namespace sqlite_orm {
              *  
              *  Example:
              *  struct Object { ... };
+             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
              *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
+             *  storage.with(cte<cte_1>(colalias_a{})(select(&Object::id)), select(column<cte_1>(colalias_a{})));
              */
             template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
             constexpr column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
                 return {{}};
             }
+
+            /**
+             *  Explicitly refer to a column alias mapped into a CTE or subquery.
+             *
+             *  Example:
+             *  struct Object { ... };
+             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
+             */
+            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
+            constexpr column_pointer<mapped_type, alias_holder<ColAlias>>
+            operator()(const alias_holder<ColAlias>&) const {
+                return {{}};
+            }
         };
 
         /**
@@ -576,8 +582,8 @@ namespace sqlite_orm {
      *  
      *  Example:
      *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>()->*&Object::id));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(cte_1{}->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*1_colalias));
      */
     template<class A, class F, internal::satisfies<internal::is_table_alias, A> = true>
     constexpr auto operator->*(const A& /*tableAlias*/, F field) {
@@ -589,7 +595,8 @@ namespace sqlite_orm {
      *  
      *  Use it like this:
      *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*0_col));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
      */
     template<class A, class F, internal::satisfies<internal::is_table_alias, A> = true>
     constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
@@ -651,7 +658,7 @@ namespace sqlite_orm {
                               bool> = true>
     auto cte(ExplicitCols... explicitColumns) {
         static_assert(internal::is_cte_alias_v<Label>, "Label must be a CTE alias");
-#if __cplusplus >= 201703L  // C++17 or later
+#ifdef SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
         static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
                       "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
 #endif
diff --git a/dev/storage_lookup.h b/dev/storage_lookup.h
index 764d17da5..d421e779a 100644
--- a/dev/storage_lookup.h
+++ b/dev/storage_lookup.h
@@ -1,8 +1,8 @@
 #pragma once
 
-#include <type_traits>  //  std::true_type, std::false_type, std::remove_const, std::enable_if, std::is_base_of
+#include <type_traits>  //  std::true_type, std::false_type, std::remove_const, std::enable_if, std::is_base_of, std::is_void
 #include <tuple>
-#include <utility>  //  std::index_sequence
+#include <utility>  //  std::index_sequence, std::make_index_sequence
 
 #include "functional/cxx_universal.h"
 #include "functional/cxx_type_traits_polyfill.h"
@@ -171,7 +171,7 @@ namespace sqlite_orm {
          * 
          *  Note: This function requires Lookup to be mapped, otherwise it is removed from the overload resolution set.
          */
-        template<class Lookup, class DBOs, satisfies<is_db_objects, DBOs> = true>
+        template<class Lookup, class DBOs, satisfies<is_mapped, DBOs, Lookup> = true>
         auto& pick_table(DBOs& dbObjects) {
             using table_type = storage_pick_table_t<Lookup, DBOs>;
             return std::get<table_type>(dbObjects);
diff --git a/dev/tuple_helper/tuple_traits.h b/dev/tuple_helper/tuple_traits.h
index 85d604e96..67e827373 100644
--- a/dev/tuple_helper/tuple_traits.h
+++ b/dev/tuple_helper/tuple_traits.h
@@ -11,7 +11,7 @@
 namespace sqlite_orm {
     namespace internal {
 
-#if __cplusplus >= 201703L  // C++17 or later
+#ifdef SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
         // cudos to OznOg https://stackoverflow.com/a/64606884/279251
         template<class X, class Tuple>
         struct tuple_index_of;
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index bde232d82..62659ef06 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -535,7 +535,6 @@ void select_from_subselect() {
 }
 
 void apfelmaennchen() {
-#if __cplusplus >= 201703L  // use of C++17 or higher
     auto storage = make_storage("");
 
     //WITH RECURSIVE
@@ -584,7 +583,7 @@ void apfelmaennchen() {
             cte<a>(t_col)(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter_col / c(7.0), 4.0), 1), ""),
                                  group_by(m2->*cy_col)))),
         select(group_concat(rtrim(a->*t_col), "\n")));
-#elif __cplusplus >= 201703L  // C++17 or later
+#else
     using cte_xaxis = decltype(1_ctealias);
     using cte_yaxis = decltype(2_ctealias);
     using cte_m = decltype(3_ctealias);
@@ -637,7 +636,6 @@ void apfelmaennchen() {
         cout << rowString << '\n';
     }
     cout << endl;
-#endif
 }
 
 void show_mapping_and_backreferencing() {
@@ -685,26 +683,32 @@ void show_mapping_and_backreferencing() {
     // map column via alias_holder into cte,
     // back-reference via `column_pointer<cte_1, alias_holder>`
     {
-        auto ast =
-            with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(column<cte_1>()->*cnt{} + c(1), limit(10)))),
-                 select(column<cte_1>()->*cnt{}));
+        auto ast = with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(cte_1{}->*cnt{} + c(1), limit(10)))),
+                        select(cte_1{}->*cnt{}));
 
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);
     }
-    // map column via alias_holder into cte,
-    // back-reference via `column_pointer<cte_1, alias_holder>`
+
+    // implicitly remap column into cte
     {
-        auto ast = with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(cte_1{}->*cnt{} + c(1), limit(10)))),
-                        select(cte_1{}->*cnt{}));
+        auto ast = with(cte<cte_1>(std::ignore)(select(&Object::id)), select(column<cte_1>(&Object::id)));
 
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);
     }
 
-    // explicitly state that column name should be taken from subselect
+    // explicitly remap column into cte (independent of subselect)
     {
-        auto ast = with(cte<cte_1>(std::ignore)(select(&Object::id)), select(column<cte_1>(&Object::id)));
+        auto ast = with(cte<cte_1>(&Object::id)(select(&Object::id)), select(column<cte_1>(&Object::id)));
+
+        string sql = storage.dump(ast);
+        auto stmt = storage.prepare(ast);
+    }
+
+    // explicitly remap column as an alias into cte (independent of subselect)
+    {
+        auto ast = with(cte<cte_1>(cnt{})(select(&Object::id)), select(column<cte_1>(get<cnt>())));
 
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);
@@ -713,7 +717,9 @@ void show_mapping_and_backreferencing() {
     // explicitly state that column name should be taken from subselect
     {
         struct CTEObject : alias_tag {
+            // a CTE object is its own table alias
             using type = CTEObject;
+
             static std::string get() {
                 return "CTEObj";
             }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index bc8f2bba6..2f4ffb97d 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -1046,7 +1046,7 @@ namespace sqlite_orm {
 namespace sqlite_orm {
     namespace internal {
 
-#if __cplusplus >= 201703L  // C++17 or later
+#ifdef SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
         // cudos to OznOg https://stackoverflow.com/a/64606884/279251
         template<class X, class Tuple>
         struct tuple_index_of;
@@ -4271,7 +4271,7 @@ namespace sqlite_orm {
         /*
          * Encapsulates extracting the alias identifier of an alias.
          * 
-         * `extract()` always returns the aliase identifier.
+         * `extract()` always returns the alias identifier.
          * `as_alias()` is used in contexts where a table is aliased.
          *   In case of a CTE the alias is empty since the CTE identifier is already the alias itself.
          */
@@ -4447,7 +4447,7 @@ namespace sqlite_orm {
     using colalias_h = internal::column_alias<'h'>;
     using colalias_i = internal::column_alias<'i'>;
 
-#if __cplusplus >= 201703L  // C++17 or later
+#ifdef SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
     namespace internal {
         template<class T>
         inline constexpr bool is_builtin_numeric_column_alias_v = false;
@@ -7093,21 +7093,12 @@ namespace sqlite_orm {
 
             using mapped_type = A;
 
-            /** 
-             *  Instantiate table alias object A in order to use it with the overloaded pointer-to-member operator.
-             */
-            constexpr mapped_type operator()() const {
-                return mapped_type{};
-            }
-
             /**
              *  Explicitly refer to a column alias mapped into a CTE or subquery.
              *  
              *  Example:
              *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
-             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
-             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
+             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
              */
             template<class F, satisfies_not<is_column_alias, F> = true>
             constexpr column_pointer<mapped_type, F> operator()(F field) const {
@@ -7119,12 +7110,27 @@ namespace sqlite_orm {
              *  
              *  Example:
              *  struct Object { ... };
+             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
              *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
+             *  storage.with(cte<cte_1>(colalias_a{})(select(&Object::id)), select(column<cte_1>(colalias_a{})));
              */
             template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
             constexpr column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
                 return {{}};
             }
+
+            /**
+             *  Explicitly refer to a column alias mapped into a CTE or subquery.
+             *
+             *  Example:
+             *  struct Object { ... };
+             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
+             */
+            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
+            constexpr column_pointer<mapped_type, alias_holder<ColAlias>>
+            operator()(const alias_holder<ColAlias>&) const {
+                return {{}};
+            }
         };
 
         /**
@@ -7513,8 +7519,8 @@ namespace sqlite_orm {
      *  
      *  Example:
      *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>()->*&Object::id));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(cte_1{}->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*1_colalias));
      */
     template<class A, class F, internal::satisfies<internal::is_table_alias, A> = true>
     constexpr auto operator->*(const A& /*tableAlias*/, F field) {
@@ -7526,7 +7532,8 @@ namespace sqlite_orm {
      *  
      *  Use it like this:
      *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*0_col));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
      */
     template<class A, class F, internal::satisfies<internal::is_table_alias, A> = true>
     constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
@@ -7588,7 +7595,7 @@ namespace sqlite_orm {
                               bool> = true>
     auto cte(ExplicitCols... explicitColumns) {
         static_assert(internal::is_cte_alias_v<Label>, "Label must be a CTE alias");
-#if __cplusplus >= 201703L  // C++17 or later
+#ifdef SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
         static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
                       "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
 #endif
@@ -9909,9 +9916,9 @@ namespace sqlite_orm {
 // #include "storage_lookup.h"
 
 
-#include <type_traits>  //  std::true_type, std::false_type, std::remove_const, std::enable_if, std::is_base_of
+#include <type_traits>  //  std::true_type, std::false_type, std::remove_const, std::enable_if, std::is_base_of, std::is_void
 #include <tuple>
-#include <utility>  //  std::index_sequence
+#include <utility>  //  std::index_sequence, std::make_index_sequence
 
 // #include "functional/cxx_universal.h"
 
@@ -10083,7 +10090,7 @@ namespace sqlite_orm {
          * 
          *  Note: This function requires Lookup to be mapped, otherwise it is removed from the overload resolution set.
          */
-        template<class Lookup, class DBOs, satisfies<is_db_objects, DBOs> = true>
+        template<class Lookup, class DBOs, satisfies<is_mapped, DBOs, Lookup> = true>
         auto& pick_table(DBOs& dbObjects) {
             using table_type = storage_pick_table_t<Lookup, DBOs>;
             return std::get<table_type>(dbObjects);
@@ -16969,7 +16976,7 @@ namespace sqlite_orm {
             using statement_type = conflict_clause_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx& context) const {
+            std::string operator()(const statement_type& statement, const Ctx& /*context*/) const {
                 switch(statement) {
                     case conflict_clause_t::rollback:
                         return "ROLLBACK";
@@ -18273,8 +18280,6 @@ namespace sqlite_orm {
 #include <string>
 #include <vector>
 
-// #include "tuple_helper/tuple_fy.h"
-
 // #include "is_base_of_template.h"
 
 // #include "table_type_of.h"
@@ -18290,6 +18295,8 @@ namespace sqlite_orm {
 
 // #include "functional/cxx_type_traits_polyfill.h"
 
+// #include "tuple_helper/tuple_transformer.h"
+
 // #include "type_traits.h"
 
 // #include "select_constraints.h"
@@ -18298,8 +18305,6 @@ namespace sqlite_orm {
 
 // #include "storage_traits.h"
 
-// #include "tuple_helper/tuple_transformer.h"
-
 
 namespace sqlite_orm {
 
@@ -20165,10 +20170,7 @@ namespace sqlite_orm {
 }
 #pragma once
 
-#include <type_traits>
-#include <string>
-
-// #include "functional/cxx_type_traits_polyfill.h"
+#include <utility>  //  std::make_index_sequence
 
 // #include "alias.h"
 
@@ -20186,22 +20188,6 @@ namespace sqlite_orm {
                           X...> {};
     }
 
-#if __cplusplus >= 201703L  // C++17 or later
-    namespace internal {
-        constexpr size_t _10_pow(size_t n) {
-            if(n == 0) {
-                return 1;
-            } else {
-                return 10 * _10_pow(n - 1);
-            }
-        }
-
-        template<class... Chars, size_t... Is>
-        constexpr size_t n_from_literal(std::index_sequence<Is...>, Chars... chars) {
-            return (((chars - '0') * _10_pow(sizeof...(Is) - 1u - Is /*reversed index sequence*/)) + ...);
-        }
-    }
-
     /**
      *  cte_alias<'n'> from a numeric literal.
      *  E.g. 1_ctealias, 2_ctealias
@@ -20245,7 +20231,6 @@ namespace sqlite_orm {
     using cte_8 = decltype(8_ctealias);
     using cte_9 = decltype(9_ctealias);
 #endif
-#endif
 }
 #pragma once
 
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index c5e7cedc5..29a186094 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -44,7 +44,6 @@ TEST_CASE("column_expression_of_t") {
 
     runTest<storage_type, column_pointer<Derived, int64 Org::*>>(column<Derived>(&Org::id));
     runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>(&Org::id));
-    runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>()->*&Org::id);
     runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>->*&Org::id);
     runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(cte_1{}->*&Org::id);
     runTest<storage_type, column_pointer<cte_1, alias_holder<internal::column_alias<'1'>>>>(column<cte_1>(1_colalias));
diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
index 38482b316..ccdf22d3a 100644
--- a/tests/static_tests/column_result_t.cpp
+++ b/tests/static_tests/column_result_t.cpp
@@ -112,7 +112,6 @@ TEST_CASE("column_result_of_t") {
     runTest<Storage, int>(column<User>(&User::id));
     runTest<Storage, User>(object<User>());
     runTest<Storage, int>(column<cte_1>(&User::id));
-    runTest<Storage, int>(column<cte_1>()->*&User::id);
     runTest<Storage, int>(column<cte_1>->*&User::id);
     runTest<Storage, int>(1_ctealias->*&User::id);
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED

From 2da31e0f321609241d9b27fe294a626099f3d3ef Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 5 Jan 2023 21:36:06 +0200
Subject: [PATCH 073/161] CTE available from C++17 and later

---
 dev/alias.h                                   |  21 ++-
 dev/ast_iterator.h                            |   2 +
 dev/column_result.h                           |   2 +
 dev/cte.h                                     |   3 +
 dev/cte_column_names_collector.h              |   5 +
 dev/cte_storage.h                             |  24 ++-
 dev/functional/cxx_core_features.h            |   4 +
 dev/node_tuple.h                              |   2 +
 dev/select_constraints.h                      |   6 +
 dev/statement_serializer.h                    |   2 +
 dev/storage.h                                 |   6 +
 dev/storage_impl.h                            |   4 +
 dev/storage_lookup.h                          |  14 +-
 dev/table.h                                   |   6 +
 dev/type_traits.h                             |   3 +
 examples/common_table_expressions.cpp         |   8 +-
 include/sqlite_orm/sqlite_orm.h               | 177 ++++++++++++------
 tests/ast_iterator_tests.cpp                  |  11 +-
 .../alias_extractor.cpp                       |   2 +
 tests/static_tests/column_expression_type.cpp |   2 +
 tests/static_tests/column_result_t.cpp        |   2 +
 tests/static_tests/cte.cpp                    |   6 +-
 tests/static_tests/node_tuple.cpp             |  11 +-
 23 files changed, 233 insertions(+), 90 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index ef2ac991a..c33ddf979 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -4,6 +4,7 @@
 #include <sstream>  //  std::stringstream
 #include <string>  //  std::string
 
+#include "functional/cxx_universal.h"
 #include "functional/cxx_type_traits_polyfill.h"
 
 namespace sqlite_orm {
@@ -38,7 +39,8 @@ namespace sqlite_orm {
         template<class A>
         using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
 
-        /** 
+#ifdef SQLITE_ORM_WITH_CTE
+        /**
          *  A CTE alias is a specialization of a table alias, which is both, a storage lookup type (mapping type) and an alias.
          */
         template<class A>
@@ -69,6 +71,7 @@ namespace sqlite_orm {
         consteval auto to_alias(std::index_sequence<Idx...>) {
             return Alias<t.id[Idx]...>{};
         }
+#endif
 #endif
     }
 
@@ -170,6 +173,7 @@ namespace sqlite_orm {
             alias_holder(const T&) noexcept {}
         };
 
+#ifdef SQLITE_ORM_WITH_CTE
         template<size_t n, char... C>
         SQLITE_ORM_CONSTEVAL auto n_to_colalias() {
             constexpr column_alias<'1' + n % 10, C...> colalias{};
@@ -179,6 +183,12 @@ namespace sqlite_orm {
                 return colalias;
             }
         }
+
+        template<class T>
+        inline constexpr bool is_builtin_numeric_column_alias_v = false;
+        template<char... C>
+        inline constexpr bool is_builtin_numeric_column_alias_v<column_alias<C...>> = ((C >= '0' && C <= '9') && ...);
+#endif
     }
 
     /**
@@ -291,14 +301,6 @@ namespace sqlite_orm {
     using colalias_h = internal::column_alias<'h'>;
     using colalias_i = internal::column_alias<'i'>;
 
-#ifdef SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
-    namespace internal {
-        template<class T>
-        inline constexpr bool is_builtin_numeric_column_alias_v = false;
-        template<char... C>
-        inline constexpr bool is_builtin_numeric_column_alias_v<column_alias<C...>> = ((C >= '0' && C <= '9') && ...);
-    }
-
     /**
      *  column_alias<'1'[, ...]> from a numeric literal.
      *  E.g. 1_colalias, 2_colalias
@@ -310,7 +312,6 @@ namespace sqlite_orm {
         static_assert(std::array{Chars...}[0] > '0');
         return internal::column_alias<Chars...>{};
     }
-#endif
 
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     /**
diff --git a/dev/ast_iterator.h b/dev/ast_iterator.h
index 1895c2d7d..a7da54980 100644
--- a/dev/ast_iterator.h
+++ b/dev/ast_iterator.h
@@ -192,6 +192,7 @@ namespace sqlite_orm {
             }
         };
 
+#ifdef SQLITE_ORM_WITH_CTE
         template<class CTE>
         struct ast_iterator<CTE, match_specialization_of<CTE, common_table_expression>> {
             using node_type = CTE;
@@ -212,6 +213,7 @@ namespace sqlite_orm {
                 iterate_ast(c.expression, lambda);
             }
         };
+#endif
 
         template<class T>
         struct ast_iterator<T, std::enable_if_t<is_base_of_template_v<T, compound_operator>>> {
diff --git a/dev/column_result.h b/dev/column_result.h
index 7b7634ce4..4aca6d3f0 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -202,6 +202,7 @@ namespace sqlite_orm {
         template<class DBOs, class T, class F>
         struct column_result_t<DBOs, column_pointer<T, F>, void> : column_result_t<DBOs, F> {};
 
+#ifdef SQLITE_ORM_WITH_CTE
         template<class DBOs, class Label, class ColAlias>
         struct column_result_t<DBOs, column_pointer<Label, alias_holder<ColAlias>>, void> {
             using table_type = storage_pick_table_t<Label, DBOs>;
@@ -217,6 +218,7 @@ namespace sqlite_orm {
 
             using type = std::tuple_element_t<ColIdx, typename cte_mapper_type::fields_type>;
         };
+#endif
 
         template<class DBOs, class... Args>
         struct column_result_t<DBOs, columns_t<Args...>, void> {
diff --git a/dev/cte.h b/dev/cte.h
index bf8613b0b..5adb2eac5 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "functional/cxx_core_features.h"
+#ifdef SQLITE_ORM_WITH_CTE
 #include <utility>  //  std::make_index_sequence
 
 #include "alias.h"
@@ -61,3 +63,4 @@ namespace sqlite_orm {
     using cte_9 = decltype(9_ctealias);
 #endif
 }
+#endif
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index f397e6565..3ba990548 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -1,10 +1,13 @@
 #pragma once
 
+#include "functional/cxx_core_features.h"
+#ifdef SQLITE_ORM_WITH_CTE
 #include <string>
 #include <vector>
 #include <functional>  //  std::reference_wrapper
 #include <system_error>
 
+#include "functional/cxx_universal.h"
 #include "functional/cxx_type_traits_polyfill.h"
 #include "is_base_of_template.h"
 #include "type_traits.h"
@@ -199,3 +202,5 @@ namespace sqlite_orm {
         }
     }
 }
+
+#endif
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 756fa0407..ea33a98d4 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -1,24 +1,29 @@
 #pragma once
 
+#include "functional/cxx_core_features.h"
+#ifdef SQLITE_ORM_WITH_CTE
 #include <type_traits>
 #include <tuple>
 #include <string>
 #include <vector>
 
+#include "functional/cxx_universal.h"
 #include "is_base_of_template.h"
 #include "table_type_of.h"
 #include "column_result.h"
-#include "column_expression.h"
 #include "select_constraints.h"
 #include "table.h"
 #include "alias.h"
 #include "cte_types.h"
 #include "cte_column_names_collector.h"
+#endif
+#include "column_expression.h"
 #include "storage_lookup.h"
 
 namespace sqlite_orm {
     namespace internal {
 
+#ifdef SQLITE_ORM_WITH_CTE
         // F = field_type
         template<typename Label,
                  typename ExplicitColRefs,
@@ -309,14 +314,6 @@ namespace sqlite_orm {
                 std::index_sequence<Ij, In...>{});
         }
 
-        /**
-         *  Return DBOs of storage_t.
-         */
-        template<class S, class E, satisfies<is_storage, S> = true>
-        decltype(auto) storage_for_expression(S& storage, const E&) {
-            return obtain_db_objects(storage);
-        }
-
         /**
          *  Return new DBOs for CTE expressions.
          */
@@ -326,5 +323,14 @@ namespace sqlite_orm {
                                                                   e.cte,
                                                                   std::index_sequence_for<CTEs...>{});
         }
+#endif
+
+        /**
+         *  Return DBOs of storage_t.
+         */
+        template<class S, class E, satisfies<is_storage, S> = true>
+        decltype(auto) storage_for_expression(S& storage, const E&) {
+            return obtain_db_objects(storage);
+        }
     }
 }
diff --git a/dev/functional/cxx_core_features.h b/dev/functional/cxx_core_features.h
index 697adc7c8..3338bf277 100644
--- a/dev/functional/cxx_core_features.h
+++ b/dev/functional/cxx_core_features.h
@@ -74,3 +74,7 @@
 #if __cpp_nontype_template_args >= 201911
 #define SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
 #endif
+
+#if defined(SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED) && defined(SQLITE_ORM_IF_CONSTEXPR_SUPPORTED)
+#define SQLITE_ORM_WITH_CTE
+#endif
diff --git a/dev/node_tuple.h b/dev/node_tuple.h
index d71e4951f..3c1f82513 100644
--- a/dev/node_tuple.h
+++ b/dev/node_tuple.h
@@ -133,6 +133,7 @@ namespace sqlite_orm {
             using type = tuple_cat_t<left_tuple, right_tuple>;
         };
 
+#ifdef SQLITE_ORM_WITH_CTE
         template<class CTE>
         struct node_tuple<CTE, std::enable_if_t<polyfill::is_specialization_of_v<CTE, common_table_expression>>> {
             using node_type = CTE;
@@ -146,6 +147,7 @@ namespace sqlite_orm {
             using expression_tuple = node_tuple_t<typename node_type::expression_type>;
             using type = typename conc_tuple<cte_tuple, expression_tuple>::type;
         };
+#endif
 
         template<class T, class... Args>
         struct node_tuple<select_t<T, Args...>, void> {
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 94cae7ba9..7d187ed95 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -150,6 +150,7 @@ namespace sqlite_orm {
             }
         };
 
+#ifdef SQLITE_ORM_WITH_CTE
         template<class A>
         struct column_pointer_builder<A, match_if<is_alias, A>> {
             static_assert(is_cte_alias_v<A>, "`A' must be a mapped table alias");
@@ -195,6 +196,7 @@ namespace sqlite_orm {
                 return {{}};
             }
         };
+#endif
 
         /**
          *  Subselect object type.
@@ -301,6 +303,7 @@ namespace sqlite_orm {
             using super::super;
         };
 
+#ifdef SQLITE_ORM_WITH_CTE
         struct with_string {
             explicit operator std::string() const {
                 return "WITH";
@@ -416,6 +419,7 @@ namespace sqlite_orm {
                 this->expression.highest_level = true;
             }
         };
+#endif
 
         /**
          *  Generic way to get DISTINCT value from any type.
@@ -638,6 +642,7 @@ namespace sqlite_orm {
         return {std::move(lhs), std::move(rhs)};
     }
 
+#ifdef SQLITE_ORM_WITH_CTE
     /**
      *  Example : cte<cte_1>()(select(&Object::id));
      *  The list of explicit columns is optional;
@@ -706,6 +711,7 @@ namespace sqlite_orm {
     with(internal::common_table_expression<Label, Select, ExplicitCols> cte, E expression) {
         return {std::make_tuple(move(cte)), std::move(expression)};
     }
+#endif
 
     /**
      *  Public function for UNION ALL operator.
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index 953856fe5..970cedeb4 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -502,6 +502,7 @@ namespace sqlite_orm {
             }
         };
 
+#ifdef SQLITE_ORM_WITH_CTE
         template<class CTE>
         struct statement_serializer<CTE, match_specialization_of<CTE, common_table_expression>> {
             using statement_type = CTE;
@@ -542,6 +543,7 @@ namespace sqlite_orm {
                 return ss.str();
             }
         };
+#endif
 
         template<class T>
         struct statement_serializer<T, std::enable_if_t<is_base_of_template_v<T, compound_operator>>> {
diff --git a/dev/storage.h b/dev/storage.h
index aebbca79a..0043aed9f 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -577,6 +577,7 @@ namespace sqlite_orm {
                 return this->execute(statement);
             }
 
+#ifdef SQLITE_ORM_WITH_CTE
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
@@ -616,6 +617,7 @@ namespace sqlite_orm {
                 auto statement = this->prepare(sqlite_orm::with(move(cte), sqlite_orm::select(std::move(sel))));
                 return this->execute(statement);
             }
+#endif
 
             template<class T, satisfies<is_prepared_statement, T> = true>
             std::string dump(const T& preparedStatement, bool parametrized = true) const {
@@ -1053,11 +1055,13 @@ namespace sqlite_orm {
 
             using storage_base::table_exists;  // now that it is in storage_base make it into overload set
 
+#ifdef SQLITE_ORM_WITH_CTE
             template<class... CTEs, class T, class... Args>
             prepared_statement_t<with_t<select_t<T, Args...>, CTEs...>>
             prepare(with_t<select_t<T, Args...>, CTEs...> sel) {
                 return prepare_impl<with_t<select_t<T, Args...>, CTEs...>>(std::move(sel));
             }
+#endif
 
             template<class T, class... Args>
             prepared_statement_t<select_t<T, Args...>> prepare(select_t<T, Args...> sel) {
@@ -1421,6 +1425,7 @@ namespace sqlite_orm {
                 return res;
             }
 
+#ifdef SQLITE_ORM_WITH_CTE
             template<class... CTEs, class T, class... Args>
             auto execute(const prepared_statement_t<with_t<select_t<T, Args...>, CTEs...>>& statement) {
                 using DBOs =
@@ -1428,6 +1433,7 @@ namespace sqlite_orm {
                 using R = column_result_of_t<DBOs, T>;
                 return _execute_select<R>(statement);
             }
+#endif
 
             template<class T, class... Args>
             auto execute(const prepared_statement_t<select_t<T, Args...>>& statement) {
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index d45d8ef96..23e3e0c38 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -77,6 +77,7 @@ namespace sqlite_orm {
             return cp.field;
         }
 
+#ifdef SQLITE_ORM_WITH_CTE
         /**
          *  Materialize column pointer:
          *  3. by label type and alias_holder<>.
@@ -97,6 +98,7 @@ namespace sqlite_orm {
 
             return &aliased_field<ColAlias, std::tuple_element_t<ColIdx, cte_mapper_type::fields_type>>;
         }
+#endif
 
         /**
          *  Find column name by:
@@ -109,6 +111,7 @@ namespace sqlite_orm {
             return pick_table<O>(dbObjects).find_column_name(field);
         }
 
+#ifdef SQLITE_ORM_WITH_CTE
         /**
          *  Find column name by:
          *  3. by label type and alias_holder<>.
@@ -137,5 +140,6 @@ namespace sqlite_orm {
             auto& table = pick_table<Label>(dboObjects);
             return &std::get<ColIdx>(table.elements).name;
         }
+#endif
     }
 }
diff --git a/dev/storage_lookup.h b/dev/storage_lookup.h
index d421e779a..0bce7c7fb 100644
--- a/dev/storage_lookup.h
+++ b/dev/storage_lookup.h
@@ -37,6 +37,7 @@ namespace sqlite_orm {
         template<class... DBO>
         struct is_db_objects<const db_objects_tuple<DBO...>> : std::true_type {};
 
+#ifdef SQLITE_ORM_WITH_CTE
         /**
          *  A data type's label type, void otherwise.
          */
@@ -51,6 +52,7 @@ namespace sqlite_orm {
          */
         template<typename T>
         using cte_label_or_nested_t = polyfill::detected_or_t<T, cte_label_type_t, T>;
+#endif
 
         /**
          *  std::true_type if given 'table' type matches, std::false_type otherwise.
@@ -72,6 +74,7 @@ namespace sqlite_orm {
         struct object_type_matches : polyfill::conjunction<polyfill::negation<std::is_void<object_type_t<DBO>>>,
                                                            std::is_same<Lookup, object_type_t<DBO>>> {};
 
+#ifdef SQLITE_ORM_WITH_CTE
         /**
          *  std::true_type if given label is mapped, std::false_type otherwise
          *
@@ -82,14 +85,19 @@ namespace sqlite_orm {
         using cte_label_type_matches =
             polyfill::conjunction<polyfill::negation<std::is_void<label_of_or_void_t<DBO>>>,
                                   std::is_same<cte_label_or_nested_t<Label>, label_of_or_void_t<DBO>>>;
+#endif
 
         /**
          *  std::true_type if given lookup type (object or label) is mapped, std::false_type otherwise.
          */
         template<typename DBO, typename Lookup>
-        using lookup_type_matches = typename polyfill::disjunction<dbo_type_matches<DBO, Lookup>,
-                                                                   object_type_matches<DBO, Lookup>,
-                                                                   cte_label_type_matches<DBO, Lookup>>::type;
+        using lookup_type_matches = typename polyfill::disjunction<object_type_matches<DBO, Lookup>
+#ifdef SQLITE_ORM_WITH_CTE
+                                                                   ,
+                                                                   dbo_type_matches<DBO, Lookup>,
+                                                                   cte_label_type_matches<DBO, Lookup>
+#endif
+                                                                   >::type;
     }
 
     // pick/lookup metafunctions
diff --git a/dev/table.h b/dev/table.h
index 862d1a5e7..f020a0eaf 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -26,6 +26,7 @@ namespace sqlite_orm {
 
     namespace internal {
 
+#ifdef SQLITE_ORM_WITH_CTE
         /**
          *  A data type's label type, void otherwise.
          */
@@ -38,6 +39,7 @@ namespace sqlite_orm {
          */
         template<typename O>
         using mapped_object_type_for_t = polyfill::detected_or_t<O, cte_label_type_t, O>;
+#endif
 
         struct basic_table {
 
@@ -53,11 +55,15 @@ namespace sqlite_orm {
         template<class O, bool WithoutRowId, class... Cs>
         struct table_t : basic_table {
             using super = basic_table;
+#ifdef SQLITE_ORM_WITH_CTE
             // this typename is used in contexts where it is known that the 'table' holds a subselect_mapper
             // instead of a regular object type
             using cte_mapper_type = O;
             using cte_label_type = label_of_or_void_t<O>;
             using object_type = mapped_object_type_for_t<O>;
+#else
+            using object_type = O;
+#endif
             using elements_type = std::tuple<Cs...>;
 
             static constexpr bool is_without_rowid_v = WithoutRowId;
diff --git a/dev/type_traits.h b/dev/type_traits.h
index b105b75e3..9d694b60b 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -2,6 +2,7 @@
 
 #include <type_traits>  //  std::enable_if, std::is_same
 
+#include "functional/cxx_core_features.h"
 #include "functional/cxx_type_traits_polyfill.h"
 
 namespace sqlite_orm {
@@ -61,6 +62,7 @@ namespace sqlite_orm {
         template<typename T>
         using target_type_t = typename T::target_type;
 
+#ifdef SQLITE_ORM_WITH_CTE
         template<typename T>
         using cte_label_type_t = typename T::cte_label_type;
 
@@ -69,6 +71,7 @@ namespace sqlite_orm {
 
         template<typename T>
         using cte_mapper_type_t = typename T::cte_mapper_type;
+#endif
 
         template<typename T>
         using expression_type_t = typename T::expression_type;
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 62659ef06..f3567d98a 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -2,12 +2,14 @@
  *  Examples partially from https://sqlite.org/lang_with.html
  */
 
-#include <tuple>
-#include <iostream>
 #include <sqlite_orm/sqlite_orm.h>
+#ifdef SQLITE_ORM_WITH_CTE
+
 #ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
 #include <optional>
 #endif
+#include <tuple>
+#include <iostream>
 
 using std::cout;
 using std::endl;
@@ -750,3 +752,5 @@ int main() {
 
     return 0;
 }
+
+#endif
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 2f4ffb97d..a48031e45 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -10,30 +10,7 @@ __pragma(push_macro("max"))
 
 #include <type_traits>  //  std::enable_if, std::is_same
 
-// #include "functional/cxx_type_traits_polyfill.h"
-
-#include <type_traits>
-
-// #include "cxx_universal.h"
-
-
-/*
- *  This header makes central C++ functionality on which sqlite_orm depends universally available:
- *  - alternative operator representations
- *  - ::size_t, ::ptrdiff_t, ::nullptr_t
- *  - C++ core feature macros
- *  - macros for dealing with compiler quirks
- */
-
-#include <iso646.h>  //  alternative operator representations
-#include <cstddef>  //  sqlite_orm is using size_t, ptrdiff_t, nullptr_t everywhere, pull it in early
-
-// earlier clang versions didn't make nullptr_t available in the global namespace via stddef.h,
-// though it should have according to C++ documentation (see https://en.cppreference.com/w/cpp/types/nullptr_t#Notes).
-// actually it should be available when including stddef.h
-using std::nullptr_t;
-
-// #include "cxx_core_features.h"
+// #include "functional/cxx_core_features.h"
 
 
 #ifdef __has_cpp_attribute
@@ -111,6 +88,35 @@ using std::nullptr_t;
 #define SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
 #endif
 
+#if defined(SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED) && defined(SQLITE_ORM_IF_CONSTEXPR_SUPPORTED)
+#define SQLITE_ORM_WITH_CTE
+#endif
+
+// #include "functional/cxx_type_traits_polyfill.h"
+
+#include <type_traits>
+
+// #include "cxx_universal.h"
+
+
+/*
+ *  This header makes central C++ functionality on which sqlite_orm depends universally available:
+ *  - alternative operator representations
+ *  - ::size_t, ::ptrdiff_t, ::nullptr_t
+ *  - C++ core feature macros
+ *  - macros for dealing with compiler quirks
+ */
+
+#include <iso646.h>  //  alternative operator representations
+#include <cstddef>  //  sqlite_orm is using size_t, ptrdiff_t, nullptr_t everywhere, pull it in early
+
+// earlier clang versions didn't make nullptr_t available in the global namespace via stddef.h,
+// though it should have according to C++ documentation (see https://en.cppreference.com/w/cpp/types/nullptr_t#Notes).
+// actually it should be available when including stddef.h
+using std::nullptr_t;
+
+// #include "cxx_core_features.h"
+
 // #include "cxx_compiler_quirks.h"
 
 
@@ -344,6 +350,7 @@ namespace sqlite_orm {
         template<typename T>
         using target_type_t = typename T::target_type;
 
+#ifdef SQLITE_ORM_WITH_CTE
         template<typename T>
         using cte_label_type_t = typename T::cte_label_type;
 
@@ -352,6 +359,7 @@ namespace sqlite_orm {
 
         template<typename T>
         using cte_mapper_type_t = typename T::cte_mapper_type;
+#endif
 
         template<typename T>
         using expression_type_t = typename T::expression_type;
@@ -4159,6 +4167,8 @@ namespace sqlite_orm {
 #include <sstream>  //  std::stringstream
 #include <string>  //  std::string
 
+// #include "functional/cxx_universal.h"
+
 // #include "functional/cxx_type_traits_polyfill.h"
 
 
@@ -4194,7 +4204,8 @@ namespace sqlite_orm {
         template<class A>
         using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
 
-        /** 
+#ifdef SQLITE_ORM_WITH_CTE
+        /**
          *  A CTE alias is a specialization of a table alias, which is both, a storage lookup type (mapping type) and an alias.
          */
         template<class A>
@@ -4225,6 +4236,7 @@ namespace sqlite_orm {
         consteval auto to_alias(std::index_sequence<Idx...>) {
             return Alias<t.id[Idx]...>{};
         }
+#endif
 #endif
     }
 
@@ -4326,6 +4338,7 @@ namespace sqlite_orm {
             alias_holder(const T&) noexcept {}
         };
 
+#ifdef SQLITE_ORM_WITH_CTE
         template<size_t n, char... C>
         SQLITE_ORM_CONSTEVAL auto n_to_colalias() {
             constexpr column_alias<'1' + n % 10, C...> colalias{};
@@ -4335,6 +4348,12 @@ namespace sqlite_orm {
                 return colalias;
             }
         }
+
+        template<class T>
+        inline constexpr bool is_builtin_numeric_column_alias_v = false;
+        template<char... C>
+        inline constexpr bool is_builtin_numeric_column_alias_v<column_alias<C...>> = ((C >= '0' && C <= '9') && ...);
+#endif
     }
 
     /**
@@ -4447,14 +4466,6 @@ namespace sqlite_orm {
     using colalias_h = internal::column_alias<'h'>;
     using colalias_i = internal::column_alias<'i'>;
 
-#ifdef SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
-    namespace internal {
-        template<class T>
-        inline constexpr bool is_builtin_numeric_column_alias_v = false;
-        template<char... C>
-        inline constexpr bool is_builtin_numeric_column_alias_v<column_alias<C...>> = ((C >= '0' && C <= '9') && ...);
-    }
-
     /**
      *  column_alias<'1'[, ...]> from a numeric literal.
      *  E.g. 1_colalias, 2_colalias
@@ -4466,7 +4477,6 @@ namespace sqlite_orm {
         static_assert(std::array{Chars...}[0] > '0');
         return internal::column_alias<Chars...>{};
     }
-#endif
 
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     /**
@@ -7087,6 +7097,7 @@ namespace sqlite_orm {
             }
         };
 
+#ifdef SQLITE_ORM_WITH_CTE
         template<class A>
         struct column_pointer_builder<A, match_if<is_alias, A>> {
             static_assert(is_cte_alias_v<A>, "`A' must be a mapped table alias");
@@ -7132,6 +7143,7 @@ namespace sqlite_orm {
                 return {{}};
             }
         };
+#endif
 
         /**
          *  Subselect object type.
@@ -7238,6 +7250,7 @@ namespace sqlite_orm {
             using super::super;
         };
 
+#ifdef SQLITE_ORM_WITH_CTE
         struct with_string {
             explicit operator std::string() const {
                 return "WITH";
@@ -7353,6 +7366,7 @@ namespace sqlite_orm {
                 this->expression.highest_level = true;
             }
         };
+#endif
 
         /**
          *  Generic way to get DISTINCT value from any type.
@@ -7575,6 +7589,7 @@ namespace sqlite_orm {
         return {std::move(lhs), std::move(rhs)};
     }
 
+#ifdef SQLITE_ORM_WITH_CTE
     /**
      *  Example : cte<cte_1>()(select(&Object::id));
      *  The list of explicit columns is optional;
@@ -7643,6 +7658,7 @@ namespace sqlite_orm {
     with(internal::common_table_expression<Label, Select, ExplicitCols> cte, E expression) {
         return {std::make_tuple(move(cte)), std::move(expression)};
     }
+#endif
 
     /**
      *  Public function for UNION ALL operator.
@@ -9956,6 +9972,7 @@ namespace sqlite_orm {
         template<class... DBO>
         struct is_db_objects<const db_objects_tuple<DBO...>> : std::true_type {};
 
+#ifdef SQLITE_ORM_WITH_CTE
         /**
          *  A data type's label type, void otherwise.
          */
@@ -9970,6 +9987,7 @@ namespace sqlite_orm {
          */
         template<typename T>
         using cte_label_or_nested_t = polyfill::detected_or_t<T, cte_label_type_t, T>;
+#endif
 
         /**
          *  std::true_type if given 'table' type matches, std::false_type otherwise.
@@ -9991,6 +10009,7 @@ namespace sqlite_orm {
         struct object_type_matches : polyfill::conjunction<polyfill::negation<std::is_void<object_type_t<DBO>>>,
                                                            std::is_same<Lookup, object_type_t<DBO>>> {};
 
+#ifdef SQLITE_ORM_WITH_CTE
         /**
          *  std::true_type if given label is mapped, std::false_type otherwise
          *
@@ -10001,14 +10020,19 @@ namespace sqlite_orm {
         using cte_label_type_matches =
             polyfill::conjunction<polyfill::negation<std::is_void<label_of_or_void_t<DBO>>>,
                                   std::is_same<cte_label_or_nested_t<Label>, label_of_or_void_t<DBO>>>;
+#endif
 
         /**
          *  std::true_type if given lookup type (object or label) is mapped, std::false_type otherwise.
          */
         template<typename DBO, typename Lookup>
-        using lookup_type_matches = typename polyfill::disjunction<dbo_type_matches<DBO, Lookup>,
-                                                                   object_type_matches<DBO, Lookup>,
-                                                                   cte_label_type_matches<DBO, Lookup>>::type;
+        using lookup_type_matches = typename polyfill::disjunction<object_type_matches<DBO, Lookup>
+#ifdef SQLITE_ORM_WITH_CTE
+                                                                   ,
+                                                                   dbo_type_matches<DBO, Lookup>,
+                                                                   cte_label_type_matches<DBO, Lookup>
+#endif
+                                                                   >::type;
     }
 
     // pick/lookup metafunctions
@@ -10585,6 +10609,7 @@ namespace sqlite_orm {
         template<class DBOs, class T, class F>
         struct column_result_t<DBOs, column_pointer<T, F>, void> : column_result_t<DBOs, F> {};
 
+#ifdef SQLITE_ORM_WITH_CTE
         template<class DBOs, class Label, class ColAlias>
         struct column_result_t<DBOs, column_pointer<Label, alias_holder<ColAlias>>, void> {
             using table_type = storage_pick_table_t<Label, DBOs>;
@@ -10600,6 +10625,7 @@ namespace sqlite_orm {
 
             using type = std::tuple_element_t<ColIdx, typename cte_mapper_type::fields_type>;
         };
+#endif
 
         template<class DBOs, class... Args>
         struct column_result_t<DBOs, columns_t<Args...>, void> {
@@ -10936,6 +10962,7 @@ namespace sqlite_orm {
 
     namespace internal {
 
+#ifdef SQLITE_ORM_WITH_CTE
         /**
          *  A data type's label type, void otherwise.
          */
@@ -10948,6 +10975,7 @@ namespace sqlite_orm {
          */
         template<typename O>
         using mapped_object_type_for_t = polyfill::detected_or_t<O, cte_label_type_t, O>;
+#endif
 
         struct basic_table {
 
@@ -10963,11 +10991,15 @@ namespace sqlite_orm {
         template<class O, bool WithoutRowId, class... Cs>
         struct table_t : basic_table {
             using super = basic_table;
+#ifdef SQLITE_ORM_WITH_CTE
             // this typename is used in contexts where it is known that the 'table' holds a subselect_mapper
             // instead of a regular object type
             using cte_mapper_type = O;
             using cte_label_type = label_of_or_void_t<O>;
             using object_type = mapped_object_type_for_t<O>;
+#else
+            using object_type = O;
+#endif
             using elements_type = std::tuple<Cs...>;
 
             static constexpr bool is_without_rowid_v = WithoutRowId;
@@ -11319,6 +11351,7 @@ namespace sqlite_orm {
             return cp.field;
         }
 
+#ifdef SQLITE_ORM_WITH_CTE
         /**
          *  Materialize column pointer:
          *  3. by label type and alias_holder<>.
@@ -11339,6 +11372,7 @@ namespace sqlite_orm {
 
             return &aliased_field<ColAlias, std::tuple_element_t<ColIdx, cte_mapper_type::fields_type>>;
         }
+#endif
 
         /**
          *  Find column name by:
@@ -11351,6 +11385,7 @@ namespace sqlite_orm {
             return pick_table<O>(dbObjects).find_column_name(field);
         }
 
+#ifdef SQLITE_ORM_WITH_CTE
         /**
          *  Find column name by:
          *  3. by label type and alias_holder<>.
@@ -11379,6 +11414,7 @@ namespace sqlite_orm {
             auto& table = pick_table<Label>(dboObjects);
             return &std::get<ColIdx>(table.elements).name;
         }
+#endif
     }
 }
 #pragma once
@@ -12924,6 +12960,7 @@ namespace sqlite_orm {
             }
         };
 
+#ifdef SQLITE_ORM_WITH_CTE
         template<class CTE>
         struct ast_iterator<CTE, match_specialization_of<CTE, common_table_expression>> {
             using node_type = CTE;
@@ -12944,6 +12981,7 @@ namespace sqlite_orm {
                 iterate_ast(c.expression, lambda);
             }
         };
+#endif
 
         template<class T>
         struct ast_iterator<T, std::enable_if_t<is_base_of_template_v<T, compound_operator>>> {
@@ -15887,11 +15925,16 @@ namespace sqlite_orm {
 // #include "cte_column_names_collector.h"
 
 
+// #include "functional/cxx_core_features.h"
+
+#ifdef SQLITE_ORM_WITH_CTE
 #include <string>
 #include <vector>
 #include <functional>  //  std::reference_wrapper
 #include <system_error>
 
+// #include "functional/cxx_universal.h"
+
 // #include "functional/cxx_type_traits_polyfill.h"
 
 // #include "is_base_of_template.h"
@@ -16095,6 +16138,8 @@ namespace sqlite_orm {
     }
 }
 
+#endif
+
 // #include "order_by_serializer.h"
 
 
@@ -16648,6 +16693,7 @@ namespace sqlite_orm {
             }
         };
 
+#ifdef SQLITE_ORM_WITH_CTE
         template<class CTE>
         struct statement_serializer<CTE, match_specialization_of<CTE, common_table_expression>> {
             using statement_type = CTE;
@@ -16688,6 +16734,7 @@ namespace sqlite_orm {
                 return ss.str();
             }
         };
+#endif
 
         template<class T>
         struct statement_serializer<T, std::enable_if_t<is_base_of_template_v<T, compound_operator>>> {
@@ -18275,17 +18322,33 @@ namespace sqlite_orm {
 // #include "cte_storage.h"
 
 
+// #include "functional/cxx_core_features.h"
+
+#ifdef SQLITE_ORM_WITH_CTE
 #include <type_traits>
 #include <tuple>
 #include <string>
 #include <vector>
 
+// #include "functional/cxx_universal.h"
+
 // #include "is_base_of_template.h"
 
 // #include "table_type_of.h"
 
 // #include "column_result.h"
 
+// #include "select_constraints.h"
+
+// #include "table.h"
+
+// #include "alias.h"
+
+// #include "cte_types.h"
+
+// #include "cte_column_names_collector.h"
+
+#endif
 // #include "column_expression.h"
 
 
@@ -18390,22 +18453,13 @@ namespace sqlite_orm {
     }
 }
 
-// #include "select_constraints.h"
-
-// #include "table.h"
-
-// #include "alias.h"
-
-// #include "cte_types.h"
-
-// #include "cte_column_names_collector.h"
-
 // #include "storage_lookup.h"
 
 
 namespace sqlite_orm {
     namespace internal {
 
+#ifdef SQLITE_ORM_WITH_CTE
         // F = field_type
         template<typename Label,
                  typename ExplicitColRefs,
@@ -18696,14 +18750,6 @@ namespace sqlite_orm {
                 std::index_sequence<Ij, In...>{});
         }
 
-        /**
-         *  Return DBOs of storage_t.
-         */
-        template<class S, class E, satisfies<is_storage, S> = true>
-        decltype(auto) storage_for_expression(S& storage, const E&) {
-            return obtain_db_objects(storage);
-        }
-
         /**
          *  Return new DBOs for CTE expressions.
          */
@@ -18713,6 +18759,15 @@ namespace sqlite_orm {
                                                                   e.cte,
                                                                   std::index_sequence_for<CTEs...>{});
         }
+#endif
+
+        /**
+         *  Return DBOs of storage_t.
+         */
+        template<class S, class E, satisfies<is_storage, S> = true>
+        decltype(auto) storage_for_expression(S& storage, const E&) {
+            return obtain_db_objects(storage);
+        }
     }
 }
 
@@ -19243,6 +19298,7 @@ namespace sqlite_orm {
                 return this->execute(statement);
             }
 
+#ifdef SQLITE_ORM_WITH_CTE
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
@@ -19282,6 +19338,7 @@ namespace sqlite_orm {
                 auto statement = this->prepare(sqlite_orm::with(move(cte), sqlite_orm::select(std::move(sel))));
                 return this->execute(statement);
             }
+#endif
 
             template<class T, satisfies<is_prepared_statement, T> = true>
             std::string dump(const T& preparedStatement, bool parametrized = true) const {
@@ -19719,11 +19776,13 @@ namespace sqlite_orm {
 
             using storage_base::table_exists;  // now that it is in storage_base make it into overload set
 
+#ifdef SQLITE_ORM_WITH_CTE
             template<class... CTEs, class T, class... Args>
             prepared_statement_t<with_t<select_t<T, Args...>, CTEs...>>
             prepare(with_t<select_t<T, Args...>, CTEs...> sel) {
                 return prepare_impl<with_t<select_t<T, Args...>, CTEs...>>(std::move(sel));
             }
+#endif
 
             template<class T, class... Args>
             prepared_statement_t<select_t<T, Args...>> prepare(select_t<T, Args...> sel) {
@@ -20087,6 +20146,7 @@ namespace sqlite_orm {
                 return res;
             }
 
+#ifdef SQLITE_ORM_WITH_CTE
             template<class... CTEs, class T, class... Args>
             auto execute(const prepared_statement_t<with_t<select_t<T, Args...>, CTEs...>>& statement) {
                 using DBOs =
@@ -20094,6 +20154,7 @@ namespace sqlite_orm {
                 using R = column_result_of_t<DBOs, T>;
                 return _execute_select<R>(statement);
             }
+#endif
 
             template<class T, class... Args>
             auto execute(const prepared_statement_t<select_t<T, Args...>>& statement) {
@@ -20170,6 +20231,9 @@ namespace sqlite_orm {
 }
 #pragma once
 
+// #include "functional/cxx_core_features.h"
+
+#ifdef SQLITE_ORM_WITH_CTE
 #include <utility>  //  std::make_index_sequence
 
 // #include "alias.h"
@@ -20232,6 +20296,7 @@ namespace sqlite_orm {
     using cte_9 = decltype(9_ctealias);
 #endif
 }
+#endif
 #pragma once
 
 #include <type_traits>  //  std::enable_if
@@ -20382,6 +20447,7 @@ namespace sqlite_orm {
             using type = tuple_cat_t<left_tuple, right_tuple>;
         };
 
+#ifdef SQLITE_ORM_WITH_CTE
         template<class CTE>
         struct node_tuple<CTE, std::enable_if_t<polyfill::is_specialization_of_v<CTE, common_table_expression>>> {
             using node_type = CTE;
@@ -20395,6 +20461,7 @@ namespace sqlite_orm {
             using expression_tuple = node_tuple_t<typename node_type::expression_type>;
             using type = typename conc_tuple<cte_tuple, expression_tuple>::type;
         };
+#endif
 
         template<class T, class... Args>
         struct node_tuple<select_t<T, Args...>, void> {
diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index 514aa1b26..24cc0e0e7 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -5,7 +5,6 @@ using namespace sqlite_orm;
 using internal::alias_holder;
 using internal::column_alias;
 using internal::column_pointer;
-using internal::cte_alias;
 
 TEST_CASE("ast_iterator") {
     struct User {
@@ -268,18 +267,20 @@ TEST_CASE("ast_iterator") {
         expected.push_back(typeid(&User::id));
         internal::iterate_ast(node, lambda);
     }
+#ifdef SQLITE_ORM_WITH_CTE
     SECTION("with") {
         auto expression =
-            with(cte<cte_alias<'1'>>()(
+            with(cte<cte_1>()(
                      union_all(select(1), select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < 10)))),
                  select(1_ctealias->*1_colalias));
         expected.push_back(typeid(int));
-        expected.push_back(typeid(column_pointer<cte_alias<'1'>, alias_holder<column_alias<'1'>>>));
+        expected.push_back(typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>));
         expected.push_back(typeid(int));
-        expected.push_back(typeid(column_pointer<cte_alias<'1'>, alias_holder<column_alias<'1'>>>));
+        expected.push_back(typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>));
         expected.push_back(typeid(int));
-        expected.push_back(typeid(column_pointer<cte_alias<'1'>, alias_holder<column_alias<'1'>>>));
+        expected.push_back(typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>));
         internal::iterate_ast(expression, lambda);
     }
+#endif
     REQUIRE(typeIndexes == expected);
 }
diff --git a/tests/statement_serializer_tests/alias_extractor.cpp b/tests/statement_serializer_tests/alias_extractor.cpp
index 3c742997c..cce033915 100644
--- a/tests/statement_serializer_tests/alias_extractor.cpp
+++ b/tests/statement_serializer_tests/alias_extractor.cpp
@@ -19,8 +19,10 @@ TEST_CASE("alias extractor") {
         REQUIRE(alias_extractor<alias_a<User>>::extract() == "a");
         REQUIRE(alias_extractor<alias_a<User>>::as_alias() == "a");
     }
+#ifdef SQLITE_ORM_WITH_CTE
     SECTION("cte table") {
         REQUIRE(alias_extractor<cte_1>::extract() == "1");
         REQUIRE(alias_extractor<cte_1>::as_alias() == "");
     }
+#endif
 }
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index 29a186094..a6581c24d 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -43,6 +43,7 @@ TEST_CASE("column_expression_of_t") {
     runTest<storage_type, internal::as_t<colalias_a, int>>(as<colalias_a>(1));
 
     runTest<storage_type, column_pointer<Derived, int64 Org::*>>(column<Derived>(&Org::id));
+#ifdef SQLITE_ORM_WITH_CTE
     runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>(&Org::id));
     runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>->*&Org::id);
     runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(cte_1{}->*&Org::id);
@@ -51,4 +52,5 @@ TEST_CASE("column_expression_of_t") {
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     runTest<storage_type, column_pointer<cte_1, alias_holder<colalias_c>>>("1"_cte->*"c"_col);
 #endif
+#endif
 }
diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
index ccdf22d3a..674133131 100644
--- a/tests/static_tests/column_result_t.cpp
+++ b/tests/static_tests/column_result_t.cpp
@@ -111,10 +111,12 @@ TEST_CASE("column_result_of_t") {
     runTest<Storage, std::tuple<int, std::string>>(columns(&User::id, &User::name));
     runTest<Storage, int>(column<User>(&User::id));
     runTest<Storage, User>(object<User>());
+#ifdef SQLITE_ORM_WITH_CTE
     runTest<Storage, int>(column<cte_1>(&User::id));
     runTest<Storage, int>(column<cte_1>->*&User::id);
     runTest<Storage, int>(1_ctealias->*&User::id);
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
     runTest<Storage, int>("1"_cte->*&User::id);
 #endif
+#endif
 }
diff --git a/tests/static_tests/cte.cpp b/tests/static_tests/cte.cpp
index 46430e497..a3f1e7d12 100644
--- a/tests/static_tests/cte.cpp
+++ b/tests/static_tests/cte.cpp
@@ -1,5 +1,8 @@
-#include <type_traits>  //  std::is_same, std::is_constructible
 #include <sqlite_orm/sqlite_orm.h>
+#ifdef SQLITE_ORM_WITH_CTE
+#include <type_traits>  //  std::is_same, std::is_constructible
+#include <tuple>    //  std::ignore
+#include <string>   //  std::string
 #include <catch2/catch.hpp>
 
 using namespace sqlite_orm;
@@ -39,3 +42,4 @@ TEST_CASE("CTE type traits") {
         runTest<tuple<std::string>>("");
     }
 }
+#endif
diff --git a/tests/static_tests/node_tuple.cpp b/tests/static_tests/node_tuple.cpp
index 162baf8cc..2e3f186a4 100644
--- a/tests/static_tests/node_tuple.cpp
+++ b/tests/static_tests/node_tuple.cpp
@@ -6,7 +6,6 @@ using namespace sqlite_orm;
 using internal::alias_holder;
 using internal::column_alias;
 using internal::column_pointer;
-using internal::cte_alias;
 
 template<class T>
 struct is_pair : std::false_type {};
@@ -940,18 +939,20 @@ TEST_CASE("Node tuple") {
         using ExpectedTuple = tuple<decltype(&User::id)>;
         STATIC_REQUIRE(std::is_same<Tuple, ExpectedTuple>::value);
     }
+#ifdef SQLITE_ORM_WITH_CTE
     SECTION("with") {
         auto expression =
-            with(cte<cte_alias<'1'>>()(
+            with(cte<cte_1>()(
                      union_all(select(1), select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < 10)))),
                  select(1_ctealias->*1_colalias));
         using Tuple = node_tuple_t<decltype(expression)>;
         using ExpectedTuple = tuple<int,
-                                    column_pointer<cte_alias<'1'>, alias_holder<column_alias<'1'>>>,
+                                    column_pointer<cte_1, alias_holder<column_alias<'1'>>>,
                                     int,
-                                    column_pointer<cte_alias<'1'>, alias_holder<column_alias<'1'>>>,
+                                    column_pointer<cte_1, alias_holder<column_alias<'1'>>>,
                                     int,
-                                    column_pointer<cte_alias<'1'>, alias_holder<column_alias<'1'>>>>;
+                                    column_pointer<cte_1, alias_holder<column_alias<'1'>>>>;
         STATIC_REQUIRE(std::is_same_v<Tuple, ExpectedTuple>);
     }
+#endif
 }

From cd35ef4514a0025112e9157b4726786c45a67c69 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 5 Jan 2023 22:17:39 +0200
Subject: [PATCH 074/161] Fixed compilation error on clang

---
 dev/storage_impl.h              |  4 +++-
 dev/type_traits.h               | 14 +++++++-------
 include/sqlite_orm/sqlite_orm.h | 18 ++++++++++--------
 3 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 23e3e0c38..6ab0a8a2c 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -81,6 +81,8 @@ namespace sqlite_orm {
         /**
          *  Materialize column pointer:
          *  3. by label type and alias_holder<>.
+         *  
+         *  internal note: there's an overload for `find_column_name()` that avoids going through `table_t<>::find_column_name()`
          */
         template<class Label, class ColAlias, class DBOs, satisfies<is_db_objects, DBOs> = true>
         constexpr decltype(auto) materialize_column_pointer(const DBOs&,
@@ -96,7 +98,7 @@ namespace sqlite_orm {
             constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
             static_assert(ColIdx != -1, "No such column mapped into the CTE.");
 
-            return &aliased_field<ColAlias, std::tuple_element_t<ColIdx, cte_mapper_type::fields_type>>;
+            return &aliased_field<ColAlias, std::tuple_element_t<ColIdx, cte_mapper_type::fields_type>>::field;
         }
 #endif
 
diff --git a/dev/type_traits.h b/dev/type_traits.h
index 9d694b60b..966d3723c 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -71,13 +71,6 @@ namespace sqlite_orm {
 
         template<typename T>
         using cte_mapper_type_t = typename T::cte_mapper_type;
-#endif
-
-        template<typename T>
-        using expression_type_t = typename T::expression_type;
-
-        template<class As>
-        using alias_type_t = typename As::alias_type;
 
         // T::alias_type or nonesuch
         template<class T>
@@ -85,5 +78,12 @@ namespace sqlite_orm {
 
         template<class T>
         using alias_holder_type_or_none_t = typename alias_holder_type_or_none<T>::type;
+#endif
+
+        template<typename T>
+        using expression_type_t = typename T::expression_type;
+
+        template<class As>
+        using alias_type_t = typename As::alias_type;
     }
 }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index a48031e45..0fe4222be 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -359,13 +359,6 @@ namespace sqlite_orm {
 
         template<typename T>
         using cte_mapper_type_t = typename T::cte_mapper_type;
-#endif
-
-        template<typename T>
-        using expression_type_t = typename T::expression_type;
-
-        template<class As>
-        using alias_type_t = typename As::alias_type;
 
         // T::alias_type or nonesuch
         template<class T>
@@ -373,6 +366,13 @@ namespace sqlite_orm {
 
         template<class T>
         using alias_holder_type_or_none_t = typename alias_holder_type_or_none<T>::type;
+#endif
+
+        template<typename T>
+        using expression_type_t = typename T::expression_type;
+
+        template<class As>
+        using alias_type_t = typename As::alias_type;
     }
 }
 #pragma once
@@ -11355,6 +11355,8 @@ namespace sqlite_orm {
         /**
          *  Materialize column pointer:
          *  3. by label type and alias_holder<>.
+         *  
+         *  internal note: there's an overload for `find_column_name()` that avoids going through `table_t<>::find_column_name()`
          */
         template<class Label, class ColAlias, class DBOs, satisfies<is_db_objects, DBOs> = true>
         constexpr decltype(auto) materialize_column_pointer(const DBOs&,
@@ -11370,7 +11372,7 @@ namespace sqlite_orm {
             constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
             static_assert(ColIdx != -1, "No such column mapped into the CTE.");
 
-            return &aliased_field<ColAlias, std::tuple_element_t<ColIdx, cte_mapper_type::fields_type>>;
+            return &aliased_field<ColAlias, std::tuple_element_t<ColIdx, cte_mapper_type::fields_type>>::field;
         }
 #endif
 

From cc7e6beae12db3410fe3424ee2ed814c27a461b3 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 5 Jan 2023 23:05:18 +0200
Subject: [PATCH 075/161] Cleaned up remnants of pre-1.8 merge

---
 dev/connection_holder.h         |  3 ---
 dev/core_functions.h            | 20 ++++++++------------
 include/sqlite_orm/sqlite_orm.h | 23 ++++++++---------------
 3 files changed, 16 insertions(+), 30 deletions(-)

diff --git a/dev/connection_holder.h b/dev/connection_holder.h
index bc380d2fd..b0f61c1f6 100644
--- a/dev/connection_holder.h
+++ b/dev/connection_holder.h
@@ -14,9 +14,6 @@ namespace sqlite_orm {
 
             connection_holder(std::string filename_) : filename(move(filename_)) {}
 
-            connection_holder(connection_holder* connection) :
-                filename{connection->filename}, db{connection->db}, _retain_count{++connection->_retain_count} {}
-
             void retain() {
                 if(1 == ++this->_retain_count) {
                     auto rc = sqlite3_open(this->filename.c_str(), &this->db);
diff --git a/dev/core_functions.h b/dev/core_functions.h
index cd494c63a..1c4a896d9 100644
--- a/dev/core_functions.h
+++ b/dev/core_functions.h
@@ -1876,23 +1876,19 @@ namespace sqlite_orm {
     }
 
     /**
-     *  MAX(X, ...) aggregate or simple multi-argument function.
-     *  The return type is deduced from the first argument.
+     *  MAX(X) aggregate function.
      */
-    template<class X, class... Rest>
-    internal::built_in_aggregate_function_t<internal::unique_ptr_result_of<X>, internal::max_string, X, Rest...>
-    max(X x, Rest... rest) {
-        return {std::tuple<X, Rest...>{std::forward<X>(x), std::forward<Rest>(rest)...}};
+    template<class X>
+    internal::built_in_aggregate_function_t<internal::unique_ptr_result_of<X>, internal::max_string, X> max(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
     }
 
     /**
-     *  MIN(X, ...) aggregate or simple multi-argument function.
-     *  The return type is deduced from the first argument.
+     *  MIN(X) aggregate function.
      */
-    template<class X, class... Rest>
-    internal::built_in_aggregate_function_t<internal::unique_ptr_result_of<X>, internal::min_string, X, Rest...>
-    min(X x, Rest... rest) {
-        return {std::tuple<X, Rest...>{std::forward<X>(x), std::forward<Rest>(rest)...}};
+    template<class X>
+    internal::built_in_aggregate_function_t<internal::unique_ptr_result_of<X>, internal::min_string, X> min(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
     }
 
     /**
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 0fe4222be..06a4de03f 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -6538,23 +6538,19 @@ namespace sqlite_orm {
     }
 
     /**
-     *  MAX(X, ...) aggregate or simple multi-argument function.
-     *  The return type is deduced from the first argument.
+     *  MAX(X) aggregate function.
      */
-    template<class X, class... Rest>
-    internal::built_in_aggregate_function_t<internal::unique_ptr_result_of<X>, internal::max_string, X, Rest...>
-    max(X x, Rest... rest) {
-        return {std::tuple<X, Rest...>{std::forward<X>(x), std::forward<Rest>(rest)...}};
+    template<class X>
+    internal::built_in_aggregate_function_t<internal::unique_ptr_result_of<X>, internal::max_string, X> max(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
     }
 
     /**
-     *  MIN(X, ...) aggregate or simple multi-argument function.
-     *  The return type is deduced from the first argument.
+     *  MIN(X) aggregate function.
      */
-    template<class X, class... Rest>
-    internal::built_in_aggregate_function_t<internal::unique_ptr_result_of<X>, internal::min_string, X, Rest...>
-    min(X x, Rest... rest) {
-        return {std::tuple<X, Rest...>{std::forward<X>(x), std::forward<Rest>(rest)...}};
+    template<class X>
+    internal::built_in_aggregate_function_t<internal::unique_ptr_result_of<X>, internal::min_string, X> min(X x) {
+        return {std::tuple<X>{std::forward<X>(x)}};
     }
 
     /**
@@ -11804,9 +11800,6 @@ namespace sqlite_orm {
 
             connection_holder(std::string filename_) : filename(move(filename_)) {}
 
-            connection_holder(connection_holder* connection) :
-                filename{connection->filename}, db{connection->db}, _retain_count{++connection->_retain_count} {}
-
             void retain() {
                 if(1 == ++this->_retain_count) {
                     auto rc = sqlite3_open(this->filename.c_str(), &this->db);

From dfd0e0db12287ae505a76cd09d14a2b418547f0c Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 5 Jan 2023 23:13:20 +0200
Subject: [PATCH 076/161] Optimized copying explicit CTE column string

---
 dev/cte_column_names_collector.h | 4 ++--
 include/sqlite_orm/sqlite_orm.h  | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index 3ba990548..32f17db9e 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -175,8 +175,8 @@ namespace sqlite_orm {
                     } else if constexpr(polyfill::is_specialization_of_v<ColRef, column_t>) {
                         columnNames[idx] = colRef.name;
                     } else if constexpr(std::is_same_v<ColRef, std::string>) {
-                        if(std::string name = colRef; !name.empty()) {
-                            columnNames[idx] = move(name);
+                        if(!colRef.empty()) {
+                            columnNames[idx] = colRef;
                         }
                     } else if constexpr(std::is_same_v<ColRef, polyfill::remove_cvref_t<decltype(std::ignore)>>) {
                         if(columnNames[idx].empty()) {
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 06a4de03f..8610b75b1 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -16105,8 +16105,8 @@ namespace sqlite_orm {
                     } else if constexpr(polyfill::is_specialization_of_v<ColRef, column_t>) {
                         columnNames[idx] = colRef.name;
                     } else if constexpr(std::is_same_v<ColRef, std::string>) {
-                        if(std::string name = colRef; !name.empty()) {
-                            columnNames[idx] = move(name);
+                        if(!colRef.empty()) {
+                            columnNames[idx] = colRef;
                         }
                     } else if constexpr(std::is_same_v<ColRef, polyfill::remove_cvref_t<decltype(std::ignore)>>) {
                         if(columnNames[idx].empty()) {

From 98738a87bd9330400523500d99cf3ddacc33fd0f Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 27 Jan 2023 16:19:46 +0200
Subject: [PATCH 077/161] Made column aliases first-class citizens

---
 dev/alias.h                     | 36 ++++++++++++------
 dev/ast_iterator.h              | 11 ++++++
 dev/node_tuple.h                |  6 +++
 dev/statement_serializer.h      | 12 ++++++
 examples/column_aliases.cpp     | 18 ++++++++-
 include/sqlite_orm/sqlite_orm.h | 65 +++++++++++++++++++++++++++------
 tests/CMakeLists.txt            |  1 +
 tests/ast_iterator_tests.cpp    | 29 ++++++++++++---
 tests/static_tests/alias.cpp    | 30 +++++++++++++++
 9 files changed, 176 insertions(+), 32 deletions(-)
 create mode 100644 tests/static_tests/alias.cpp

diff --git a/dev/alias.h b/dev/alias.h
index c33ddf979..8b8fa0902 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -3,6 +3,9 @@
 #include <type_traits>  //  std::enable_if, std::is_base_of, std::is_member_pointer
 #include <sstream>  //  std::stringstream
 #include <string>  //  std::string
+#ifdef SQLITE_ORM_WITH_CTE
+#include <array>
+#endif
 
 #include "functional/cxx_universal.h"
 #include "functional/cxx_type_traits_polyfill.h"
@@ -233,10 +236,17 @@ namespace sqlite_orm {
         return {std::move(expression)};
     }
 
-    template<class T>
-    internal::alias_holder<T> get() {
+    template<class A, internal::satisfies<internal::is_column_alias, A> = true>
+    internal::alias_holder<A> get() {
+        return {};
+    }
+
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+    template<auto als>
+    internal::alias_holder<decltype(als)> get() {
         return {};
     }
+#endif
 
     template<class T>
     using alias_a = internal::table_alias<T, 'a'>;
@@ -301,6 +311,18 @@ namespace sqlite_orm {
     using colalias_h = internal::column_alias<'h'>;
     using colalias_i = internal::column_alias<'i'>;
 
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+    /**
+     *  column_alias<'a'[, ...]> from a string literal.
+     *  E.g. "a"_col, "b"_col
+     */
+    template<internal::string_identifier_template t>
+    [[nodiscard]] consteval auto operator"" _col() {
+        return internal::to_alias<internal::column_alias, t>(std::make_index_sequence<t.size()>{});
+    }
+#endif
+
+#ifdef SQLITE_ORM_WITH_CTE
     /**
      *  column_alias<'1'[, ...]> from a numeric literal.
      *  E.g. 1_colalias, 2_colalias
@@ -312,15 +334,5 @@ namespace sqlite_orm {
         static_assert(std::array{Chars...}[0] > '0');
         return internal::column_alias<Chars...>{};
     }
-
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
-    /**
-     *  column_alias<'a'[, ...]> from a string literal.
-     *  E.g. "a"_col, "b"_col
-     */
-    template<internal::string_identifier_template t>
-    [[nodiscard]] consteval auto operator"" _col() {
-        return internal::to_alias<internal::column_alias, t>(std::make_index_sequence<t.size()>{});
-    }
 #endif
 }
diff --git a/dev/ast_iterator.h b/dev/ast_iterator.h
index a7da54980..57bf0a8e4 100644
--- a/dev/ast_iterator.h
+++ b/dev/ast_iterator.h
@@ -692,6 +692,17 @@ namespace sqlite_orm {
             void operator()(const node_type& /*node*/, L& /*lambda*/) const {}
         };
 
+        /**
+         *  Column alias
+         */
+        template<char... C>
+        struct ast_iterator<column_alias<C...>, void> {
+            using node_type = column_alias<C...>;
+
+            template<class L>
+            void operator()(const node_type& /*node*/, L& /*lambda*/) const {}
+        };
+
         template<class E>
         struct ast_iterator<order_by_t<E>, void> {
             using node_type = order_by_t<E>;
diff --git a/dev/node_tuple.h b/dev/node_tuple.h
index 3c1f82513..750e77c27 100644
--- a/dev/node_tuple.h
+++ b/dev/node_tuple.h
@@ -75,6 +75,12 @@ namespace sqlite_orm {
         template<class A>
         struct node_tuple<alias_holder<A>, void> : node_tuple<void> {};
 
+        /**
+         *  Column alias
+         */
+        template<char... C>
+        struct node_tuple<column_alias<C...>, void> : node_tuple<void> {};
+
         /**
          *  Literal
          */
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index 297e31477..9e5fd2574 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -212,6 +212,18 @@ namespace sqlite_orm {
             }
         };
 
+        template<char... C>
+        struct statement_serializer<column_alias<C...>, void> {
+            using statement_type = column_alias<C...>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type&, const Ctx&) {
+                std::stringstream ss;
+                ss << streaming_identifier(statement_type::get());
+                return ss.str();
+            }
+        };
+
         template<class... TargetArgs, class... ActionsArgs>
         struct statement_serializer<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void> {
             using statement_type = upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>;
diff --git a/examples/column_aliases.cpp b/examples/column_aliases.cpp
index 7a9cad26f..4541a4729 100644
--- a/examples/column_aliases.cpp
+++ b/examples/column_aliases.cpp
@@ -58,12 +58,26 @@ void marvel_hero_ordered_by_o_pos() {
         }
     }
     cout << endl;
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+    {
+        //  SELECT name, instr(abilities, 'o') i
+        //  FROM marvel
+        //  WHERE i > 0
+        //  ORDER BY i
+        auto rows = storage.select(columns(&MarvelHero::name, as<"i"_col>(instr(&MarvelHero::abilities, "o"))),
+                                   where("i"_col > c(0)),
+                                   order_by("i"_col));
+        for(auto& row: rows) {
+            cout << get<0>(row) << '\t' << get<1>(row) << '\n';
+        }
+    }
+    cout << endl;
+#endif
     {
         //  SELECT name, instr(abilities, 'o')
         //  FROM marvel
         //  ORDER BY 2
-        auto rows =
-            storage.select(columns(&MarvelHero::name, as<colalias_i>(instr(&MarvelHero::abilities, "o"))), order_by(2));
+        auto rows = storage.select(columns(&MarvelHero::name, instr(&MarvelHero::abilities, "o")), order_by(2));
         for(auto& row: rows) {
             cout << get<0>(row) << '\t' << get<1>(row) << '\n';
         }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index c94141e36..b9ecbbed8 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4142,6 +4142,9 @@ namespace sqlite_orm {
 #include <type_traits>  //  std::enable_if, std::is_base_of, std::is_member_pointer
 #include <sstream>  //  std::stringstream
 #include <string>  //  std::string
+#ifdef SQLITE_ORM_WITH_CTE
+#include <array>
+#endif
 
 // #include "functional/cxx_universal.h"
 
@@ -4373,10 +4376,17 @@ namespace sqlite_orm {
         return {std::move(expression)};
     }
 
-    template<class T>
-    internal::alias_holder<T> get() {
+    template<class A, internal::satisfies<internal::is_column_alias, A> = true>
+    internal::alias_holder<A> get() {
+        return {};
+    }
+
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+    template<auto als>
+    internal::alias_holder<decltype(als)> get() {
         return {};
     }
+#endif
 
     template<class T>
     using alias_a = internal::table_alias<T, 'a'>;
@@ -4441,6 +4451,18 @@ namespace sqlite_orm {
     using colalias_h = internal::column_alias<'h'>;
     using colalias_i = internal::column_alias<'i'>;
 
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+    /**
+     *  column_alias<'a'[, ...]> from a string literal.
+     *  E.g. "a"_col, "b"_col
+     */
+    template<internal::string_identifier_template t>
+    [[nodiscard]] consteval auto operator"" _col() {
+        return internal::to_alias<internal::column_alias, t>(std::make_index_sequence<t.size()>{});
+    }
+#endif
+
+#ifdef SQLITE_ORM_WITH_CTE
     /**
      *  column_alias<'1'[, ...]> from a numeric literal.
      *  E.g. 1_colalias, 2_colalias
@@ -4452,16 +4474,6 @@ namespace sqlite_orm {
         static_assert(std::array{Chars...}[0] > '0');
         return internal::column_alias<Chars...>{};
     }
-
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
-    /**
-     *  column_alias<'a'[, ...]> from a string literal.
-     *  E.g. "a"_col, "b"_col
-     */
-    template<internal::string_identifier_template t>
-    [[nodiscard]] consteval auto operator"" _col() {
-        return internal::to_alias<internal::column_alias, t>(std::make_index_sequence<t.size()>{});
-    }
 #endif
 }
 #pragma once
@@ -13364,6 +13376,17 @@ namespace sqlite_orm {
             void operator()(const node_type& /*node*/, L& /*lambda*/) const {}
         };
 
+        /**
+         *  Column alias
+         */
+        template<char... C>
+        struct ast_iterator<column_alias<C...>, void> {
+            using node_type = column_alias<C...>;
+
+            template<class L>
+            void operator()(const node_type& /*node*/, L& /*lambda*/) const {}
+        };
+
         template<class E>
         struct ast_iterator<order_by_t<E>, void> {
             using node_type = order_by_t<E>;
@@ -16278,6 +16301,18 @@ namespace sqlite_orm {
             }
         };
 
+        template<char... C>
+        struct statement_serializer<column_alias<C...>, void> {
+            using statement_type = column_alias<C...>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type&, const Ctx&) {
+                std::stringstream ss;
+                ss << streaming_identifier(statement_type::get());
+                return ss.str();
+            }
+        };
+
         template<class... TargetArgs, class... ActionsArgs>
         struct statement_serializer<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void> {
             using statement_type = upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>;
@@ -20256,6 +20291,12 @@ namespace sqlite_orm {
         template<class A>
         struct node_tuple<alias_holder<A>, void> : node_tuple<void> {};
 
+        /**
+         *  Column alias
+         */
+        template<char... C>
+        struct node_tuple<column_alias<C...>, void> : node_tuple<void> {};
+
         /**
          *  Literal
          */
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 5a69d2074..89d55569b 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -27,6 +27,7 @@ add_executable(unit_tests
     static_tests/core_function_return_types.cpp
     static_tests/column_expression_type.cpp
     static_tests/column_result_t.cpp
+    static_tests/alias.cpp
     static_tests/cte.cpp
     static_tests/is_primary_key_insertable.cpp
     static_tests/is_column_with_insertable_primary_key.cpp
diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index 3a7758486..6dce2dcad 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -267,18 +267,35 @@ TEST_CASE("ast_iterator") {
         expected.push_back(typeid(&User::id));
         internal::iterate_ast(node, lambda);
     }
+    SECTION("aliases") {
+        SECTION("holder") {
+            auto expression = get<colalias_a>() > c(0);
+            expected.push_back(typeid(int));
+            internal::iterate_ast(expression, lambda);
+        }
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+        {
+            SECTION("direct") {
+                auto expression = "a"_col > c(0);
+                expected.push_back(typeid(int));
+                internal::iterate_ast(expression, lambda);
+            }
+        }
+#endif
+    }
 #ifdef SQLITE_ORM_WITH_CTE
     SECTION("with") {
         auto expression =
             with(cte<cte_1>()(
                      union_all(select(1), select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < 10)))),
                  select(1_ctealias->*1_colalias));
-        expected.push_back(typeid(int));
-        expected.push_back(typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>));
-        expected.push_back(typeid(int));
-        expected.push_back(typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>));
-        expected.push_back(typeid(int));
-        expected.push_back(typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>));
+        expected.insert(expected.cend(),
+                        {typeid(int),
+                         typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>),
+                         typeid(int),
+                         typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>),
+                         typeid(int),
+                         typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>)});
         internal::iterate_ast(expression, lambda);
     }
 #endif
diff --git a/tests/static_tests/alias.cpp b/tests/static_tests/alias.cpp
new file mode 100644
index 000000000..1a93859e9
--- /dev/null
+++ b/tests/static_tests/alias.cpp
@@ -0,0 +1,30 @@
+#include <sqlite_orm/sqlite_orm.h>
+#include <type_traits>  //  std::is_same
+#include <catch2/catch_all.hpp>
+
+using namespace sqlite_orm;
+using internal::alias_holder;
+using internal::column_alias;
+
+template<class ColAlias, class E>
+void do_assert() {
+    STATIC_REQUIRE(std::is_same<ColAlias, E>::value);
+}
+
+template<class E, class ColAlias>
+void runTest(ColAlias /*colRef*/) {
+    do_assert<ColAlias, E>();
+}
+
+TEST_CASE("aliases") {
+    SECTION("column alias expressions") {
+        runTest<alias_holder<column_alias<'a'>>>(get<colalias_a>());
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+        runTest<alias_holder<column_alias<'a'>>>(get<"a"_col>());
+        runTest<column_alias<'a'>>("a"_col);
+#endif
+#ifdef SQLITE_ORM_WITH_CTE
+        runTest<column_alias<'1'>>(1_colalias);
+#endif
+    }
+}

From c6af050a26bf65e5010ff6ac8244a28ee432bd1d Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 27 Jan 2023 18:16:02 +0200
Subject: [PATCH 078/161] Correct shadowed template parameter

---
 dev/table.h                     | 4 ++--
 include/sqlite_orm/sqlite_orm.h | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/dev/table.h b/dev/table.h
index f020a0eaf..db2906b6d 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -259,11 +259,11 @@ namespace sqlite_orm {
                 iterate_tuple(this->elements, fk_index_sequence{}, lambda);
             }
 
-            template<class O, class L>
+            template<class Target, class L>
             void for_each_foreign_key_to(L&& lambda) const {
                 using fk_index_sequence = filter_tuple_sequence_t<elements_type, is_foreign_key>;
                 using filtered_index_sequence = filter_tuple_sequence_t<elements_type,
-                                                                        check_if_is_type<O>::template fn,
+                                                                        check_if_is_type<Target>::template fn,
                                                                         target_type_t,
                                                                         fk_index_sequence>;
                 iterate_tuple(this->elements, filtered_index_sequence{}, lambda);
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index b9ecbbed8..91fa187e8 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -11137,11 +11137,11 @@ namespace sqlite_orm {
                 iterate_tuple(this->elements, fk_index_sequence{}, lambda);
             }
 
-            template<class O, class L>
+            template<class Target, class L>
             void for_each_foreign_key_to(L&& lambda) const {
                 using fk_index_sequence = filter_tuple_sequence_t<elements_type, is_foreign_key>;
                 using filtered_index_sequence = filter_tuple_sequence_t<elements_type,
-                                                                        check_if_is_type<O>::template fn,
+                                                                        check_if_is_type<Target>::template fn,
                                                                         target_type_t,
                                                                         fk_index_sequence>;
                 iterate_tuple(this->elements, filtered_index_sequence{}, lambda);

From a2fddcb9b7d0920ead3a267465e8a1e91032009d Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 27 Jan 2023 22:19:15 +0200
Subject: [PATCH 079/161] Ability to daisy-chain the concatenation operator

---
 dev/conditions.h                         | 10 ++++++++++
 include/sqlite_orm/sqlite_orm.h          | 10 ++++++++++
 tests/operators/arithmetic_operators.cpp | 17 +++++++++++++----
 3 files changed, 33 insertions(+), 4 deletions(-)

diff --git a/dev/conditions.h b/dev/conditions.h
index 82060643e..d5d6ea660 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -896,6 +896,16 @@ namespace sqlite_orm {
         return {std::move(l.value), std::move(r.value)};
     }
 
+    template<class R, class L1, class R1>
+    internal::conc_t<internal::conc_t<L1, R1>, R> operator||(internal::conc_t<L1, R1> expr, R r) {
+        return {std::move(expr), std::move(r)};
+    }
+
+    template<class L, class L1, class R1>
+    internal::conc_t<L, internal::conc_t<L1, R1>> operator||(L l, internal::conc_t<L1, R1> expr) {
+        return {std::move(l), std::move(expr)};
+    }
+
     template<class T, class R>
     internal::add_t<T, R> operator+(internal::expression_t<T> expr, R r) {
         return {std::move(expr.value), std::move(r)};
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 91fa187e8..a00b8a23e 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3742,6 +3742,16 @@ namespace sqlite_orm {
         return {std::move(l.value), std::move(r.value)};
     }
 
+    template<class R, class L1, class R1>
+    internal::conc_t<internal::conc_t<L1, R1>, R> operator||(internal::conc_t<L1, R1> expr, R r) {
+        return {std::move(expr), std::move(r)};
+    }
+
+    template<class L, class L1, class R1>
+    internal::conc_t<L, internal::conc_t<L1, R1>> operator||(L l, internal::conc_t<L1, R1> expr) {
+        return {std::move(l), std::move(expr)};
+    }
+
     template<class T, class R>
     internal::add_t<T, R> operator+(internal::expression_t<T> expr, R r) {
         return {std::move(expr.value), std::move(r)};
diff --git a/tests/operators/arithmetic_operators.cpp b/tests/operators/arithmetic_operators.cpp
index d0d92083d..c2eb3c0a6 100644
--- a/tests/operators/arithmetic_operators.cpp
+++ b/tests/operators/arithmetic_operators.cpp
@@ -35,11 +35,11 @@ TEST_CASE("Arithmetic operators") {
         }
     }
     {  //  +
-        auto rows = storage.select(columns(c(&Object::nameLen) + 1000));
+        auto rows = storage.select(c(&Object::nameLen) + 1000);
         for(size_t i = 0; i < rows.size(); ++i) {
             auto& row = rows[i];
             auto& name = names[i];
-            REQUIRE(int(std::get<0>(row)) == name.length() + 1000);
+            REQUIRE(int(row) == name.length() + 1000);
         }
     }
     {  //  ||
@@ -51,13 +51,22 @@ TEST_CASE("Arithmetic operators") {
             REQUIRE(row == name + suffix);
         }
     }
+    {  //  daisy-chaining ||
+        std::string suffix = "ototo";
+        auto rows = storage.select(c(&Object::name) || suffix || ".");
+        for(size_t i = 0; i < rows.size(); ++i) {
+            auto& row = rows[i];
+            auto& name = names[i];
+            REQUIRE(row == name + suffix + ".");
+        }
+    }
     {  //  ||
         std::string suffix = "ototo";
-        auto rows = storage.select(columns(conc(&Object::name, suffix)));
+        auto rows = storage.select(conc(&Object::name, suffix));
         for(size_t i = 0; i < rows.size(); ++i) {
             auto& row = rows[i];
             auto& name = names[i];
-            REQUIRE(std::get<0>(row) == name + suffix);
+            REQUIRE(row == name + suffix);
         }
     }
     {  //  different

From 304fee3c1bf01f64ddf2f72a79b392a28ce47f0e Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 27 Jan 2023 22:56:32 +0200
Subject: [PATCH 080/161] EXISTS must use parentheses

---
 dev/statement_serializer.h                              | 4 +++-
 include/sqlite_orm/sqlite_orm.h                         | 4 +++-
 tests/statement_serializer_tests/select_constraints.cpp | 7 +++++++
 3 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index 9e5fd2574..833e1e32f 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -824,7 +824,9 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& statement, const Ctx& context) const {
                 std::stringstream ss;
                 ss << "EXISTS ";
-                ss << serialize(statement.expression, context);
+                auto newContext = context;
+                newContext.use_parentheses = true;
+                ss << serialize(statement.expression, newContext);
                 return ss.str();
             }
         };
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index a00b8a23e..df4a8fbe5 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -16923,7 +16923,9 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& statement, const Ctx& context) const {
                 std::stringstream ss;
                 ss << "EXISTS ";
-                ss << serialize(statement.expression, context);
+                auto newContext = context;
+                newContext.use_parentheses = true;
+                ss << serialize(statement.expression, newContext);
                 return ss.str();
             }
         };
diff --git a/tests/statement_serializer_tests/select_constraints.cpp b/tests/statement_serializer_tests/select_constraints.cpp
index 29861b4d6..dfb1331d6 100644
--- a/tests/statement_serializer_tests/select_constraints.cpp
+++ b/tests/statement_serializer_tests/select_constraints.cpp
@@ -86,5 +86,12 @@ TEST_CASE("statement_serializer select constraints") {
         value = serialize(expression, context);
         expected = R"(EVEN("id"))";
     }
+    SECTION("exists") {
+        // EXISTS must use parentheses
+        context.use_parentheses = false;
+        auto expression = exists(select(1));
+        value = serialize(expression, context);
+        expected = "EXISTS (SELECT 1)";
+    }
     REQUIRE(value == expected);
 }

From 881115b61e1fba171b2e4fe8803b781d454359c8 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 27 Jan 2023 23:09:41 +0200
Subject: [PATCH 081/161] Aliasing of CTE aliases

---
 dev/alias.h                     | 20 ++++++++++++-----
 dev/conditions.h                | 12 ++++++++++
 dev/mapped_type_proxy.h         |  2 +-
 dev/table_name_collector.h      |  6 +++--
 include/sqlite_orm/sqlite_orm.h | 40 ++++++++++++++++++++++++++-------
 5 files changed, 64 insertions(+), 16 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 8b8fa0902..fd0b08ae2 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -48,7 +48,8 @@ namespace sqlite_orm {
          */
         template<class A>
         SQLITE_ORM_INLINE_VAR constexpr bool is_cte_alias_v =
-            polyfill::conjunction_v<std::is_base_of<alias_tag, A>, std::is_same<polyfill::detected_t<type_t, A>, A>>;
+            polyfill::conjunction_v<std::is_base_of<alias_tag, A>,
+                                    std::is_same<polyfill::detected_t<type_t, A>, std::remove_const_t<A>>>;
 
         template<class A>
         using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
@@ -198,13 +199,22 @@ namespace sqlite_orm {
      *  @return column with table alias attached. Place it instead of a column statement in case you need to specify a
      *  column with table alias prefix like 'a.column'. For more information please look through self_join.cpp example
      */
-    template<class T, class C>
-    internal::alias_column_t<T, C> alias_column(C c) {
-        static_assert(std::is_member_pointer<C>::value,
-                      "alias_column argument must be a member pointer mapped to a storage");
+    template<class A, class C, internal::satisfies<internal::is_table_alias, A> = true>
+    internal::alias_column_t<A, C> alias_column(C c) {
+        static_assert(internal::is_cte_alias_v<internal::type_t<A>> || std::is_member_pointer<C>::value,
+                      "alias_column argument must be mapped to a storage");
         return {c};
     }
 
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+    template<auto als, class C, internal::satisfies<internal::is_table_alias, decltype(als)> = true>
+    internal::alias_column_t<decltype(als), C> alias_column(C c) {
+        static_assert(internal::is_cte_alias_v<internal::type_t<decltype(als)>> || std::is_member_pointer<C>::value,
+                      "alias_column argument must be mapped to a storage");
+        return {c};
+    }
+#endif
+
     /** 
      *  Alias a column expression.
      */
diff --git a/dev/conditions.h b/dev/conditions.h
index d5d6ea660..f47d800e7 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -813,6 +813,18 @@ namespace sqlite_orm {
         return {};
     }
 
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+    /**
+     *  Explicit FROM function. Usage:
+     *  `storage.select(&User::id, from<"a"_cte>());`
+     */
+    template<auto... args>
+    internal::from_t<decltype(args)...> from() {
+        static_assert(std::tuple_size<std::tuple<decltype(args)...>>::value > 0, "");
+        return {};
+    }
+#endif
+
     template<class T, internal::satisfies<std::is_base_of, internal::negatable_t, T> = true>
     internal::negated_condition_t<T> operator!(T arg) {
         return {std::move(arg)};
diff --git a/dev/mapped_type_proxy.h b/dev/mapped_type_proxy.h
index 9072d50b3..4dc68b4b1 100644
--- a/dev/mapped_type_proxy.h
+++ b/dev/mapped_type_proxy.h
@@ -18,7 +18,7 @@ namespace sqlite_orm {
 
         template<class T>
         struct mapped_type_proxy<T, match_if<is_table_alias, T>> {
-            using type = type_t<T>;
+            using type = std::remove_const_t<type_t<T>>;
         };
 
         template<class T>
diff --git a/dev/table_name_collector.h b/dev/table_name_collector.h
index 7ef215deb..3e540af63 100644
--- a/dev/table_name_collector.h
+++ b/dev/table_name_collector.h
@@ -44,8 +44,10 @@ namespace sqlite_orm {
             }
 
             template<class T, class C>
-            void operator()(const alias_column_t<T, C>& a) const {
-                (*this)(a.column, alias_extractor<T>::as_alias());
+            void operator()(const alias_column_t<T, C>&) const {
+                // note: instead of accessing the column, we are interested in the type the column is aliased into
+                auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<T>));
+                table_names.emplace(move(tableName), alias_extractor<T>::as_alias());
             }
 
             template<class T>
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index df4a8fbe5..68a5096de 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3659,6 +3659,18 @@ namespace sqlite_orm {
         return {};
     }
 
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+    /**
+     *  Explicit FROM function. Usage:
+     *  `storage.select(&User::id, from<"a"_cte>());`
+     */
+    template<auto... args>
+    internal::from_t<decltype(args)...> from() {
+        static_assert(std::tuple_size<std::tuple<decltype(args)...>>::value > 0, "");
+        return {};
+    }
+#endif
+
     template<class T, internal::satisfies<std::is_base_of, internal::negatable_t, T> = true>
     internal::negated_condition_t<T> operator!(T arg) {
         return {std::move(arg)};
@@ -4198,7 +4210,8 @@ namespace sqlite_orm {
          */
         template<class A>
         SQLITE_ORM_INLINE_VAR constexpr bool is_cte_alias_v =
-            polyfill::conjunction_v<std::is_base_of<alias_tag, A>, std::is_same<polyfill::detected_t<type_t, A>, A>>;
+            polyfill::conjunction_v<std::is_base_of<alias_tag, A>,
+                                    std::is_same<polyfill::detected_t<type_t, A>, std::remove_const_t<A>>>;
 
         template<class A>
         using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
@@ -4348,13 +4361,22 @@ namespace sqlite_orm {
      *  @return column with table alias attached. Place it instead of a column statement in case you need to specify a
      *  column with table alias prefix like 'a.column'. For more information please look through self_join.cpp example
      */
-    template<class T, class C>
-    internal::alias_column_t<T, C> alias_column(C c) {
-        static_assert(std::is_member_pointer<C>::value,
-                      "alias_column argument must be a member pointer mapped to a storage");
+    template<class A, class C, internal::satisfies<internal::is_table_alias, A> = true>
+    internal::alias_column_t<A, C> alias_column(C c) {
+        static_assert(internal::is_cte_alias_v<internal::type_t<A>> || std::is_member_pointer<C>::value,
+                      "alias_column argument must be mapped to a storage");
         return {c};
     }
 
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+    template<auto als, class C, internal::satisfies<internal::is_table_alias, decltype(als)> = true>
+    internal::alias_column_t<decltype(als), C> alias_column(C c) {
+        static_assert(internal::is_cte_alias_v<internal::type_t<decltype(als)>> || std::is_member_pointer<C>::value,
+                      "alias_column argument must be mapped to a storage");
+        return {c};
+    }
+#endif
+
     /** 
      *  Alias a column expression.
      */
@@ -9701,7 +9723,7 @@ namespace sqlite_orm {
 
         template<class T>
         struct mapped_type_proxy<T, match_if<is_table_alias, T>> {
-            using type = type_t<T>;
+            using type = std::remove_const_t<type_t<T>>;
         };
 
         template<class T>
@@ -15659,8 +15681,10 @@ namespace sqlite_orm {
             }
 
             template<class T, class C>
-            void operator()(const alias_column_t<T, C>& a) const {
-                (*this)(a.column, alias_extractor<T>::as_alias());
+            void operator()(const alias_column_t<T, C>&) const {
+                // note: instead of accessing the column, we are interested in the type the column is aliased into
+                auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<T>));
+                table_names.emplace(move(tableName), alias_extractor<T>::as_alias());
             }
 
             template<class T>

From a6c6b466745d071526209ff3653328e5762510c0 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 27 Jan 2023 23:11:24 +0200
Subject: [PATCH 082/161] Sudoku as another outlandish CTE query example

---
 examples/common_table_expressions.cpp | 83 +++++++++++++++++++++++++++
 1 file changed, 83 insertions(+)

diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index f3567d98a..8d8d734a7 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -640,6 +640,88 @@ void apfelmaennchen() {
     cout << endl;
 }
 
+void sudoku() {
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+    auto storage = make_storage("");
+
+    //WITH RECURSIVE
+    //    input(sud) AS(
+    //        VALUES('53..7....6..195....98....6.8...6...34..8.3..17...2...6.6....28....419..5....8..79')
+    //    ),
+    //    digits(z, lp) AS(
+    //        VALUES('1', 1)
+    //        UNION ALL SELECT
+    //        CAST(lp + 1 AS TEXT), lp + 1 FROM digits WHERE lp < 9
+    //    ),
+    //    x(s, ind) AS(
+    //        SELECT sud, instr(sud, '.') FROM input
+    //        UNION ALL
+    //        SELECT
+    //        substr(s, 1, ind - 1) || z || substr(s, ind + 1),
+    //        instr(substr(s, 1, ind - 1) || z || substr(s, ind + 1), '.')
+    //        FROM x, digits AS z
+    //        WHERE ind > 0
+    //        AND NOT EXISTS(
+    //            SELECT 1
+    //            FROM digits AS lp
+    //            WHERE z.z = substr(s, ((ind - 1) / 9) * 9 + lp, 1)
+    //            OR z.z = substr(s, ((ind - 1) % 9) + (lp - 1) * 9 + 1, 1)
+    //            OR z.z = substr(s, (((ind - 1) / 3) % 3) * 3
+    //                + ((ind - 1) / 27) * 27 + lp
+    //                + ((lp - 1) / 3) * 6, 1)
+    //        )
+    //    )
+    //    SELECT s FROM x WHERE ind = 0;
+
+    constexpr auto input = "input"_cte;
+    constexpr auto digits = "digits"_cte;
+    using z_alias = alias_z<decltype(digits)>;
+    constexpr auto x = "_x"_cte;
+    constexpr auto sud = "sud"_col;
+    constexpr auto z = "z"_col;
+    constexpr auto lp = "lp"_col;
+    constexpr auto s = "s"_col;
+    constexpr auto ind = "ind"_col;
+    auto ast = with(
+        make_tuple(
+            cte<input>(sud)(
+                select("53..7....6..195....98....6.8...6...34..8.3..17...2...6.6....28....419..5....8..79")),
+            cte<digits>(z, lp)(union_all(
+                select(columns("1", 1)),
+                select(columns(cast<std::string>(digits->*lp + c(1)), digits->*lp + c(1)), where(digits->*lp < 9)))),
+            cte<x>(s, ind)(union_all(
+                select(columns(input->*sud, instr(input->*sud, "."))),
+                select(columns(substr(x->*s, 1, x->*ind - c(1)) || c(z) || substr(x->*s, x->*ind + c(1)),
+                               instr(substr(x->*s, 1, x->*ind - c(1)) || c(z) || substr(x->*s, x->*ind + c(1)), ".")),
+                       from<x, z_alias{}>(),
+                       where(x->*ind > 0 and
+                             not exists(select(
+                                 1 >>= lp,
+                                 from<digits>(),
+                                 where(is_equal(alias_column<z_alias>(z),
+                                                substr(x->*s, ((x->*ind - c(1)) / 9) * 9 + lp, 1)) or
+                                       is_equal(alias_column<z_alias>(z),
+                                                substr(x->*s, ((x->*ind - c(1)) % 9) + (lp - c(1)) * 9 + 1, 1)) or
+                                       is_equal(alias_column<z_alias>(z),
+                                                substr(x->*s,
+                                                       (((x->*ind - c(1)) / 3) % 3) * 3 + ((x->*ind - c(1)) / 27) * 27 +
+                                                           lp + ((lp - c(1)) / 3) * 6,
+                                                       1)))))))))),
+        select(x->*s, where(x->*ind == 0)));
+
+    string sql = storage.dump(ast);
+
+    auto stmt = storage.prepare(ast);
+    auto results = storage.execute(stmt);
+
+    cout << "Sudoku solution:\n";
+    for(const string& answer: results) {
+        cout << answer << '\n';
+    }
+    cout << endl;
+#endif
+}
+
 void show_mapping_and_backreferencing() {
     struct Object {
         int64 id;
@@ -745,6 +827,7 @@ int main() {
         depth_or_breadth_first();
         select_from_subselect();
         apfelmaennchen();
+        sudoku();
         show_mapping_and_backreferencing();
     } catch(const system_error& e) {
         cout << "[" << e.code() << "] " << e.what();

From 4d7b911a0041a52275562af4822f261c4fe95667 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 28 Jan 2023 09:51:21 +0200
Subject: [PATCH 083/161] Runner-up: Ability to daisy-chain the concatenation
 operator

---
 dev/conditions.h                         |  8 ++++----
 include/sqlite_orm/sqlite_orm.h          |  8 ++++----
 tests/operators/arithmetic_operators.cpp | 11 ++++++++++-
 3 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/dev/conditions.h b/dev/conditions.h
index f47d800e7..4dc921a53 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -908,13 +908,13 @@ namespace sqlite_orm {
         return {std::move(l.value), std::move(r.value)};
     }
 
-    template<class R, class L1, class R1>
-    internal::conc_t<internal::conc_t<L1, R1>, R> operator||(internal::conc_t<L1, R1> expr, R r) {
+    template<class R, class E, internal::satisfies<std::is_base_of, internal::conc_string, E> = true>
+    internal::conc_t<E, R> operator||(E expr, R r) {
         return {std::move(expr), std::move(r)};
     }
 
-    template<class L, class L1, class R1>
-    internal::conc_t<L, internal::conc_t<L1, R1>> operator||(L l, internal::conc_t<L1, R1> expr) {
+    template<class L, class E, internal::satisfies<std::is_base_of, internal::conc_string, E> = true>
+    internal::conc_t<L, E> operator||(L l, E expr) {
         return {std::move(l), std::move(expr)};
     }
 
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 68a5096de..2c1af90ac 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3754,13 +3754,13 @@ namespace sqlite_orm {
         return {std::move(l.value), std::move(r.value)};
     }
 
-    template<class R, class L1, class R1>
-    internal::conc_t<internal::conc_t<L1, R1>, R> operator||(internal::conc_t<L1, R1> expr, R r) {
+    template<class R, class E, internal::satisfies<std::is_base_of, internal::conc_string, E> = true>
+    internal::conc_t<E, R> operator||(E expr, R r) {
         return {std::move(expr), std::move(r)};
     }
 
-    template<class L, class L1, class R1>
-    internal::conc_t<L, internal::conc_t<L1, R1>> operator||(L l, internal::conc_t<L1, R1> expr) {
+    template<class L, class E, internal::satisfies<std::is_base_of, internal::conc_string, E> = true>
+    internal::conc_t<L, E> operator||(L l, E expr) {
         return {std::move(l), std::move(expr)};
     }
 
diff --git a/tests/operators/arithmetic_operators.cpp b/tests/operators/arithmetic_operators.cpp
index c2eb3c0a6..909cdd13c 100644
--- a/tests/operators/arithmetic_operators.cpp
+++ b/tests/operators/arithmetic_operators.cpp
@@ -51,7 +51,7 @@ TEST_CASE("Arithmetic operators") {
             REQUIRE(row == name + suffix);
         }
     }
-    {  //  daisy-chaining ||
+    {  //  daisy-chaining ||, left
         std::string suffix = "ototo";
         auto rows = storage.select(c(&Object::name) || suffix || ".");
         for(size_t i = 0; i < rows.size(); ++i) {
@@ -60,6 +60,15 @@ TEST_CASE("Arithmetic operators") {
             REQUIRE(row == name + suffix + ".");
         }
     }
+    {  //  daisy-chaining ||, right
+        std::string prefix = "ototo";
+        auto rows = storage.select(prefix || (c(&Object::name) || "."));
+        for(size_t i = 0; i < rows.size(); ++i) {
+            auto& row = rows[i];
+            auto& name = names[i];
+            REQUIRE(row == prefix + name + ".");
+        }
+    }
     {  //  ||
         std::string suffix = "ototo";
         auto rows = storage.select(conc(&Object::name, suffix));

From 852e5723c7ddcc61ebd55b94b62be3edf1498c47 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 28 Jan 2023 09:52:26 +0200
Subject: [PATCH 084/161] Trying to fix compiler errors with clang

---
 dev/alias.h                     | 1 +
 include/sqlite_orm/sqlite_orm.h | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/dev/alias.h b/dev/alias.h
index fd0b08ae2..3f8da454e 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -9,6 +9,7 @@
 
 #include "functional/cxx_universal.h"
 #include "functional/cxx_type_traits_polyfill.h"
+#include "type_traits.h"
 
 namespace sqlite_orm {
 
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 2c1af90ac..3f782bbdb 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4172,6 +4172,8 @@ namespace sqlite_orm {
 
 // #include "functional/cxx_type_traits_polyfill.h"
 
+// #include "type_traits.h"
+
 namespace sqlite_orm {
 
     /**

From f65156e8ebd148964e7dcd4e532515e58a9b8bf8 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 28 Jan 2023 20:39:38 +0200
Subject: [PATCH 085/161] Corrected availability of `is_cte_alias_v`

---
 dev/alias.h                     | 6 ++++--
 include/sqlite_orm/sqlite_orm.h | 6 ++++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 3f8da454e..d9a686dba 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -43,14 +43,17 @@ namespace sqlite_orm {
         template<class A>
         using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
 
-#ifdef SQLITE_ORM_WITH_CTE
         /**
          *  A CTE alias is a specialization of a table alias, which is both, a storage lookup type (mapping type) and an alias.
          */
         template<class A>
         SQLITE_ORM_INLINE_VAR constexpr bool is_cte_alias_v =
+#ifdef SQLITE_ORM_WITH_CTE
             polyfill::conjunction_v<std::is_base_of<alias_tag, A>,
                                     std::is_same<polyfill::detected_t<type_t, A>, std::remove_const_t<A>>>;
+#else
+            false;
+#endif
 
         template<class A>
         using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
@@ -76,7 +79,6 @@ namespace sqlite_orm {
         consteval auto to_alias(std::index_sequence<Idx...>) {
             return Alias<t.id[Idx]...>{};
         }
-#endif
 #endif
     }
 
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 3f782bbdb..83e1c1cb9 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4206,14 +4206,17 @@ namespace sqlite_orm {
         template<class A>
         using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
 
-#ifdef SQLITE_ORM_WITH_CTE
         /**
          *  A CTE alias is a specialization of a table alias, which is both, a storage lookup type (mapping type) and an alias.
          */
         template<class A>
         SQLITE_ORM_INLINE_VAR constexpr bool is_cte_alias_v =
+#ifdef SQLITE_ORM_WITH_CTE
             polyfill::conjunction_v<std::is_base_of<alias_tag, A>,
                                     std::is_same<polyfill::detected_t<type_t, A>, std::remove_const_t<A>>>;
+#else
+            false;
+#endif
 
         template<class A>
         using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
@@ -4239,7 +4242,6 @@ namespace sqlite_orm {
         consteval auto to_alias(std::index_sequence<Idx...>) {
             return Alias<t.id[Idx]...>{};
         }
-#endif
 #endif
     }
 

From 46cf220340edf45ed8b49daad2de3b01e85ac515 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 30 Jan 2023 14:08:30 +0200
Subject: [PATCH 086/161] Aliased columns mapped into a CTE

Includes
* Split alias traits and column pointer into separate header files
* UTs for AST iteration of aliased columns
* UTs for the table name collector
---
 dev/alias.h                                   | 154 +++---
 dev/alias_traits.h                            |  72 +++
 dev/ast_iterator.h                            |  11 +-
 dev/column_expression.h                       |   7 +-
 dev/column_pointer.h                          | 153 ++++++
 dev/column_result.h                           |   4 +-
 dev/mapped_type_proxy.h                       |   2 +-
 dev/select_constraints.h                      | 150 +-----
 dev/table_name_collector.h                    |   8 +-
 examples/common_table_expressions.cpp         |  22 +-
 include/sqlite_orm/sqlite_orm.h               | 481 +++++++++++-------
 tests/CMakeLists.txt                          |   1 +
 tests/ast_iterator_tests.cpp                  | 123 +++--
 .../column_names.cpp                          |  34 ++
 .../select_constraints.cpp                    |  42 +-
 tests/static_tests/alias.cpp                  |   7 +
 tests/static_tests/column_expression_type.cpp |  68 ++-
 tests/static_tests/column_result_t.cpp        | 152 +++---
 tests/table_name_collector.cpp                |  91 ++++
 19 files changed, 1029 insertions(+), 553 deletions(-)
 create mode 100644 dev/alias_traits.h
 create mode 100644 dev/column_pointer.h
 create mode 100644 tests/table_name_collector.cpp

diff --git a/dev/alias.h b/dev/alias.h
index d9a686dba..cd1e15065 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -10,56 +10,15 @@
 #include "functional/cxx_universal.h"
 #include "functional/cxx_type_traits_polyfill.h"
 #include "type_traits.h"
+#include "alias_traits.h"
+#include "column_pointer.h"
 
 namespace sqlite_orm {
 
-    /**
-     *  This is base class for every class which is used as a custom table alias, column alias or expression alias.
-     *  For more information please look through self_join.cpp example
-     */
-    struct alias_tag {};
-
     namespace internal {
 
-        template<class A>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_alias_v = std::is_base_of<alias_tag, A>::value;
-
-        template<class A>
-        using is_alias = polyfill::bool_constant<is_alias_v<A>>;
-
-        /*
-         *  Note: Currently, there is no distinguishing property of a column alias other than that it is derived from "alias_tag".
-         */
-        template<class A>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_column_alias_v = is_alias_v<A>;
-
-        template<class A>
-        using is_column_alias = is_alias<A>;
-
-        template<class A>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_table_alias_v =
-            polyfill::conjunction_v<is_alias<A>, polyfill::is_detected<type_t, A>>;
-
-        template<class A>
-        using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
-
-        /**
-         *  A CTE alias is a specialization of a table alias, which is both, a storage lookup type (mapping type) and an alias.
-         */
-        template<class A>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_cte_alias_v =
-#ifdef SQLITE_ORM_WITH_CTE
-            polyfill::conjunction_v<std::is_base_of<alias_tag, A>,
-                                    std::is_same<polyfill::detected_t<type_t, A>, std::remove_const_t<A>>>;
-#else
-            false;
-#endif
-
-        template<class A>
-        using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
-
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
-        /*  
+        /*
          *  Helper class to facilitate user-defined string literal operator template
          */
         template<size_t N>
@@ -80,9 +39,6 @@ namespace sqlite_orm {
             return Alias<t.id[Idx]...>{};
         }
 #endif
-    }
-
-    namespace internal {
 
         /**
          *  This is a common built-in class used for custom single character table aliases.
@@ -171,15 +127,6 @@ namespace sqlite_orm {
             }
         };
 
-        template<class T>
-        struct alias_holder {
-            using type = T;
-
-            alias_holder() = default;
-            // CTE feature needs it to implicitly convert a column alias to an alias_holder; see `cte()` factory function
-            alias_holder(const T&) noexcept {}
-        };
-
 #ifdef SQLITE_ORM_WITH_CTE
         template<size_t n, char... C>
         SQLITE_ORM_CONSTEVAL auto n_to_colalias() {
@@ -202,19 +149,68 @@ namespace sqlite_orm {
      *  @return column with table alias attached. Place it instead of a column statement in case you need to specify a
      *  column with table alias prefix like 'a.column'. For more information please look through self_join.cpp example
      */
-    template<class A, class C, internal::satisfies<internal::is_table_alias, A> = true>
+    template<class A,
+             class C,
+             std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<A>,
+                                                      polyfill::negation<internal::is_cte_alias<internal::type_t<A>>>>,
+                              bool> = true>
     internal::alias_column_t<A, C> alias_column(C c) {
-        static_assert(internal::is_cte_alias_v<internal::type_t<A>> || std::is_member_pointer<C>::value,
-                      "alias_column argument must be mapped to a storage");
+        using table_type = internal::type_t<A>;
+        static_assert(std::is_same<internal::table_type_of_t<C>, table_type>::value,
+                      "Column must be from aliased table");
         return {c};
     }
 
+#ifdef SQLITE_ORM_WITH_CTE
+    namespace internal {
+        template<class T, class F>
+        struct column_pointer;
+    }
+
+    template<class A,
+             class C,
+             std::enable_if_t<
+                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_alias<internal::type_t<A>>>,
+                 bool> = true>
+    auto alias_column(C c) {
+        using cte_alias_t = internal::type_t<A>;
+        if constexpr(polyfill::is_specialization_of_v<C, internal::column_pointer>) {
+            static_assert(std::is_same<internal::table_type_of_t<C>, cte_alias_t>::value,
+                          "Column pointer must match aliased CTE");
+            return internal::alias_column_t<A, C>{c};
+        } else {
+            auto cp = column<cte_alias_t>(c);
+            return internal::alias_column_t<A, decltype(cp)>{cp};
+        }
+    }
+
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
-    template<auto als, class C, internal::satisfies<internal::is_table_alias, decltype(als)> = true>
-    internal::alias_column_t<decltype(als), C> alias_column(C c) {
-        static_assert(internal::is_cte_alias_v<internal::type_t<decltype(als)>> || std::is_member_pointer<C>::value,
-                      "alias_column argument must be mapped to a storage");
-        return {c};
+    template<auto als,
+             class C,
+             std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<decltype(als)>,
+                                                      internal::is_cte_alias<internal::type_t<decltype(als)>>>,
+                              bool> = true>
+    auto alias_column(C c) {
+        using A = std::remove_const_t<decltype(als)>;
+        using cte_alias_t = internal::type_t<A>;
+        if constexpr(polyfill::is_specialization_of_v<C, internal::column_pointer>) {
+            static_assert(std::is_same<internal::table_type_of_t<C>, cte_alias_t>::value,
+                          "Column pointer must match aliased CTE");
+            return internal::alias_column_t<A, C>{c};
+        } else {
+            auto cp = column<cte_alias_t>(c);
+            return internal::alias_column_t<A, decltype(cp)>{cp};
+        }
+    }
+#endif
+
+    template<class A,
+             class F,
+             std::enable_if_t<
+                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_alias<internal::type_t<A>>>,
+                 bool> = true>
+    constexpr auto operator->*(const A& /*tableAlias*/, F field) {
+        return alias_column<A>(std::move(field));
     }
 #endif
 
@@ -314,6 +310,36 @@ namespace sqlite_orm {
     template<class T>
     using alias_z = internal::table_alias<T, 'z'>;
 
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_WITH_CTE
+    namespace internal {
+        template<char A, char... C>
+        struct table_alias_builder {
+            static_assert(sizeof...(C) == 0 && ((A >= 'A' && 'Z' <= A) || (A >= 'a' && 'z' <= A)),
+                          "Table alias identifiers shall consist of a single alphabetic character, in order "
+                          "to evade clashes with the built-in CTE aliases.");
+
+            template<class T>
+            [[nodiscard]] consteval internal::table_alias<T, A, C...> operator()(T t) const {
+                return {};
+            }
+        };
+    }
+
+    /** @short Create aliased CTEs, e.g. `constexpr auto z_alias = alias_<'z'>("digits"_cte)`.
+     */
+    template<char A>
+    SQLITE_ORM_INLINE_VAR constexpr internal::table_alias_builder<A> alias_{};
+
+    /** @short Create aliased CTEs, e.g. `constexpr auto z_alias = "z"_alias("digits"_cte)`.
+     */
+    template<internal::string_identifier_template t>
+    [[nodiscard]] consteval auto operator"" _alias() {
+        return internal::to_alias<internal::table_alias_builder, t>(std::make_index_sequence<t.size()>{});
+    }
+#endif
+#endif
+
     using colalias_a = internal::column_alias<'a'>;
     using colalias_b = internal::column_alias<'b'>;
     using colalias_c = internal::column_alias<'c'>;
diff --git a/dev/alias_traits.h b/dev/alias_traits.h
new file mode 100644
index 000000000..8f8622a01
--- /dev/null
+++ b/dev/alias_traits.h
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <type_traits>  //  std::remove_const, std::is_base_of, std::is_same
+
+#include "functional/cxx_universal.h"
+#include "functional/cxx_type_traits_polyfill.h"
+
+namespace sqlite_orm {
+
+    /**
+     *  This is base class for every class which is used as a custom table alias, column alias or expression alias.
+     *  For more information please look through self_join.cpp example
+     */
+    struct alias_tag {};
+
+    namespace internal {
+
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_alias_v = std::is_base_of<alias_tag, A>::value;
+
+        template<class A>
+        using is_alias = polyfill::bool_constant<is_alias_v<A>>;
+
+        /*
+         *  Note: Currently, there is no distinguishing property of a column alias other than that it is derived from "alias_tag".
+         */
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_column_alias_v = is_alias_v<A>;
+
+        template<class A>
+        using is_column_alias = is_alias<A>;
+
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_any_table_alias_v =
+            polyfill::conjunction_v<is_alias<A>, polyfill::is_detected<type_t, A>>;
+
+        template<class A>
+        using is_any_table_alias = polyfill::bool_constant<is_any_table_alias_v<A>>;
+
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_table_alias_v = polyfill::conjunction_v<
+            std::is_base_of<alias_tag, A>,
+            polyfill::negation<std::is_same<polyfill::detected_t<type_t, A>, std::remove_const_t<A>>>>;
+
+        template<class A>
+        using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
+
+        /**
+         *  A CTE alias is a specialization of a table alias, which is both, a storage lookup type (mapping type) and an alias.
+         */
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_cte_alias_v =
+#ifdef SQLITE_ORM_WITH_CTE
+            polyfill::conjunction_v<std::is_base_of<alias_tag, A>,
+                                    std::is_same<polyfill::detected_t<type_t, A>, std::remove_const_t<A>>>;
+#else
+            false;
+#endif
+
+        template<class A>
+        using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
+
+        template<class T>
+        struct alias_holder {
+            using type = T;
+
+            alias_holder() = default;
+            // CTE feature needs it to implicitly convert a column alias to an alias_holder; see `cte()` factory function
+            alias_holder(const T&) noexcept {}
+        };
+    }
+}
diff --git a/dev/ast_iterator.h b/dev/ast_iterator.h
index 57bf0a8e4..3dce72cf6 100644
--- a/dev/ast_iterator.h
+++ b/dev/ast_iterator.h
@@ -6,6 +6,7 @@
 #include "tuple_helper/tuple_iteration.h"
 #include "type_traits.h"
 #include "conditions.h"
+#include "alias.h"
 #include "select_constraints.h"
 #include "operators.h"
 #include "core_functions.h"
@@ -29,8 +30,8 @@ namespace sqlite_orm {
          *  E.g. if we pass `where(is_equal(5, max(&User::id, 10))` then
          *  callable object will be called with 5, &User::id and 10.
          *  ast_iterator is used mostly in finding literals to be bound to
-         *  a statement. To use it just call `iterate_ast(object, callable);`
-         *  T is an ast element. E.g. where_t
+         *  a statement, and collecting table names.
+         *  To use it just call `iterate_ast(object, callable);` T is an ast element.
          */
         template<class T, class SFINAE = void>
         struct ast_iterator {
@@ -204,7 +205,7 @@ namespace sqlite_orm {
         };
 
         template<class With>
-        struct ast_iterator<With, std::enable_if_t<polyfill::is_specialization_of_v<With, with_t>>> {
+        struct ast_iterator<With, match_specialization_of<With, with_t>> {
             using node_type = With;
 
             template<class L>
@@ -679,7 +680,7 @@ namespace sqlite_orm {
         };
 
         /**
-         *  Column alias or literal
+         *  Column alias or literal: skipped
          */
         template<class T>
         struct ast_iterator<
@@ -693,7 +694,7 @@ namespace sqlite_orm {
         };
 
         /**
-         *  Column alias
+         *  Column alias: skipped
          */
         template<char... C>
         struct ast_iterator<column_alias<C...>, void> {
diff --git a/dev/column_expression.h b/dev/column_expression.h
index df9cb9d9f..c3cb192f1 100644
--- a/dev/column_expression.h
+++ b/dev/column_expression.h
@@ -56,11 +56,14 @@ namespace sqlite_orm {
         };
 
         /**
-         *  Resolve all columns of an object.
+         *  Resolve all columns of a mapped object or CTE.
          *  asterisk_t<O> -> tuple<ColExpr...>
          */
         template<class DBOs, class E>
-        struct column_expression_type<DBOs, asterisk_t<E>, match_if_not<is_table_alias, E>>
+        struct column_expression_type<
+            DBOs,
+            asterisk_t<E>,
+            std::enable_if_t<polyfill::disjunction_v<polyfill::negation<is_any_table_alias<E>>, is_cte_alias<E>>>>
             : storage_traits::storage_mapped_column_expressions<DBOs, E> {};
 
         template<class A>
diff --git a/dev/column_pointer.h b/dev/column_pointer.h
new file mode 100644
index 000000000..ea14533c4
--- /dev/null
+++ b/dev/column_pointer.h
@@ -0,0 +1,153 @@
+#pragma once
+
+#include <string>  //  std::string
+#include <utility>  //  std::move
+
+#include "conditions.h"
+#include "alias_traits.h"
+
+namespace sqlite_orm {
+    namespace internal {
+        /**
+         *  This class is used to store explicit mapped type T and its column descriptor (member pointer/getter/setter).
+         *  Is useful when mapped type is derived from other type and base class has members mapped to a storage.
+         */
+        template<class T, class F>
+        struct column_pointer {
+            using self = column_pointer<T, F>;
+            using type = T;
+            using field_type = F;
+
+            field_type field;
+
+            template<class R>
+            is_equal_t<self, R> operator==(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            is_not_equal_t<self, R> operator!=(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            lesser_than_t<self, R> operator<(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            lesser_or_equal_t<self, R> operator<=(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            greater_than_t<self, R> operator>(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            greater_or_equal_t<self, R> operator>=(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+        };
+
+        template<class O, class SFINAE = void>
+        struct column_pointer_builder {
+            using mapped_type = O;
+
+            /**
+             *  Explicitly refer to a column, used in contexts
+             *  where the automatic object mapping deduction needs to be overridden.
+             *
+             *  Example:
+             *  struct MyType : BaseType { ... };
+             *  storage.select(column<MyType>(&BaseType::id));
+             */
+            template<class F>
+            column_pointer<mapped_type, F> operator()(F field) const {
+                return {std::move(field)};
+            }
+        };
+
+#ifdef SQLITE_ORM_WITH_CTE
+        template<class A>
+        struct column_pointer_builder<A, match_if<is_alias, A>> {
+            static_assert(is_cte_alias_v<A>, "`A' must be a mapped table alias");
+
+            using mapped_type = A;
+
+            /**
+             *  Explicitly refer to a column alias mapped into a CTE or subquery.
+             *
+             *  Example:
+             *  struct Object { ... };
+             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
+             */
+            template<class F, satisfies_not<is_column_alias, F> = true>
+            constexpr column_pointer<mapped_type, F> operator()(F field) const {
+                return {std::move(field)};
+            }
+
+            /**
+             *  Explicitly refer to a column alias mapped into a CTE or subquery.
+             *
+             *  Example:
+             *  struct Object { ... };
+             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
+             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
+             *  storage.with(cte<cte_1>(colalias_a{})(select(&Object::id)), select(column<cte_1>(colalias_a{})));
+             */
+            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
+            constexpr column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
+                return {{}};
+            }
+
+            /**
+             *  Explicitly refer to a column alias mapped into a CTE or subquery.
+             *
+             *  Example:
+             *  struct Object { ... };
+             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
+             */
+            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
+            constexpr column_pointer<mapped_type, alias_holder<ColAlias>>
+            operator()(const alias_holder<ColAlias>&) const {
+                return {{}};
+            }
+        };
+#endif
+
+    }
+
+    /**
+     *  Explicit column references.
+     */
+    template<class Lookup>
+    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer_builder<Lookup> column{};
+
+    /**
+     *  Explicitly refer to a column mapped into a CTE or subquery.
+     *
+     *  Example:
+     *  struct Object { ... };
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*1_colalias));
+     */
+    template<class A, class F, internal::satisfies<internal::is_cte_alias, A> = true>
+    constexpr auto operator->*(const A& /*cteAlias*/, F field) {
+        return column<A>(std::move(field));
+    }
+
+    /**
+     *  Explicitly refer to an aliased column mapped into a CTE or subquery.
+     *
+     *  Use it like this:
+     *  struct Object { ... };
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
+     */
+    template<class A, class F, internal::satisfies<internal::is_cte_alias, A> = true>
+    constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
+        return column<A>(std::move(field));
+    }
+}
\ No newline at end of file
diff --git a/dev/column_result.h b/dev/column_result.h
index 4aca6d3f0..d30ecab77 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -267,11 +267,11 @@ namespace sqlite_orm {
         struct column_result_t<DBOs, as_t<T, E>, void> : column_result_t<DBOs, std::decay_t<E>> {};
 
         template<class DBOs, class T>
-        struct column_result_t<DBOs, asterisk_t<T>, match_if_not<is_table_alias, T>>
+        struct column_result_t<DBOs, asterisk_t<T>, match_if_not<is_any_table_alias, T>>
             : storage_traits::storage_mapped_columns<DBOs, T> {};
 
         template<class DBOs, class A>
-        struct column_result_t<DBOs, asterisk_t<A>, match_if<is_table_alias, A>>
+        struct column_result_t<DBOs, asterisk_t<A>, match_if<is_any_table_alias, A>>
             : storage_traits::storage_mapped_columns<DBOs, type_t<A>> {};
 
         template<class DBOs, class T>
diff --git a/dev/mapped_type_proxy.h b/dev/mapped_type_proxy.h
index 4dc68b4b1..17d97f02d 100644
--- a/dev/mapped_type_proxy.h
+++ b/dev/mapped_type_proxy.h
@@ -17,7 +17,7 @@ namespace sqlite_orm {
         struct mapped_type_proxy : std::remove_const<T> {};
 
         template<class T>
-        struct mapped_type_proxy<T, match_if<is_table_alias, T>> {
+        struct mapped_type_proxy<T, match_if<is_any_table_alias, T>> {
             using type = std::remove_const_t<type_t<T>>;
         };
 
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 7d187ed95..ae2661578 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <string>  //  std::string
-#include <utility>  //  std::declval
+#include <utility>  //  std::move
 #include <tuple>  //  std::tuple, std::get, std::tuple_size
 #include "functional/cxx_optional.h"
 
@@ -14,6 +14,7 @@
 #include "ast/where.h"
 #include "ast/group_by.h"
 #include "core_functions.h"
+#include "column_pointer.h"
 #include "alias.h"
 
 namespace sqlite_orm {
@@ -89,115 +90,6 @@ namespace sqlite_orm {
             assigns_type assigns;
         };
 
-        /**
-         *  This class is used to store explicit mapped type T and its column descriptor (member pointer/getter/setter).
-         *  Is useful when mapped type is derived from other type and base class has members mapped to a storage.
-         */
-        template<class T, class F>
-        struct column_pointer {
-            using self = column_pointer<T, F>;
-            using type = T;
-            using field_type = F;
-
-            field_type field;
-
-            template<class R>
-            internal::is_equal_t<self, R> operator==(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::is_not_equal_t<self, R> operator!=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::lesser_than_t<self, R> operator<(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::lesser_or_equal_t<self, R> operator<=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::greater_than_t<self, R> operator>(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::greater_or_equal_t<self, R> operator>=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-        };
-
-        template<class O, class SFINAE = void>
-        struct column_pointer_builder {
-            using mapped_type = O;
-
-            /**
-             *  Explicitly refer to a column, used in contexts
-             *  where the automatic object mapping deduction needs to be overridden.
-             *  
-             *  Example:
-             *  struct MyType : BaseType { ... };
-             *  storage.select(column<MyType>(&BaseType::id));
-             */
-            template<class F>
-            column_pointer<mapped_type, F> operator()(F field) const {
-                return {std::move(field)};
-            }
-        };
-
-#ifdef SQLITE_ORM_WITH_CTE
-        template<class A>
-        struct column_pointer_builder<A, match_if<is_alias, A>> {
-            static_assert(is_cte_alias_v<A>, "`A' must be a mapped table alias");
-
-            using mapped_type = A;
-
-            /**
-             *  Explicitly refer to a column alias mapped into a CTE or subquery.
-             *  
-             *  Example:
-             *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
-             */
-            template<class F, satisfies_not<is_column_alias, F> = true>
-            constexpr column_pointer<mapped_type, F> operator()(F field) const {
-                return {std::move(field)};
-            }
-
-            /** 
-             *  Explicitly refer to a column alias mapped into a CTE or subquery.
-             *  
-             *  Example:
-             *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
-             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
-             *  storage.with(cte<cte_1>(colalias_a{})(select(&Object::id)), select(column<cte_1>(colalias_a{})));
-             */
-            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
-            constexpr column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
-                return {{}};
-            }
-
-            /**
-             *  Explicitly refer to a column alias mapped into a CTE or subquery.
-             *
-             *  Example:
-             *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
-             */
-            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
-            constexpr column_pointer<mapped_type, alias_holder<ColAlias>>
-            operator()(const alias_holder<ColAlias>&) const {
-                return {{}};
-            }
-        };
-#endif
-
         /**
          *  Subselect object type.
          */
@@ -575,38 +467,6 @@ namespace sqlite_orm {
         return {std::make_tuple<Args...>(std::forward<Args>(args)...)};
     }
 
-    /** 
-     *  Explicit column references.
-     */
-    template<class Lookup>
-    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer_builder<Lookup> column{};
-
-    /**
-     *  Explicitly refer to a column mapped into a CTE or subquery.
-     *  
-     *  Example:
-     *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*&Object::id));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*1_colalias));
-     */
-    template<class A, class F, internal::satisfies<internal::is_table_alias, A> = true>
-    constexpr auto operator->*(const A& /*tableAlias*/, F field) {
-        return column<A>(std::move(field));
-    }
-
-    /**
-     *  Explicitly refer to an aliased column mapped into a CTE or subquery.
-     *  
-     *  Use it like this:
-     *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
-     */
-    template<class A, class F, internal::satisfies<internal::is_table_alias, A> = true>
-    constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
-        return column<A>(std::move(field));
-    }
-
     /**
      *  Public function for subselect query. Is useful in UNION queries.
      */
@@ -748,9 +608,9 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
-    template<auto T, internal::satisfies<internal::is_table_alias, decltype(T)> = true>
-    internal::asterisk_t<decltype(T)> asterisk() {
-        return {};
+    template<auto A, internal::satisfies<internal::is_any_table_alias, decltype(A)> = true>
+    internal::asterisk_t<decltype(A)> asterisk(bool definedOrder = false) {
+        return {definedOrder};
     }
 #endif
 
diff --git a/dev/table_name_collector.h b/dev/table_name_collector.h
index 3e540af63..b961a446f 100644
--- a/dev/table_name_collector.h
+++ b/dev/table_name_collector.h
@@ -43,11 +43,11 @@ namespace sqlite_orm {
                 table_names.emplace(move(tableName), alias_extractor<T>::as_alias());
             }
 
-            template<class T, class C>
-            void operator()(const alias_column_t<T, C>&) const {
+            template<class A, class C>
+            void operator()(const alias_column_t<A, C>&) const {
                 // note: instead of accessing the column, we are interested in the type the column is aliased into
-                auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<T>));
-                table_names.emplace(move(tableName), alias_extractor<T>::as_alias());
+                auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<A>));
+                table_names.emplace(move(tableName), alias_extractor<A>::as_alias());
             }
 
             template<class T>
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 8d8d734a7..13f0d5d0a 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -4,7 +4,10 @@
 
 #include <sqlite_orm/sqlite_orm.h>
 #ifdef SQLITE_ORM_WITH_CTE
+#define ENABLE_THIS_EXAMPLE
+#endif
 
+#ifdef ENABLE_THIS_EXAMPLE
 #ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
 #include <optional>
 #endif
@@ -675,8 +678,8 @@ void sudoku() {
 
     constexpr auto input = "input"_cte;
     constexpr auto digits = "digits"_cte;
-    using z_alias = alias_z<decltype(digits)>;
-    constexpr auto x = "_x"_cte;
+    constexpr auto z_alias = "z"_alias(digits);
+    constexpr auto x = "x_"_cte;
     constexpr auto sud = "sud"_col;
     constexpr auto z = "z"_col;
     constexpr auto lp = "lp"_col;
@@ -688,21 +691,19 @@ void sudoku() {
                 select("53..7....6..195....98....6.8...6...34..8.3..17...2...6.6....28....419..5....8..79")),
             cte<digits>(z, lp)(union_all(
                 select(columns("1", 1)),
-                select(columns(cast<std::string>(digits->*lp + c(1)), digits->*lp + c(1)), where(digits->*lp < 9)))),
+                select(columns(cast<string>(digits->*lp + c(1)), digits->*lp + c(1)), where(digits->*lp < 9)))),
             cte<x>(s, ind)(union_all(
                 select(columns(input->*sud, instr(input->*sud, "."))),
                 select(columns(substr(x->*s, 1, x->*ind - c(1)) || c(z) || substr(x->*s, x->*ind + c(1)),
                                instr(substr(x->*s, 1, x->*ind - c(1)) || c(z) || substr(x->*s, x->*ind + c(1)), ".")),
-                       from<x, z_alias{}>(),
                        where(x->*ind > 0 and
                              not exists(select(
                                  1 >>= lp,
                                  from<digits>(),
-                                 where(is_equal(alias_column<z_alias>(z),
-                                                substr(x->*s, ((x->*ind - c(1)) / 9) * 9 + lp, 1)) or
-                                       is_equal(alias_column<z_alias>(z),
+                                 where(is_equal(z_alias->*z, substr(x->*s, ((x->*ind - c(1)) / 9) * 9 + lp, 1)) or
+                                       is_equal(z_alias->*z,
                                                 substr(x->*s, ((x->*ind - c(1)) % 9) + (lp - c(1)) * 9 + 1, 1)) or
-                                       is_equal(alias_column<z_alias>(z),
+                                       is_equal(z_alias->*z,
                                                 substr(x->*s,
                                                        (((x->*ind - c(1)) / 3) % 3) * 3 + ((x->*ind - c(1)) / 27) * 27 +
                                                            lp + ((lp - c(1)) / 3) * 6,
@@ -817,8 +818,10 @@ void show_mapping_and_backreferencing() {
         auto stmt = storage.prepare(ast);
     }
 }
+#endif
 
 int main() {
+#ifdef ENABLE_THIS_EXAMPLE
     try {
         all_integers_between(1, 10);
         supervisor_chain();
@@ -832,8 +835,7 @@ int main() {
     } catch(const system_error& e) {
         cout << "[" << e.code() << "] " << e.what();
     }
+#endif
 
     return 0;
 }
-
-#endif
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 83e1c1cb9..871cd9520 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4174,6 +4174,14 @@ namespace sqlite_orm {
 
 // #include "type_traits.h"
 
+// #include "alias_traits.h"
+
+#include <type_traits>  //  std::remove_const, std::is_base_of, std::is_same
+
+// #include "functional/cxx_universal.h"
+
+// #include "functional/cxx_type_traits_polyfill.h"
+
 namespace sqlite_orm {
 
     /**
@@ -4200,9 +4208,17 @@ namespace sqlite_orm {
         using is_column_alias = is_alias<A>;
 
         template<class A>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_table_alias_v =
+        SQLITE_ORM_INLINE_VAR constexpr bool is_any_table_alias_v =
             polyfill::conjunction_v<is_alias<A>, polyfill::is_detected<type_t, A>>;
 
+        template<class A>
+        using is_any_table_alias = polyfill::bool_constant<is_any_table_alias_v<A>>;
+
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_table_alias_v = polyfill::conjunction_v<
+            std::is_base_of<alias_tag, A>,
+            polyfill::negation<std::is_same<polyfill::detected_t<type_t, A>, std::remove_const_t<A>>>>;
+
         template<class A>
         using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
 
@@ -4221,8 +4237,178 @@ namespace sqlite_orm {
         template<class A>
         using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
 
+        template<class T>
+        struct alias_holder {
+            using type = T;
+
+            alias_holder() = default;
+            // CTE feature needs it to implicitly convert a column alias to an alias_holder; see `cte()` factory function
+            alias_holder(const T&) noexcept {}
+        };
+    }
+}
+
+// #include "column_pointer.h"
+
+#include <string>  //  std::string
+#include <utility>  //  std::move
+
+// #include "conditions.h"
+
+// #include "alias_traits.h"
+
+namespace sqlite_orm {
+    namespace internal {
+        /**
+         *  This class is used to store explicit mapped type T and its column descriptor (member pointer/getter/setter).
+         *  Is useful when mapped type is derived from other type and base class has members mapped to a storage.
+         */
+        template<class T, class F>
+        struct column_pointer {
+            using self = column_pointer<T, F>;
+            using type = T;
+            using field_type = F;
+
+            field_type field;
+
+            template<class R>
+            is_equal_t<self, R> operator==(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            is_not_equal_t<self, R> operator!=(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            lesser_than_t<self, R> operator<(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            lesser_or_equal_t<self, R> operator<=(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            greater_than_t<self, R> operator>(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+
+            template<class R>
+            greater_or_equal_t<self, R> operator>=(R rhs) const {
+                return {*this, std::move(rhs)};
+            }
+        };
+
+        template<class O, class SFINAE = void>
+        struct column_pointer_builder {
+            using mapped_type = O;
+
+            /**
+             *  Explicitly refer to a column, used in contexts
+             *  where the automatic object mapping deduction needs to be overridden.
+             *
+             *  Example:
+             *  struct MyType : BaseType { ... };
+             *  storage.select(column<MyType>(&BaseType::id));
+             */
+            template<class F>
+            column_pointer<mapped_type, F> operator()(F field) const {
+                return {std::move(field)};
+            }
+        };
+
+#ifdef SQLITE_ORM_WITH_CTE
+        template<class A>
+        struct column_pointer_builder<A, match_if<is_alias, A>> {
+            static_assert(is_cte_alias_v<A>, "`A' must be a mapped table alias");
+
+            using mapped_type = A;
+
+            /**
+             *  Explicitly refer to a column alias mapped into a CTE or subquery.
+             *
+             *  Example:
+             *  struct Object { ... };
+             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
+             */
+            template<class F, satisfies_not<is_column_alias, F> = true>
+            constexpr column_pointer<mapped_type, F> operator()(F field) const {
+                return {std::move(field)};
+            }
+
+            /**
+             *  Explicitly refer to a column alias mapped into a CTE or subquery.
+             *
+             *  Example:
+             *  struct Object { ... };
+             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
+             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
+             *  storage.with(cte<cte_1>(colalias_a{})(select(&Object::id)), select(column<cte_1>(colalias_a{})));
+             */
+            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
+            constexpr column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
+                return {{}};
+            }
+
+            /**
+             *  Explicitly refer to a column alias mapped into a CTE or subquery.
+             *
+             *  Example:
+             *  struct Object { ... };
+             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
+             */
+            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
+            constexpr column_pointer<mapped_type, alias_holder<ColAlias>>
+            operator()(const alias_holder<ColAlias>&) const {
+                return {{}};
+            }
+        };
+#endif
+
+    }
+
+    /**
+     *  Explicit column references.
+     */
+    template<class Lookup>
+    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer_builder<Lookup> column{};
+
+    /**
+     *  Explicitly refer to a column mapped into a CTE or subquery.
+     *
+     *  Example:
+     *  struct Object { ... };
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*1_colalias));
+     */
+    template<class A, class F, internal::satisfies<internal::is_cte_alias, A> = true>
+    constexpr auto operator->*(const A& /*cteAlias*/, F field) {
+        return column<A>(std::move(field));
+    }
+
+    /**
+     *  Explicitly refer to an aliased column mapped into a CTE or subquery.
+     *
+     *  Use it like this:
+     *  struct Object { ... };
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
+     */
+    template<class A, class F, internal::satisfies<internal::is_cte_alias, A> = true>
+    constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
+        return column<A>(std::move(field));
+    }
+}
+
+namespace sqlite_orm {
+
+    namespace internal {
+
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
-        /*  
+        /*
          *  Helper class to facilitate user-defined string literal operator template
          */
         template<size_t N>
@@ -4243,9 +4429,6 @@ namespace sqlite_orm {
             return Alias<t.id[Idx]...>{};
         }
 #endif
-    }
-
-    namespace internal {
 
         /**
          *  This is a common built-in class used for custom single character table aliases.
@@ -4334,15 +4517,6 @@ namespace sqlite_orm {
             }
         };
 
-        template<class T>
-        struct alias_holder {
-            using type = T;
-
-            alias_holder() = default;
-            // CTE feature needs it to implicitly convert a column alias to an alias_holder; see `cte()` factory function
-            alias_holder(const T&) noexcept {}
-        };
-
 #ifdef SQLITE_ORM_WITH_CTE
         template<size_t n, char... C>
         SQLITE_ORM_CONSTEVAL auto n_to_colalias() {
@@ -4365,19 +4539,68 @@ namespace sqlite_orm {
      *  @return column with table alias attached. Place it instead of a column statement in case you need to specify a
      *  column with table alias prefix like 'a.column'. For more information please look through self_join.cpp example
      */
-    template<class A, class C, internal::satisfies<internal::is_table_alias, A> = true>
+    template<class A,
+             class C,
+             std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<A>,
+                                                      polyfill::negation<internal::is_cte_alias<internal::type_t<A>>>>,
+                              bool> = true>
     internal::alias_column_t<A, C> alias_column(C c) {
-        static_assert(internal::is_cte_alias_v<internal::type_t<A>> || std::is_member_pointer<C>::value,
-                      "alias_column argument must be mapped to a storage");
+        using table_type = internal::type_t<A>;
+        static_assert(std::is_same<internal::table_type_of_t<C>, table_type>::value,
+                      "Column must be from aliased table");
         return {c};
     }
 
+#ifdef SQLITE_ORM_WITH_CTE
+    namespace internal {
+        template<class T, class F>
+        struct column_pointer;
+    }
+
+    template<class A,
+             class C,
+             std::enable_if_t<
+                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_alias<internal::type_t<A>>>,
+                 bool> = true>
+    auto alias_column(C c) {
+        using cte_alias_t = internal::type_t<A>;
+        if constexpr(polyfill::is_specialization_of_v<C, internal::column_pointer>) {
+            static_assert(std::is_same<internal::table_type_of_t<C>, cte_alias_t>::value,
+                          "Column pointer must match aliased CTE");
+            return internal::alias_column_t<A, C>{c};
+        } else {
+            auto cp = column<cte_alias_t>(c);
+            return internal::alias_column_t<A, decltype(cp)>{cp};
+        }
+    }
+
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
-    template<auto als, class C, internal::satisfies<internal::is_table_alias, decltype(als)> = true>
-    internal::alias_column_t<decltype(als), C> alias_column(C c) {
-        static_assert(internal::is_cte_alias_v<internal::type_t<decltype(als)>> || std::is_member_pointer<C>::value,
-                      "alias_column argument must be mapped to a storage");
-        return {c};
+    template<auto als,
+             class C,
+             std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<decltype(als)>,
+                                                      internal::is_cte_alias<internal::type_t<decltype(als)>>>,
+                              bool> = true>
+    auto alias_column(C c) {
+        using A = std::remove_const_t<decltype(als)>;
+        using cte_alias_t = internal::type_t<A>;
+        if constexpr(polyfill::is_specialization_of_v<C, internal::column_pointer>) {
+            static_assert(std::is_same<internal::table_type_of_t<C>, cte_alias_t>::value,
+                          "Column pointer must match aliased CTE");
+            return internal::alias_column_t<A, C>{c};
+        } else {
+            auto cp = column<cte_alias_t>(c);
+            return internal::alias_column_t<A, decltype(cp)>{cp};
+        }
+    }
+#endif
+
+    template<class A,
+             class F,
+             std::enable_if_t<
+                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_alias<internal::type_t<A>>>,
+                 bool> = true>
+    constexpr auto operator->*(const A& /*tableAlias*/, F field) {
+        return alias_column<A>(std::move(field));
     }
 #endif
 
@@ -4477,6 +4700,36 @@ namespace sqlite_orm {
     template<class T>
     using alias_z = internal::table_alias<T, 'z'>;
 
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_WITH_CTE
+    namespace internal {
+        template<char A, char... C>
+        struct table_alias_builder {
+            static_assert(sizeof...(C) == 0 && ((A >= 'A' && 'Z' <= A) || (A >= 'a' && 'z' <= A)),
+                          "Table alias identifiers shall consist of a single alphabetic character, in order "
+                          "to evade clashes with the built-in CTE aliases.");
+
+            template<class T>
+            [[nodiscard]] consteval internal::table_alias<T, A, C...> operator()(T t) const {
+                return {};
+            }
+        };
+    }
+
+    /** @short Create aliased CTEs, e.g. `constexpr auto z_alias = alias_<'z'>("digits"_cte)`.
+     */
+    template<char A>
+    SQLITE_ORM_INLINE_VAR constexpr internal::table_alias_builder<A> alias_{};
+
+    /** @short Create aliased CTEs, e.g. `constexpr auto z_alias = "z"_alias("digits"_cte)`.
+     */
+    template<internal::string_identifier_template t>
+    [[nodiscard]] consteval auto operator"" _alias() {
+        return internal::to_alias<internal::table_alias_builder, t>(std::make_index_sequence<t.size()>{});
+    }
+#endif
+#endif
+
     using colalias_a = internal::column_alias<'a'>;
     using colalias_b = internal::column_alias<'b'>;
     using colalias_c = internal::column_alias<'c'>;
@@ -6793,7 +7046,7 @@ namespace sqlite_orm {
 #pragma once
 
 #include <string>  //  std::string
-#include <utility>  //  std::declval
+#include <utility>  //  std::move
 #include <tuple>  //  std::tuple, std::get, std::tuple_size
 // #include "functional/cxx_optional.h"
 
@@ -6967,6 +7220,8 @@ namespace sqlite_orm {
 
 // #include "core_functions.h"
 
+// #include "column_pointer.h"
+
 // #include "alias.h"
 
 namespace sqlite_orm {
@@ -7042,115 +7297,6 @@ namespace sqlite_orm {
             assigns_type assigns;
         };
 
-        /**
-         *  This class is used to store explicit mapped type T and its column descriptor (member pointer/getter/setter).
-         *  Is useful when mapped type is derived from other type and base class has members mapped to a storage.
-         */
-        template<class T, class F>
-        struct column_pointer {
-            using self = column_pointer<T, F>;
-            using type = T;
-            using field_type = F;
-
-            field_type field;
-
-            template<class R>
-            internal::is_equal_t<self, R> operator==(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::is_not_equal_t<self, R> operator!=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::lesser_than_t<self, R> operator<(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::lesser_or_equal_t<self, R> operator<=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::greater_than_t<self, R> operator>(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            internal::greater_or_equal_t<self, R> operator>=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-        };
-
-        template<class O, class SFINAE = void>
-        struct column_pointer_builder {
-            using mapped_type = O;
-
-            /**
-             *  Explicitly refer to a column, used in contexts
-             *  where the automatic object mapping deduction needs to be overridden.
-             *  
-             *  Example:
-             *  struct MyType : BaseType { ... };
-             *  storage.select(column<MyType>(&BaseType::id));
-             */
-            template<class F>
-            column_pointer<mapped_type, F> operator()(F field) const {
-                return {std::move(field)};
-            }
-        };
-
-#ifdef SQLITE_ORM_WITH_CTE
-        template<class A>
-        struct column_pointer_builder<A, match_if<is_alias, A>> {
-            static_assert(is_cte_alias_v<A>, "`A' must be a mapped table alias");
-
-            using mapped_type = A;
-
-            /**
-             *  Explicitly refer to a column alias mapped into a CTE or subquery.
-             *  
-             *  Example:
-             *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
-             */
-            template<class F, satisfies_not<is_column_alias, F> = true>
-            constexpr column_pointer<mapped_type, F> operator()(F field) const {
-                return {std::move(field)};
-            }
-
-            /** 
-             *  Explicitly refer to a column alias mapped into a CTE or subquery.
-             *  
-             *  Example:
-             *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
-             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
-             *  storage.with(cte<cte_1>(colalias_a{})(select(&Object::id)), select(column<cte_1>(colalias_a{})));
-             */
-            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
-            constexpr column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
-                return {{}};
-            }
-
-            /**
-             *  Explicitly refer to a column alias mapped into a CTE or subquery.
-             *
-             *  Example:
-             *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
-             */
-            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
-            constexpr column_pointer<mapped_type, alias_holder<ColAlias>>
-            operator()(const alias_holder<ColAlias>&) const {
-                return {{}};
-            }
-        };
-#endif
-
         /**
          *  Subselect object type.
          */
@@ -7528,38 +7674,6 @@ namespace sqlite_orm {
         return {std::make_tuple<Args...>(std::forward<Args>(args)...)};
     }
 
-    /** 
-     *  Explicit column references.
-     */
-    template<class Lookup>
-    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer_builder<Lookup> column{};
-
-    /**
-     *  Explicitly refer to a column mapped into a CTE or subquery.
-     *  
-     *  Example:
-     *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*&Object::id));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*1_colalias));
-     */
-    template<class A, class F, internal::satisfies<internal::is_table_alias, A> = true>
-    constexpr auto operator->*(const A& /*tableAlias*/, F field) {
-        return column<A>(std::move(field));
-    }
-
-    /**
-     *  Explicitly refer to an aliased column mapped into a CTE or subquery.
-     *  
-     *  Use it like this:
-     *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
-     */
-    template<class A, class F, internal::satisfies<internal::is_table_alias, A> = true>
-    constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
-        return column<A>(std::move(field));
-    }
-
     /**
      *  Public function for subselect query. Is useful in UNION queries.
      */
@@ -7701,9 +7815,9 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
-    template<auto T, internal::satisfies<internal::is_table_alias, decltype(T)> = true>
-    internal::asterisk_t<decltype(T)> asterisk() {
-        return {};
+    template<auto A, internal::satisfies<internal::is_any_table_alias, decltype(A)> = true>
+    internal::asterisk_t<decltype(A)> asterisk(bool definedOrder = false) {
+        return {definedOrder};
     }
 #endif
 
@@ -9726,7 +9840,7 @@ namespace sqlite_orm {
         struct mapped_type_proxy : std::remove_const<T> {};
 
         template<class T>
-        struct mapped_type_proxy<T, match_if<is_table_alias, T>> {
+        struct mapped_type_proxy<T, match_if<is_any_table_alias, T>> {
             using type = std::remove_const_t<type_t<T>>;
         };
 
@@ -10656,11 +10770,11 @@ namespace sqlite_orm {
         struct column_result_t<DBOs, as_t<T, E>, void> : column_result_t<DBOs, std::decay_t<E>> {};
 
         template<class DBOs, class T>
-        struct column_result_t<DBOs, asterisk_t<T>, match_if_not<is_table_alias, T>>
+        struct column_result_t<DBOs, asterisk_t<T>, match_if_not<is_any_table_alias, T>>
             : storage_traits::storage_mapped_columns<DBOs, T> {};
 
         template<class DBOs, class A>
-        struct column_result_t<DBOs, asterisk_t<A>, match_if<is_table_alias, A>>
+        struct column_result_t<DBOs, asterisk_t<A>, match_if<is_any_table_alias, A>>
             : storage_traits::storage_mapped_columns<DBOs, type_t<A>> {};
 
         template<class DBOs, class T>
@@ -11727,6 +11841,8 @@ namespace sqlite_orm {
 
 // #include "conditions.h"
 
+// #include "alias.h"
+
 // #include "select_constraints.h"
 
 // #include "operators.h"
@@ -12749,8 +12865,8 @@ namespace sqlite_orm {
          *  E.g. if we pass `where(is_equal(5, max(&User::id, 10))` then
          *  callable object will be called with 5, &User::id and 10.
          *  ast_iterator is used mostly in finding literals to be bound to
-         *  a statement. To use it just call `iterate_ast(object, callable);`
-         *  T is an ast element. E.g. where_t
+         *  a statement, and collecting table names.
+         *  To use it just call `iterate_ast(object, callable);` T is an ast element.
          */
         template<class T, class SFINAE = void>
         struct ast_iterator {
@@ -12924,7 +13040,7 @@ namespace sqlite_orm {
         };
 
         template<class With>
-        struct ast_iterator<With, std::enable_if_t<polyfill::is_specialization_of_v<With, with_t>>> {
+        struct ast_iterator<With, match_specialization_of<With, with_t>> {
             using node_type = With;
 
             template<class L>
@@ -13399,7 +13515,7 @@ namespace sqlite_orm {
         };
 
         /**
-         *  Column alias or literal
+         *  Column alias or literal: skipped
          */
         template<class T>
         struct ast_iterator<
@@ -13413,7 +13529,7 @@ namespace sqlite_orm {
         };
 
         /**
-         *  Column alias
+         *  Column alias: skipped
          */
         template<char... C>
         struct ast_iterator<column_alias<C...>, void> {
@@ -15684,11 +15800,11 @@ namespace sqlite_orm {
                 table_names.emplace(move(tableName), alias_extractor<T>::as_alias());
             }
 
-            template<class T, class C>
-            void operator()(const alias_column_t<T, C>&) const {
+            template<class A, class C>
+            void operator()(const alias_column_t<A, C>&) const {
                 // note: instead of accessing the column, we are interested in the type the column is aliased into
-                auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<T>));
-                table_names.emplace(move(tableName), alias_extractor<T>::as_alias());
+                auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<A>));
+                table_names.emplace(move(tableName), alias_extractor<A>::as_alias());
             }
 
             template<class T>
@@ -18361,11 +18477,14 @@ namespace sqlite_orm {
         };
 
         /**
-         *  Resolve all columns of an object.
+         *  Resolve all columns of a mapped object or CTE.
          *  asterisk_t<O> -> tuple<ColExpr...>
          */
         template<class DBOs, class E>
-        struct column_expression_type<DBOs, asterisk_t<E>, match_if_not<is_table_alias, E>>
+        struct column_expression_type<
+            DBOs,
+            asterisk_t<E>,
+            std::enable_if_t<polyfill::disjunction_v<polyfill::negation<is_any_table_alias<E>>, is_cte_alias<E>>>>
             : storage_traits::storage_mapped_column_expressions<DBOs, E> {};
 
         template<class A>
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 89d55569b..a2785bcde 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -131,6 +131,7 @@ add_executable(unit_tests
     row_id.cpp
     trigger_tests.cpp
     ast_iterator_tests.cpp
+    table_name_collector.cpp
     pointer_passing_interface.cpp
 )
 
diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index 6dce2dcad..9cc6a4640 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -2,9 +2,11 @@
 #include <catch2/catch_all.hpp>
 
 using namespace sqlite_orm;
+using internal::alias_column_t;
 using internal::alias_holder;
 using internal::column_alias;
 using internal::column_pointer;
+using internal::iterate_ast;
 
 TEST_CASE("ast_iterator") {
     struct User {
@@ -19,62 +21,62 @@ TEST_CASE("ast_iterator") {
     SECTION("bindables") {
         auto node = select(1);
         expected.push_back(typeid(int));
-        internal::iterate_ast(node, lambda);
+        iterate_ast(node, lambda);
     }
     SECTION("aggregate functions") {
         SECTION("avg") {
             auto node = avg(&User::id);
             expected.push_back(typeid(&User::id));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("avg filter") {
             auto node = avg(&User::id).filter(where(length(&User::name) > 5));
             expected.push_back(typeid(&User::id));
             expected.push_back(typeid(&User::name));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("count(*)") {
             auto node = count<User>();
             expected.push_back(typeid(node));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("count(*) filter") {
             auto node = count<User>().filter(where(length(&User::name) > 5));
             expected.push_back(typeid(decltype(count<User>())));
             expected.push_back(typeid(&User::name));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("count(X)") {
             auto node = count(&User::id);
             expected.push_back(typeid(&User::id));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("count(X) filter") {
             auto node = count(&User::id).filter(where(length(&User::name) > 5));
             expected.push_back(typeid(&User::id));
             expected.push_back(typeid(&User::name));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("group_concat(X)") {
             auto node = group_concat(&User::id);
             expected.push_back(typeid(&User::id));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("group_concat(X) filter") {
             auto node = group_concat(&User::id).filter(where(length(&User::name) > 5));
             expected.push_back(typeid(&User::id));
             expected.push_back(typeid(&User::name));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("group_concat(X,Y)") {
             auto node = group_concat(&User::id, std::string("-"));
             expected.push_back(typeid(&User::id));
             expected.push_back(typeid(std::string));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("group_concat(X,Y) filter") {
             auto node = group_concat(&User::id, std::string("-")).filter(where(length(&User::name) > 5));
@@ -82,55 +84,55 @@ TEST_CASE("ast_iterator") {
             expected.push_back(typeid(std::string));
             expected.push_back(typeid(&User::name));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("max(X)") {
             auto node = max(&User::id);
             expected.push_back(typeid(&User::id));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("max(X) filter") {
             auto node = max(&User::id).filter(where(length(&User::name) > 5));
             expected.push_back(typeid(&User::id));
             expected.push_back(typeid(&User::name));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("min(X)") {
             auto node = min(&User::id);
             expected.push_back(typeid(&User::id));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("min(X) filter") {
             auto node = min(&User::id).filter(where(length(&User::name) > 5));
             expected.push_back(typeid(&User::id));
             expected.push_back(typeid(&User::name));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("sum(X)") {
             auto node = sum(&User::id);
             expected.push_back(typeid(&User::id));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("sum(X) filter") {
             auto node = sum(&User::id).filter(where(length(&User::name) > 5));
             expected.push_back(typeid(&User::id));
             expected.push_back(typeid(&User::name));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("total(X)") {
             auto node = total(&User::id);
             expected.push_back(typeid(&User::id));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("total(X) filter") {
             auto node = total(&User::id).filter(where(length(&User::name) > 5));
             expected.push_back(typeid(&User::id));
             expected.push_back(typeid(&User::name));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
     }
     SECTION("scalar functions") {
@@ -138,76 +140,80 @@ TEST_CASE("ast_iterator") {
             auto node = max(&User::id, 4);
             expected.push_back(typeid(&User::id));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("min(X,Y)") {
             auto node = min(&User::id, 4);
             expected.push_back(typeid(&User::id));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
     }
     SECTION("on") {
         auto node = on(&User::id == c(0));
         expected.push_back(typeid(&User::id));
         expected.push_back(typeid(int));
-        internal::iterate_ast(node, lambda);
+        iterate_ast(node, lambda);
     }
     SECTION("using") {
         auto node = using_(&User::id);
-        expected.push_back(typeid(column_pointer<User, decltype(&User::id)>{&User::id}));
-        internal::iterate_ast(node, lambda);
+        expected.push_back(typeid(column_pointer<User, decltype(&User::id)>));
+        iterate_ast(node, lambda);
     }
     SECTION("exists") {
         auto node = exists(select(5));
         expected.push_back(typeid(int));
-        internal::iterate_ast(node, lambda);
+        iterate_ast(node, lambda);
     }
     SECTION("order_by") {
         SECTION("expression") {
             auto node = order_by(c(&User::id) == 0);
             expected.push_back(typeid(&User::id));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("bindable") {
             auto node = order_by("");
             expected.push_back(typeid(const char*));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("positional ordinal") {
             auto node = order_by(1);
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("sole column alias") {
             auto node = order_by(get<colalias_a>());
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
+        }
+        SECTION("direct sole column alias") {
+            auto node = order_by(colalias_a{});
+            iterate_ast(node, lambda);
         }
         SECTION("column alias in expression") {
             auto node = order_by(get<colalias_a>() > c(1));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
     }
     SECTION("group_by") {
         auto node = group_by(&User::id);
         expected.push_back(typeid(&User::id));
-        internal::iterate_ast(node, lambda);
+        iterate_ast(node, lambda);
     }
     SECTION("excluded") {
         auto node = excluded(&User::id);
         expected.push_back(typeid(&User::id));
-        internal::iterate_ast(node, lambda);
+        iterate_ast(node, lambda);
     }
     SECTION("upsert_clause") {
         auto node = on_conflict(&User::id).do_update(set(c(&User::name) = excluded(&User::name)));
         expected.push_back(typeid(&User::name));
         expected.push_back(typeid(&User::name));
-        internal::iterate_ast(node, lambda);
+        iterate_ast(node, lambda);
     }
     SECTION("into") {
         auto node = into<User>();
-        internal::iterate_ast(node, lambda);
+        iterate_ast(node, lambda);
     }
     SECTION("replace") {
         auto node =
@@ -216,7 +222,7 @@ TEST_CASE("ast_iterator") {
         expected.push_back(typeid(&User::name));
         expected.push_back(typeid(int));
         expected.push_back(typeid(std::string));
-        internal::iterate_ast(node, lambda);
+        iterate_ast(node, lambda);
     }
     SECTION("insert") {
         auto node =
@@ -225,19 +231,19 @@ TEST_CASE("ast_iterator") {
         expected.push_back(typeid(&User::name));
         expected.push_back(typeid(int));
         expected.push_back(typeid(std::string));
-        internal::iterate_ast(node, lambda);
+        iterate_ast(node, lambda);
     }
     SECTION("values") {
         auto node = values(std::make_tuple(1, std::string("hi")));
         expected.push_back(typeid(int));
         expected.push_back(typeid(std::string));
-        internal::iterate_ast(node, lambda);
+        iterate_ast(node, lambda);
     }
     SECTION("tuple") {
         auto node = std::make_tuple(1, std::string("hi"));
         expected.push_back(typeid(int));
         expected.push_back(typeid(std::string));
-        internal::iterate_ast(node, lambda);
+        iterate_ast(node, lambda);
     }
     SECTION("in") {
         SECTION("static") {
@@ -246,7 +252,7 @@ TEST_CASE("ast_iterator") {
             expected.push_back(typeid(int));
             expected.push_back(typeid(int));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
         SECTION("dynamic") {
             auto node = in(&User::id, {1, 2, 3});
@@ -254,7 +260,7 @@ TEST_CASE("ast_iterator") {
             expected.push_back(typeid(int));
             expected.push_back(typeid(int));
             expected.push_back(typeid(int));
-            internal::iterate_ast(node, lambda);
+            iterate_ast(node, lambda);
         }
     }
     SECTION("function_call") {
@@ -265,24 +271,36 @@ TEST_CASE("ast_iterator") {
         };
         auto node = func<Func>(&User::id);
         expected.push_back(typeid(&User::id));
-        internal::iterate_ast(node, lambda);
+        iterate_ast(node, lambda);
     }
     SECTION("aliases") {
         SECTION("holder") {
             auto expression = get<colalias_a>() > c(0);
             expected.push_back(typeid(int));
-            internal::iterate_ast(expression, lambda);
+            iterate_ast(expression, lambda);
         }
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
         {
             SECTION("direct") {
                 auto expression = "a"_col > c(0);
                 expected.push_back(typeid(int));
-                internal::iterate_ast(expression, lambda);
+                iterate_ast(expression, lambda);
             }
         }
 #endif
     }
+    SECTION("aliased regular column") {
+        using als = alias_z<User>;
+        auto expression = alias_column<als>(&User::id);
+        expected.push_back(typeid(alias_column_t<alias_z<User>, decltype(&User::id)>));
+        iterate_ast(expression, lambda);
+    }
+    SECTION("aliased regular column pointer") {
+        using als = alias_z<User>;
+        auto expression = alias_column<als>(column<User>(&User::id));
+        expected.push_back(typeid(alias_column_t<alias_z<User>, column_pointer<User, decltype(&User::id)>>));
+        iterate_ast(expression, lambda);
+    }
 #ifdef SQLITE_ORM_WITH_CTE
     SECTION("with") {
         auto expression =
@@ -296,8 +314,25 @@ TEST_CASE("ast_iterator") {
                          typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>),
                          typeid(int),
                          typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>)});
-        internal::iterate_ast(expression, lambda);
+        iterate_ast(expression, lambda);
     }
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+    SECTION("aliased CTE column pointer") {
+        constexpr auto c = "1"_cte;
+        constexpr auto z_alias = "z"_alias(c);
+        auto expression = z_alias->*&User::id;
+        expected.push_back(typeid(alias_column_t<alias_z<cte_1>, column_pointer<cte_1, decltype(&User::id)>>));
+        iterate_ast(expression, lambda);
+    }
+    SECTION("aliased CTE column alias") {
+        constexpr auto c = "1"_cte;
+        constexpr auto z_alias = "z"_alias(c);
+        auto expression = z_alias->*1_colalias;
+        expected.push_back(
+            typeid(alias_column_t<alias_z<cte_1>, column_pointer<cte_1, alias_holder<column_alias<'1'>>>>));
+        iterate_ast(expression, lambda);
+    }
+#endif
 #endif
     REQUIRE(typeIndexes == expected);
 }
diff --git a/tests/statement_serializer_tests/column_names.cpp b/tests/statement_serializer_tests/column_names.cpp
index 1cc7dc48f..e427f5fea 100644
--- a/tests/statement_serializer_tests/column_names.cpp
+++ b/tests/statement_serializer_tests/column_names.cpp
@@ -138,6 +138,40 @@ TEST_CASE("statement_serializer column names") {
             }
         }
     }
+    SECTION("aliased column") {
+        struct Object {
+            int id = 0;
+        };
+        struct Object2 {
+            int id = 0;
+        };
+        auto table = make_table("object", make_column("id", &Object::id));
+        using db_objects_t = internal::db_objects_tuple<decltype(table)>;
+        db_objects_t dbObjects{table};
+        SECTION("regular") {
+            using context_t = internal::serializer_context<db_objects_t>;
+            context_t context{dbObjects};
+            context.skip_table_name = false;
+            using als = alias_a<Object>;
+            auto value = serialize(alias_column<als>(&Object::id), context);
+            REQUIRE(value == R"("a"."id")");
+        }
+#ifdef SQLITE_ORM_WITH_CTE
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+        SECTION("cte") {
+            auto dbObjects2 =
+                internal::storage_db_objects_cat(dbObjects,
+                                                 internal::make_cte_table(dbObjects, cte<1_ctealias>()(select(1))));
+            using context_t = internal::serializer_context<decltype(dbObjects2)>;
+            context_t context{dbObjects2};
+            context.skip_table_name = false;
+            constexpr auto als = "a"_alias(1_ctealias);
+            auto value = serialize(als->*1_colalias, context);
+            REQUIRE(value == R"("a"."1")");
+        }
+#endif
+#endif
+    }
     SECTION("escaped identifiers") {
         struct Object1 {
             int id = 0;
diff --git a/tests/statement_serializer_tests/select_constraints.cpp b/tests/statement_serializer_tests/select_constraints.cpp
index dfb1331d6..44abc45d7 100644
--- a/tests/statement_serializer_tests/select_constraints.cpp
+++ b/tests/statement_serializer_tests/select_constraints.cpp
@@ -60,7 +60,7 @@ TEST_CASE("statement_serializer select constraints") {
             expected = "OR ROLLBACK";
         }
     }
-    SECTION("from") {
+    SECTION("from table") {
         SECTION("without alias") {
             auto expression = from<User>();
             value = serialize(expression, context);
@@ -72,6 +72,46 @@ TEST_CASE("statement_serializer select constraints") {
             expected = R"(FROM "users" "u")";
         }
     }
+#ifdef SQLITE_ORM_WITH_CTE
+    SECTION("from CTE") {
+        auto dbObjects2 =
+            internal::storage_db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
+        using context_t = internal::serializer_context<decltype(dbObjects2)>;
+        context_t context{dbObjects2};
+        SECTION("without alias 1") {
+            auto expression = from<cte_1>();
+            value = serialize(expression, context);
+            expected = R"(FROM "1")";
+        }
+        SECTION("with alias 1") {
+            auto expression = from<alias_z<cte_1>>();
+            value = serialize(expression, context);
+            expected = R"(FROM "1" "z")";
+        }
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+        SECTION("without alias 2") {
+            auto expression = from<"1"_cte>();
+            value = serialize(expression, context);
+            expected = R"(FROM "1")";
+        }
+        SECTION("with alias 2") {
+            constexpr auto z_alias = "z"_alias("1"_cte);
+            auto expression = from<z_alias>();
+            value = serialize(expression, context);
+            expected = R"(FROM "1" "z")";
+        }
+#endif
+        SECTION("complete select") {
+            auto expression = with(
+                cte<cte_1>()(
+                    union_all(select(1), select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < 10)))),
+                select(1_ctealias->*1_colalias));
+            value = serialize(expression, context);
+            expected =
+                R"(WITH "1"("1") AS (SELECT 1 UNION ALL SELECT "1"."1" + 1 FROM "1" WHERE ("1"."1" < 10)) SELECT "1"."1" FROM "1")";
+        }
+    }
+#endif
     SECTION("function_call") {
         struct Func {
             bool operator()(int arg) const {
diff --git a/tests/static_tests/alias.cpp b/tests/static_tests/alias.cpp
index 1a93859e9..5f0213623 100644
--- a/tests/static_tests/alias.cpp
+++ b/tests/static_tests/alias.cpp
@@ -3,8 +3,10 @@
 #include <catch2/catch_all.hpp>
 
 using namespace sqlite_orm;
+using internal::alias_column_t;
 using internal::alias_holder;
 using internal::column_alias;
+using internal::column_pointer;
 
 template<class ColAlias, class E>
 void do_assert() {
@@ -22,6 +24,11 @@ TEST_CASE("aliases") {
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
         runTest<alias_holder<column_alias<'a'>>>(get<"a"_col>());
         runTest<column_alias<'a'>>("a"_col);
+        constexpr auto z_alias = "z"_alias("1"_cte);
+        runTest<alias_column_t<alias_z<cte_1>, column_pointer<cte_1, alias_holder<column_alias<'a'>>>>>(
+            alias_column<z_alias>("a"_col));
+        runTest<alias_column_t<alias_z<cte_1>, column_pointer<cte_1, alias_holder<column_alias<'a'>>>>>(
+            z_alias->*"a"_col);
 #endif
 #ifdef SQLITE_ORM_WITH_CTE
         runTest<column_alias<'1'>>(1_colalias);
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index dd99efc7d..3f347ab1d 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -3,15 +3,21 @@
 #include <catch2/catch_all.hpp>
 
 using namespace sqlite_orm;
+using internal::alias_column_t;
 using internal::alias_holder;
+using internal::column_alias;
 using internal::column_pointer;
 
-template<class St, class E, class V>
-void runTest(V /*value*/) {
-    using Type = internal::column_expression_of_t<typename St::db_objects_type, V>;
+template<class Type, class E>
+void do_assert() {
     STATIC_REQUIRE(std::is_same<Type, E>::value);
 }
 
+template<class DBOs, class E, class V>
+void runTest(V /*value*/) {
+    do_assert<internal::column_expression_of_t<DBOs, V>, E>();
+}
+
 TEST_CASE("column_expression_of_t") {
     struct Org {
         int64 id = 0;
@@ -19,38 +25,52 @@ TEST_CASE("column_expression_of_t") {
     };
     struct Derived : Org {};
 
-    auto storage = make_storage(
-        "",
+    auto dbObjects = std::make_tuple(
         make_table("org", make_column("id", &Org::id), make_column("boss", &Org::boss)),
         make_table<Derived>("derived", make_column("id", &Derived::id), make_column("boss", &Derived::boss)));
-    using storage_type = decltype(storage);
+    using db_objects_t = decltype(dbObjects);
 
-    runTest<storage_type, int>(1);
-    runTest<storage_type, internal::rowid_t>(rowid());
-    runTest<storage_type, int64 Org::*>(&Org::id);
+    runTest<db_objects_t, int>(1);
+    runTest<db_objects_t, internal::rowid_t>(rowid());
+    runTest<db_objects_t, int64 Org::*>(&Org::id);
     // std::reference_wrapper
     {
         const int64 x = 42;
-        runTest<storage_type, const int64&>(std::ref(x));
+        runTest<db_objects_t, const int64&>(std::ref(x));
     }
-    runTest<storage_type, std::tuple<int64 Org::*>>(columns(&Org::boss));
-    runTest<storage_type, std::tuple<int64 Org::*, int64 Org::*>>(asterisk<Org>());
-    runTest<storage_type,
-            std::tuple<internal::alias_column_t<alias_a<Org>, int64 Org::*>,
-                       internal::alias_column_t<alias_a<Org>, int64 Org::*>>>(asterisk<alias_a<Org>>());
+    runTest<db_objects_t, std::tuple<int64 Org::*>>(columns(&Org::boss));
+    runTest<db_objects_t, std::tuple<int64 Org::*, int64 Org::*>>(asterisk<Org>());
+    runTest<db_objects_t,
+            std::tuple<alias_column_t<alias_a<Org>, int64 Org::*>, alias_column_t<alias_a<Org>, int64 Org::*>>>(
+        asterisk<alias_a<Org>>());
     // object_t not allowed
-    //runTest<storage_type, Org>(object<Org>());
-    runTest<storage_type, internal::as_t<colalias_a, int>>(as<colalias_a>(1));
+    //runTest<db_objects_t, Org>(object<Org>());
+    runTest<db_objects_t, internal::as_t<colalias_a, int>>(as<colalias_a>(1));
+    runTest<db_objects_t, alias_column_t<alias_a<Org>, int64 Org::*>>(alias_column<alias_a<Org>>(&Org::id));
 
-    runTest<storage_type, column_pointer<Derived, int64 Org::*>>(column<Derived>(&Org::id));
+    runTest<db_objects_t, column_pointer<Derived, int64 Org::*>>(column<Derived>(&Org::id));
 #ifdef SQLITE_ORM_WITH_CTE
-    runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>(&Org::id));
-    runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(column<cte_1>->*&Org::id);
-    runTest<storage_type, column_pointer<cte_1, int64 Org::*>>(cte_1{}->*&Org::id);
-    runTest<storage_type, column_pointer<cte_1, alias_holder<internal::column_alias<'1'>>>>(column<cte_1>(1_colalias));
-    runTest<storage_type, column_pointer<cte_1, alias_holder<colalias_c>>>(1_ctealias->*colalias_c{});
+    auto dbObjects2 = internal::storage_db_objects_cat(
+        dbObjects,
+        internal::make_cte_table(dbObjects, cte<cte_1>()(select(columns(&Org::id, 1)))));
+    using db_objects2_t = decltype(dbObjects2);
+    runTest<db_objects_t, column_pointer<cte_1, int64 Org::*>>(column<cte_1>(&Org::id));
+    runTest<db_objects_t, column_pointer<cte_1, int64 Org::*>>(column<cte_1>->*&Org::id);
+    runTest<db_objects_t, column_pointer<cte_1, int64 Org::*>>(cte_1{}->*&Org::id);
+    runTest<db_objects_t, column_pointer<cte_1, alias_holder<column_alias<'1'>>>>(column<cte_1>(1_colalias));
+    runTest<db_objects_t, column_pointer<cte_1, alias_holder<colalias_c>>>(1_ctealias->*colalias_c{});
+    runTest<db_objects_t, alias_column_t<alias_a<cte_1>, column_pointer<cte_1, int64 Org::*>>>(
+        alias_column<alias_a<cte_1>>(&Org::id));
+    runTest<db_objects_t, alias_column_t<alias_a<cte_1>, column_pointer<cte_1, alias_holder<column_alias<'1'>>>>>(
+        alias_column<alias_a<cte_1>>(1_colalias));
+    runTest<db_objects2_t, std::tuple<int64 Org::*, int internal::aliased_field<column_alias<'2'>, int>::*>>(
+        asterisk<cte_1>());
+    runTest<db_objects2_t,
+            std::tuple<alias_column_t<alias_a<cte_1>, int64 Org::*>,
+                       alias_column_t<alias_a<cte_1>, int internal::aliased_field<column_alias<'2'>, int>::*>>>(
+        asterisk<alias_a<cte_1>>());
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
-    runTest<storage_type, column_pointer<cte_1, alias_holder<colalias_c>>>("1"_cte->*"c"_col);
+    runTest<db_objects_t, column_pointer<cte_1, alias_holder<colalias_c>>>("1"_cte->*"c"_col);
 #endif
 #endif
 }
diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
index 3b2bf08d9..539732995 100644
--- a/tests/static_tests/column_result_t.cpp
+++ b/tests/static_tests/column_result_t.cpp
@@ -4,12 +4,16 @@
 
 using namespace sqlite_orm;
 
-template<class St, class E, class V>
-void runTest(V /*value*/) {
-    using Type = internal::column_result_of_t<typename St::db_objects_type, V>;
+template<class Type, class E>
+void do_assert() {
     STATIC_REQUIRE(std::is_same<Type, E>::value);
 }
 
+template<class DBOs, class E, class V>
+void runTest(V /*value*/) {
+    do_assert<internal::column_result_of_t<DBOs, V>, E>();
+}
+
 TEST_CASE("column_result_of_t") {
     struct User {
         int id = 0;
@@ -37,86 +41,94 @@ TEST_CASE("column_result_of_t") {
         int id = 0;
         std::string comment;
     };
-    auto storage =
-        make_storage({}, make_table("users", make_column("id", &User::id), make_column("name", &User::name)));
+    auto dbObjects =
+        std::make_tuple(make_table("users", make_column("id", &User::id), make_column("name", &User::name)));
+    using db_objects_t = decltype(dbObjects);
 
-    using Storage = decltype(storage);
-    runTest<Storage, int>(&User::id);
-    runTest<Storage, std::string>(&User::name);
-    runTest<Storage, bool>(in(&User::id, {1, 2, 3}));
+    runTest<db_objects_t, int>(&User::id);
+    runTest<db_objects_t, std::string>(&User::name);
+    runTest<db_objects_t, bool>(in(&User::id, {1, 2, 3}));
     {
         std::vector<int> vector;
-        vector.push_back(1);
-        vector.push_back(2);
-        vector.push_back(3);
-        runTest<Storage, bool>(in(&User::id, vector));
+        vector.insert(vector.cend(), {1, 2, 3});
+        runTest<db_objects_t, bool>(in(&User::id, vector));
     }
-    runTest<Storage, bool>(in(&User::id, select(&User::id)));
-    runTest<Storage, bool>(c(&User::id).in(1, 2, 3));
-    runTest<Storage, int>(&Visit::getId);
-    runTest<Storage, std::string>(&Visit::getComment);
-    runTest<Storage, int>(&Visit::setId);
-    runTest<Storage, std::string>(&Visit::setComment);
-    runTest<Storage, std::unique_ptr<double>>(sqlite_orm::abs(&User::id));
-    runTest<Storage, int>(sqlite_orm::length(&User::id));
-    runTest<Storage, int>(sqlite_orm::unicode(&User::id));
-    runTest<Storage, std::string>(sqlite_orm::typeof_(&User::id));
-    runTest<Storage, std::string>(sqlite_orm::lower(&User::id));
-    runTest<Storage, std::string>(sqlite_orm::upper(&User::id));
-    runTest<Storage, std::unique_ptr<int>>(max(&User::id, 4));
-    runTest<Storage, std::unique_ptr<int>>(min(&User::id, 4));
-    runTest<Storage, std::unique_ptr<int>>(max(&User::id));
-    runTest<Storage, std::unique_ptr<std::string>>(max(&User::name));
-    runTest<Storage, std::unique_ptr<int>>(min(&User::id));
-    runTest<Storage, std::unique_ptr<std::string>>(min(&User::name));
-    runTest<Storage, int>(count<User>());
-    runTest<Storage, int>(count());
+    runTest<db_objects_t, bool>(in(&User::id, select(&User::id)));
+    runTest<db_objects_t, bool>(c(&User::id).in(1, 2, 3));
+    runTest<db_objects_t, int>(&Visit::getId);
+    runTest<db_objects_t, std::string>(&Visit::getComment);
+    runTest<db_objects_t, int>(&Visit::setId);
+    runTest<db_objects_t, std::string>(&Visit::setComment);
+    runTest<db_objects_t, std::unique_ptr<double>>(sqlite_orm::abs(&User::id));
+    runTest<db_objects_t, int>(sqlite_orm::length(&User::id));
+    runTest<db_objects_t, int>(sqlite_orm::unicode(&User::id));
+    runTest<db_objects_t, std::string>(sqlite_orm::typeof_(&User::id));
+    runTest<db_objects_t, std::string>(sqlite_orm::lower(&User::id));
+    runTest<db_objects_t, std::string>(sqlite_orm::upper(&User::id));
+    runTest<db_objects_t, std::unique_ptr<int>>(max(&User::id, 4));
+    runTest<db_objects_t, std::unique_ptr<int>>(min(&User::id, 4));
+    runTest<db_objects_t, std::unique_ptr<int>>(max(&User::id));
+    runTest<db_objects_t, std::unique_ptr<std::string>>(max(&User::name));
+    runTest<db_objects_t, std::unique_ptr<int>>(min(&User::id));
+    runTest<db_objects_t, std::unique_ptr<std::string>>(min(&User::name));
+    runTest<db_objects_t, int>(count<User>());
+    runTest<db_objects_t, int>(count());
     {
         struct RandomFunc {
             int operator()() const {
                 return 4;
             }
         };
-        runTest<Storage, int>(func<RandomFunc>());
+        runTest<db_objects_t, int>(func<RandomFunc>());
     }
-    runTest<Storage, int>(distinct(&User::id));
-    runTest<Storage, std::string>(distinct(&User::name));
-    runTest<Storage, int>(all(&User::id));
-    runTest<Storage, std::string>(all(&User::name));
-    runTest<Storage, std::string>(conc(&User::name, &User::id));
-    runTest<Storage, std::string>(c(&User::name) || &User::id);
-    runTest<Storage, double>(add(&User::id, 5));
-    runTest<Storage, double>(c(&User::id) + 5);
-    runTest<Storage, double>(sub(&User::id, 5));
-    runTest<Storage, double>(c(&User::id) - 5);
-    runTest<Storage, double>(mul(&User::id, 5));
-    runTest<Storage, double>(c(&User::id) * 5);
-    runTest<Storage, double>(sqlite_orm::div(&User::id, 5));
-    runTest<Storage, double>(c(&User::id) / 5);
-    runTest<Storage, double>(mod(&User::id, 5));
-    runTest<Storage, double>(c(&User::id) % 5);
-    runTest<Storage, int>(bitwise_shift_left(&User::id, 4));
-    runTest<Storage, int>(bitwise_shift_right(&User::id, 4));
-    runTest<Storage, int>(bitwise_and(&User::id, 4));
-    runTest<Storage, int>(bitwise_or(&User::id, 4));
-    runTest<Storage, int>(bitwise_not(&User::id));
-    runTest<Storage, int64>(rowid());
-    runTest<Storage, int64>(oid());
-    runTest<Storage, int64>(_rowid_());
-    runTest<Storage, int64>(rowid<User>());
-    runTest<Storage, int64>(oid<User>());
-    runTest<Storage, int64>(_rowid_<User>());
-    runTest<Storage, std::tuple<int, std::string>>(asterisk<User>());
-    runTest<Storage, std::tuple<int, std::string>>(asterisk<alias_a<User>>());
-    runTest<Storage, std::tuple<int, std::string>>(columns(&User::id, &User::name));
-    runTest<Storage, int>(column<User>(&User::id));
-    runTest<Storage, User>(object<User>());
+    runTest<db_objects_t, int>(distinct(&User::id));
+    runTest<db_objects_t, std::string>(distinct(&User::name));
+    runTest<db_objects_t, int>(all(&User::id));
+    runTest<db_objects_t, std::string>(all(&User::name));
+    runTest<db_objects_t, std::string>(conc(&User::name, &User::id));
+    runTest<db_objects_t, std::string>(c(&User::name) || &User::id);
+    runTest<db_objects_t, double>(add(&User::id, 5));
+    runTest<db_objects_t, double>(c(&User::id) + 5);
+    runTest<db_objects_t, double>(sub(&User::id, 5));
+    runTest<db_objects_t, double>(c(&User::id) - 5);
+    runTest<db_objects_t, double>(mul(&User::id, 5));
+    runTest<db_objects_t, double>(c(&User::id) * 5);
+    runTest<db_objects_t, double>(sqlite_orm::div(&User::id, 5));
+    runTest<db_objects_t, double>(c(&User::id) / 5);
+    runTest<db_objects_t, double>(mod(&User::id, 5));
+    runTest<db_objects_t, double>(c(&User::id) % 5);
+    runTest<db_objects_t, int>(bitwise_shift_left(&User::id, 4));
+    runTest<db_objects_t, int>(bitwise_shift_right(&User::id, 4));
+    runTest<db_objects_t, int>(bitwise_and(&User::id, 4));
+    runTest<db_objects_t, int>(bitwise_or(&User::id, 4));
+    runTest<db_objects_t, int>(bitwise_not(&User::id));
+    runTest<db_objects_t, int64>(rowid());
+    runTest<db_objects_t, int64>(oid());
+    runTest<db_objects_t, int64>(_rowid_());
+    runTest<db_objects_t, int64>(rowid<User>());
+    runTest<db_objects_t, int64>(oid<User>());
+    runTest<db_objects_t, int64>(_rowid_<User>());
+    runTest<db_objects_t, std::tuple<int, std::string>>(asterisk<User>());
+    runTest<db_objects_t, std::tuple<int, std::string>>(asterisk<alias_a<User>>());
+    runTest<db_objects_t, std::tuple<int, std::string>>(columns(&User::id, &User::name));
+    runTest<db_objects_t, int>(column<User>(&User::id));
+    runTest<db_objects_t, int>(alias_column<alias_a<User>>(&User::id));
+    runTest<db_objects_t, User>(object<User>());
 #ifdef SQLITE_ORM_WITH_CTE
-    runTest<Storage, int>(column<cte_1>(&User::id));
-    runTest<Storage, int>(column<cte_1>->*&User::id);
-    runTest<Storage, int>(1_ctealias->*&User::id);
+    // note: even though used with the CTE, &User::id doesn't need to be mapped into the CTE to make column results work;
+    //       this is because the result type is taken from the member pointer just because we can't look it up in the storage definition
+    auto dbObjects2 =
+        internal::storage_db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
+    using db_objects2_t = decltype(dbObjects2);
+    runTest<db_objects_t, int>(column<cte_1>(&User::id));
+    runTest<db_objects_t, int>(column<cte_1>->*&User::id);
+    runTest<db_objects_t, int>(1_ctealias->*&User::id);
+    runTest<db_objects_t, int>(alias_column<alias_a<cte_1>>(&User::id));
+    runTest<db_objects2_t, int>(alias_column<alias_a<cte_1>>(1_colalias));
+    runTest<db_objects2_t, std::tuple<int>>(asterisk<cte_1>());
+    runTest<db_objects2_t, std::tuple<int>>(asterisk<alias_a<cte_1>>());
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
-    runTest<Storage, int>("1"_cte->*&User::id);
+    runTest<db_objects_t, int>("1"_cte->*&User::id);
 #endif
 #endif
 }
diff --git a/tests/table_name_collector.cpp b/tests/table_name_collector.cpp
new file mode 100644
index 000000000..575ffe7f7
--- /dev/null
+++ b/tests/table_name_collector.cpp
@@ -0,0 +1,91 @@
+#include <sqlite_orm/sqlite_orm.h>
+#include <catch2/catch_all.hpp>
+
+using namespace sqlite_orm;
+using internal::alias_extractor;
+
+TEST_CASE("table name collector") {
+    struct User {
+        int id = 0;
+        std::string name;
+    };
+
+    auto table = make_table("users", make_column("id", &User::id), make_column("name", &User::name));
+    using db_objects_t = internal::db_objects_tuple<decltype(table)>;
+    auto dbObjects = db_objects_t{table};
+    internal::table_name_collector::table_name_set expected;
+
+    SECTION("from table") {
+        internal::serializer_context<db_objects_t> context{dbObjects};
+        internal::table_name_collector collector([&context](const std::type_index& ti) {
+            return internal::find_table_name(context.db_objects, ti);
+        });
+
+        SECTION("regular column") {
+            using als = alias_z<User>;
+            auto expression = &User::id;
+            expected.emplace(table.name, "");
+            iterate_ast(expression, collector);
+        }
+        SECTION("regular column pointer") {
+            auto expression = column<User>(&User::id);
+            expected.emplace(table.name, "");
+            iterate_ast(expression, collector);
+        }
+        SECTION("aliased regular column") {
+            using als = alias_z<User>;
+            auto expression = alias_column<als>(&User::id);
+            expected.emplace(table.name, "z");
+            iterate_ast(expression, collector);
+        }
+        SECTION("aliased regular column pointer") {
+            using als = alias_z<User>;
+            auto expression = alias_column<als>(column<User>(&User::id));
+            expected.emplace(table.name, "z");
+            iterate_ast(expression, collector);
+        }
+        REQUIRE(collector.table_names == expected);
+    }
+
+#ifdef SQLITE_ORM_WITH_CTE
+    SECTION("from CTE") {
+        auto dbObjects2 =
+            internal::storage_db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
+        using context_t = internal::serializer_context<decltype(dbObjects2)>;
+        context_t context{dbObjects2};
+        internal::table_name_collector collector([&context](const std::type_index& ti) {
+            return internal::find_table_name(context.db_objects, ti);
+        });
+
+        SECTION("CTE column") {
+            constexpr auto c = 1_ctealias;
+            auto expression = c->*&User::id;
+            expected.emplace(alias_extractor<decltype(c)>::extract(), "");
+            iterate_ast(expression, collector);
+        }
+        SECTION("CTE column alias") {
+            constexpr auto c = 1_ctealias;
+            auto expression = c->*1_colalias;
+            expected.emplace(alias_extractor<decltype(c)>::extract(), "");
+            iterate_ast(expression, collector);
+        }
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+        SECTION("aliased CTE column") {
+            constexpr auto c = "1"_cte;
+            constexpr auto z_alias = "z"_alias(c);
+            auto expression = z_alias->*&User::id;
+            expected.emplace(alias_extractor<decltype(c)>::extract(), "z");
+            iterate_ast(expression, collector);
+        }
+        SECTION("aliased CTE column alias") {
+            constexpr auto c = "1"_cte;
+            constexpr auto z_alias = "z"_alias(c);
+            auto expression = z_alias->*1_colalias;
+            expected.emplace(alias_extractor<decltype(c)>::extract(), "z");
+            iterate_ast(expression, collector);
+        }
+#endif
+        REQUIRE(collector.table_names == expected);
+    }
+#endif
+}

From 8c4a1988748c540eb88b14e28a30a57ac6b81372 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 30 Jan 2023 17:13:49 +0200
Subject: [PATCH 087/161] Addressed a few CTE+clang related things

---
 dev/alias.h                                   | 12 ++---
 dev/conditions.h                              | 10 ++---
 dev/cte.h                                     |  6 +--
 dev/functional/cxx_compiler_quirks.h          |  6 +++
 dev/functional/cxx_core_features.h            |  4 +-
 dev/select_constraints.h                      |  4 +-
 dev/storage_impl.h                            |  4 +-
 examples/column_aliases.cpp                   |  2 +-
 examples/common_table_expressions.cpp         | 20 ++++-----
 include/sqlite_orm/sqlite_orm.h               | 44 +++++++++++--------
 tests/ast_iterator_tests.cpp                  |  4 +-
 .../column_names.cpp                          |  2 +-
 .../select_constraints.cpp                    |  2 +-
 tests/static_tests/alias.cpp                  |  2 +-
 tests/static_tests/column_expression_type.cpp |  2 +-
 tests/static_tests/column_result_t.cpp        |  2 +-
 tests/static_tests/cte.cpp                    |  2 +-
 tests/table_name_collector.cpp                |  2 +-
 tests/tests.cpp                               |  8 ++++
 19 files changed, 79 insertions(+), 59 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index cd1e15065..eb5a6d8aa 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -17,7 +17,7 @@ namespace sqlite_orm {
 
     namespace internal {
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         /*
          *  Helper class to facilitate user-defined string literal operator template
          */
@@ -184,7 +184,7 @@ namespace sqlite_orm {
         }
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto als,
              class C,
              std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<decltype(als)>,
@@ -222,7 +222,7 @@ namespace sqlite_orm {
         return {std::move(expression)};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto als, class E>
     internal::as_t<decltype(als), E> as(E expression) {
         return {std::move(expression)};
@@ -250,7 +250,7 @@ namespace sqlite_orm {
         return {};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto als>
     internal::alias_holder<decltype(als)> get() {
         return {};
@@ -310,7 +310,7 @@ namespace sqlite_orm {
     template<class T>
     using alias_z = internal::table_alias<T, 'z'>;
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
 #ifdef SQLITE_ORM_WITH_CTE
     namespace internal {
         template<char A, char... C>
@@ -350,7 +350,7 @@ namespace sqlite_orm {
     using colalias_h = internal::column_alias<'h'>;
     using colalias_i = internal::column_alias<'i'>;
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     /**
      *  column_alias<'a'[, ...]> from a string literal.
      *  E.g. "a"_col, "b"_col
diff --git a/dev/conditions.h b/dev/conditions.h
index 4dc921a53..40a2be3af 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -813,7 +813,7 @@ namespace sqlite_orm {
         return {};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     /**
      *  Explicit FROM function. Usage:
      *  `storage.select(&User::id, from<"a"_cte>());`
@@ -1022,7 +1022,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto als, class O>
     internal::left_join_t<decltype(als), O> left_join(O o) {
         return {std::move(o)};
@@ -1034,7 +1034,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto als, class O>
     internal::join_t<decltype(als), O> join(O o) {
         return {std::move(o)};
@@ -1046,7 +1046,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto als, class O>
     internal::left_outer_join_t<decltype(als), O> left_outer_join(O o) {
         return {std::move(o)};
@@ -1058,7 +1058,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto als, class O>
     internal::inner_join_t<decltype(als), O> inner_join(O o) {
         return {std::move(o)};
diff --git a/dev/cte.h b/dev/cte.h
index 5adb2eac5..1c9ccccd1 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "functional/cxx_core_features.h"
+#include "functional/cxx_universal.h"
 #ifdef SQLITE_ORM_WITH_CTE
 #include <utility>  //  std::make_index_sequence
 
@@ -27,7 +27,7 @@ namespace sqlite_orm {
     [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
         return internal::cte_alias<Chars...>{};
     }
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     /**
      *  cte_alias<'1'[, ...]> from a string literal.
      *  E.g. "1"_cte, "2"_cte
@@ -41,7 +41,7 @@ namespace sqlite_orm {
     }
 #endif
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     using cte_1 = decltype("1"_cte);
     using cte_2 = decltype("2"_cte);
     using cte_3 = decltype("3"_cte);
diff --git a/dev/functional/cxx_compiler_quirks.h b/dev/functional/cxx_compiler_quirks.h
index ab84d2980..59ec1b3a7 100644
--- a/dev/functional/cxx_compiler_quirks.h
+++ b/dev/functional/cxx_compiler_quirks.h
@@ -28,3 +28,9 @@
 #if defined(_MSC_VER) && (_MSC_VER < 1920)
 #define SQLITE_ORM_BROKEN_VARIADIC_PACK_EXPANSION
 #endif
+
+// overwrite SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
+#if(__cpp_nontype_template_args < 201911L) &&                                                                          \
+    (defined(__clang__) && (__clang_major__ >= 12) && (__cplusplus >= 202002L))
+#define SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
+#endif
diff --git a/dev/functional/cxx_core_features.h b/dev/functional/cxx_core_features.h
index 3338bf277..b472a9ec5 100644
--- a/dev/functional/cxx_core_features.h
+++ b/dev/functional/cxx_core_features.h
@@ -71,8 +71,8 @@
 #define SQLITE_ORM_CONCEPTS_SUPPORTED
 #endif
 
-#if __cpp_nontype_template_args >= 201911
-#define SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#if __cpp_nontype_template_args >= 201911L
+#define SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
 #endif
 
 #if defined(SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED) && defined(SQLITE_ORM_IF_CONSTEXPR_SUPPORTED)
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index ae2661578..f82b450e5 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -534,7 +534,7 @@ namespace sqlite_orm {
         return builder_type{{std::move(explicitColumns)...}};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto label,
              class... ExplicitCols,
              std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
@@ -607,7 +607,7 @@ namespace sqlite_orm {
         return {definedOrder};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto A, internal::satisfies<internal::is_any_table_alias, decltype(A)> = true>
     internal::asterisk_t<decltype(A)> asterisk(bool definedOrder = false) {
         return {definedOrder};
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 6ab0a8a2c..f9d75e1ab 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -98,7 +98,7 @@ namespace sqlite_orm {
             constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
             static_assert(ColIdx != -1, "No such column mapped into the CTE.");
 
-            return &aliased_field<ColAlias, std::tuple_element_t<ColIdx, cte_mapper_type::fields_type>>::field;
+            return &aliased_field<ColAlias, std::tuple_element_t<ColIdx, typename cte_mapper_type::fields_type>>::field;
         }
 #endif
 
@@ -132,7 +132,7 @@ namespace sqlite_orm {
                 transform_tuple_t<typename cte_mapper_type::final_colrefs_tuple, alias_holder_type_or_none_t>;
 
             // lookup index of ColAlias in alias_types_tuple
-            static constexpr auto I = tuple_index_of_v<ColAlias, alias_types_tuple>;
+            constexpr auto I = tuple_index_of_v<ColAlias, alias_types_tuple>;
             static_assert(I != -1, "No such column mapped into the CTE.");
 
             // note: we could "materialize" the alias to an `aliased_field<>::*` and use the regular `table_t<>::find_column_name()` mechanism;
diff --git a/examples/column_aliases.cpp b/examples/column_aliases.cpp
index 4541a4729..e5a881169 100644
--- a/examples/column_aliases.cpp
+++ b/examples/column_aliases.cpp
@@ -58,7 +58,7 @@ void marvel_hero_ordered_by_o_pos() {
         }
     }
     cout << endl;
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     {
         //  SELECT name, instr(abilities, 'o') i
         //  FROM marvel
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 13f0d5d0a..dc056bd74 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -31,7 +31,7 @@ void all_integers_between(int from, int end) {
         //WITH RECURSIVE
         //    cnt(x) AS(VALUES(1) UNION ALL SELECT x + 1 FROM cnt WHERE x < 1000000)
         //    SELECT x FROM cnt;
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         constexpr auto cnt_cte = "cnt"_cte;
         auto ast =
             with(cte<cnt_cte>()(
@@ -73,7 +73,7 @@ void all_integers_between(int from, int end) {
         //        LIMIT 1000000
         //    )
         //    SELECT x FROM cnt;
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         auto ast = with(cte<"cnt"_cte>("y"_col)(
                             union_all(select(from >>= "x"_col), select("cnt"_cte->*"y"_col + c(1), limit(end)))),
                         select("cnt"_cte->*"y"_col));
@@ -154,7 +154,7 @@ void supervisor_chain() {
         //        WHERE parent.name = chain.boss
         //    )
         //    SELECT name FROM chain;
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         auto ast = with(cte<"chain"_cte>()(union_all(
                             select(asterisk<Org>(), where(&Org::name == c("Fred"))),
                             select(asterisk<alias_a<Org>>(),
@@ -220,7 +220,7 @@ void works_for_alice() {
         //    )
         //    SELECT avg(height) FROM org
         //    WHERE org.name IN works_for_alice;
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         constexpr auto works_for_alice = "works_for_alice"_cte;
         auto ast =
             with(cte<works_for_alice>("n"_col)(
@@ -305,7 +305,7 @@ void family_tree() {
     //    WHERE ancestor_of_alice.name = family.name
     //    AND died IS NULL
     //    ORDER BY born;
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     constexpr auto parent_of = "parent_of"_cte;
     constexpr auto ancestor_of_alice = "ancestor_of_alice"_cte;
     constexpr auto parent_col = "parent"_col;
@@ -423,7 +423,7 @@ void depth_or_breadth_first() {
         //        ORDER BY 2
         //    )
         //    SELECT substr('..........', 1, level * 3) || name FROM under_alice;
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         constexpr auto under_alice = "under_alice"_cte;
         constexpr auto level_col = "level"_col;
         auto ast = with(cte<under_alice>(&Org::name, level_col)(
@@ -464,7 +464,7 @@ void depth_or_breadth_first() {
         //        ORDER BY 2
         //    )
         //    SELECT substr('..........', 1, level * 3) || name FROM under_alice;
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         constexpr auto under_alice = "under_alice"_cte;
         constexpr auto level_col = "level"_col;
         auto ast = with(cte<under_alice>(&Org::name, level_col)(
@@ -518,7 +518,7 @@ void select_from_subselect() {
     });
 
     // SELECT * FROM (SELECT salary, comm AS commmission FROM emp) WHERE salary < 5000
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     constexpr auto sub = "sub"_cte;
     auto expression = with(cte<sub>()(select(columns(&Employee::m_salary, &Employee::m_commission))),
                            select(asterisk<sub>(), where(c(sub->*&Employee::m_salary) < 5000)));
@@ -559,7 +559,7 @@ void apfelmaennchen() {
     //        FROM m2 GROUP BY cy
     //    )
     //    SELECT group_concat(rtrim(t), x'0a') FROM a;
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     constexpr auto xaxis = "xaxis"_cte;
     constexpr auto yaxis = "yaxis"_cte;
     constexpr auto m = "mi"_cte;
@@ -644,7 +644,7 @@ void apfelmaennchen() {
 }
 
 void sudoku() {
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     auto storage = make_storage("");
 
     //WITH RECURSIVE
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 871cd9520..3b4cc9acf 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -83,8 +83,8 @@ __pragma(push_macro("max"))
 #define SQLITE_ORM_CONCEPTS_SUPPORTED
 #endif
 
-#if __cpp_nontype_template_args >= 201911
-#define SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#if __cpp_nontype_template_args >= 201911L
+#define SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
 #endif
 
 #if defined(SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED) && defined(SQLITE_ORM_IF_CONSTEXPR_SUPPORTED)
@@ -146,6 +146,12 @@ using std::nullptr_t;
 #define SQLITE_ORM_BROKEN_VARIADIC_PACK_EXPANSION
 #endif
 
+// overwrite SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
+#if(__cpp_nontype_template_args < 201911L) &&                                                                          \
+    (defined(__clang__) && (__clang_major__ >= 12) && (__cplusplus >= 202002L))
+#define SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
+#endif
+
 namespace sqlite_orm {
     namespace internal {
         namespace polyfill {
@@ -3659,7 +3665,7 @@ namespace sqlite_orm {
         return {};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     /**
      *  Explicit FROM function. Usage:
      *  `storage.select(&User::id, from<"a"_cte>());`
@@ -3868,7 +3874,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto als, class O>
     internal::left_join_t<decltype(als), O> left_join(O o) {
         return {std::move(o)};
@@ -3880,7 +3886,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto als, class O>
     internal::join_t<decltype(als), O> join(O o) {
         return {std::move(o)};
@@ -3892,7 +3898,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto als, class O>
     internal::left_outer_join_t<decltype(als), O> left_outer_join(O o) {
         return {std::move(o)};
@@ -3904,7 +3910,7 @@ namespace sqlite_orm {
         return {std::move(o)};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto als, class O>
     internal::inner_join_t<decltype(als), O> inner_join(O o) {
         return {std::move(o)};
@@ -4407,7 +4413,7 @@ namespace sqlite_orm {
 
     namespace internal {
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         /*
          *  Helper class to facilitate user-defined string literal operator template
          */
@@ -4574,7 +4580,7 @@ namespace sqlite_orm {
         }
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto als,
              class C,
              std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<decltype(als)>,
@@ -4612,7 +4618,7 @@ namespace sqlite_orm {
         return {std::move(expression)};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto als, class E>
     internal::as_t<decltype(als), E> as(E expression) {
         return {std::move(expression)};
@@ -4640,7 +4646,7 @@ namespace sqlite_orm {
         return {};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto als>
     internal::alias_holder<decltype(als)> get() {
         return {};
@@ -4700,7 +4706,7 @@ namespace sqlite_orm {
     template<class T>
     using alias_z = internal::table_alias<T, 'z'>;
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
 #ifdef SQLITE_ORM_WITH_CTE
     namespace internal {
         template<char A, char... C>
@@ -4740,7 +4746,7 @@ namespace sqlite_orm {
     using colalias_h = internal::column_alias<'h'>;
     using colalias_i = internal::column_alias<'i'>;
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     /**
      *  column_alias<'a'[, ...]> from a string literal.
      *  E.g. "a"_col, "b"_col
@@ -7741,7 +7747,7 @@ namespace sqlite_orm {
         return builder_type{{std::move(explicitColumns)...}};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto label,
              class... ExplicitCols,
              std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
@@ -7814,7 +7820,7 @@ namespace sqlite_orm {
         return {definedOrder};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     template<auto A, internal::satisfies<internal::is_any_table_alias, decltype(A)> = true>
     internal::asterisk_t<decltype(A)> asterisk(bool definedOrder = false) {
         return {definedOrder};
@@ -11463,7 +11469,7 @@ namespace sqlite_orm {
             constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
             static_assert(ColIdx != -1, "No such column mapped into the CTE.");
 
-            return &aliased_field<ColAlias, std::tuple_element_t<ColIdx, cte_mapper_type::fields_type>>::field;
+            return &aliased_field<ColAlias, std::tuple_element_t<ColIdx, typename cte_mapper_type::fields_type>>::field;
         }
 #endif
 
@@ -11497,7 +11503,7 @@ namespace sqlite_orm {
                 transform_tuple_t<typename cte_mapper_type::final_colrefs_tuple, alias_holder_type_or_none_t>;
 
             // lookup index of ColAlias in alias_types_tuple
-            static constexpr auto I = tuple_index_of_v<ColAlias, alias_types_tuple>;
+            constexpr auto I = tuple_index_of_v<ColAlias, alias_types_tuple>;
             static_assert(I != -1, "No such column mapped into the CTE.");
 
             // note: we could "materialize" the alias to an `aliased_field<>::*` and use the regular `table_t<>::find_column_name()` mechanism;
@@ -20323,7 +20329,7 @@ namespace sqlite_orm {
     [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
         return internal::cte_alias<Chars...>{};
     }
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     /**
      *  cte_alias<'1'[, ...]> from a string literal.
      *  E.g. "1"_cte, "2"_cte
@@ -20337,7 +20343,7 @@ namespace sqlite_orm {
     }
 #endif
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     using cte_1 = decltype("1"_cte);
     using cte_2 = decltype("2"_cte);
     using cte_3 = decltype("3"_cte);
diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index 9cc6a4640..d7784c12f 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -279,7 +279,7 @@ TEST_CASE("ast_iterator") {
             expected.push_back(typeid(int));
             iterate_ast(expression, lambda);
         }
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         {
             SECTION("direct") {
                 auto expression = "a"_col > c(0);
@@ -316,7 +316,7 @@ TEST_CASE("ast_iterator") {
                          typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>)});
         iterate_ast(expression, lambda);
     }
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     SECTION("aliased CTE column pointer") {
         constexpr auto c = "1"_cte;
         constexpr auto z_alias = "z"_alias(c);
diff --git a/tests/statement_serializer_tests/column_names.cpp b/tests/statement_serializer_tests/column_names.cpp
index e427f5fea..a0adb17ff 100644
--- a/tests/statement_serializer_tests/column_names.cpp
+++ b/tests/statement_serializer_tests/column_names.cpp
@@ -157,7 +157,7 @@ TEST_CASE("statement_serializer column names") {
             REQUIRE(value == R"("a"."id")");
         }
 #ifdef SQLITE_ORM_WITH_CTE
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         SECTION("cte") {
             auto dbObjects2 =
                 internal::storage_db_objects_cat(dbObjects,
diff --git a/tests/statement_serializer_tests/select_constraints.cpp b/tests/statement_serializer_tests/select_constraints.cpp
index 44abc45d7..7e9fec9ad 100644
--- a/tests/statement_serializer_tests/select_constraints.cpp
+++ b/tests/statement_serializer_tests/select_constraints.cpp
@@ -88,7 +88,7 @@ TEST_CASE("statement_serializer select constraints") {
             value = serialize(expression, context);
             expected = R"(FROM "1" "z")";
         }
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         SECTION("without alias 2") {
             auto expression = from<"1"_cte>();
             value = serialize(expression, context);
diff --git a/tests/static_tests/alias.cpp b/tests/static_tests/alias.cpp
index 5f0213623..7843d2353 100644
--- a/tests/static_tests/alias.cpp
+++ b/tests/static_tests/alias.cpp
@@ -21,7 +21,7 @@ void runTest(ColAlias /*colRef*/) {
 TEST_CASE("aliases") {
     SECTION("column alias expressions") {
         runTest<alias_holder<column_alias<'a'>>>(get<colalias_a>());
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         runTest<alias_holder<column_alias<'a'>>>(get<"a"_col>());
         runTest<column_alias<'a'>>("a"_col);
         constexpr auto z_alias = "z"_alias("1"_cte);
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index 3f347ab1d..1fcef87b7 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -69,7 +69,7 @@ TEST_CASE("column_expression_of_t") {
             std::tuple<alias_column_t<alias_a<cte_1>, int64 Org::*>,
                        alias_column_t<alias_a<cte_1>, int internal::aliased_field<column_alias<'2'>, int>::*>>>(
         asterisk<alias_a<cte_1>>());
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     runTest<db_objects_t, column_pointer<cte_1, alias_holder<colalias_c>>>("1"_cte->*"c"_col);
 #endif
 #endif
diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
index 539732995..8c2b0936e 100644
--- a/tests/static_tests/column_result_t.cpp
+++ b/tests/static_tests/column_result_t.cpp
@@ -127,7 +127,7 @@ TEST_CASE("column_result_of_t") {
     runTest<db_objects2_t, int>(alias_column<alias_a<cte_1>>(1_colalias));
     runTest<db_objects2_t, std::tuple<int>>(asterisk<cte_1>());
     runTest<db_objects2_t, std::tuple<int>>(asterisk<alias_a<cte_1>>());
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
     runTest<db_objects_t, int>("1"_cte->*&User::id);
 #endif
 #endif
diff --git a/tests/static_tests/cte.cpp b/tests/static_tests/cte.cpp
index 24760f570..3a9cb5bb3 100644
--- a/tests/static_tests/cte.cpp
+++ b/tests/static_tests/cte.cpp
@@ -34,7 +34,7 @@ TEST_CASE("CTE type traits") {
         runTest<tuple<decltype(&Org::id)>>(&Org::id);
         runTest<tuple<decltype(&Org::getId)>>(&Org::getId);
         runTest<tuple<alias_holder<column_alias<'1'>>>>(1_colalias);
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         runTest<tuple<alias_holder<column_alias<'a'>>>>("a"_col);
 #endif
         runTest<tuple<column_t<int64 Org::*, internal::empty_setter>>>(make_column("id", &Org::id));
diff --git a/tests/table_name_collector.cpp b/tests/table_name_collector.cpp
index 575ffe7f7..f7520a90d 100644
--- a/tests/table_name_collector.cpp
+++ b/tests/table_name_collector.cpp
@@ -69,7 +69,7 @@ TEST_CASE("table name collector") {
             expected.emplace(alias_extractor<decltype(c)>::extract(), "");
             iterate_ast(expression, collector);
         }
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARG_SUPPORTED
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         SECTION("aliased CTE column") {
             constexpr auto c = "1"_cte;
             constexpr auto z_alias = "z"_alias(c);
diff --git a/tests/tests.cpp b/tests/tests.cpp
index d0e13dc57..71687322d 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -1,6 +1,14 @@
 #include <sqlite_orm/sqlite_orm.h>
 #include <catch2/catch_all.hpp>
 
+#ifdef _DEBUG
+#pragma comment(lib, "Catch2d.Lib")
+#pragma comment(lib, "manual-link/Catch2Maind.Lib")
+#else
+#pragma comment(lib, "Catch2.Lib")
+#pragma comment(lib, "manual-link/Catch2Main.Lib")
+#endif
+
 #include <vector>  //  std::vector
 #include <string>  //  std::string
 #include <memory>  //  std::unique_ptr

From 026d37c3912efde682bc0371724dac791625f5f0 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 30 Jan 2023 17:16:08 +0200
Subject: [PATCH 088/161] Removed code used in local test environment

---
 tests/tests.cpp | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/tests/tests.cpp b/tests/tests.cpp
index 71687322d..d0e13dc57 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -1,14 +1,6 @@
 #include <sqlite_orm/sqlite_orm.h>
 #include <catch2/catch_all.hpp>
 
-#ifdef _DEBUG
-#pragma comment(lib, "Catch2d.Lib")
-#pragma comment(lib, "manual-link/Catch2Maind.Lib")
-#else
-#pragma comment(lib, "Catch2.Lib")
-#pragma comment(lib, "manual-link/Catch2Main.Lib")
-#endif
-
 #include <vector>  //  std::vector
 #include <string>  //  std::string
 #include <memory>  //  std::unique_ptr

From 26b323a4b46f494ce55b7b3ad5f62085da0305a7 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 30 Jan 2023 18:26:26 +0200
Subject: [PATCH 089/161] Included <algorithm> in tuple_traits.h

---
 dev/tuple_helper/tuple_traits.h | 3 ++-
 include/sqlite_orm/sqlite_orm.h | 5 +++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/dev/tuple_helper/tuple_traits.h b/dev/tuple_helper/tuple_traits.h
index 67e827373..bd1afaffe 100644
--- a/dev/tuple_helper/tuple_traits.h
+++ b/dev/tuple_helper/tuple_traits.h
@@ -1,7 +1,8 @@
 #pragma once
 
 #include <type_traits>  //  std::is_same
-#include <utility>  //  std::index_sequence, std::make_index_sequence
+#include <utility>  //  std::index_sequence, std::index_sequence_for
+#include <algorithm>  //  std::max
 #include <tuple>
 
 #include "../functional/cxx_universal.h"
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 3b4cc9acf..8a507b130 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -1033,7 +1033,8 @@ namespace sqlite_orm {
 // #include "tuple_helper/tuple_traits.h"
 
 #include <type_traits>  //  std::is_same
-#include <utility>  //  std::index_sequence, std::make_index_sequence
+#include <utility>  //  std::index_sequence, std::index_sequence_for
+#include <algorithm>  //  std::max
 #include <tuple>
 
 // #include "../functional/cxx_universal.h"
@@ -20301,7 +20302,7 @@ namespace sqlite_orm {
 }
 #pragma once
 
-// #include "functional/cxx_core_features.h"
+// #include "functional/cxx_universal.h"
 
 #ifdef SQLITE_ORM_WITH_CTE
 #include <utility>  //  std::make_index_sequence

From 99ad4f30a3382e9e4815673e442ea704e70eac60 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 2 Feb 2023 16:50:44 +0200
Subject: [PATCH 090/161] Qualified remaining calls to `std::move()`

---
 dev/ast/set.h                                 |  8 +--
 dev/carray.h                                  |  2 +-
 dev/cte_column_names_collector.h              |  4 +-
 dev/cte_storage.h                             | 12 ++--
 dev/index.h                                   |  2 +-
 dev/select_constraints.h                      | 24 +++----
 dev/statement_serializer.h                    |  2 +-
 dev/storage.h                                 |  4 +-
 dev/table_name_collector.h                    |  6 +-
 examples/case.cpp                             |  2 +-
 examples/check.cpp                            |  5 +-
 examples/column_aliases.cpp                   |  2 +-
 examples/core_functions.cpp                   | 11 ++--
 examples/custom_aliases.cpp                   |  4 +-
 examples/except_intersection.cpp              |  4 +-
 examples/generated_column.cpp                 |  2 +-
 examples/prepared_statement.cpp               |  6 +-
 examples/triggers.cpp                         |  3 +-
 include/sqlite_orm/sqlite_orm.h               | 64 +++++++++----------
 tests/backup_tests.cpp                        |  2 +-
 .../core_functions_tests.cpp                  | 15 +++--
 tests/constraints/unique.cpp                  |  6 +-
 tests/get_all_custom_containers.cpp           |  2 +-
 tests/index_tests.cpp                         |  2 +-
 tests/json.cpp                                |  2 +-
 tests/operators/glob.cpp                      |  2 +-
 tests/operators/is_null.cpp                   |  2 +-
 tests/operators/like.cpp                      |  2 +-
 tests/pointer_passing_interface.cpp           |  4 +-
 tests/prepared_statement_tests/insert.cpp     |  2 +-
 .../prepared_common.h                         |  4 +-
 tests/private_getters_tests.cpp               |  2 +-
 tests/select_constraints_tests.cpp            | 13 ++--
 .../column_names.cpp                          |  2 +-
 .../foreign_key.cpp                           |  2 +-
 .../statements/insert_replace.cpp             |  4 +-
 tests/static_tests/column_result_t.cpp        |  2 +-
 tests/static_tests/function_static_tests.cpp  |  2 +-
 tests/storage_non_crud_tests.cpp              | 14 ++--
 tests/sync_schema_tests.cpp                   |  4 +-
 tests/table_tests.cpp                         |  6 +-
 tests/tests.cpp                               |  8 +++
 tests/tests2.cpp                              |  2 +-
 tests/tests4.cpp                              |  4 +-
 tests/transaction_tests.cpp                   |  4 +-
 tests/trigger_tests.cpp                       |  6 +-
 .../unique_cases/get_all_with_two_tables.cpp  |  4 +-
 .../prepare_get_all_with_case.cpp             |  2 +-
 48 files changed, 153 insertions(+), 140 deletions(-)

diff --git a/dev/ast/set.h b/dev/ast/set.h
index 77a631ac9..c17615132 100644
--- a/dev/ast/set.h
+++ b/dev/ast/set.h
@@ -51,11 +51,11 @@ namespace sqlite_orm {
             }
 
             dynamic_set_t(dynamic_set_t&& other) :
-                entries(move(other.entries)), context(std::move(other.context)),
+                entries(std::move(other.entries)), context(std::move(other.context)),
                 collector([this](const std::type_index& ti) {
                     return find_table_name(this->context.db_objects, ti);
                 }) {
-                collector.table_names = move(other.collector.table_names);
+                collector.table_names = std::move(other.collector.table_names);
             }
 
             dynamic_set_t& operator=(const dynamic_set_t& other) {
@@ -68,12 +68,12 @@ namespace sqlite_orm {
             }
 
             dynamic_set_t& operator=(dynamic_set_t&& other) {
-                this->entries = move(other.entries);
+                this->entries = std::move(other.entries);
                 this->context = std::move(other.context);
                 this->collector = table_name_collector([this](const std::type_index& ti) {
                     return find_table_name(this->context.db_objects, ti);
                 });
-                this->collector.table_names = move(other.collector.table_names);
+                this->collector.table_names = std::move(other.collector.table_names);
             }
 
             template<class L, class R>
diff --git a/dev/carray.h b/dev/carray.h
index 4e7188792..fe1c1d128 100644
--- a/dev/carray.h
+++ b/dev/carray.h
@@ -50,7 +50,7 @@ namespace sqlite_orm {
 
     /**
      *  Generalized form of the 'remember' SQL function that is a pass-through for values
-     *  (it returns its argument unchanged using move semantics) but also saves the
+     *  (it returns its argument unchanged using std::move semantics) but also saves the
      *  value that is passed through into a bound variable.
      */
     template<typename P>
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index 32f17db9e..dd42ddbd4 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -61,7 +61,7 @@ namespace sqlite_orm {
                     throw std::system_error{orm_error_code::column_not_found};
                 }
                 unquote_or_erase(columnName);
-                return {move(columnName)};
+                return {std::move(columnName)};
             }
         };
 
@@ -136,7 +136,7 @@ namespace sqlite_orm {
                         columnName = serialize(m, newContext);
                     }
                     if(!columnName.empty()) {
-                        columnNames.push_back(move(columnName));
+                        columnNames.push_back(std::move(columnName));
                     } else {
                         throw std::system_error{orm_error_code::column_not_found};
                     }
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index ea33a98d4..27504046e 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -66,7 +66,7 @@ namespace sqlite_orm {
         static auto make_cte_column(std::string name, const ColRef& /*finalColRef*/) {
             using object_type = aliased_field<type_t<ColRef>, F>;
 
-            return sqlite_orm::make_column<>(move(name), &object_type::field);
+            return sqlite_orm::make_column<>(std::move(name), &object_type::field);
         }
 
         // F O::*
@@ -75,7 +75,7 @@ namespace sqlite_orm {
             using object_type = table_type_of_t<ColRef>;
             using column_type = column_t<ColRef, empty_setter>;
 
-            return column_type{move(name), finalColRef, empty_setter{}};
+            return column_type{std::move(name), finalColRef, empty_setter{}};
         }
 
         /**
@@ -250,8 +250,8 @@ namespace sqlite_orm {
                                                  const ColRefs& finalColRefs,
                                                  std::index_sequence<CIs...>) {
             return make_table<Mapper>(
-                move(tableName),
-                make_cte_column<std::tuple_element_t<CIs, typename Mapper::fields_type>>(move(columnNames.at(CIs)),
+                std::move(tableName),
+                make_cte_column<std::tuple_element_t<CIs, typename Mapper::fields_type>>(std::move(columnNames.at(CIs)),
                                                                                          get<CIs>(finalColRefs))...);
         }
 
@@ -286,8 +286,8 @@ namespace sqlite_orm {
                                                     polyfill::remove_cvref_t<decltype(finalColRefs)>,
                                                     column_results>;
             return make_cte_table_using_column_indices<mapper_type>(dbObjects,
-                                                                    move(tableName),
-                                                                    move(columnNames),
+                                                                    std::move(tableName),
+                                                                    std::move(columnNames),
                                                                     finalColRefs,
                                                                     index_sequence{});
         }
diff --git a/dev/index.h b/dev/index.h
index 39b6c2eb8..efa5a9ff5 100644
--- a/dev/index.h
+++ b/dev/index.h
@@ -55,7 +55,7 @@ namespace sqlite_orm {
         static_assert(internal::count_tuple<cols_tuple, internal::is_where>::value <= 1,
                       "amount of where arguments can be 0 or 1");
         SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(
-            return {move(name), false, std::make_tuple(internal::make_indexed_column(std::move(cols))...)});
+            return {std::move(name), false, std::make_tuple(internal::make_indexed_column(std::move(cols))...)});
     }
 
     template<class... Cols>
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index d3ba3f24a..b4a2903f8 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -228,7 +228,7 @@ namespace sqlite_orm {
             expression_type subselect;
 
             common_table_expression(explicit_colrefs_tuple explicitColumns, expression_type subselect) :
-                explicitColumns{move(explicitColumns)}, subselect{std::move(subselect)} {
+                explicitColumns{std::move(explicitColumns)}, subselect{std::move(subselect)} {
                 this->subselect.highest_level = true;
             }
         };
@@ -241,52 +241,52 @@ namespace sqlite_orm {
 
             template<class T, class... Args>
             common_table_expression<Label, select_t<T, Args...>, ExplicitCols> operator()(select_t<T, Args...> sel) && {
-                return {move(this->explicitColumns), std::move(sel)};
+                return {std::move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
             common_table_expression<Label, select_t<Compound>, ExplicitCols> operator()(Compound sel) && {
-                return {move(this->explicitColumns), {std::move(sel)}};
+                return {std::move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
             common_table_expression<Label, select_t<T, Args...>, ExplicitCols> as(select_t<T, Args...> sel) && {
-                return {move(this->explicitColumns), std::move(sel)};
+                return {std::move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
             common_table_expression<Label, select_t<Compound>, ExplicitCols> as(Compound sel) && {
-                return {move(this->explicitColumns), {std::move(sel)}};
+                return {std::move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
             common_table_expression<Label, select_t<T, Args...>, ExplicitCols>
             materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumns), std::move(sel)};
+                return {std::move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
             common_table_expression<Label, select_t<Compound>, ExplicitCols> materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumns), {std::move(sel)}};
+                return {std::move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
             common_table_expression<Label, select_t<T, Args...>, ExplicitCols>
             not_materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumns), std::move(sel)};
+                return {std::move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
             common_table_expression<Label, select_t<Compound>, ExplicitCols> not_materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumns), {std::move(sel)}};
+                return {std::move(this->explicitColumns), {std::move(sel)}};
             }
         };
 
@@ -301,7 +301,7 @@ namespace sqlite_orm {
             cte_type cte;
             expression_type expression;
 
-            with_t(cte_type cte, expression_type expression) : cte{move(cte)}, expression{std::move(expression)} {
+            with_t(cte_type cte, expression_type expression) : cte{std::move(cte)}, expression{std::move(expression)} {
                 this->expression.highest_level = true;
             }
         };
@@ -541,7 +541,7 @@ namespace sqlite_orm {
     template<class E, class... Labels, class... Selects, class... ExplicitCols>
     internal::with_t<E, internal::common_table_expression<Labels, Selects, ExplicitCols>...>
     with(std::tuple<internal::common_table_expression<Labels, Selects, ExplicitCols>...> cte, E expression) {
-        return {move(cte), std::move(expression)};
+        return {std::move(cte), std::move(expression)};
     }
 
     /** A single CTE.
@@ -550,7 +550,7 @@ namespace sqlite_orm {
     template<class E, class Label, class Select, class ExplicitCols>
     internal::with_t<E, internal::common_table_expression<Label, Select, ExplicitCols>>
     with(internal::common_table_expression<Label, Select, ExplicitCols> cte, E expression) {
-        return {std::make_tuple(move(cte)), std::move(expression)};
+        return {std::make_tuple(std::move(cte)), std::move(expression)};
     }
 #endif
 
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index 29b86ca06..0e37b3d51 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -1173,7 +1173,7 @@ namespace sqlite_orm {
         struct table_name_collector_holder<set_t<Args...>> {
 
             table_name_collector_holder(table_name_collector::find_table_name_t find_table_name) :
-                collector(move(find_table_name)) {}
+                collector(std::move(find_table_name)) {}
 
             table_name_collector collector;
         };
diff --git a/dev/storage.h b/dev/storage.h
index b35acd1b0..417765ead 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -594,7 +594,7 @@ namespace sqlite_orm {
              */
             template<class... CTEs, class T, class... Args>
             auto with(common_table_expressions<CTEs...> cte, select_t<T, Args...> sel) {
-                auto statement = this->prepare(sqlite_orm::with(move(cte), std::move(sel)));
+                auto statement = this->prepare(sqlite_orm::with(std::move(cte), std::move(sel)));
                 return this->execute(statement);
             }
 
@@ -616,7 +616,7 @@ namespace sqlite_orm {
                      class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
             auto with(common_table_expressions<CTEs...> cte, Compound sel) {
-                auto statement = this->prepare(sqlite_orm::with(move(cte), sqlite_orm::select(std::move(sel))));
+                auto statement = this->prepare(sqlite_orm::with(std::move(cte), sqlite_orm::select(std::move(sel))));
                 return this->execute(statement);
             }
 #endif
diff --git a/dev/table_name_collector.h b/dev/table_name_collector.h
index 8114956cd..4ec677b3a 100644
--- a/dev/table_name_collector.h
+++ b/dev/table_name_collector.h
@@ -40,14 +40,14 @@ namespace sqlite_orm {
             template<class T, class F>
             void operator()(const column_pointer<T, F>&) const {
                 auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<T>));
-                table_names.emplace(move(tableName), alias_extractor<T>::as_alias());
+                table_names.emplace(std::move(tableName), alias_extractor<T>::as_alias());
             }
 
             template<class A, class C>
             void operator()(const alias_column_t<A, C>&) const {
                 // note: instead of accessing the column, we are interested in the type the column is aliased into
                 auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<A>));
-                table_names.emplace(move(tableName), alias_extractor<A>::as_alias());
+                table_names.emplace(std::move(tableName), alias_extractor<A>::as_alias());
             }
 
             template<class T>
@@ -61,7 +61,7 @@ namespace sqlite_orm {
             template<class T>
             void operator()(const asterisk_t<T>&) const {
                 auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<T>));
-                table_names.emplace(move(tableName), alias_extractor<T>::as_alias());
+                table_names.emplace(std::move(tableName), alias_extractor<T>::as_alias());
             }
 
             template<class T>
diff --git a/examples/case.cpp b/examples/case.cpp
index ef0dbd6cd..8d288e82a 100644
--- a/examples/case.cpp
+++ b/examples/case.cpp
@@ -19,7 +19,7 @@ int main() {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Student() {}
         Student(int id, std::string name, std::string email, float marks) :
-            id{id}, name{move(name)}, email{move(email)}, marks{marks} {}
+            id{id}, name{std::move(name)}, email{std::move(email)}, marks{marks} {}
 #endif
     };
 
diff --git a/examples/check.cpp b/examples/check.cpp
index e6e74fc72..c19456db2 100644
--- a/examples/check.cpp
+++ b/examples/check.cpp
@@ -17,7 +17,8 @@ int main() {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Contact() {}
         Contact(int id, std::string firstName, std::string lastName, std::string email, std::string phone) :
-            id{id}, firstName{move(firstName)}, lastName{move(lastName)}, email{move(email)}, phone{move(phone)} {}
+            id{id}, firstName{std::move(firstName)}, lastName{std::move(lastName)}, email{std::move(email)},
+            phone{std::move(phone)} {}
 #endif
     };
 
@@ -30,7 +31,7 @@ int main() {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Product() {}
         Product(int id, std::string name, float listPrice, float discount) :
-            id{id}, name{move(name)}, listPrice{listPrice}, discount{discount} {}
+            id{id}, name{std::move(name)}, listPrice{listPrice}, discount{discount} {}
 #endif
     };
 
diff --git a/examples/column_aliases.cpp b/examples/column_aliases.cpp
index e5a881169..afcb100e8 100644
--- a/examples/column_aliases.cpp
+++ b/examples/column_aliases.cpp
@@ -17,7 +17,7 @@ void marvel_hero_ordered_by_o_pos() {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         MarvelHero() {}
         MarvelHero(int id, std::string name, std::string abilities, short points) :
-            id{id}, name{move(name)}, abilities{move(abilities)}, points{points} {}
+            id{id}, name{std::move(name)}, abilities{std::move(abilities)}, points{points} {}
 #endif
     };
 
diff --git a/examples/core_functions.cpp b/examples/core_functions.cpp
index 9a6520223..4f783db21 100644
--- a/examples/core_functions.cpp
+++ b/examples/core_functions.cpp
@@ -14,7 +14,7 @@ struct MarvelHero {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
     MarvelHero() {}
     MarvelHero(int id, std::string name, std::string abilities, short points) :
-        id{id}, name{move(name)}, abilities{move(abilities)}, points{points} {}
+        id{id}, name{std::move(name)}, abilities{std::move(abilities)}, points{points} {}
 #endif
 };
 
@@ -27,7 +27,7 @@ struct Contact {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
     Contact() {}
     Contact(int id, std::string firstName, std::string lastName, std::string phone) :
-        id{id}, firstName{move(firstName)}, lastName{move(lastName)}, phone{move(phone)} {}
+        id{id}, firstName{std::move(firstName)}, lastName{std::move(lastName)}, phone{std::move(phone)} {}
 #endif
 };
 
@@ -62,9 +62,10 @@ struct Customer {
              std::string email,
              int supportRepId) :
         id{id},
-        firstName{move(firstName)}, lastName{move(lastName)}, company{move(company)}, address{move(address)},
-        city{move(city)}, state{move(state)}, country{move(country)}, postalCode{move(postalCode)}, phone{move(phone)},
-        fax{move(fax)}, email{move(email)}, supportRepId{supportRepId} {}
+        firstName{std::move(firstName)}, lastName{std::move(lastName)}, company{std::move(company)},
+        address{std::move(address)}, city{std::move(city)}, state{std::move(state)}, country{std::move(country)},
+        postalCode{std::move(postalCode)}, phone{std::move(phone)}, fax{std::move(fax)}, email{std::move(email)},
+        supportRepId{supportRepId} {}
 #endif
 };
 
diff --git a/examples/custom_aliases.cpp b/examples/custom_aliases.cpp
index 47daf1553..0d6ffa7ca 100644
--- a/examples/custom_aliases.cpp
+++ b/examples/custom_aliases.cpp
@@ -21,7 +21,7 @@ struct Employee {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
     Employee() {}
     Employee(int id, std::string name, int age, std::string address, float salary) :
-        id{id}, name{move(name)}, age{age}, address{move(address)}, salary{salary} {}
+        id{id}, name{std::move(name)}, age{age}, address{std::move(address)}, salary{salary} {}
 #endif
 };
 
@@ -32,7 +32,7 @@ struct Department {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
     Department() {}
-    Department(int id, std::string dept, int empId) : id{id}, dept{move(dept)}, empId{empId} {}
+    Department(int id, std::string dept, int empId) : id{id}, dept{std::move(dept)}, empId{empId} {}
 #endif
 };
 
diff --git a/examples/except_intersection.cpp b/examples/except_intersection.cpp
index 03a36d151..97a7629ed 100644
--- a/examples/except_intersection.cpp
+++ b/examples/except_intersection.cpp
@@ -14,7 +14,7 @@ struct DeptMaster {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
     DeptMaster() = default;
-    DeptMaster(int deptId, std::string deptName) : deptId{deptId}, deptName{move(deptName)} {}
+    DeptMaster(int deptId, std::string deptName) : deptId{deptId}, deptName{std::move(deptName)} {}
 #endif
 };
 
@@ -33,7 +33,7 @@ struct EmpMaster {
               long salary,
               decltype(DeptMaster::deptId) deptId) :
         empId{empId},
-        firstName{move(firstName)}, lastName{move(lastName)}, salary{salary}, deptId{deptId} {}
+        firstName{std::move(firstName)}, lastName{std::move(lastName)}, salary{salary}, deptId{deptId} {}
 #endif
 };
 
diff --git a/examples/generated_column.cpp b/examples/generated_column.cpp
index e8e8cfb95..699cf3963 100644
--- a/examples/generated_column.cpp
+++ b/examples/generated_column.cpp
@@ -22,7 +22,7 @@ int main() {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Product() {}
         Product(int id, std::string name, int quantity, float price, float totalValue = 0.f) :
-            id{id}, name{move(name)}, quantity{quantity}, price{price}, totalValue{totalValue} {}
+            id{id}, name{std::move(name)}, quantity{quantity}, price{price}, totalValue{totalValue} {}
 #endif
     };
     auto storage = make_storage({},
diff --git a/examples/prepared_statement.cpp b/examples/prepared_statement.cpp
index 6a43a883f..e637e72bd 100644
--- a/examples/prepared_statement.cpp
+++ b/examples/prepared_statement.cpp
@@ -22,7 +22,7 @@ struct Doctor {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
     Doctor() = default;
     Doctor(int doctor_id, std::string doctor_name, std::string degree) :
-        doctor_id{doctor_id}, doctor_name{move(doctor_name)}, degree{move(degree)} {}
+        doctor_id{doctor_id}, doctor_name{std::move(doctor_name)}, degree{std::move(degree)} {}
 #endif
 };
 
@@ -34,7 +34,7 @@ struct Speciality {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
     Speciality() = default;
     Speciality(int spl_id, std::string spl_descrip, int doctor_id) :
-        spl_id{spl_id}, spl_descrip{move(spl_descrip)}, doctor_id{doctor_id} {}
+        spl_id{spl_id}, spl_descrip{std::move(spl_descrip)}, doctor_id{doctor_id} {}
 #endif
 };
 
@@ -46,7 +46,7 @@ struct Visit {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
     Visit() = default;
     Visit(int doctor_id, std::string patient_name, std::string vdate) :
-        doctor_id{doctor_id}, patient_name{move(patient_name)}, vdate{move(vdate)} {}
+        doctor_id{doctor_id}, patient_name{std::move(patient_name)}, vdate{std::move(vdate)} {}
 #endif
 };
 
diff --git a/examples/triggers.cpp b/examples/triggers.cpp
index 0a8dc6726..d2a2c2ca1 100644
--- a/examples/triggers.cpp
+++ b/examples/triggers.cpp
@@ -20,7 +20,8 @@ struct Lead {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
     Lead() = default;
     Lead(int id, std::string firstName, std::string lastName, std::string email, std::string phone) :
-        id{id}, firstName{move(firstName)}, lastName{move(lastName)}, email{move(email)}, phone{move(phone)} {}
+        id{id}, firstName{std::move(firstName)}, lastName{std::move(lastName)}, email{std::move(email)},
+        phone{std::move(phone)} {}
 #endif
 };
 
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index f7c8a1292..73916d7a9 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -7523,7 +7523,7 @@ namespace sqlite_orm {
             expression_type subselect;
 
             common_table_expression(explicit_colrefs_tuple explicitColumns, expression_type subselect) :
-                explicitColumns{move(explicitColumns)}, subselect{std::move(subselect)} {
+                explicitColumns{std::move(explicitColumns)}, subselect{std::move(subselect)} {
                 this->subselect.highest_level = true;
             }
         };
@@ -7536,52 +7536,52 @@ namespace sqlite_orm {
 
             template<class T, class... Args>
             common_table_expression<Label, select_t<T, Args...>, ExplicitCols> operator()(select_t<T, Args...> sel) && {
-                return {move(this->explicitColumns), std::move(sel)};
+                return {std::move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
             common_table_expression<Label, select_t<Compound>, ExplicitCols> operator()(Compound sel) && {
-                return {move(this->explicitColumns), {std::move(sel)}};
+                return {std::move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
             common_table_expression<Label, select_t<T, Args...>, ExplicitCols> as(select_t<T, Args...> sel) && {
-                return {move(this->explicitColumns), std::move(sel)};
+                return {std::move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
             common_table_expression<Label, select_t<Compound>, ExplicitCols> as(Compound sel) && {
-                return {move(this->explicitColumns), {std::move(sel)}};
+                return {std::move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
             common_table_expression<Label, select_t<T, Args...>, ExplicitCols>
             materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumns), std::move(sel)};
+                return {std::move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
             common_table_expression<Label, select_t<Compound>, ExplicitCols> materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumns), {std::move(sel)}};
+                return {std::move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
             common_table_expression<Label, select_t<T, Args...>, ExplicitCols>
             not_materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumns), std::move(sel)};
+                return {std::move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
             common_table_expression<Label, select_t<Compound>, ExplicitCols> not_materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
-                return {move(this->explicitColumns), {std::move(sel)}};
+                return {std::move(this->explicitColumns), {std::move(sel)}};
             }
         };
 
@@ -7596,7 +7596,7 @@ namespace sqlite_orm {
             cte_type cte;
             expression_type expression;
 
-            with_t(cte_type cte, expression_type expression) : cte{move(cte)}, expression{std::move(expression)} {
+            with_t(cte_type cte, expression_type expression) : cte{std::move(cte)}, expression{std::move(expression)} {
                 this->expression.highest_level = true;
             }
         };
@@ -7836,7 +7836,7 @@ namespace sqlite_orm {
     template<class E, class... Labels, class... Selects, class... ExplicitCols>
     internal::with_t<E, internal::common_table_expression<Labels, Selects, ExplicitCols>...>
     with(std::tuple<internal::common_table_expression<Labels, Selects, ExplicitCols>...> cte, E expression) {
-        return {move(cte), std::move(expression)};
+        return {std::move(cte), std::move(expression)};
     }
 
     /** A single CTE.
@@ -7845,7 +7845,7 @@ namespace sqlite_orm {
     template<class E, class Label, class Select, class ExplicitCols>
     internal::with_t<E, internal::common_table_expression<Label, Select, ExplicitCols>>
     with(internal::common_table_expression<Label, Select, ExplicitCols> cte, E expression) {
-        return {std::make_tuple(move(cte)), std::move(expression)};
+        return {std::make_tuple(std::move(cte)), std::move(expression)};
     }
 #endif
 
@@ -9822,7 +9822,7 @@ namespace sqlite_orm {
         static_assert(internal::count_tuple<cols_tuple, internal::is_where>::value <= 1,
                       "amount of where arguments can be 0 or 1");
         SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(
-            return {move(name), false, std::make_tuple(internal::make_indexed_column(std::move(cols))...)});
+            return {std::move(name), false, std::make_tuple(internal::make_indexed_column(std::move(cols))...)});
     }
 
     template<class... Cols>
@@ -12125,14 +12125,14 @@ namespace sqlite_orm {
             template<class T, class F>
             void operator()(const column_pointer<T, F>&) const {
                 auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<T>));
-                table_names.emplace(move(tableName), alias_extractor<T>::as_alias());
+                table_names.emplace(std::move(tableName), alias_extractor<T>::as_alias());
             }
 
             template<class A, class C>
             void operator()(const alias_column_t<A, C>&) const {
                 // note: instead of accessing the column, we are interested in the type the column is aliased into
                 auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<A>));
-                table_names.emplace(move(tableName), alias_extractor<A>::as_alias());
+                table_names.emplace(std::move(tableName), alias_extractor<A>::as_alias());
             }
 
             template<class T>
@@ -12146,7 +12146,7 @@ namespace sqlite_orm {
             template<class T>
             void operator()(const asterisk_t<T>&) const {
                 auto tableName = this->find_table_name(typeid(mapped_type_proxy_t<T>));
-                table_names.emplace(move(tableName), alias_extractor<T>::as_alias());
+                table_names.emplace(std::move(tableName), alias_extractor<T>::as_alias());
             }
 
             template<class T>
@@ -12217,11 +12217,11 @@ namespace sqlite_orm {
             }
 
             dynamic_set_t(dynamic_set_t&& other) :
-                entries(move(other.entries)), context(std::move(other.context)),
+                entries(std::move(other.entries)), context(std::move(other.context)),
                 collector([this](const std::type_index& ti) {
                     return find_table_name(this->context.db_objects, ti);
                 }) {
-                collector.table_names = move(other.collector.table_names);
+                collector.table_names = std::move(other.collector.table_names);
             }
 
             dynamic_set_t& operator=(const dynamic_set_t& other) {
@@ -12234,12 +12234,12 @@ namespace sqlite_orm {
             }
 
             dynamic_set_t& operator=(dynamic_set_t&& other) {
-                this->entries = move(other.entries);
+                this->entries = std::move(other.entries);
                 this->context = std::move(other.context);
                 this->collector = table_name_collector([this](const std::type_index& ti) {
                     return find_table_name(this->context.db_objects, ti);
                 });
-                this->collector.table_names = move(other.collector.table_names);
+                this->collector.table_names = std::move(other.collector.table_names);
             }
 
             template<class L, class R>
@@ -16225,7 +16225,7 @@ namespace sqlite_orm {
                     throw std::system_error{orm_error_code::column_not_found};
                 }
                 unquote_or_erase(columnName);
-                return {move(columnName)};
+                return {std::move(columnName)};
             }
         };
 
@@ -16300,7 +16300,7 @@ namespace sqlite_orm {
                         columnName = serialize(m, newContext);
                     }
                     if(!columnName.empty()) {
-                        columnNames.push_back(move(columnName));
+                        columnNames.push_back(std::move(columnName));
                     } else {
                         throw std::system_error{orm_error_code::column_not_found};
                     }
@@ -17591,7 +17591,7 @@ namespace sqlite_orm {
         struct table_name_collector_holder<set_t<Args...>> {
 
             table_name_collector_holder(table_name_collector::find_table_name_t find_table_name) :
-                collector(move(find_table_name)) {}
+                collector(std::move(find_table_name)) {}
 
             table_name_collector collector;
         };
@@ -18783,7 +18783,7 @@ namespace sqlite_orm {
         static auto make_cte_column(std::string name, const ColRef& /*finalColRef*/) {
             using object_type = aliased_field<type_t<ColRef>, F>;
 
-            return sqlite_orm::make_column<>(move(name), &object_type::field);
+            return sqlite_orm::make_column<>(std::move(name), &object_type::field);
         }
 
         // F O::*
@@ -18792,7 +18792,7 @@ namespace sqlite_orm {
             using object_type = table_type_of_t<ColRef>;
             using column_type = column_t<ColRef, empty_setter>;
 
-            return column_type{move(name), finalColRef, empty_setter{}};
+            return column_type{std::move(name), finalColRef, empty_setter{}};
         }
 
         /**
@@ -18967,8 +18967,8 @@ namespace sqlite_orm {
                                                  const ColRefs& finalColRefs,
                                                  std::index_sequence<CIs...>) {
             return make_table<Mapper>(
-                move(tableName),
-                make_cte_column<std::tuple_element_t<CIs, typename Mapper::fields_type>>(move(columnNames.at(CIs)),
+                std::move(tableName),
+                make_cte_column<std::tuple_element_t<CIs, typename Mapper::fields_type>>(std::move(columnNames.at(CIs)),
                                                                                          get<CIs>(finalColRefs))...);
         }
 
@@ -19003,8 +19003,8 @@ namespace sqlite_orm {
                                                     polyfill::remove_cvref_t<decltype(finalColRefs)>,
                                                     column_results>;
             return make_cte_table_using_column_indices<mapper_type>(dbObjects,
-                                                                    move(tableName),
-                                                                    move(columnNames),
+                                                                    std::move(tableName),
+                                                                    std::move(columnNames),
                                                                     finalColRefs,
                                                                     index_sequence{});
         }
@@ -19595,7 +19595,7 @@ namespace sqlite_orm {
              */
             template<class... CTEs, class T, class... Args>
             auto with(common_table_expressions<CTEs...> cte, select_t<T, Args...> sel) {
-                auto statement = this->prepare(sqlite_orm::with(move(cte), std::move(sel)));
+                auto statement = this->prepare(sqlite_orm::with(std::move(cte), std::move(sel)));
                 return this->execute(statement);
             }
 
@@ -19617,7 +19617,7 @@ namespace sqlite_orm {
                      class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
             auto with(common_table_expressions<CTEs...> cte, Compound sel) {
-                auto statement = this->prepare(sqlite_orm::with(move(cte), sqlite_orm::select(std::move(sel))));
+                auto statement = this->prepare(sqlite_orm::with(std::move(cte), sqlite_orm::select(std::move(sel))));
                 return this->execute(statement);
             }
 #endif
@@ -21153,7 +21153,7 @@ namespace sqlite_orm {
 
     /**
      *  Generalized form of the 'remember' SQL function that is a pass-through for values
-     *  (it returns its argument unchanged using move semantics) but also saves the
+     *  (it returns its argument unchanged using std::move semantics) but also saves the
      *  value that is passed through into a bound variable.
      */
     template<typename P>
diff --git a/tests/backup_tests.cpp b/tests/backup_tests.cpp
index 0f127cd0d..3d4df0835 100644
--- a/tests/backup_tests.cpp
+++ b/tests/backup_tests.cpp
@@ -11,7 +11,7 @@ namespace {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User() = default;
-        User(int id, std::string name) : id{id}, name{move(name)} {}
+        User(int id, std::string name) : id{id}, name{std::move(name)} {}
 #endif
     };
 
diff --git a/tests/built_in_functions_tests/core_functions_tests.cpp b/tests/built_in_functions_tests/core_functions_tests.cpp
index 312cbc85d..3faf6623f 100644
--- a/tests/built_in_functions_tests/core_functions_tests.cpp
+++ b/tests/built_in_functions_tests/core_functions_tests.cpp
@@ -11,7 +11,7 @@ TEST_CASE("substr") {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Test() = default;
-        Test(std::string text, int x, int y) : text{move(text)}, x{x}, y{y} {}
+        Test(std::string text, int x, int y) : text{std::move(text)}, x{x}, y{y} {}
 #endif
     };
     auto storage = make_storage(
@@ -184,7 +184,7 @@ TEST_CASE("quote") {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Department() = default;
         Department(int id, std::string name, int managerId, int locationId) :
-            id{id}, name{move(name)}, managerId{managerId}, locationId{locationId} {}
+            id{id}, name{std::move(name)}, managerId{managerId}, locationId{locationId} {}
 #endif
     };
     auto storage = make_storage({},
@@ -268,7 +268,7 @@ TEST_CASE("instr") {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Employee() = default;
         Employee(int id, std::string firstName, std::string lastName, std::string address) :
-            id{id}, firstName{move(firstName)}, lastName{move(lastName)}, address{move(address)} {}
+            id{id}, firstName{std::move(firstName)}, lastName{std::move(lastName)}, address{std::move(address)} {}
 #endif
     };
 
@@ -340,7 +340,7 @@ namespace replace_func_local {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Contact() = default;
         Contact(int id, std::string firstName, std::string lastName, std::string phone) :
-            id{id}, firstName{move(firstName)}, lastName{move(lastName)}, phone{move(phone)} {}
+            id{id}, firstName{std::move(firstName)}, lastName{std::move(lastName)}, phone{std::move(phone)} {}
 #endif
     };
 
@@ -541,9 +541,10 @@ TEST_CASE("ifnull") {
                  std::string email,
                  int supportRepId) :
             id{id},
-            firstName{move(firstName)}, lastName{move(lastName)}, company{move(company)}, address{move(address)},
-            city{move(city)}, state{move(state)}, country{move(country)}, postalCode{move(postalCode)},
-            phone{move(phone)}, fax{move(fax)}, email{move(email)}, supportRepId{supportRepId} {}
+            firstName{std::move(firstName)}, lastName{std::move(lastName)}, company{std::move(company)},
+            address{std::move(address)}, city{std::move(city)}, state{std::move(state)}, country{std::move(country)},
+            postalCode{std::move(postalCode)}, phone{std::move(phone)}, fax{std::move(fax)}, email{std::move(email)},
+            supportRepId{supportRepId} {}
 #endif
     };
     auto storage = make_storage({},
diff --git a/tests/constraints/unique.cpp b/tests/constraints/unique.cpp
index 300570a60..dd7a81be9 100644
--- a/tests/constraints/unique.cpp
+++ b/tests/constraints/unique.cpp
@@ -15,7 +15,7 @@ TEST_CASE("Unique") {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Contact() = default;
         Contact(int id, std::string firstName, std::string lastName, std::string email) :
-            id{id}, firstName{move(firstName)}, lastName{move(lastName)}, email{move(email)} {}
+            id{id}, firstName{std::move(firstName)}, lastName{std::move(lastName)}, email{std::move(email)} {}
 #endif
     };
     struct Shape {
@@ -26,7 +26,7 @@ TEST_CASE("Unique") {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Shape() = default;
         Shape(int id, std::string backgroundColor, std::string foregroundColor) :
-            id{id}, backgroundColor{move(backgroundColor)}, foregroundColor{move(foregroundColor)} {}
+            id{id}, backgroundColor{std::move(backgroundColor)}, foregroundColor{std::move(foregroundColor)} {}
 #endif
     };
     struct List {
@@ -35,7 +35,7 @@ TEST_CASE("Unique") {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         List() = default;
-        List(int id, decltype(email) email) : id{id}, email{move(email)} {}
+        List(int id, decltype(email) email) : id{id}, email{std::move(email)} {}
 #endif
     };
 
diff --git a/tests/get_all_custom_containers.cpp b/tests/get_all_custom_containers.cpp
index 00eaf931d..99d05bc0a 100644
--- a/tests/get_all_custom_containers.cpp
+++ b/tests/get_all_custom_containers.cpp
@@ -13,7 +13,7 @@ namespace {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User() = default;
-        User(int id, std::string name) : id{id}, name{move(name)} {}
+        User(int id, std::string name) : id{id}, name{std::move(name)} {}
 #endif
     };
 
diff --git a/tests/index_tests.cpp b/tests/index_tests.cpp
index b3ca02827..080967656 100644
--- a/tests/index_tests.cpp
+++ b/tests/index_tests.cpp
@@ -105,7 +105,7 @@ TEST_CASE("Compound index") {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User() = default;
-        User(int id, std::string name) : id{id}, name{move(name)} {}
+        User(int id, std::string name) : id{id}, name{std::move(name)} {}
 #endif
     };
     auto table = make_table("users", make_column("id", &User::id), make_column("name", &User::name));
diff --git a/tests/json.cpp b/tests/json.cpp
index 88534489d..ebc223892 100644
--- a/tests/json.cpp
+++ b/tests/json.cpp
@@ -97,7 +97,7 @@ TEST_CASE("json_array_length nullable") {
         rows = storage.select(json_array_length<Type>("{\"one\":[1,2,3]}", "$.two"));
         expected = nullptr;
     }
-    value = move(rows[0]);
+    value = std::move(rows[0]);
     REQUIRE(rows.size() == 1);
     REQUIRE(bool(expected) == bool(value));
     if(expected) {
diff --git a/tests/operators/glob.cpp b/tests/operators/glob.cpp
index d44c92ab1..43ebf5113 100644
--- a/tests/operators/glob.cpp
+++ b/tests/operators/glob.cpp
@@ -19,7 +19,7 @@ namespace {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Employee() = default;
         Employee(int id, std::string firstName, std::string lastName, float salary, int deptId) :
-            id{id}, firstName{move(firstName)}, lastName{move(lastName)}, salary{salary}, deptId{deptId} {}
+            id{id}, firstName{std::move(firstName)}, lastName{std::move(lastName)}, salary{salary}, deptId{deptId} {}
 #endif
     };
 }
diff --git a/tests/operators/is_null.cpp b/tests/operators/is_null.cpp
index c358ab3f0..473559e99 100644
--- a/tests/operators/is_null.cpp
+++ b/tests/operators/is_null.cpp
@@ -10,7 +10,7 @@ TEST_CASE("Is null") {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User() = default;
-        User(int id, decltype(name) name = nullptr) : id{id}, name{move(name)} {}
+        User(int id, decltype(name) name = nullptr) : id{id}, name{std::move(name)} {}
 #endif
     };
     auto storage = make_storage(
diff --git a/tests/operators/like.cpp b/tests/operators/like.cpp
index 18a701cf6..65b68ae73 100644
--- a/tests/operators/like.cpp
+++ b/tests/operators/like.cpp
@@ -10,7 +10,7 @@ TEST_CASE("Like operator") {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User() = default;
-        User(int id, std::string name) : id{id}, name{move(name)} {}
+        User(int id, std::string name) : id{id}, name{std::move(name)} {}
 #endif
     };
     struct Pattern {
diff --git a/tests/pointer_passing_interface.cpp b/tests/pointer_passing_interface.cpp
index 5a13c80c6..8a6a4a030 100644
--- a/tests/pointer_passing_interface.cpp
+++ b/tests/pointer_passing_interface.cpp
@@ -112,7 +112,7 @@ TEST_CASE("pointer-passing") {
         SECTION("unbound is deleted") {
             try {
                 unique_ptr<int64, delete_int64> x{new int64(42)};
-                auto ast = select(func<fetch_from_pointer_fn>(bindable_pointer<carray_pvt>(move(x))));
+                auto ast = select(func<fetch_from_pointer_fn>(bindable_pointer<carray_pvt>(std::move(x))));
                 auto stmt = storage.prepare(std::move(ast));
                 throw std::system_error{0, std::system_category()};
             } catch(const std::system_error&) {
@@ -124,7 +124,7 @@ TEST_CASE("pointer-passing") {
         SECTION("deleted with prepared statement") {
             {
                 unique_ptr<int64, delete_int64> x{new int64(42)};
-                auto ast = select(func<fetch_from_pointer_fn>(bindable_pointer<carray_pvt>(move(x))));
+                auto ast = select(func<fetch_from_pointer_fn>(bindable_pointer<carray_pvt>(std::move(x))));
                 auto stmt = storage.prepare(std::move(ast));
 
                 storage.execute(stmt);
diff --git a/tests/prepared_statement_tests/insert.cpp b/tests/prepared_statement_tests/insert.cpp
index 8a5d88835..e5e00814b 100644
--- a/tests/prepared_statement_tests/insert.cpp
+++ b/tests/prepared_statement_tests/insert.cpp
@@ -15,7 +15,7 @@ TEST_CASE("Prepared insert") {
 
         Artist() = default;
 
-        Artist(decltype(id) id_, decltype(name) name_) : id(id_), name(move(name_)) {}
+        Artist(decltype(id) id_, decltype(name) name_) : id(id_), name(std::move(name_)) {}
 
         Artist(const Artist& other) :
             id(other.id), name(other.name ? std::make_unique<std::string>(*other.name) : nullptr) {}
diff --git a/tests/prepared_statement_tests/prepared_common.h b/tests/prepared_statement_tests/prepared_common.h
index bc18a96f1..f45d30287 100644
--- a/tests/prepared_statement_tests/prepared_common.h
+++ b/tests/prepared_statement_tests/prepared_common.h
@@ -12,7 +12,7 @@ namespace PreparedStatementTests {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User() = default;
-        User(int id, std::string name) : id{id}, name{move(name)} {}
+        User(int id, std::string name) : id{id}, name{std::move(name)} {}
 #endif
     };
 
@@ -38,7 +38,7 @@ namespace PreparedStatementTests {
                      decltype(UserAndVisit::visitId) visitId,
                      std::string description) :
             userId{userId},
-            visitId{visitId}, description{move(description)} {}
+            visitId{visitId}, description{std::move(description)} {}
 #endif
     };
 
diff --git a/tests/private_getters_tests.cpp b/tests/private_getters_tests.cpp
index 21e72400c..b5a138cff 100644
--- a/tests/private_getters_tests.cpp
+++ b/tests/private_getters_tests.cpp
@@ -9,7 +9,7 @@ TEST_CASE("Issue 343") {
       public:
         A() = default;
 
-        A(int id_, std::string name_) : name(move(name_)), id(id_) {}
+        A(int id_, std::string name_) : name(std::move(name_)), id(id_) {}
 
         int getId() const {
             return this->id;
diff --git a/tests/select_constraints_tests.cpp b/tests/select_constraints_tests.cpp
index bf085276c..c1d4d7d08 100644
--- a/tests/select_constraints_tests.cpp
+++ b/tests/select_constraints_tests.cpp
@@ -219,7 +219,7 @@ namespace {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User1() = default;
-        User1(int id, std::string name) : id{id}, name{move(name)} {}
+        User1(int id, std::string name) : id{id}, name{std::move(name)} {}
 #endif
     };
 
@@ -270,7 +270,7 @@ namespace {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User2() = default;
         User2(int id, std::string firstName, std::string lastName, std::string country) :
-            id{id}, firstName{move(firstName)}, lastName{move(lastName)}, country{country} {}
+            id{id}, firstName{std::move(firstName)}, lastName{std::move(lastName)}, country{country} {}
 #endif
     };
 
@@ -281,7 +281,8 @@ namespace {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Track2() = default;
-        Track2(int id, std::string name, long milliseconds) : id{id}, name{move(name)}, milliseconds{milliseconds} {}
+        Track2(int id, std::string name, long milliseconds) :
+            id{id}, name{std::move(name)}, milliseconds{milliseconds} {}
 #endif
     };
 
@@ -377,7 +378,7 @@ namespace {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User3() = default;
-        User3(int id, int age, std::string name) : id{id}, age{age}, name{move(name)} {}
+        User3(int id, int age, std::string name) : id{id}, age{age}, name{std::move(name)} {}
 #endif
     };
 
@@ -420,7 +421,7 @@ namespace {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User4() = default;
-        User4(int id, std::string firstName) : id{id}, firstName{move(firstName)} {}
+        User4(int id, std::string firstName) : id{id}, firstName{std::move(firstName)} {}
 #endif
 
         bool operator==(const User4& user) const {
@@ -457,7 +458,7 @@ namespace {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User5() = default;
         User5(int id, std::string firstName, std::string lastName, long registerTime) :
-            id{id}, firstName{move(firstName)}, lastName{move(lastName)}, registerTime{registerTime} {}
+            id{id}, firstName{std::move(firstName)}, lastName{std::move(lastName)}, registerTime{registerTime} {}
 #endif
     };
 
diff --git a/tests/statement_serializer_tests/column_names.cpp b/tests/statement_serializer_tests/column_names.cpp
index a0adb17ff..f72356f92 100644
--- a/tests/statement_serializer_tests/column_names.cpp
+++ b/tests/statement_serializer_tests/column_names.cpp
@@ -48,7 +48,7 @@ TEST_CASE("statement_serializer column names") {
             }
 
             void setName(std::string value) {
-                this->name = move(value);
+                this->name = std::move(value);
             }
 
           private:
diff --git a/tests/statement_serializer_tests/foreign_key.cpp b/tests/statement_serializer_tests/foreign_key.cpp
index 4a938fe99..1a79ca061 100644
--- a/tests/statement_serializer_tests/foreign_key.cpp
+++ b/tests/statement_serializer_tests/foreign_key.cpp
@@ -297,7 +297,7 @@ TEST_CASE("statement_serializer foreign key") {
         struct User : Object {
             std::string name;
 
-            User(decltype(id) id_, decltype(name) name_) : Object{id_}, name(move(name_)) {}
+            User(decltype(id) id_, decltype(name) name_) : Object{id_}, name(std::move(name_)) {}
         };
 
         struct Token : Object {
diff --git a/tests/statement_serializer_tests/statements/insert_replace.cpp b/tests/statement_serializer_tests/statements/insert_replace.cpp
index b13e7e08a..e30be740a 100644
--- a/tests/statement_serializer_tests/statements/insert_replace.cpp
+++ b/tests/statement_serializer_tests/statements/insert_replace.cpp
@@ -16,7 +16,7 @@ TEST_CASE("statement_serializer insert/replace") {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User() = default;
-        User(int id, std::string name) : id{id}, name{move(name)} {}
+        User(int id, std::string name) : id{id}, name{std::move(name)} {}
 #endif
     };
     struct UserBackup {
@@ -25,7 +25,7 @@ TEST_CASE("statement_serializer insert/replace") {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         UserBackup() = default;
-        UserBackup(int id, std::string name) : id{id}, name{move(name)} {}
+        UserBackup(int id, std::string name) : id{id}, name{std::move(name)} {}
 #endif
     };
     auto table = make_table("users", make_column("id", &User::id), make_column("name", &User::name));
diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
index 8c2b0936e..1dbbf4dbf 100644
--- a/tests/static_tests/column_result_t.cpp
+++ b/tests/static_tests/column_result_t.cpp
@@ -30,7 +30,7 @@ TEST_CASE("column_result_of_t") {
         }
 
         void setComment(std::string comment) {
-            this->comment = move(comment);
+            this->comment = std::move(comment);
         }
 
         const std::string& getComment() const {
diff --git a/tests/static_tests/function_static_tests.cpp b/tests/static_tests/function_static_tests.cpp
index 00a3d5aa2..9217d3a89 100644
--- a/tests/static_tests/function_static_tests.cpp
+++ b/tests/static_tests/function_static_tests.cpp
@@ -201,7 +201,7 @@ TEST_CASE("function static") {
                 }
 
                 std::string fin() {
-                    return move(result);
+                    return std::move(result);
                 }
             };
 
diff --git a/tests/storage_non_crud_tests.cpp b/tests/storage_non_crud_tests.cpp
index e65856f10..100bffdd6 100644
--- a/tests/storage_non_crud_tests.cpp
+++ b/tests/storage_non_crud_tests.cpp
@@ -10,7 +10,7 @@ TEST_CASE("explicit from") {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User() = default;
-        User(int id, std::string name) : id{id}, name{move(name)} {}
+        User(int id, std::string name) : id{id}, name{std::move(name)} {}
 #endif
     };
     auto storage = make_storage(
@@ -80,7 +80,7 @@ TEST_CASE("update set null") {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User() = default;
-        User(int id, decltype(name) name) : id{id}, name{move(name)} {}
+        User(int id, decltype(name) name) : id{id}, name{std::move(name)} {}
 #endif
     };
 
@@ -127,7 +127,7 @@ TEST_CASE("InsertRange") {
 
 #ifndef SQLITE_ORM_AGGREGATE_PAREN_INIT_SUPPORTED
         Object() = default;
-        Object(int id, std::string name) : id{id}, name{move(name)} {}
+        Object(int id, std::string name) : id{id}, name{std::move(name)} {}
 #endif
     };
 
@@ -137,7 +137,7 @@ TEST_CASE("InsertRange") {
 
 #ifndef SQLITE_ORM_AGGREGATE_PAREN_INIT_SUPPORTED
         ObjectWithoutRowid() = default;
-        ObjectWithoutRowid(int id, std::string name) : id{id}, name{move(name)} {}
+        ObjectWithoutRowid(int id, std::string name) : id{id}, name{std::move(name)} {}
 #endif
     };
 
@@ -391,13 +391,13 @@ TEST_CASE("Replace query") {
 
 #ifndef SQLITE_ORM_AGGREGATE_PAREN_INIT_SUPPORTED
         Object() = default;
-        Object(int id, std::string name) : id{id}, name{move(name)} {}
+        Object(int id, std::string name) : id{id}, name{std::move(name)} {}
 #endif
     };
 
     struct User {
 
-        User(int id_, std::string name_) : id(id_), name(move(name_)) {}
+        User(int id_, std::string name_) : id(id_), name(std::move(name_)) {}
 
         int getId() const {
             return this->id;
@@ -412,7 +412,7 @@ TEST_CASE("Replace query") {
         }
 
         void setName(std::string name_) {
-            this->name = move(name_);
+            this->name = std::move(name_);
         }
 
       private:
diff --git a/tests/sync_schema_tests.cpp b/tests/sync_schema_tests.cpp
index 7ec68d229..a7e1d21c3 100644
--- a/tests/sync_schema_tests.cpp
+++ b/tests/sync_schema_tests.cpp
@@ -145,7 +145,7 @@ TEST_CASE("issue521") {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         MockDatabasePoco() = default;
         MockDatabasePoco(int id, std::string name, uint32_t alpha, float beta) :
-            id{id}, name{move(name)}, alpha{alpha}, beta{beta} {}
+            id{id}, name{std::move(name)}, alpha{alpha}, beta{beta} {}
 #endif
     };
     std::vector<MockDatabasePoco> pocosToInsert;
@@ -291,7 +291,7 @@ TEST_CASE("sync_schema") {
 
         User(int id_) : id(id_) {}
 
-        User(int id_, std::string name_) : id(id_), name(move(name_)) {}
+        User(int id_, std::string name_) : id(id_), name(std::move(name_)) {}
 
         User(int id_, int age_) : id(id_), age(age_) {}
 
diff --git a/tests/table_tests.cpp b/tests/table_tests.cpp
index d36e5e8dc..0b5618b0d 100644
--- a/tests/table_tests.cpp
+++ b/tests/table_tests.cpp
@@ -57,7 +57,7 @@ TEST_CASE("table::find_column_name") {
             }
 
             void setFirstName(std::string value) {
-                this->_firstName = move(value);
+                this->_firstName = std::move(value);
             }
 
             const std::string& lastName() const {
@@ -65,7 +65,7 @@ TEST_CASE("table::find_column_name") {
             }
 
             void setLastName(std::string value) {
-                this->_lastName = move(value);
+                this->_lastName = std::move(value);
             }
 
             int countryCode() const {
@@ -81,7 +81,7 @@ TEST_CASE("table::find_column_name") {
             }
 
             void setPhoneNumber(std::string value) {
-                this->_phoneNumber = move(value);
+                this->_phoneNumber = std::move(value);
             }
 
             int visitsCount() const {
diff --git a/tests/tests.cpp b/tests/tests.cpp
index d0e13dc57..7bff3bed2 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -8,6 +8,14 @@
 #include <numeric>  //  std::iota
 #include <algorithm>  //  std::fill
 
+#ifdef _DEBUG
+#pragma comment(lib, "Catch2d.Lib")
+#pragma comment(lib, "manual-link/Catch2Maind.Lib")
+#else
+#pragma comment(lib, "Catch2.Lib")
+#pragma comment(lib, "manual-link/Catch2Main.Lib")
+#endif
+
 using namespace sqlite_orm;
 
 TEST_CASE("Limits") {
diff --git a/tests/tests2.cpp b/tests/tests2.cpp
index e69ddfd02..871b9c3b5 100644
--- a/tests/tests2.cpp
+++ b/tests/tests2.cpp
@@ -79,7 +79,7 @@ TEST_CASE("insert with generated column") {
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Product() = default;
         Product(std::string name, double price, double discount, double tax, double netPrice) :
-            name{move(name)}, price{price}, discount{discount}, tax{tax}, netPrice{netPrice} {}
+            name{std::move(name)}, price{price}, discount{discount}, tax{tax}, netPrice{netPrice} {}
 #endif
 
         bool operator==(const Product& other) const {
diff --git a/tests/tests4.cpp b/tests/tests4.cpp
index 9a72a9f7e..3a690df26 100644
--- a/tests/tests4.cpp
+++ b/tests/tests4.cpp
@@ -29,7 +29,7 @@ TEST_CASE("Unique ptr in update") {
     }
     {
         std::unique_ptr<std::string> ptr;
-        storage.update_all(set(assign(&User::name, move(ptr))));
+        storage.update_all(set(assign(&User::name, std::move(ptr))));
         REQUIRE(storage.count<User>(where(is_not_null(&User::name))) == 0);
     }
 }
@@ -77,7 +77,7 @@ TEST_CASE("join") {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         User() = default;
-        User(int id, std::string name) : id{id}, name{move(name)} {}
+        User(int id, std::string name) : id{id}, name{std::move(name)} {}
 #endif
     };
 
diff --git a/tests/transaction_tests.cpp b/tests/transaction_tests.cpp
index adf9792f8..6df82d22e 100644
--- a/tests/transaction_tests.cpp
+++ b/tests/transaction_tests.cpp
@@ -10,7 +10,7 @@ namespace {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Object() = default;
-        Object(int id, std::string name) : id{id}, name{move(name)} {}
+        Object(int id, std::string name) : id{id}, name{std::move(name)} {}
 #endif
 
         bool operator==(const Object& other) const {
@@ -175,7 +175,7 @@ TEST_CASE("Transaction guard") {
         auto countNow = storage.count<Object>();
         REQUIRE(countNow == countBefore + 1);
     }
-    SECTION("move ctor") {
+    SECTION("std::move ctor") {
         std::vector<internal::transaction_guard_t> guards;
         auto countBefore = storage.count<Object>();
         {
diff --git a/tests/trigger_tests.cpp b/tests/trigger_tests.cpp
index 36d6a7de3..a5946ac80 100644
--- a/tests/trigger_tests.cpp
+++ b/tests/trigger_tests.cpp
@@ -12,7 +12,7 @@ TEST_CASE("triggers_basics") {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         TestInsert() = default;
-        TestInsert(int id, std::string text, int x, int y) : id{id}, text{move(text)}, x{x}, y{y} {}
+        TestInsert(int id, std::string text, int x, int y) : id{id}, text{std::move(text)}, x{x}, y{y} {}
 #endif
     };
     struct TestUpdate {
@@ -23,7 +23,7 @@ TEST_CASE("triggers_basics") {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         TestUpdate() = default;
-        TestUpdate(int id, std::string text, int x, int y) : id{id}, text{move(text)}, x{x}, y{y} {}
+        TestUpdate(int id, std::string text, int x, int y) : id{id}, text{std::move(text)}, x{x}, y{y} {}
 #endif
     };
     struct TestDelete {
@@ -34,7 +34,7 @@ TEST_CASE("triggers_basics") {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         TestDelete() = default;
-        TestDelete(int id, std::string text, int x, int y) : id{id}, text{move(text)}, x{x}, y{y} {}
+        TestDelete(int id, std::string text, int x, int y) : id{id}, text{std::move(text)}, x{x}, y{y} {}
 #endif
     };
 
diff --git a/tests/unique_cases/get_all_with_two_tables.cpp b/tests/unique_cases/get_all_with_two_tables.cpp
index f0eb715f3..91d17acde 100644
--- a/tests/unique_cases/get_all_with_two_tables.cpp
+++ b/tests/unique_cases/get_all_with_two_tables.cpp
@@ -9,7 +9,7 @@ namespace {
 
 #ifndef SQLITE_ORM_AGGREGATE_PAREN_INIT_SUPPORTED
         Pattern() = default;
-        Pattern(std::string value) : value{move(value)} {}
+        Pattern(std::string value) : value{std::move(value)} {}
 #endif
     };
     struct Item {
@@ -18,7 +18,7 @@ namespace {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         Item() = default;
-        Item(int id, std::string attributes) : id{id}, attributes{move(attributes)} {}
+        Item(int id, std::string attributes) : id{id}, attributes{std::move(attributes)} {}
 #endif
     };
 
diff --git a/tests/unique_cases/prepare_get_all_with_case.cpp b/tests/unique_cases/prepare_get_all_with_case.cpp
index 1633a0f5d..60d21dcb4 100644
--- a/tests/unique_cases/prepare_get_all_with_case.cpp
+++ b/tests/unique_cases/prepare_get_all_with_case.cpp
@@ -10,7 +10,7 @@ TEST_CASE("Prepare with case") {
 
 #ifndef SQLITE_ORM_AGGREGATE_NSDMI_SUPPORTED
         UserProfile() = default;
-        UserProfile(int id, std::string firstName) : id{id}, firstName{move(firstName)} {}
+        UserProfile(int id, std::string firstName) : id{id}, firstName{std::move(firstName)} {}
 #endif
     };
 

From 3d2f3a3f3cebcfefef29d671a807d02df83c37b6 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 2 Feb 2023 22:37:05 +0200
Subject: [PATCH 091/161] Removed code used in local test environment

---
 tests/tests.cpp | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/tests/tests.cpp b/tests/tests.cpp
index 7bff3bed2..d0e13dc57 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -8,14 +8,6 @@
 #include <numeric>  //  std::iota
 #include <algorithm>  //  std::fill
 
-#ifdef _DEBUG
-#pragma comment(lib, "Catch2d.Lib")
-#pragma comment(lib, "manual-link/Catch2Maind.Lib")
-#else
-#pragma comment(lib, "Catch2.Lib")
-#pragma comment(lib, "manual-link/Catch2Main.Lib")
-#endif
-
 using namespace sqlite_orm;
 
 TEST_CASE("Limits") {

From 9404d5df9d377fe97ad85d02b377ae3a2350391e Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 7 Feb 2023 13:02:28 +0200
Subject: [PATCH 092/161] Made CTE select work with a `columns_t` expression
 having only 1 column

---
 dev/cte_storage.h               | 7 +++++--
 include/sqlite_orm/sqlite_orm.h | 7 +++++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 27504046e..88b4b42f1 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -16,8 +16,8 @@
 #include "alias.h"
 #include "cte_types.h"
 #include "cte_column_names_collector.h"
-#endif
 #include "column_expression.h"
+#endif
 #include "storage_lookup.h"
 
 namespace sqlite_orm {
@@ -126,7 +126,10 @@ namespace sqlite_orm {
         }
 
         // any expression -> numeric column alias
-        template<class DBOs, class E, size_t Idx = 0>
+        template<class DBOs,
+                 class E,
+                 size_t Idx = 0,
+                 std::enable_if_t<polyfill::negation_v<polyfill::is_specialization_of<E, std::tuple>>, bool> = true>
         auto extract_colref_expressions(const DBOs& /*dbObjects*/, const E& /*col*/, std::index_sequence<Idx> = {})
             -> std::tuple<alias_holder<decltype(n_to_colalias<Idx>())>> {
             return {};
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 73916d7a9..547e18462 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -18629,7 +18629,6 @@ namespace sqlite_orm {
 
 // #include "cte_column_names_collector.h"
 
-#endif
 // #include "column_expression.h"
 
 #include <type_traits>  //  std::enable_if, std::is_same, std::decay, std::is_arithmetic
@@ -18735,6 +18734,7 @@ namespace sqlite_orm {
     }
 }
 
+#endif
 // #include "storage_lookup.h"
 
 namespace sqlite_orm {
@@ -18843,7 +18843,10 @@ namespace sqlite_orm {
         }
 
         // any expression -> numeric column alias
-        template<class DBOs, class E, size_t Idx = 0>
+        template<class DBOs,
+                 class E,
+                 size_t Idx = 0,
+                 std::enable_if_t<polyfill::negation_v<polyfill::is_specialization_of<E, std::tuple>>, bool> = true>
         auto extract_colref_expressions(const DBOs& /*dbObjects*/, const E& /*col*/, std::index_sequence<Idx> = {})
             -> std::tuple<alias_holder<decltype(n_to_colalias<Idx>())>> {
             return {};

From c53d72b63206a9fb87ca7da79546ffb6c890f6fb Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 7 Feb 2023 18:02:31 +0200
Subject: [PATCH 093/161] Fixed collecting CTE column names from column aliases

---
 dev/cte_column_names_collector.h | 17 ++++++++---------
 include/sqlite_orm/sqlite_orm.h  | 17 ++++++++---------
 2 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index dd42ddbd4..c584e2e59 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -129,18 +129,17 @@ namespace sqlite_orm {
                 iterate_tuple(cols.columns, [&columnNames, &newContext](auto& m) {
                     using value_type = polyfill::remove_cvref_t<decltype(m)>;
 
-                    std::string columnName;
                     if constexpr(polyfill::is_specialization_of_v<value_type, as_t>) {
-                        columnName = alias_extractor<alias_type_t<value_type>>::extract();
+                        columnNames.push_back(alias_extractor<alias_type_t<value_type>>::extract());
                     } else {
-                        columnName = serialize(m, newContext);
-                    }
-                    if(!columnName.empty()) {
-                        columnNames.push_back(std::move(columnName));
-                    } else {
-                        throw std::system_error{orm_error_code::column_not_found};
+                        std::string columnName = serialize(m, newContext);
+                        if(!columnName.empty()) {
+                            columnNames.push_back(std::move(columnName));
+                        } else {
+                            throw std::system_error{orm_error_code::column_not_found};
+                        }
+                        unquote_or_erase(columnNames.back());
                     }
-                    unquote_or_erase(columnNames.back());
                 });
                 return columnNames;
             }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 547e18462..86d3e0985 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -16293,18 +16293,17 @@ namespace sqlite_orm {
                 iterate_tuple(cols.columns, [&columnNames, &newContext](auto& m) {
                     using value_type = polyfill::remove_cvref_t<decltype(m)>;
 
-                    std::string columnName;
                     if constexpr(polyfill::is_specialization_of_v<value_type, as_t>) {
-                        columnName = alias_extractor<alias_type_t<value_type>>::extract();
+                        columnNames.push_back(alias_extractor<alias_type_t<value_type>>::extract());
                     } else {
-                        columnName = serialize(m, newContext);
-                    }
-                    if(!columnName.empty()) {
-                        columnNames.push_back(std::move(columnName));
-                    } else {
-                        throw std::system_error{orm_error_code::column_not_found};
+                        std::string columnName = serialize(m, newContext);
+                        if(!columnName.empty()) {
+                            columnNames.push_back(std::move(columnName));
+                        } else {
+                            throw std::system_error{orm_error_code::column_not_found};
+                        }
+                        unquote_or_erase(columnNames.back());
                     }
-                    unquote_or_erase(columnNames.back());
                 });
                 return columnNames;
             }

From 89c2882340d9eae80ca94e0debe5e63e24f3517b Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 7 Feb 2023 18:03:14 +0200
Subject: [PATCH 094/161] Updated example using the newer `group_by().having()`
 expression

---
 examples/exists.cpp | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/examples/exists.cpp b/examples/exists.cpp
index ec2d82d19..ab5a888ba 100644
--- a/examples/exists.cpp
+++ b/examples/exists.cpp
@@ -435,12 +435,11 @@ int main(int, char**) {
         //      WHERE grade=2
         //      GROUP BY grade
         //      HAVING COUNT(*)>2);
-        auto rows =
-            storage.select(columns(&Customer::code, &Customer::name, &Customer::city, &Customer::grade),
-                           where(is_equal(&Customer::grade, 2) and exists(select(count<Customer>(),
-                                                                                 where(is_equal(&Customer::grade, 2)),
-                                                                                 group_by(&Customer::grade),
-                                                                                 having(greater_than(count(), 2))))));
+        auto rows = storage.select(columns(&Customer::code, &Customer::name, &Customer::city, &Customer::grade),
+                                   where(is_equal(&Customer::grade, 2) and
+                                         exists(select(count<Customer>(),
+                                                       where(is_equal(&Customer::grade, 2)),
+                                                       group_by(&Customer::grade).having(greater_than(count(), 2))))));
         cout << "CUST_CODE   CUST_NAME   CUST_CITY                            GRADE" << endl;
         cout << "----------  ----------  -----------------------------------  ----------" << endl;
         for(auto& row: rows) {

From 22705d302515ff69170a5fd8f1c1e210212f3d2c Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 7 Feb 2023 18:27:14 +0200
Subject: [PATCH 095/161] User retention calculation example using CTEs

* Shows yet another subquery hoisted into a CTE as required in issue #222
---
 examples/common_table_expressions.cpp | 102 +++++++++++++++++++++++++-
 1 file changed, 101 insertions(+), 1 deletion(-)

diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index dc056bd74..cd05a2391 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -13,6 +13,7 @@
 #endif
 #include <tuple>
 #include <iostream>
+#include <iomanip>
 
 using std::cout;
 using std::endl;
@@ -818,6 +819,104 @@ void show_mapping_and_backreferencing() {
         auto stmt = storage.prepare(ast);
     }
 }
+
+void neevek_issue_222() {
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
+    //WITH
+    //    register_user AS(
+    //        SELECT
+    //        uid, MIN(DATE(user_activity.timestamp)) register_date
+    //        FROM user_activity
+    //        GROUP BY uid
+    //        HAVING register_date >= DATE('now', '-7 days')
+    //    ),
+    //    register_user_count AS(
+    //        SELECT
+    //        R.register_date,
+    //        COUNT(DISTINCT R.uid) AS user_count
+    //        FROM register_user R
+    //        GROUP BY R.register_date
+    //    )
+    //    SELECT
+    //    R.register_date,
+    //    CAST(julianday(DATE(A.timestamp)) AS INT) - CAST(julianday(R.register_date) AS INT) AS ndays,
+    //    COUNT(DISTINCT A.uid) AS retention,
+    //    C.user_count
+    //    FROM user_activity A
+    //    LEFT JOIN register_user R ON A.uid = R.uid
+    //    LEFT JOIN register_user_count C ON R.register_date = C.register_date
+    //    GROUP BY R.register_date, ndays
+    //    HAVING DATE(A.timestamp) >= DATE('now', '-7 days');
+
+    struct user_activity {
+        int64 id;
+        int64 uid;
+        __time64_t timestamp;
+    };
+
+    auto storage = make_storage("",
+                                make_table("user_activity",
+                                           make_column("id", &user_activity::id, primary_key().autoincrement()),
+                                           make_column("uid", &user_activity::uid),
+                                           make_column("timestamp", &user_activity::timestamp)));
+    storage.sync_schema();
+    storage.transaction([&storage]() {
+        __time64_t now = _time64(nullptr);
+        auto values = {user_activity{0, 1, now - 86400 * 3},
+                       user_activity{0, 1, now - 86400 * 2},
+                       user_activity{0, 1, now},
+                       user_activity{0, 2, now}};
+        storage.insert_range(values.begin(), values.end());
+        return true;
+    });
+
+    constexpr auto register_user = "register_user"_cte;
+    constexpr auto registered_cnt = "registered_cnt"_cte;
+    constexpr auto register_date = "register_date"_col;
+    constexpr auto user_count = "user_count"_col;
+    constexpr auto ndays = "ndays"_col;
+    auto expression = with(
+        make_tuple(
+            cte<register_user>()(select(
+                columns(&user_activity::uid, min(date(&user_activity::timestamp, "unixepoch")) >>= register_date),
+                group_by(&user_activity::uid).having(greater_or_equal(register_date, date("now", "-7 days"))))),
+            cte<registered_cnt>()(select(columns(register_user->*register_date,
+                                                 count(distinct(register_user->*&user_activity::uid)) >>= user_count),
+                                         group_by(register_user->*register_date)))),
+        select(columns(register_user->*register_date,
+                       c(cast<int>(julianday(date(&user_activity::timestamp, "unixepoch")))) -
+                           cast<int>(julianday(register_user->*register_date)) >>= ndays,
+                       count(distinct(&user_activity::uid)) >>= "retention"_col,
+                       registered_cnt->*user_count),
+               left_join<register_user>(using_(&user_activity::uid)),
+               left_join<registered_cnt>(using_(registered_cnt->*register_date)),
+               group_by(register_user->*register_date, ndays)
+                   .having(date(&user_activity::timestamp, "unixepoch") >= date("now", "-7 days"))));
+
+    string sql = storage.dump(expression);
+
+    auto stmt = storage.prepare(expression);
+    auto results = storage.execute(stmt);
+
+    cout << "User Retention:\n";
+    for(const char* colName: {"register_date", "ndays", "retention", "user_count"}) {
+        cout << " " << std::setw(13) << colName;
+    }
+    cout << '\n';
+    for(int i = 0; i < 4; ++i) {
+        cout << std::setfill(' ') << " " << std::setw(13) << std::setfill('_') << "";
+    }
+    cout << std::setfill(' ') << '\n';
+    for(auto& result: results) {
+        cout << " " << std::setw(13) << *get<0>(result);
+        cout << " " << std::setw(13) << get<1>(result);
+        cout << " " << std::setw(13) << get<2>(result);
+        cout << " " << std::setw(13) << get<3>(result);
+        cout << '\n';
+    }
+    cout << endl;
+#endif
+}
 #endif
 
 int main() {
@@ -828,9 +927,10 @@ int main() {
         works_for_alice();
         family_tree();
         depth_or_breadth_first();
-        select_from_subselect();
         apfelmaennchen();
         sudoku();
+        neevek_issue_222();
+        select_from_subselect();
         show_mapping_and_backreferencing();
     } catch(const system_error& e) {
         cout << "[" << e.code() << "] " << e.what();

From dcf07ea62c9aad28e900269207ae1b2bf66858dd Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 7 Feb 2023 18:29:40 +0200
Subject: [PATCH 096/161] Trying multi-processor compilation for appveyor
 builds

---
 appveyor.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/appveyor.yml b/appveyor.yml
index 7eb6d8551..6805e47b5 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -111,7 +111,7 @@ for:
   # build examples, and run tests (ie make & make test)
   build_script:
     - |-
-      cmake --build . --config %configuration%
+      cmake --build . --config %configuration% -- /m
       ctest --verbose --output-on-failure --build-config %configuration%
 
 -
@@ -140,7 +140,7 @@ for:
   # build examples, and run tests (ie make & make test)
   build_script:
     - |-
-      cmake --build .
+      cmake --build . --parallel
       ctest --verbose --output-on-failure
 -
   # macOS
@@ -166,5 +166,5 @@ for:
   # build examples, and run tests (ie make & make test)
   build_script:
     - |-
-      cmake --build .
+      cmake --build . --parallel
       ctest --verbose --output-on-failure

From 8ff7f2085c292ac4acdec3a1d547ff9c507caee2 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 7 Feb 2023 19:31:40 +0200
Subject: [PATCH 097/161] Fixed missing `column_expression_of_t`

---
 dev/cte_storage.h               | 2 +-
 include/sqlite_orm/sqlite_orm.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 88b4b42f1..d6702021d 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -16,8 +16,8 @@
 #include "alias.h"
 #include "cte_types.h"
 #include "cte_column_names_collector.h"
-#include "column_expression.h"
 #endif
+#include "column_expression.h"
 #include "storage_lookup.h"
 
 namespace sqlite_orm {
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 86d3e0985..928be8134 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -18628,6 +18628,7 @@ namespace sqlite_orm {
 
 // #include "cte_column_names_collector.h"
 
+#endif
 // #include "column_expression.h"
 
 #include <type_traits>  //  std::enable_if, std::is_same, std::decay, std::is_arithmetic
@@ -18733,7 +18734,6 @@ namespace sqlite_orm {
     }
 }
 
-#endif
 // #include "storage_lookup.h"
 
 namespace sqlite_orm {

From ecdd32a9f5fd7b7bd58d3f9592c12e20d8e65b58 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 7 Feb 2023 23:15:46 +0200
Subject: [PATCH 098/161] Trying multi-processor compilation for appveyor
 builds except for gcc

---
 appveyor.yml | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/appveyor.yml b/appveyor.yml
index 6805e47b5..4e0922596 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -25,12 +25,15 @@ environment:
       CC: clang
       CXX: clang++
       SQLITE_ORM_CXX_STANDARD: "-DSQLITE_ORM_ENABLE_CXX_14=ON"
+      cmake_build_parallel: --parallel
 
     - job_name: gcc, C++14
       appveyor_build_worker_image: Ubuntu
       CC: gcc
       CXX: g++
       SQLITE_ORM_CXX_STANDARD: "-DSQLITE_ORM_ENABLE_CXX_14=ON"
+      # gcc was stuck with a parallel build
+      cmake_build_parallel: ""
 
     # Representative for C++14
     - job_name: Visual Studio 2022, x64, C++14
@@ -43,24 +46,28 @@ environment:
       CC: clang
       CXX: clang++
       SQLITE_ORM_CXX_STANDARD: "-DSQLITE_ORM_ENABLE_CXX_17=ON"
+      cmake_build_parallel: --parallel
 
     - job_name: clang, C++20
       appveyor_build_worker_image: Ubuntu
       CC: clang
       CXX: clang++
       SQLITE_ORM_CXX_STANDARD: "-DSQLITE_ORM_ENABLE_CXX_20=ON"
+      cmake_build_parallel: --parallel
 
     - job_name: gcc, C++17
       appveyor_build_worker_image: Ubuntu
       CC: gcc
       CXX: g++
       SQLITE_ORM_CXX_STANDARD: "-DSQLITE_ORM_ENABLE_CXX_17=ON"
+      cmake_build_parallel: ""
 
     - job_name: gcc, C++20
       appveyor_build_worker_image: Ubuntu
       CC: gcc
       CXX: g++
       SQLITE_ORM_CXX_STANDARD: "-DSQLITE_ORM_ENABLE_CXX_20=ON"
+      cmake_build_parallel: ""
 
     - job_name: Visual Studio 2022, x64, C++17
       appveyor_build_worker_image: Visual Studio 2022
@@ -140,7 +147,7 @@ for:
   # build examples, and run tests (ie make & make test)
   build_script:
     - |-
-      cmake --build . --parallel
+      cmake --build . $cmake_build_parallel
       ctest --verbose --output-on-failure
 -
   # macOS

From 74f8e6415e143c683d8835124f98e176bfad6a4b Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 14 Feb 2023 22:49:05 +0200
Subject: [PATCH 099/161] 'greatest n per group' using a self-join

Possible solution for discussion #773
---
 examples/common_table_expressions.cpp | 75 +++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)

diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index cd05a2391..22835774a 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -917,6 +917,80 @@ void neevek_issue_222() {
     cout << endl;
 #endif
 }
+
+void greatest_n_per_group() {
+#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
+    // Having a table consisting of multiple results for items,
+    // I want to select a single result row per item, based on a condition like an aggregated value.
+    // This is possible using a (self) join and filtering by aggregated value (in case it is unique), or using window functions.
+    //
+    // In this example, we select the most recent (successful) result per item
+
+    struct some_result {
+        int64 result_id;
+        int64 item_id;
+        __time64_t timestamp;
+        bool flag;
+    };
+
+    auto storage =
+        make_storage("",
+                     make_table("some_result",
+                                make_column("result_id", &some_result::result_id, primary_key().autoincrement()),
+                                make_column("item_id", &some_result::item_id) /*foreign key*/,
+                                make_column("timestamp", &some_result::timestamp),
+                                make_column("flag", &some_result::flag)));
+    storage.sync_schema();
+    storage.transaction([&storage]() {
+        __time64_t now = _time64(nullptr);
+        auto values = std::initializer_list<some_result>{{-1, 1, now - 86400 * 3, false},
+                                                         {-1, 1, now - 86400 * 2, true},
+                                                         {-1, 1, now, true},
+                                                         {-1, 2, now, false},
+                                                         {-1, 3, now - 86400 * 2, true}};
+        storage.insert_range(values.begin(), values.end());
+        return true;
+    });
+
+    //select r.*
+    //    from some_result r
+    //    inner join(
+    //        select item_id,
+    //        max(timestamp) as max_date
+    //        from some_result
+    //        group by item)id
+    //    ) wnd
+    //    on wnd.item_id = r.item_id
+    //    and r.timestamp = wnd.max_date
+    //    -- other conditions
+    //where r.flag = 1
+    constexpr auto wnd = "wnd"_cte;
+    constexpr auto max_date = "max_date"_col;
+    auto expression =
+        with(cte<wnd>(&some_result::item_id, max_date)(
+                 select(columns(&some_result::item_id, max(&some_result::timestamp)), group_by(&some_result::item_id))),
+             select(object<some_result>(),
+                    inner_join<wnd>(on(c(&some_result::item_id) == wnd->*&some_result::item_id and
+                                       c(&some_result::timestamp) == wnd->*max_date)),
+                    // additional conditions
+                    where(c(&some_result::flag) == true)));
+    string sql = storage.dump(expression);
+
+    auto stmt = storage.prepare(expression);
+    auto results = storage.execute(stmt);
+
+    cout << "most recent (successful) result per item:\n";
+    for(const char* colName: {"id", "item_id", "timestamp", "flag"}) {
+        cout << "\t" << colName;
+    }
+    cout << '\n';
+    for(auto& result: results) {
+        cout << "\t" << result.result_id << "\t" << result.item_id << "\t" << result.timestamp << "\t" << result.flag
+             << '\n';
+    }
+    cout << endl;
+#endif
+}
 #endif
 
 int main() {
@@ -931,6 +1005,7 @@ int main() {
         sudoku();
         neevek_issue_222();
         select_from_subselect();
+        greatest_n_per_group();
         show_mapping_and_backreferencing();
     } catch(const system_error& e) {
         cout << "[" << e.code() << "] " << e.what();

From 84cb56c280b119859d9890b379c71de753f7728b Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 17 Feb 2023 23:15:42 +0200
Subject: [PATCH 100/161] Simplified a few internal CTE-related things

---
 dev/cte_column_names_collector.h              |  2 +-
 dev/cte_storage.h                             | 57 ++++++--------
 dev/storage.h                                 | 19 ++---
 include/sqlite_orm/sqlite_orm.h               | 78 +++++++++----------
 .../column_names.cpp                          |  3 +-
 .../select_constraints.cpp                    |  2 +-
 tests/static_tests/column_expression_type.cpp |  6 +-
 tests/static_tests/column_result_t.cpp        |  3 +-
 tests/table_name_collector.cpp                |  2 +-
 9 files changed, 77 insertions(+), 95 deletions(-)

diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index c584e2e59..bb9de9fff 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -49,7 +49,7 @@ namespace sqlite_orm {
         struct cte_column_names_collector {
             using expression_type = T;
 
-            // Compound statements are never passed in by storage_for_expression()
+            // Compound statements are never passed in by db_objects_for_expression()
             static_assert(!is_base_of_template_v<T, compound_operator>);
 
             template<class Ctx>
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index d6702021d..d810f8023 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -83,8 +83,8 @@ namespace sqlite_orm {
          *  forming a new storage implementation object.
          */
         template<typename... Ts, typename... CTETables>
-        db_objects_tuple<CTETables..., Ts...> storage_db_objects_cat(const db_objects_tuple<Ts...>& storage,
-                                                                     CTETables&&... cteTables) {
+        db_objects_tuple<CTETables..., Ts...> db_objects_cat(const db_objects_tuple<Ts...>& storage,
+                                                             CTETables&&... cteTables) {
             return {std::forward<CTETables>(cteTables)..., pick_table<Ts>(storage)...};
         }
 
@@ -121,7 +121,7 @@ namespace sqlite_orm {
          *  Return a tuple of member pointers of all columns
          */
         template<class C, size_t... Idx>
-        auto get_fields_of_columns(const C& coldef, std::index_sequence<Idx...>) {
+        auto get_table_columns_fields(const C& coldef, std::index_sequence<Idx...>) {
             return std::make_tuple(get<Idx>(coldef).member_pointer...);
         }
 
@@ -194,7 +194,7 @@ namespace sqlite_orm {
             using column_idxs = filter_tuple_sequence_t<elements_t, is_column>;
 
             auto& table = pick_table<O>(dbObjects);
-            return get_fields_of_columns(table.elements, column_idxs{});
+            return get_table_columns_fields(table.elements, column_idxs{});
         }
 
         template<class DBOs, class E, class... Args>
@@ -272,14 +272,12 @@ namespace sqlite_orm {
                           "Number of explicit columns of common table expression doesn't match the number of columns "
                           "in the subselect.");
 
-            using context_type = serializer_context<DBOs>;
-
             std::string tableName = alias_extractor<cte_label_type_t<cte_type>>::extract();
             auto subselectColRefs = extract_colref_expressions(dbObjects, subSelect.col);
             const auto& finalColRefs =
                 determine_cte_colrefs(dbObjects, subselectColRefs, cte.explicitColumns, index_sequence{});
 
-            context_type context{dbObjects};
+            serializer_context context{dbObjects};
             std::vector<std::string> columnNames = collect_cte_column_names(subSelect, cte.explicitColumns, context);
 
             using mapper_type = create_cte_mapper_t<cte_label_type_t<cte_type>,
@@ -295,45 +293,38 @@ namespace sqlite_orm {
                                                                     index_sequence{});
         }
 
-        template<typename DBOs, typename... CTEs, size_t Ii>
-        decltype(auto) make_recursive_cte_storage_using_table_indices(const DBOs& dbObjects,
-                                                                      const common_table_expressions<CTEs...>& cte,
-                                                                      std::index_sequence<Ii>) {
+        template<typename DBOs, typename... CTEs, size_t Ii, size_t... In>
+        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));
 
-            return storage_db_objects_cat(dbObjects, std::move(tbl));
-        }
-
-        template<typename DBOs, typename... CTEs, size_t Ii, size_t Ij, size_t... In>
-        decltype(auto) make_recursive_cte_storage_using_table_indices(const DBOs& dbObjects,
-                                                                      const common_table_expressions<CTEs...>& cte,
-                                                                      std::index_sequence<Ii, Ij, In...>) {
-            auto tbl = make_cte_table(dbObjects, get<Ii>(cte));
-
-            return make_recursive_cte_storage_using_table_indices(
-                // Because CTEs can depend on their predecessor we recursively pass in a new storage object
-                storage_db_objects_cat(dbObjects, std::move(tbl)),
-                cte,
-                std::index_sequence<Ij, In...>{});
+            if constexpr(sizeof...(In) > 0) {
+                return make_recursive_cte_db_objects(
+                    // Because CTEs can depend on their predecessor we recursively pass in a new storage object
+                    db_objects_cat(dbObjects, std::move(tbl)),
+                    cte,
+                    std::index_sequence<In...>{});
+            } else {
+                return db_objects_cat(dbObjects, std::move(tbl));
+            }
         }
 
         /**
          *  Return new DBOs for CTE expressions.
          */
-        template<class S, class E, class... CTEs, satisfies<is_storage, S> = true>
-        decltype(auto) storage_for_expression(S& storage, const with_t<E, CTEs...>& e) {
-            return make_recursive_cte_storage_using_table_indices(obtain_db_objects(storage),
-                                                                  e.cte,
-                                                                  std::index_sequence_for<CTEs...>{});
+        template<class DBOs, class E, class... CTEs, satisfies<is_db_objects, DBOs> = true>
+        decltype(auto) db_objects_for_expression(DBOs& dbObjects, const with_t<E, CTEs...>& e) {
+            return make_recursive_cte_db_objects(dbObjects, e.cte, std::index_sequence_for<CTEs...>{});
         }
 #endif
 
         /**
          *  Return DBOs of storage_t.
          */
-        template<class S, class E, satisfies<is_storage, S> = true>
-        decltype(auto) storage_for_expression(S& storage, const E&) {
-            return obtain_db_objects(storage);
+        template<class DBOs, class E, satisfies<is_db_objects, DBOs> = true>
+        decltype(auto) db_objects_for_expression(DBOs& dbObjects, const E&) {
+            return dbObjects;
         }
     }
 }
diff --git a/dev/storage.h b/dev/storage.h
index 5ecf24f1d..9a231db6a 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -640,9 +640,9 @@ namespace sqlite_orm {
                     [](const auto& expression) -> decltype(auto) {
                         return (expression);
                     })(std::forward<E>(expression));
-                const auto& exprImpl = storage_for_expression(*this, expression);
-                using context_t = serializer_context<polyfill::remove_cvref_t<decltype(exprImpl)>>;
-                context_t context{exprImpl};
+                const auto& exprDBOs = db_objects_for_expression(this->db_objects, expression);
+                using context_t = serializer_context<polyfill::remove_cvref_t<decltype(exprDBOs)>>;
+                context_t context{exprDBOs};
                 context.replace_bindable_with_question = parametrized;
                 // just like prepare_impl()
                 context.skip_table_name = false;
@@ -991,9 +991,9 @@ namespace sqlite_orm {
 
             template<typename S>
             prepared_statement_t<S> prepare_impl(S statement) {
-                const auto& exprImpl = storage_for_expression(*this, statement);
-                using context_t = serializer_context<polyfill::remove_cvref_t<decltype(exprImpl)>>;
-                context_t context{exprImpl};
+                const auto& exprDBOs = db_objects_for_expression(this->db_objects, statement);
+                using context_t = serializer_context<polyfill::remove_cvref_t<decltype(exprDBOs)>>;
+                context_t context{exprDBOs};
                 context.skip_table_name = false;
                 context.replace_bindable_with_question = true;
 
@@ -1427,9 +1427,10 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_WITH_CTE
             template<class... CTEs, class T, class... Args>
             auto execute(const prepared_statement_t<with_t<select_t<T, Args...>, CTEs...>>& statement) {
-                using DBOs =
-                    decltype(storage_for_expression(*this, std::declval<with_t<select_t<T, Args...>, CTEs...>>()));
-                using R = column_result_of_t<DBOs, T>;
+                using ExprDBOs =
+                    decltype(db_objects_for_expression(this->db_objects,
+                                                       std::declval<with_t<select_t<T, Args...>, CTEs...>>()));
+                using R = column_result_of_t<ExprDBOs, T>;
                 return _execute_select<R>(statement);
             }
 #endif
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index e8c5277a1..9864afffd 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -16114,7 +16114,7 @@ namespace sqlite_orm {
         struct cte_column_names_collector {
             using expression_type = T;
 
-            // Compound statements are never passed in by storage_for_expression()
+            // Compound statements are never passed in by db_objects_for_expression()
             static_assert(!is_base_of_template_v<T, compound_operator>);
 
             template<class Ctx>
@@ -18664,8 +18664,8 @@ namespace sqlite_orm {
          *  forming a new storage implementation object.
          */
         template<typename... Ts, typename... CTETables>
-        db_objects_tuple<CTETables..., Ts...> storage_db_objects_cat(const db_objects_tuple<Ts...>& storage,
-                                                                     CTETables&&... cteTables) {
+        db_objects_tuple<CTETables..., Ts...> db_objects_cat(const db_objects_tuple<Ts...>& storage,
+                                                             CTETables&&... cteTables) {
             return {std::forward<CTETables>(cteTables)..., pick_table<Ts>(storage)...};
         }
 
@@ -18702,7 +18702,7 @@ namespace sqlite_orm {
          *  Return a tuple of member pointers of all columns
          */
         template<class C, size_t... Idx>
-        auto get_fields_of_columns(const C& coldef, std::index_sequence<Idx...>) {
+        auto get_table_columns_fields(const C& coldef, std::index_sequence<Idx...>) {
             return std::make_tuple(get<Idx>(coldef).member_pointer...);
         }
 
@@ -18775,7 +18775,7 @@ namespace sqlite_orm {
             using column_idxs = filter_tuple_sequence_t<elements_t, is_column>;
 
             auto& table = pick_table<O>(dbObjects);
-            return get_fields_of_columns(table.elements, column_idxs{});
+            return get_table_columns_fields(table.elements, column_idxs{});
         }
 
         template<class DBOs, class E, class... Args>
@@ -18853,14 +18853,12 @@ namespace sqlite_orm {
                           "Number of explicit columns of common table expression doesn't match the number of columns "
                           "in the subselect.");
 
-            using context_type = serializer_context<DBOs>;
-
             std::string tableName = alias_extractor<cte_label_type_t<cte_type>>::extract();
             auto subselectColRefs = extract_colref_expressions(dbObjects, subSelect.col);
             const auto& finalColRefs =
                 determine_cte_colrefs(dbObjects, subselectColRefs, cte.explicitColumns, index_sequence{});
 
-            context_type context{dbObjects};
+            serializer_context context{dbObjects};
             std::vector<std::string> columnNames = collect_cte_column_names(subSelect, cte.explicitColumns, context);
 
             using mapper_type = create_cte_mapper_t<cte_label_type_t<cte_type>,
@@ -18876,45 +18874,38 @@ namespace sqlite_orm {
                                                                     index_sequence{});
         }
 
-        template<typename DBOs, typename... CTEs, size_t Ii>
-        decltype(auto) make_recursive_cte_storage_using_table_indices(const DBOs& dbObjects,
-                                                                      const common_table_expressions<CTEs...>& cte,
-                                                                      std::index_sequence<Ii>) {
+        template<typename DBOs, typename... CTEs, size_t Ii, size_t... In>
+        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));
 
-            return storage_db_objects_cat(dbObjects, std::move(tbl));
-        }
-
-        template<typename DBOs, typename... CTEs, size_t Ii, size_t Ij, size_t... In>
-        decltype(auto) make_recursive_cte_storage_using_table_indices(const DBOs& dbObjects,
-                                                                      const common_table_expressions<CTEs...>& cte,
-                                                                      std::index_sequence<Ii, Ij, In...>) {
-            auto tbl = make_cte_table(dbObjects, get<Ii>(cte));
-
-            return make_recursive_cte_storage_using_table_indices(
-                // Because CTEs can depend on their predecessor we recursively pass in a new storage object
-                storage_db_objects_cat(dbObjects, std::move(tbl)),
-                cte,
-                std::index_sequence<Ij, In...>{});
+            if constexpr(sizeof...(In) > 0) {
+                return make_recursive_cte_db_objects(
+                    // Because CTEs can depend on their predecessor we recursively pass in a new storage object
+                    db_objects_cat(dbObjects, std::move(tbl)),
+                    cte,
+                    std::index_sequence<In...>{});
+            } else {
+                return db_objects_cat(dbObjects, std::move(tbl));
+            }
         }
 
         /**
          *  Return new DBOs for CTE expressions.
          */
-        template<class S, class E, class... CTEs, satisfies<is_storage, S> = true>
-        decltype(auto) storage_for_expression(S& storage, const with_t<E, CTEs...>& e) {
-            return make_recursive_cte_storage_using_table_indices(obtain_db_objects(storage),
-                                                                  e.cte,
-                                                                  std::index_sequence_for<CTEs...>{});
+        template<class DBOs, class E, class... CTEs, satisfies<is_db_objects, DBOs> = true>
+        decltype(auto) db_objects_for_expression(DBOs& dbObjects, const with_t<E, CTEs...>& e) {
+            return make_recursive_cte_db_objects(dbObjects, e.cte, std::index_sequence_for<CTEs...>{});
         }
 #endif
 
         /**
          *  Return DBOs of storage_t.
          */
-        template<class S, class E, satisfies<is_storage, S> = true>
-        decltype(auto) storage_for_expression(S& storage, const E&) {
-            return obtain_db_objects(storage);
+        template<class DBOs, class E, satisfies<is_db_objects, DBOs> = true>
+        decltype(auto) db_objects_for_expression(DBOs& dbObjects, const E&) {
+            return dbObjects;
         }
     }
 }
@@ -19508,9 +19499,9 @@ namespace sqlite_orm {
                     [](const auto& expression) -> decltype(auto) {
                         return (expression);
                     })(std::forward<E>(expression));
-                const auto& exprImpl = storage_for_expression(*this, expression);
-                using context_t = serializer_context<polyfill::remove_cvref_t<decltype(exprImpl)>>;
-                context_t context{exprImpl};
+                const auto& exprDBOs = db_objects_for_expression(this->db_objects, expression);
+                using context_t = serializer_context<polyfill::remove_cvref_t<decltype(exprDBOs)>>;
+                context_t context{exprDBOs};
                 context.replace_bindable_with_question = parametrized;
                 // just like prepare_impl()
                 context.skip_table_name = false;
@@ -19859,9 +19850,9 @@ namespace sqlite_orm {
 
             template<typename S>
             prepared_statement_t<S> prepare_impl(S statement) {
-                const auto& exprImpl = storage_for_expression(*this, statement);
-                using context_t = serializer_context<polyfill::remove_cvref_t<decltype(exprImpl)>>;
-                context_t context{exprImpl};
+                const auto& exprDBOs = db_objects_for_expression(this->db_objects, statement);
+                using context_t = serializer_context<polyfill::remove_cvref_t<decltype(exprDBOs)>>;
+                context_t context{exprDBOs};
                 context.skip_table_name = false;
                 context.replace_bindable_with_question = true;
 
@@ -20295,9 +20286,10 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_WITH_CTE
             template<class... CTEs, class T, class... Args>
             auto execute(const prepared_statement_t<with_t<select_t<T, Args...>, CTEs...>>& statement) {
-                using DBOs =
-                    decltype(storage_for_expression(*this, std::declval<with_t<select_t<T, Args...>, CTEs...>>()));
-                using R = column_result_of_t<DBOs, T>;
+                using ExprDBOs =
+                    decltype(db_objects_for_expression(this->db_objects,
+                                                       std::declval<with_t<select_t<T, Args...>, CTEs...>>()));
+                using R = column_result_of_t<ExprDBOs, T>;
                 return _execute_select<R>(statement);
             }
 #endif
diff --git a/tests/statement_serializer_tests/column_names.cpp b/tests/statement_serializer_tests/column_names.cpp
index f72356f92..cda9b5243 100644
--- a/tests/statement_serializer_tests/column_names.cpp
+++ b/tests/statement_serializer_tests/column_names.cpp
@@ -160,8 +160,7 @@ TEST_CASE("statement_serializer column names") {
 #ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
         SECTION("cte") {
             auto dbObjects2 =
-                internal::storage_db_objects_cat(dbObjects,
-                                                 internal::make_cte_table(dbObjects, cte<1_ctealias>()(select(1))));
+                internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<1_ctealias>()(select(1))));
             using context_t = internal::serializer_context<decltype(dbObjects2)>;
             context_t context{dbObjects2};
             context.skip_table_name = false;
diff --git a/tests/statement_serializer_tests/select_constraints.cpp b/tests/statement_serializer_tests/select_constraints.cpp
index 874bd8eec..49e9ba38f 100644
--- a/tests/statement_serializer_tests/select_constraints.cpp
+++ b/tests/statement_serializer_tests/select_constraints.cpp
@@ -75,7 +75,7 @@ TEST_CASE("statement_serializer select constraints") {
 #ifdef SQLITE_ORM_WITH_CTE
     SECTION("from CTE") {
         auto dbObjects2 =
-            internal::storage_db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
+            internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
         using context_t = internal::serializer_context<decltype(dbObjects2)>;
         context_t context{dbObjects2};
         SECTION("without alias 1") {
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index 1fcef87b7..161c0a70b 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -50,9 +50,9 @@ TEST_CASE("column_expression_of_t") {
 
     runTest<db_objects_t, column_pointer<Derived, int64 Org::*>>(column<Derived>(&Org::id));
 #ifdef SQLITE_ORM_WITH_CTE
-    auto dbObjects2 = internal::storage_db_objects_cat(
-        dbObjects,
-        internal::make_cte_table(dbObjects, cte<cte_1>()(select(columns(&Org::id, 1)))));
+    auto dbObjects2 =
+        internal::db_objects_cat(dbObjects,
+                                 internal::make_cte_table(dbObjects, cte<cte_1>()(select(columns(&Org::id, 1)))));
     using db_objects2_t = decltype(dbObjects2);
     runTest<db_objects_t, column_pointer<cte_1, int64 Org::*>>(column<cte_1>(&Org::id));
     runTest<db_objects_t, column_pointer<cte_1, int64 Org::*>>(column<cte_1>->*&Org::id);
diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
index c7df02e1d..678d599bf 100644
--- a/tests/static_tests/column_result_t.cpp
+++ b/tests/static_tests/column_result_t.cpp
@@ -118,8 +118,7 @@ TEST_CASE("column_result_of_t") {
 #ifdef SQLITE_ORM_WITH_CTE
     // note: even though used with the CTE, &User::id doesn't need to be mapped into the CTE to make column results work;
     //       this is because the result type is taken from the member pointer just because we can't look it up in the storage definition
-    auto dbObjects2 =
-        internal::storage_db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
+    auto dbObjects2 = internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
     using db_objects2_t = decltype(dbObjects2);
     runTest<db_objects_t, int>(column<cte_1>(&User::id));
     runTest<db_objects_t, int>(column<cte_1>->*&User::id);
diff --git a/tests/table_name_collector.cpp b/tests/table_name_collector.cpp
index 887685f51..1e0e04208 100644
--- a/tests/table_name_collector.cpp
+++ b/tests/table_name_collector.cpp
@@ -48,7 +48,7 @@ TEST_CASE("table name collector") {
 #ifdef SQLITE_ORM_WITH_CTE
     SECTION("from CTE") {
         auto dbObjects2 =
-            internal::storage_db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
+            internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
         using context_t = internal::serializer_context<decltype(dbObjects2)>;
         context_t context{dbObjects2};
         auto collector = internal::make_table_name_collector(context.db_objects);

From 94b1fc6dba0443b6a8de0fe881a06776caafd5de Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 18 Feb 2023 16:23:05 +0200
Subject: [PATCH 101/161] Updated sqlite_orm.h

---
 include/sqlite_orm/sqlite_orm.h | 220 +++++++++++++++-----------------
 1 file changed, 101 insertions(+), 119 deletions(-)

diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index ed036e00e..9e240fdf7 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4493,6 +4493,9 @@ namespace sqlite_orm {
         };
 
 #ifdef SQLITE_ORM_WITH_CTE
+        template<class A>
+        struct alias_holder;
+
         template<class A>
         struct column_pointer_builder<A, match_if<is_alias, A>> {
             static_assert(is_cte_alias_v<A>, "`A' must be a mapped table alias");
@@ -4710,6 +4713,12 @@ namespace sqlite_orm {
             [[nodiscard]] consteval table_alias<T, A, C...> for_() const {
                 return {};
             }
+
+            template<auto t>
+            [[nodiscard]] consteval auto for_() const {
+                using T = std::remove_const_t<decltype(t)>;
+                return table_alias<T, A, C...>{};
+            }
         };
 #endif
 
@@ -4824,6 +4833,14 @@ namespace sqlite_orm {
     internal::as_t<A, E> operator>>=(E expression, const A&) {
         return {std::move(expression)};
     }
+#else
+    /**
+     *  Alias a column expression.
+     */
+    template<class A, class E, internal::satisfies<internal::is_column_alias, A> = true>
+    internal::as_t<A, E> operator>>=(E expression, const A&) {
+        return {std::move(expression)};
+    }
 #endif
 
     template<class T>
@@ -4891,34 +4908,6 @@ namespace sqlite_orm {
     template<class T>
     using alias_z = internal::table_alias<T, 'z'>;
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
-    namespace internal {
-        template<char A, char... C>
-        struct table_alias_builder {
-            static_assert(sizeof...(C) == 0 && ((A >= 'A' && 'Z' <= A) || (A >= 'a' && 'z' <= A)),
-                          "Table alias identifiers shall consist of a single alphabetic character, in order "
-                          "to evade clashes with the built-in CTE aliases.");
-
-            template<class T>
-            [[nodiscard]] consteval internal::table_alias<T, A, C...> operator()(T t) const {
-                return {};
-            }
-        };
-    }
-
-    /** @short Create aliased CTEs, e.g. `constexpr auto z_alias = alias_<'z'>("digits"_cte)`.
-     */
-    template<char A>
-    SQLITE_ORM_INLINE_VAR constexpr internal::table_alias_builder<A> alias_{};
-
-    /** @short Create aliased CTEs, e.g. `constexpr auto z_alias = "z"_alias("digits"_cte)`.
-     */
-    template<internal::string_identifier_template t>
-    [[nodiscard]] consteval auto operator"" _alias() {
-        return internal::to_alias<internal::table_alias_builder, t>(std::make_index_sequence<t.size()>{});
-    }
-#endif
-
     using colalias_a = internal::column_alias<'a'>;
     using colalias_b = internal::column_alias<'b'>;
     using colalias_c = internal::column_alias<'c'>;
@@ -10523,6 +10512,88 @@ namespace sqlite_orm {
 
 // #include "select_constraints.h"
 
+// #include "cte_types.h"
+
+#ifdef SQLITE_ORM_WITH_CTE
+#include <type_traits>
+#include <tuple>
+
+// #include "functional/cxx_core_features.h"
+
+// #include "functional/cxx_type_traits_polyfill.h"
+
+// #include "tuple_helper/tuple_fy.h"
+
+#include <tuple>
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        template<typename T>
+        struct tuplify {
+            using type = std::tuple<T>;
+        };
+        template<typename... Ts>
+        struct tuplify<std::tuple<Ts...>> {
+            using type = std::tuple<Ts...>;
+        };
+
+        template<typename T>
+        using tuplify_t = typename tuplify<T>::type;
+    }
+}
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  Aliased column expression mapped into a CTE, stored as a field in a table column.
+         */
+        template<class A, class F>
+        struct aliased_field {
+            ~aliased_field() = delete;
+            aliased_field(const aliased_field&) = delete;
+            void operator=(const aliased_field&) = delete;
+
+            F field;
+        };
+
+        /**
+         *  This class captures various properties and aspects of a subselect's column expression,
+         *  and is used as a proxy in table_t<>.
+         */
+        template<typename Label,
+                 typename ExplicitColRefs,
+                 typename Expression,
+                 typename SubselectColRefs,
+                 typename FinalColRefs,
+                 typename... Fs>
+        class subselect_mapper {
+          public:
+            subselect_mapper() = delete;
+
+            // this type name is used to detect the mapping from label to object
+            using cte_label_type = Label;
+            using fields_type = std::tuple<Fs...>;
+            // this type captures the expressions forming the columns in a subselect;
+            // it is currently unused, however proves to be useful in compilation errors,
+            // as it simplifies recognizing errors in column expressions
+            using expressions_tuple = tuplify_t<Expression>;
+            // this type captures column reference expressions specified at CTE construction;
+            // those are: member pointers, alias holders
+            using explicit_colrefs_tuple = ExplicitColRefs;
+            // this type captures column reference expressions from the subselect;
+            // those are: member pointers, alias holders
+            using subselect_colrefs_tuple = SubselectColRefs;
+            // this type captures column reference expressions merged from SubselectColRefs and ExplicitColRefs
+            using final_colrefs_tuple = FinalColRefs;
+        };
+    }
+}
+#endif
+
 // #include "storage_lookup.h"
 
 #include <type_traits>  //  std::true_type, std::false_type, std::remove_const, std::enable_if, std::is_base_of, std::is_void
@@ -11043,26 +11114,6 @@ namespace sqlite_orm {
 
 // #include "tuple_helper/tuple_fy.h"
 
-#include <tuple>
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        template<typename T>
-        struct tuplify {
-            using type = std::tuple<T>;
-        };
-        template<typename... Ts>
-        struct tuplify<std::tuple<Ts...>> {
-            using type = std::tuple<Ts...>;
-        };
-
-        template<typename T>
-        using tuplify_t = typename tuplify<T>::type;
-    }
-}
-
 // #include "tuple_helper/tuple_filter.h"
 
 // #include "type_traits.h"
@@ -11108,64 +11159,6 @@ namespace sqlite_orm {
 
 // #include "cte_types.h"
 
-#include <type_traits>
-#include <tuple>
-
-// #include "functional/cxx_core_features.h"
-
-// #include "functional/cxx_type_traits_polyfill.h"
-
-// #include "tuple_helper/tuple_fy.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         *  Aliased column expression mapped into a CTE, stored as a field in a table column.
-         */
-        template<class A, class F>
-        struct aliased_field {
-            ~aliased_field() = delete;
-            aliased_field(const aliased_field&) = delete;
-            void operator=(const aliased_field&) = delete;
-
-            F field;
-        };
-
-        /**
-         *  This class captures various properties and aspects of a subselect's column expression,
-         *  and is used as a proxy in table_t<>.
-         */
-        template<typename Label,
-                 typename ExplicitColRefs,
-                 typename Expression,
-                 typename SubselectColRefs,
-                 typename FinalColRefs,
-                 typename... Fs>
-        class subselect_mapper {
-          public:
-            subselect_mapper() = delete;
-
-            // this type name is used to detect the mapping from label to object
-            using cte_label_type = Label;
-            using fields_type = std::tuple<Fs...>;
-            // this type captures the expressions forming the columns in a subselect;
-            // it is currently unused, however proves to be useful in compilation errors,
-            // as it simplifies recognizing errors in column expressions
-            using expressions_tuple = tuplify_t<Expression>;
-            // this type captures column reference expressions specified at CTE construction;
-            // those are: member pointers, alias holders
-            using explicit_colrefs_tuple = ExplicitColRefs;
-            // this type captures column reference expressions from the subselect;
-            // those are: member pointers, alias holders
-            using subselect_colrefs_tuple = SubselectColRefs;
-            // this type captures column reference expressions merged from SubselectColRefs and ExplicitColRefs
-            using final_colrefs_tuple = FinalColRefs;
-        };
-    }
-}
-
 // #include "storage_traits.h"
 
 #include <tuple>  //  std::tuple
@@ -13823,17 +13816,6 @@ namespace sqlite_orm {
             void operator()(const node_type& /*node*/, L& /*lambda*/) const {}
         };
 
-        /**
-         *  Column alias: skipped
-         */
-        template<char... C>
-        struct ast_iterator<column_alias<C...>, void> {
-            using node_type = column_alias<C...>;
-
-            template<class L>
-            void operator()(const node_type& /*node*/, L& /*lambda*/) const {}
-        };
-
         template<class E>
         struct ast_iterator<order_by_t<E>, void> {
             using node_type = order_by_t<E>;
@@ -18276,7 +18258,7 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& statement, const Ctx& context) const {
                 std::stringstream ss;
                 ss << statement.serialize() << " ";
-                auto whereString = serialize(statement.expression, newContext);
+                auto whereString = serialize(statement.expression, context);
                 ss << '(' << whereString << ')';
                 return ss.str();
             }
@@ -18686,7 +18668,7 @@ namespace sqlite_orm {
         struct column_expression_type<
             DBOs,
             asterisk_t<E>,
-            std::enable_if_t<polyfill::disjunction_v<polyfill::negation<is_any_table_alias<E>>, is_cte_alias<E>>>>
+            std::enable_if_t<polyfill::disjunction_v<polyfill::negation<is_recordset_alias<E>>, is_cte_alias<E>>>>
             : storage_traits::storage_mapped_column_expressions<DBOs, E> {};
 
         template<class A>

From 209c1964aa4a0978cc686691c35f700b8e978ca5 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 18 Feb 2023 17:44:45 +0200
Subject: [PATCH 102/161] Fixed a few things detected with clang

---
 dev/alias_traits.h              | 1 -
 dev/cte_storage.h               | 1 +
 include/sqlite_orm/sqlite_orm.h | 3 ++-
 3 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/dev/alias_traits.h b/dev/alias_traits.h
index 8dc089fec..978a842f7 100644
--- a/dev/alias_traits.h
+++ b/dev/alias_traits.h
@@ -51,7 +51,6 @@ namespace sqlite_orm {
         template<class A>
         using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
 
-        /**
         /** @short Alias of a CTE, see `orm_cte_alias`.
          */
         template<class A>
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index d810f8023..c19ece625 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "functional/cxx_universal.h"
+#include "tuple_helper/tuple_fy.h"
 #include "is_base_of_template.h"
 #include "table_type_of.h"
 #include "column_result.h"
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 9e240fdf7..066a8df5a 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -2924,7 +2924,6 @@ namespace sqlite_orm {
         template<class A>
         using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
 
-        /**
         /** @short Alias of a CTE, see `orm_cte_alias`.
          */
         template<class A>
@@ -18581,6 +18580,8 @@ namespace sqlite_orm {
 
 // #include "functional/cxx_universal.h"
 
+// #include "tuple_helper/tuple_fy.h"
+
 // #include "is_base_of_template.h"
 
 // #include "table_type_of.h"

From f3d9ff985e44f855b531317f37e9c8ff312a331a Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 18 Feb 2023 21:55:03 +0200
Subject: [PATCH 103/161] Must not guard `#include`s subject to amalgamation

---
 dev/cte.h                        |  4 +++-
 dev/cte_column_names_collector.h |  4 ++--
 dev/cte_storage.h                |  3 +--
 dev/cte_types.h                  |  2 ++
 dev/type_traits.h                |  2 +-
 include/sqlite_orm/sqlite_orm.h  | 19 ++++++++++---------
 6 files changed, 19 insertions(+), 15 deletions(-)

diff --git a/dev/cte.h b/dev/cte.h
index 1c9ccccd1..941ebead9 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -1,11 +1,13 @@
 #pragma once
 
-#include "functional/cxx_universal.h"
 #ifdef SQLITE_ORM_WITH_CTE
 #include <utility>  //  std::make_index_sequence
+#endif
 
+#include "functional/cxx_universal.h"
 #include "alias.h"
 
+#ifdef SQLITE_ORM_WITH_CTE
 namespace sqlite_orm {
 
     namespace internal {
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index bb9de9fff..657dd7584 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -1,11 +1,11 @@
 #pragma once
 
-#include "functional/cxx_core_features.h"
 #ifdef SQLITE_ORM_WITH_CTE
 #include <string>
 #include <vector>
 #include <functional>  //  std::reference_wrapper
 #include <system_error>
+#endif
 
 #include "functional/cxx_universal.h"
 #include "functional/cxx_type_traits_polyfill.h"
@@ -17,6 +17,7 @@
 #include "select_constraints.h"
 #include "serializer_context.h"
 
+#ifdef SQLITE_ORM_WITH_CTE
 namespace sqlite_orm {
     namespace internal {
         // collecting column names utilizes the statement serializer
@@ -201,5 +202,4 @@ namespace sqlite_orm {
         }
     }
 }
-
 #endif
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index c19ece625..963723291 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -1,11 +1,11 @@
 #pragma once
 
-#include "functional/cxx_core_features.h"
 #ifdef SQLITE_ORM_WITH_CTE
 #include <type_traits>
 #include <tuple>
 #include <string>
 #include <vector>
+#endif
 
 #include "functional/cxx_universal.h"
 #include "tuple_helper/tuple_fy.h"
@@ -17,7 +17,6 @@
 #include "alias.h"
 #include "cte_types.h"
 #include "cte_column_names_collector.h"
-#endif
 #include "column_expression.h"
 #include "storage_lookup.h"
 
diff --git a/dev/cte_types.h b/dev/cte_types.h
index 39a64d476..da7b85e33 100644
--- a/dev/cte_types.h
+++ b/dev/cte_types.h
@@ -3,11 +3,13 @@
 #ifdef SQLITE_ORM_WITH_CTE
 #include <type_traits>
 #include <tuple>
+#endif
 
 #include "functional/cxx_core_features.h"
 #include "functional/cxx_type_traits_polyfill.h"
 #include "tuple_helper/tuple_fy.h"
 
+#ifdef SQLITE_ORM_WITH_CTE
 namespace sqlite_orm {
 
     namespace internal {
diff --git a/dev/type_traits.h b/dev/type_traits.h
index 4874c695f..a856b7d01 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -86,7 +86,7 @@ namespace sqlite_orm {
         using alias_holder_type_or_none_t = typename alias_holder_type_or_none<T>::type;
 #endif
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         template<auto T>
         using auto_type_t = typename decltype(T)::type;
 #endif
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 066a8df5a..0620d897b 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -408,7 +408,7 @@ namespace sqlite_orm {
         using alias_holder_type_or_none_t = typename alias_holder_type_or_none<T>::type;
 #endif
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         template<auto T>
         using auto_type_t = typename decltype(T)::type;
 #endif
@@ -10516,6 +10516,7 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_WITH_CTE
 #include <type_traits>
 #include <tuple>
+#endif
 
 // #include "functional/cxx_core_features.h"
 
@@ -10543,6 +10544,7 @@ namespace sqlite_orm {
     }
 }
 
+#ifdef SQLITE_ORM_WITH_CTE
 namespace sqlite_orm {
 
     namespace internal {
@@ -16165,13 +16167,12 @@ namespace sqlite_orm {
 
 // #include "cte_column_names_collector.h"
 
-// #include "functional/cxx_core_features.h"
-
 #ifdef SQLITE_ORM_WITH_CTE
 #include <string>
 #include <vector>
 #include <functional>  //  std::reference_wrapper
 #include <system_error>
+#endif
 
 // #include "functional/cxx_universal.h"
 
@@ -16191,6 +16192,7 @@ namespace sqlite_orm {
 
 // #include "serializer_context.h"
 
+#ifdef SQLITE_ORM_WITH_CTE
 namespace sqlite_orm {
     namespace internal {
         // collecting column names utilizes the statement serializer
@@ -16375,7 +16377,6 @@ namespace sqlite_orm {
         }
     }
 }
-
 #endif
 
 // #include "order_by_serializer.h"
@@ -18570,13 +18571,12 @@ namespace sqlite_orm {
 
 // #include "cte_storage.h"
 
-// #include "functional/cxx_core_features.h"
-
 #ifdef SQLITE_ORM_WITH_CTE
 #include <type_traits>
 #include <tuple>
 #include <string>
 #include <vector>
+#endif
 
 // #include "functional/cxx_universal.h"
 
@@ -18598,7 +18598,6 @@ namespace sqlite_orm {
 
 // #include "cte_column_names_collector.h"
 
-#endif
 // #include "column_expression.h"
 
 #include <type_traits>  //  std::enable_if, std::is_same, std::decay, std::is_arithmetic
@@ -20473,13 +20472,15 @@ namespace sqlite_orm {
 }
 #pragma once
 
-// #include "functional/cxx_universal.h"
-
 #ifdef SQLITE_ORM_WITH_CTE
 #include <utility>  //  std::make_index_sequence
+#endif
+
+// #include "functional/cxx_universal.h"
 
 // #include "alias.h"
 
+#ifdef SQLITE_ORM_WITH_CTE
 namespace sqlite_orm {
 
     namespace internal {

From 5b1d723d75ec6236293e765a29f5b5fe8660c20d Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 25 Feb 2023 08:09:57 +0100
Subject: [PATCH 104/161] Removed artificial constraint on single-character CTE
 aliases

---
 dev/cte.h                             | 3 ---
 examples/common_table_expressions.cpp | 6 +++---
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/dev/cte.h b/dev/cte.h
index 515262650..6953731e9 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -36,9 +36,6 @@ namespace sqlite_orm {
      */
     template<internal::string_identifier_template t>
     [[nodiscard]] consteval auto operator"" _cte() {
-        static_assert(t.size() != 1 || ((t.id[0] < 'A' || 'Z' < t.id[0]) && (t.id[0] < 'a' || 'z' < t.id[0])),
-                      "CTE alias identifiers consisting of a single alphabetic character should be avoided, in order "
-                      "to evade clashes with the built-in table aliases.");
         return internal::to_alias<internal::cte_alias, t>(std::make_index_sequence<t.size()>{});
     }
 #endif
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 57be86a19..7ca761462 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -563,8 +563,8 @@ void apfelmaennchen() {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     constexpr auto xaxis = "xaxis"_cte;
     constexpr auto yaxis = "yaxis"_cte;
-    constexpr auto m = "mi"_cte;
-    constexpr auto m2 = "maxi"_cte;
+    constexpr auto m = "m"_cte;
+    constexpr auto m2 = "m2"_cte;
     constexpr auto a = "string"_cte;
     constexpr auto x_col = "x"_col;
     constexpr auto y_col = "y"_col;
@@ -680,7 +680,7 @@ void sudoku() {
     constexpr auto input = "input"_cte;
     constexpr auto digits = "digits"_cte;
     constexpr auto z_alias = "z"_alias.for_<digits>();
-    constexpr auto x = "x_"_cte;
+    constexpr auto x = "x"_cte;
     constexpr auto sud = "sud"_col;
     constexpr auto z = "z"_col;
     constexpr auto lp = "lp"_col;

From ef444ec7021fe4e4308ec06094dead89387842fb Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 25 Feb 2023 08:27:26 +0100
Subject: [PATCH 105/161] Removed '_col' suffix from columns in CTE examples

---
 examples/common_table_expressions.cpp | 129 ++++++++++++--------------
 1 file changed, 60 insertions(+), 69 deletions(-)

diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 7ca761462..c8716dc7e 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -309,17 +309,17 @@ void family_tree() {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     constexpr auto parent_of = "parent_of"_cte;
     constexpr auto ancestor_of_alice = "ancestor_of_alice"_cte;
-    constexpr auto parent_col = "parent"_col;
-    constexpr auto name_col = "name"_col;
-    auto ast = with(
-        make_tuple(cte<parent_of>(&Family::name, parent_col)(union_(select(columns(&Family::name, &Family::mom)),
-                                                                    select(columns(&Family::name, &Family::dad)))),
-                   cte<ancestor_of_alice>(name_col)(union_all(
-                       select(parent_of->*parent_col, where(parent_of->*&Family::name == "Alice")),
-                       select(parent_of->*parent_col, join<ancestor_of_alice>(using_(parent_of->*&Family::name)))))),
-        select(&Family::name,
-               where(is_equal(ancestor_of_alice->*name_col, &Family::name) && is_null(&Family::died)),
-               order_by(&Family::born)));
+    constexpr auto parent = "parent"_col;
+    constexpr auto name = "name"_col;
+    auto ast =
+        with(make_tuple(cte<parent_of>(&Family::name, parent)(union_(select(columns(&Family::name, &Family::mom)),
+                                                                     select(columns(&Family::name, &Family::dad)))),
+                        cte<ancestor_of_alice>(name)(union_all(
+                            select(parent_of->*parent, where(parent_of->*&Family::name == "Alice")),
+                            select(parent_of->*parent, join<ancestor_of_alice>(using_(parent_of->*&Family::name)))))),
+             select(&Family::name,
+                    where(is_equal(ancestor_of_alice->*name, &Family::name) && is_null(&Family::died)),
+                    order_by(&Family::born)));
 #else
     auto ast = with(
         make_tuple(cte<cte_1>("name", "parent")(union_(select(columns(&Family::name, &Family::mom >>= colalias_h{})),
@@ -426,13 +426,13 @@ void depth_or_breadth_first() {
         //    SELECT substr('..........', 1, level * 3) || name FROM under_alice;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto under_alice = "under_alice"_cte;
-        constexpr auto level_col = "level"_col;
-        auto ast = with(cte<under_alice>(&Org::name, level_col)(
+        constexpr auto level = "level"_col;
+        auto ast = with(cte<under_alice>(&Org::name, level)(
                             union_all(select(columns("Alice", 0)),
-                                      select(columns(&Org::name, under_alice->*level_col + c(1)),
+                                      select(columns(&Org::name, under_alice->*level + c(1)),
                                              join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
                                              order_by(2)))),
-                        select(substr("..........", 1, under_alice->*level_col * c(3)) || c(under_alice->*&Org::name)));
+                        select(substr("..........", 1, under_alice->*level * c(3)) || c(under_alice->*&Org::name)));
 #else
         auto ast =
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
@@ -467,13 +467,13 @@ void depth_or_breadth_first() {
         //    SELECT substr('..........', 1, level * 3) || name FROM under_alice;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto under_alice = "under_alice"_cte;
-        constexpr auto level_col = "level"_col;
-        auto ast = with(cte<under_alice>(&Org::name, level_col)(
+        constexpr auto level = "level"_col;
+        auto ast = with(cte<under_alice>(&Org::name, level)(
                             union_all(select(columns("Alice", 0)),
-                                      select(columns(&Org::name, under_alice->*level_col + c(1)),
+                                      select(columns(&Org::name, under_alice->*level + c(1)),
                                              join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
                                              order_by(2).desc()))),
-                        select(substr("..........", 1, under_alice->*level_col * c(3)) || c(under_alice->*&Org::name)));
+                        select(substr("..........", 1, under_alice->*level * c(3)) || c(under_alice->*&Org::name)));
 #else
         auto ast =
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
@@ -566,29 +566,27 @@ void apfelmaennchen() {
     constexpr auto m = "m"_cte;
     constexpr auto m2 = "m2"_cte;
     constexpr auto a = "string"_cte;
-    constexpr auto x_col = "x"_col;
-    constexpr auto y_col = "y"_col;
-    constexpr auto iter_col = "iter"_col;
-    constexpr auto cx_col = "cx"_col;
-    constexpr auto cy_col = "cy"_col;
-    constexpr auto t_col = "t"_col;
+    constexpr auto x = "x"_col;
+    constexpr auto y = "y"_col;
+    constexpr auto iter = "iter"_col;
+    constexpr auto cx = "cx"_col;
+    constexpr auto cy = "cy"_col;
+    constexpr auto t = "t"_col;
     auto ast = with(
-        make_tuple(
-            cte<xaxis>(x_col)(union_all(select(-2.0), select(xaxis->*x_col + c(0.05), where(xaxis->*x_col < 1.2)))),
-            cte<yaxis>(y_col)(union_all(select(-1.0), select(yaxis->*y_col + c(0.10), where(yaxis->*y_col < 1.0)))),
-            cte<m>(iter_col, cx_col, cy_col, x_col, y_col)(union_all(
-                select(columns(0, xaxis->*x_col, yaxis->*y_col, 0.0, 0.0)),
-                select(columns(m->*iter_col + c(1),
-                               m->*cx_col,
-                               m->*cy_col,
-                               m->*x_col * c(m->*x_col) - m->*y_col * c(m->*y_col) + m->*cx_col,
-                               c(2.0) * m->*x_col * m->*y_col + m->*cy_col),
-                       where((m->*x_col * c(m->*x_col) + m->*y_col * c(m->*y_col)) < c(4.0) && m->*iter_col < 28)))),
-            cte<m2>(iter_col, cx_col, cy_col)(
-                select(columns(max<>(m->*iter_col), m->*cx_col, m->*cy_col), group_by(m->*cx_col, m->*cy_col))),
-            cte<a>(t_col)(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter_col / c(7.0), 4.0), 1), ""),
-                                 group_by(m2->*cy_col)))),
-        select(group_concat(rtrim(a->*t_col), "\n")));
+        make_tuple(cte<xaxis>(x)(union_all(select(-2.0), select(xaxis->*x + c(0.05), where(xaxis->*x < 1.2)))),
+                   cte<yaxis>(y)(union_all(select(-1.0), select(yaxis->*y + c(0.10), where(yaxis->*y < 1.0)))),
+                   cte<m>(iter, cx, cy, x, y)(
+                       union_all(select(columns(0, xaxis->*x, yaxis->*y, 0.0, 0.0)),
+                                 select(columns(m->*iter + c(1),
+                                                m->*cx,
+                                                m->*cy,
+                                                m->*x * c(m->*x) - m->*y * c(m->*y) + m->*cx,
+                                                c(2.0) * m->*x * m->*y + m->*cy),
+                                        where((m->*x * c(m->*x) + m->*y * c(m->*y)) < c(4.0) && m->*iter < 28)))),
+                   cte<m2>(iter, cx, cy)(select(columns(max<>(m->*iter), m->*cx, m->*cy), group_by(m->*cx, m->*cy))),
+                   cte<a>(t)(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / c(7.0), 4.0), 1), ""),
+                                    group_by(m2->*cy)))),
+        select(group_concat(rtrim(a->*t), "\n")));
 #else
     using cte_xaxis = decltype(1_ctealias);
     using cte_yaxis = decltype(2_ctealias);
@@ -600,36 +598,29 @@ void apfelmaennchen() {
     constexpr cte_m m{};
     constexpr cte_m2 m2{};
     constexpr cte_a a{};
-    constexpr internal::column_alias<'x'> x_col;
-    constexpr internal::column_alias<'y'> y_col;
-    constexpr internal::column_alias<'i', 't', 'e', 'r'> iter_col;
-    constexpr internal::column_alias<'c', 'x'> cx_col;
-    constexpr internal::column_alias<'c', 'y'> cy_col;
-    constexpr internal::column_alias<'t'> t_col;
+    constexpr internal::column_alias<'x'> x;
+    constexpr internal::column_alias<'y'> y;
+    constexpr internal::column_alias<'i', 't', 'e', 'r'> iter;
+    constexpr internal::column_alias<'c', 'x'> cx;
+    constexpr internal::column_alias<'c', 'y'> cy;
+    constexpr internal::column_alias<'t'> t;
     auto ast = with(
         make_tuple(
-            cte<cte_xaxis>("x")(
-                union_all(select(-2.0 >>= x_col), select(xaxis->*x_col + c(0.05), where(xaxis->*x_col < 1.2)))),
-            cte<cte_yaxis>("y")(
-                union_all(select(-1.0 >>= y_col), select(yaxis->*y_col + c(0.10), where(yaxis->*y_col < 1.0)))),
-            cte<cte_m>("iter", "cx", "cy", "x", "y")(union_all(
-                select(columns(0 >>= iter_col,
-                               xaxis->*x_col >>= cx_col,
-                               yaxis->*y_col >>= cy_col,
-                               0.0 >>= x_col,
-                               0.0 >>= y_col)),
-                select(columns(m->*iter_col + c(1),
-                               m->*cx_col,
-                               m->*cy_col,
-                               m->*x_col * c(m->*x_col) - m->*y_col * c(m->*y_col) + m->*cx_col,
-                               c(2.0) * m->*x_col * m->*y_col + m->*cy_col),
-                       where((m->*x_col * c(m->*x_col) + m->*y_col * c(m->*y_col)) < c(4.0) && m->*iter_col < 28)))),
-            cte<cte_m2>("iter", "cx", "cy")(select(columns(max<>(m->*iter_col) >>= iter_col, m->*cx_col, m->*cy_col),
-                                                   group_by(m->*cx_col, m->*cy_col))),
-            cte<cte_a>("t")(
-                select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter_col / c(7.0), 4.0), 1), "") >>= t_col,
-                       group_by(m2->*cy_col)))),
-        select(group_concat(rtrim(a->*t_col), "\n")));
+            cte<cte_xaxis>("x")(union_all(select(-2.0 >>= x), select(xaxis->*x + c(0.05), where(xaxis->*x < 1.2)))),
+            cte<cte_yaxis>("y")(union_all(select(-1.0 >>= y), select(yaxis->*y + c(0.10), where(yaxis->*y < 1.0)))),
+            cte<cte_m>("iter", "cx", "cy", "x", "y")(
+                union_all(select(columns(0 >>= iter, xaxis->*x >>= cx, yaxis->*y >>= cy, 0.0 >>= x, 0.0 >>= y)),
+                          select(columns(m->*iter + c(1),
+                                         m->*cx,
+                                         m->*cy,
+                                         m->*x * c(m->*x) - m->*y * c(m->*y) + m->*cx,
+                                         c(2.0) * m->*x * m->*y + m->*cy),
+                                 where((m->*x * c(m->*x) + m->*y * c(m->*y)) < c(4.0) && m->*iter < 28)))),
+            cte<cte_m2>("iter", "cx", "cy")(
+                select(columns(max<>(m->*iter) >>= iter, m->*cx, m->*cy), group_by(m->*cx, m->*cy))),
+            cte<cte_a>("t")(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / c(7.0), 4.0), 1), "") >>= t,
+                                   group_by(m2->*cy)))),
+        select(group_concat(rtrim(a->*t), "\n")));
 #endif
 
     string sql = storage.dump(ast);

From dc7a118d73f528f29d2e48f96669977fa6d970a9 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 25 Feb 2023 08:28:16 +0100
Subject: [PATCH 106/161] Removed superfluous fold expression preprocessor
 guard

---
 dev/select_constraints.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 3c3b2bde4..cc1274d08 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -511,10 +511,8 @@ namespace sqlite_orm {
                               bool> = true>
     auto cte(ExplicitCols... explicitColumns) {
         static_assert(internal::is_cte_alias_v<Label>, "Label must be a CTE alias");
-#ifdef SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
         static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
                       "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
-#endif
 
         using builder_type = internal::cte_builder<
             Label,

From 89466cd1bbd3d090361869317a2f8d5ce9975e34 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 25 Feb 2023 08:29:44 +0100
Subject: [PATCH 107/161] appveryor: Updated build worker image name for clang
 C++20

---
 appveyor.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/appveyor.yml b/appveyor.yml
index c805e66be..55bed4074 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -55,7 +55,7 @@ environment:
       SQLITE_ORM_CXX_STANDARD: "-DSQLITE_ORM_ENABLE_CXX_17=ON"
       cmake_build_parallel: ""
 
-    - job_name: clang, C++20
+    - job_name: clang, C++20 (with examples)
       appveyor_build_worker_image: Ubuntu
       CC: clang
       CXX: clang++

From b520578bf777f1f2bfd7fd04936a2a358090f276 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 25 Feb 2023 09:35:54 +0100
Subject: [PATCH 108/161] Replaced SFINAE on `cte<>()` with concepts

---
 dev/cte.h                       |  6 +++---
 dev/select_constraints.h        | 18 +++++++-----------
 include/sqlite_orm/sqlite_orm.h | 29 ++++++++++-------------------
 3 files changed, 20 insertions(+), 33 deletions(-)

diff --git a/dev/cte.h b/dev/cte.h
index 6953731e9..a8386e17e 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -12,7 +12,7 @@ namespace sqlite_orm {
 
     namespace internal {
         /** 
-         *  A special table alias that is both, a storage lookup type (mapping type) and an alias.
+         *  A special record set alias that is both, a storage lookup type (mapping type) and an alias.
          */
         template<char A, char... X>
         struct cte_alias
@@ -29,7 +29,7 @@ namespace sqlite_orm {
     [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
         return internal::cte_alias<Chars...>{};
     }
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
      *  cte_alias<'1'[, ...]> from a string literal.
      *  E.g. "1"_cte, "2"_cte
@@ -40,7 +40,7 @@ namespace sqlite_orm {
     }
 #endif
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     using cte_1 = decltype("1"_cte);
     using cte_2 = decltype("2"_cte);
     using cte_3 = decltype("3"_cte);
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index cc1274d08..c4f9d34e0 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -520,18 +520,14 @@ namespace sqlite_orm {
         return builder_type{{std::move(explicitColumns)...}};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
-    template<auto label,
-             class... ExplicitCols,
-             std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
-                                  internal::is_column_alias<ExplicitCols>,
-                                  std::is_member_pointer<ExplicitCols>,
-                                  internal::is_column<ExplicitCols>,
-                                  std::is_same<ExplicitCols, std::remove_cvref_t<decltype(std::ignore)>>,
-                                  std::is_convertible<ExplicitCols, std::string>>...>,
-                              bool> = true>
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    template<orm_cte_alias auto label, class... ExplicitCols>
+        requires((internal::is_column_alias_v<ExplicitCols> || std::is_member_pointer_v<ExplicitCols> ||
+                  internal::is_column_v<ExplicitCols> ||
+                  std::same_as<ExplicitCols, std::remove_cvref_t<decltype(std::ignore)>> ||
+                  std::convertible_to<ExplicitCols, std::string>) &&
+                 ...)
     auto cte(ExplicitCols... explicitColumns) {
-        static_assert(internal::is_cte_alias_v<decltype(label)>, "Label must be a CTE alias");
         static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
                       "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
 
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index f43e0b4cb..9e59ece83 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -7764,10 +7764,8 @@ namespace sqlite_orm {
                               bool> = true>
     auto cte(ExplicitCols... explicitColumns) {
         static_assert(internal::is_cte_alias_v<Label>, "Label must be a CTE alias");
-#ifdef SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
         static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
                       "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
-#endif
 
         using builder_type = internal::cte_builder<
             Label,
@@ -7775,18 +7773,14 @@ namespace sqlite_orm {
         return builder_type{{std::move(explicitColumns)...}};
     }
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
-    template<auto label,
-             class... ExplicitCols,
-             std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
-                                  internal::is_column_alias<ExplicitCols>,
-                                  std::is_member_pointer<ExplicitCols>,
-                                  internal::is_column<ExplicitCols>,
-                                  std::is_same<ExplicitCols, std::remove_cvref_t<decltype(std::ignore)>>,
-                                  std::is_convertible<ExplicitCols, std::string>>...>,
-                              bool> = true>
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    template<orm_cte_alias auto label, class... ExplicitCols>
+        requires((internal::is_column_alias_v<ExplicitCols> || std::is_member_pointer_v<ExplicitCols> ||
+                  internal::is_column_v<ExplicitCols> ||
+                  std::same_as<ExplicitCols, std::remove_cvref_t<decltype(std::ignore)>> ||
+                  std::convertible_to<ExplicitCols, std::string>) &&
+                 ...)
     auto cte(ExplicitCols... explicitColumns) {
-        static_assert(internal::is_cte_alias_v<decltype(label)>, "Label must be a CTE alias");
         static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
                       "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
 
@@ -20491,7 +20485,7 @@ namespace sqlite_orm {
 
     namespace internal {
         /** 
-         *  A special table alias that is both, a storage lookup type (mapping type) and an alias.
+         *  A special record set alias that is both, a storage lookup type (mapping type) and an alias.
          */
         template<char A, char... X>
         struct cte_alias
@@ -20508,21 +20502,18 @@ namespace sqlite_orm {
     [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
         return internal::cte_alias<Chars...>{};
     }
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
      *  cte_alias<'1'[, ...]> from a string literal.
      *  E.g. "1"_cte, "2"_cte
      */
     template<internal::string_identifier_template t>
     [[nodiscard]] consteval auto operator"" _cte() {
-        static_assert(t.size() != 1 || ((t.id[0] < 'A' || 'Z' < t.id[0]) && (t.id[0] < 'a' || 'z' < t.id[0])),
-                      "CTE alias identifiers consisting of a single alphabetic character should be avoided, in order "
-                      "to evade clashes with the built-in table aliases.");
         return internal::to_alias<internal::cte_alias, t>(std::make_index_sequence<t.size()>{});
     }
 #endif
 
-#ifdef SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     using cte_1 = decltype("1"_cte);
     using cte_2 = decltype("2"_cte);
     using cte_3 = decltype("3"_cte);

From 6bf1bdb3527495ed2aad213877a462eaacfbdb8f Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 25 Feb 2023 10:57:38 +0100
Subject: [PATCH 109/161] Renamed 'CTE label' and 'CTE alias' to 'CTE moniker'

---
 dev/alias.h                     |  32 +++--
 dev/alias_traits.h              |  12 +-
 dev/column_expression.h         |   2 +-
 dev/column_pointer.h            |   6 +-
 dev/column_result.h             |   6 +-
 dev/cte.h                       |  17 +--
 dev/cte_storage.h               |  22 +--
 dev/cte_types.h                 |   6 +-
 dev/select_constraints.h        |  47 +++----
 dev/statement_serializer.h      |   2 +-
 dev/storage_impl.h              |  22 +--
 dev/storage_lookup.h            |  40 +++---
 dev/table.h                     |  10 +-
 dev/table_name_collector.h      |   2 +-
 dev/type_traits.h               |   5 +-
 include/sqlite_orm/sqlite_orm.h | 231 ++++++++++++++++----------------
 16 files changed, 234 insertions(+), 228 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 7b2a5c3ed..763c3d8b5 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -101,11 +101,14 @@ namespace sqlite_orm {
             static std::string as_alias() {
                 return alias_extractor::extract();
             }
-            // for cte aliases -> empty
+
+#ifdef SQLITE_ORM_WITH_CTE
+            // for cte monikers -> empty
             template<class T = A, satisfies<std::is_same, polyfill::detected_t<type_t, T>, A> = true>
             static std::string as_alias() {
                 return {};
             }
+#endif
         };
 
         /**
@@ -178,11 +181,12 @@ namespace sqlite_orm {
      *  @return column with table alias attached. Place it instead of a column statement in case you need to specify a
      *  column with table alias prefix like 'a.column'.
      */
-    template<class A,
-             class C,
-             std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<A>,
-                                                      polyfill::negation<internal::is_cte_alias<internal::type_t<A>>>>,
-                              bool> = true>
+    template<
+        class A,
+        class C,
+        std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<A>,
+                                                 polyfill::negation<internal::is_cte_moniker<internal::type_t<A>>>>,
+                         bool> = true>
     internal::alias_column_t<A, C> alias_column(C c) {
         using aliased_type = internal::type_t<A>;
         static_assert(std::is_same<polyfill::detected_t<internal::table_type_of_t, C>, aliased_type>::value,
@@ -192,7 +196,7 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     template<orm_table_alias auto als, class C>
-        requires(!orm_cte_alias<internal::auto_type_t<als>>)
+        requires(!orm_cte_moniker<internal::auto_type_t<als>>)
     auto alias_column(C c) {
         using A = std::remove_const_t<decltype(als)>;
         using aliased_type = internal::type_t<A>;
@@ -202,7 +206,7 @@ namespace sqlite_orm {
     }
 
     template<orm_table_alias A, class F>
-        requires(!orm_cte_alias<internal::type_t<A>>)
+        requires(!orm_cte_moniker<internal::type_t<A>>)
     constexpr auto operator->*(const A&, F field) {
         return internal::alias_column_t<A, decltype(field)>{field};
     }
@@ -212,16 +216,16 @@ namespace sqlite_orm {
     template<class A,
              class C,
              std::enable_if_t<
-                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_alias<internal::type_t<A>>>,
+                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_moniker<internal::type_t<A>>>,
                  bool> = true>
     auto alias_column(C c) {
-        using cte_alias_t = internal::type_t<A>;
+        using cte_moniker_t = internal::type_t<A>;
         if constexpr(polyfill::is_specialization_of_v<C, internal::column_pointer>) {
-            static_assert(std::is_same<internal::table_type_of_t<C>, cte_alias_t>::value,
+            static_assert(std::is_same<internal::table_type_of_t<C>, cte_moniker_t>::value,
                           "Column pointer must match aliased CTE");
             return internal::alias_column_t<A, C>{c};
         } else {
-            auto cp = column<cte_alias_t>(c);
+            auto cp = column<cte_moniker_t>(c);
             return internal::alias_column_t<A, decltype(cp)>{cp};
         }
     }
@@ -229,7 +233,7 @@ namespace sqlite_orm {
     template<class A,
              class F,
              std::enable_if_t<
-                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_alias<internal::type_t<A>>>,
+                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_moniker<internal::type_t<A>>>,
                  bool> = true>
     constexpr auto operator->*(const A& /*tableAlias*/, F field) {
         return alias_column<A>(std::move(field));
@@ -237,7 +241,7 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     template<orm_table_alias auto als, class C>
-        requires(orm_cte_alias<internal::auto_type_t<als>>)
+        requires(orm_cte_moniker<internal::auto_type_t<als>>)
     auto alias_column(C c) {
         using A = std::remove_const_t<decltype(als)>;
         return alias_column<A>(std::move(c));
diff --git a/dev/alias_traits.h b/dev/alias_traits.h
index 978a842f7..e3fd06728 100644
--- a/dev/alias_traits.h
+++ b/dev/alias_traits.h
@@ -51,10 +51,10 @@ namespace sqlite_orm {
         template<class A>
         using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
 
-        /** @short Alias of a CTE, see `orm_cte_alias`.
+        /** @short Alias of a CTE, see `orm_cte_moniker`.
          */
         template<class A>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_cte_alias_v =
+        SQLITE_ORM_INLINE_VAR constexpr bool is_cte_moniker_v =
 #ifdef SQLITE_ORM_WITH_CTE
             polyfill::conjunction_v<is_recordset_alias<A>,
                                     std::is_same<polyfill::detected_t<type_t, A>, std::remove_const_t<A>>>;
@@ -63,7 +63,7 @@ namespace sqlite_orm {
 #endif
 
         template<class A>
-        using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
+        using is_cte_moniker = polyfill::bool_constant<is_cte_moniker_v<A>>;
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
@@ -97,13 +97,13 @@ namespace sqlite_orm {
     template<class A>
     concept orm_table_alias = (orm_recordset_alias<A> && !std::same_as<typename A::type, std::remove_const_t<A>>);
 
-    /** @short Alias of a CTE.
+    /** @short Moniker of a CTE.
      *
-     *  A CTE alias has the following traits:
+     *  A CTE moniker has the following traits:
      *  - is derived from `alias_tag`.
      *  - has a `type` typename, which refers to itself.
      */
     template<class A>
-    concept orm_cte_alias = (orm_recordset_alias<A> && std::same_as<typename A::type, std::remove_const_t<A>>);
+    concept orm_cte_moniker = (orm_recordset_alias<A> && std::same_as<typename A::type, std::remove_const_t<A>>);
 #endif
 }
diff --git a/dev/column_expression.h b/dev/column_expression.h
index 1455b294b..f57366b7e 100644
--- a/dev/column_expression.h
+++ b/dev/column_expression.h
@@ -63,7 +63,7 @@ namespace sqlite_orm {
         struct column_expression_type<
             DBOs,
             asterisk_t<E>,
-            std::enable_if_t<polyfill::disjunction_v<polyfill::negation<is_recordset_alias<E>>, is_cte_alias<E>>>>
+            std::enable_if_t<polyfill::disjunction_v<polyfill::negation<is_recordset_alias<E>>, is_cte_moniker<E>>>>
             : storage_traits::storage_mapped_column_expressions<DBOs, E> {};
 
         template<class A>
diff --git a/dev/column_pointer.h b/dev/column_pointer.h
index 464f41816..c32f0d61c 100644
--- a/dev/column_pointer.h
+++ b/dev/column_pointer.h
@@ -82,7 +82,7 @@ namespace sqlite_orm {
 
         template<class A>
         struct column_pointer_builder<A, match_if<is_alias, A>> {
-            static_assert(is_cte_alias_v<A>, "`A' must be a mapped table alias");
+            static_assert(is_cte_moniker_v<A>, "`A' must be a mapped table alias");
 
             using mapped_type = A;
 
@@ -143,7 +143,7 @@ namespace sqlite_orm {
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*&Object::id));
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*1_colalias));
      */
-    template<class A, class F, internal::satisfies<internal::is_cte_alias, A> = true>
+    template<class A, class F, internal::satisfies<internal::is_cte_moniker, A> = true>
     constexpr auto operator->*(const A& /*cteAlias*/, F field) {
         return column<A>(std::move(field));
     }
@@ -156,7 +156,7 @@ namespace sqlite_orm {
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
      */
-    template<class A, class F, internal::satisfies<internal::is_cte_alias, A> = true>
+    template<class A, class F, internal::satisfies<internal::is_cte_moniker, A> = true>
     constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
         return column<A>(std::move(field));
     }
diff --git a/dev/column_result.h b/dev/column_result.h
index dd22c201f..e2c04a8ed 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -207,9 +207,9 @@ namespace sqlite_orm {
         struct column_result_t<DBOs, column_pointer<T, F>, void> : column_result_t<DBOs, F> {};
 
 #ifdef SQLITE_ORM_WITH_CTE
-        template<class DBOs, class Label, class ColAlias>
-        struct column_result_t<DBOs, column_pointer<Label, alias_holder<ColAlias>>, void> {
-            using table_type = storage_pick_table_t<Label, DBOs>;
+        template<class DBOs, class Moniker, class ColAlias>
+        struct column_result_t<DBOs, column_pointer<Moniker, alias_holder<ColAlias>>, void> {
+            using table_type = storage_pick_table_t<Moniker, DBOs>;
             using cte_mapper_type = cte_mapper_type_t<table_type>;
 
             // filter all column references being `alias_holder<>`
diff --git a/dev/cte.h b/dev/cte.h
index a8386e17e..06cd1daa1 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -15,28 +15,29 @@ namespace sqlite_orm {
          *  A special record set alias that is both, a storage lookup type (mapping type) and an alias.
          */
         template<char A, char... X>
-        struct cte_alias
-            : recordset_alias<cte_alias<A, X...> /* refer to self, since a label is both, an alias and a lookup type */,
-                              A,
-                              X...> {};
+        struct cte_moniker
+            : recordset_alias<
+                  cte_moniker<A, X...> /* refer to self, since a moniker is both, an alias and a mapped type */,
+                  A,
+                  X...> {};
     }
 
     /**
-     *  cte_alias<'n'> from a numeric literal.
+     *  cte_moniker<'n'> from a numeric literal.
      *  E.g. 1_ctealias, 2_ctealias
      */
     template<char... Chars>
     [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
-        return internal::cte_alias<Chars...>{};
+        return internal::cte_moniker<Chars...>{};
     }
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
-     *  cte_alias<'1'[, ...]> from a string literal.
+     *  cte_moniker<'1'[, ...]> from a string literal.
      *  E.g. "1"_cte, "2"_cte
      */
     template<internal::string_identifier_template t>
     [[nodiscard]] consteval auto operator"" _cte() {
-        return internal::to_alias<internal::cte_alias, t>(std::make_index_sequence<t.size()>{});
+        return internal::to_alias<internal::cte_moniker, t>(std::make_index_sequence<t.size()>{});
     }
 #endif
 
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 963723291..d91d57dd3 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -25,40 +25,40 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
         // F = field_type
-        template<typename Label,
+        template<typename Moniker,
                  typename ExplicitColRefs,
                  typename Expression,
                  typename SubselectColRefs,
                  typename FinalColRefs,
                  typename F>
         struct create_cte_mapper {
-            using type = subselect_mapper<Label, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, F>;
+            using type = subselect_mapper<Moniker, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, F>;
         };
 
         // std::tuple<Fs...>
-        template<typename Label,
+        template<typename Moniker,
                  typename ExplicitColRefs,
                  typename Expression,
                  typename SubselectColRefs,
                  typename FinalColRefs,
                  typename... Fs>
-        struct create_cte_mapper<Label,
+        struct create_cte_mapper<Moniker,
                                  ExplicitColRefs,
                                  Expression,
                                  SubselectColRefs,
                                  FinalColRefs,
                                  std::tuple<Fs...>> {
-            using type = subselect_mapper<Label, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Fs...>;
+            using type = subselect_mapper<Moniker, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Fs...>;
         };
 
-        template<typename Label,
+        template<typename Moniker,
                  typename ExplicitColRefs,
                  typename Expression,
                  typename SubselectColRefs,
                  typename FinalColRefs,
                  typename Result>
         using create_cte_mapper_t =
-            typename create_cte_mapper<Label, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Result>::
+            typename create_cte_mapper<Moniker, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Result>::
                 type;
 
         // aliased column expressions, explicit or implicitly numbered
@@ -165,9 +165,9 @@ namespace sqlite_orm {
         }
 
         // column_pointer<>
-        template<class DBOs, class Label, class F, size_t Idx = 0>
+        template<class DBOs, class Moniker, class F, size_t Idx = 0>
         auto extract_colref_expressions(const DBOs& dbObjects,
-                                        const column_pointer<Label, F>& col,
+                                        const column_pointer<Moniker, F>& col,
                                         std::index_sequence<Idx> s = {}) {
             return extract_colref_expressions(dbObjects, col.field, s);
         }
@@ -272,7 +272,7 @@ namespace sqlite_orm {
                           "Number of explicit columns of common table expression doesn't match the number of columns "
                           "in the subselect.");
 
-            std::string tableName = alias_extractor<cte_label_type_t<cte_type>>::extract();
+            std::string tableName = alias_extractor<cte_moniker_type_t<cte_type>>::extract();
             auto subselectColRefs = extract_colref_expressions(dbObjects, subSelect.col);
             const auto& finalColRefs =
                 determine_cte_colrefs(dbObjects, subselectColRefs, cte.explicitColumns, index_sequence{});
@@ -280,7 +280,7 @@ namespace sqlite_orm {
             serializer_context context{dbObjects};
             std::vector<std::string> columnNames = collect_cte_column_names(subSelect, cte.explicitColumns, context);
 
-            using mapper_type = create_cte_mapper_t<cte_label_type_t<cte_type>,
+            using mapper_type = create_cte_mapper_t<cte_moniker_type_t<cte_type>,
                                                     typename cte_type::explicit_colrefs_tuple,
                                                     column_expression_of_t<DBOs, subselect_type>,
                                                     decltype(subselectColRefs),
diff --git a/dev/cte_types.h b/dev/cte_types.h
index da7b85e33..7d5636a8e 100644
--- a/dev/cte_types.h
+++ b/dev/cte_types.h
@@ -30,7 +30,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<>.
          */
-        template<typename Label,
+        template<typename Moniker,
                  typename ExplicitColRefs,
                  typename Expression,
                  typename SubselectColRefs,
@@ -40,8 +40,8 @@ namespace sqlite_orm {
           public:
             subselect_mapper() = delete;
 
-            // this type name is used to detect the mapping from label to object
-            using cte_label_type = Label;
+            // this type name is used to detect the mapping from moniker to object
+            using cte_moniker_type = Moniker;
             using fields_type = std::tuple<Fs...>;
             // this type captures the expressions forming the columns in a subselect;
             // it is currently unused, however proves to be useful in compilation errors,
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index c4f9d34e0..27564228d 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -222,11 +222,11 @@ namespace sqlite_orm {
         using decay_explicit_column_t = typename decay_explicit_column<T>::type;
 
         /**
-         *  Labeled (aliased) CTE expression.
+         *  Monikered (aliased) CTE expression.
          */
-        template<class Label, class Select, class ExplicitCols>
+        template<class Moniker, class Select, class ExplicitCols>
         struct common_table_expression {
-            using cte_label_type = Label;
+            using cte_moniker_type = Moniker;
             using expression_type = Select;
             using explicit_colrefs_tuple = ExplicitCols;
             static constexpr size_t explicit_colref_count = std::tuple_size_v<ExplicitCols>;
@@ -242,34 +242,35 @@ namespace sqlite_orm {
         template<class... CTEs>
         using common_table_expressions = std::tuple<CTEs...>;
 
-        template<typename Label, class ExplicitCols>
+        template<typename Moniker, class ExplicitCols>
         struct cte_builder {
             ExplicitCols explicitColumns;
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols> operator()(select_t<T, Args...> sel) && {
+            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols>
+            operator()(select_t<T, Args...> sel) && {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols> operator()(Compound sel) && {
+            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> operator()(Compound sel) && {
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols> as(select_t<T, Args...> sel) && {
+            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols> as(select_t<T, Args...> sel) && {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols> as(Compound sel) && {
+            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> as(Compound sel) && {
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols>
+            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols>
             materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS MATERIALIZED` is unimplemented");
                 return {std::move(this->explicitColumns), std::move(sel)};
@@ -277,13 +278,13 @@ namespace sqlite_orm {
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols> materialized(Compound sel) && {
+            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS MATERIALIZED` is unimplemented");
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols>
+            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols>
             not_materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
                 return {std::move(this->explicitColumns), std::move(sel)};
@@ -291,7 +292,7 @@ namespace sqlite_orm {
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols> not_materialized(Compound sel) && {
+            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> not_materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
@@ -500,7 +501,7 @@ namespace sqlite_orm {
      *  2. explicit columns
      *  3. fill in empty column names with column index
      */
-    template<class Label,
+    template<class Moniker,
              class... ExplicitCols,
              std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
                                   internal::is_column_alias<ExplicitCols>,
@@ -510,18 +511,18 @@ namespace sqlite_orm {
                                   std::is_convertible<ExplicitCols, std::string>>...>,
                               bool> = true>
     auto cte(ExplicitCols... explicitColumns) {
-        static_assert(internal::is_cte_alias_v<Label>, "Label must be a CTE alias");
+        static_assert(internal::is_cte_moniker_v<Moniker>, "Moniker must be a CTE moniker");
         static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
                       "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
 
         using builder_type = internal::cte_builder<
-            Label,
+            Moniker,
             internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column_t>>;
         return builder_type{{std::move(explicitColumns)...}};
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    template<orm_cte_alias auto label, class... ExplicitCols>
+    template<orm_cte_moniker auto moniker, class... ExplicitCols>
         requires((internal::is_column_alias_v<ExplicitCols> || std::is_member_pointer_v<ExplicitCols> ||
                   internal::is_column_v<ExplicitCols> ||
                   std::same_as<ExplicitCols, std::remove_cvref_t<decltype(std::ignore)>> ||
@@ -532,25 +533,25 @@ namespace sqlite_orm {
                       "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
 
         using builder_type = internal::cte_builder<
-            decltype(label),
+            decltype(moniker),
             internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column_t>>;
         return builder_type{{std::move(explicitColumns)...}};
     }
 #endif
 
     // tuple of CTEs
-    template<class E, class... Labels, class... Selects, class... ExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Labels, Selects, ExplicitCols>...>
-    with(std::tuple<internal::common_table_expression<Labels, Selects, ExplicitCols>...> cte, E expression) {
+    template<class E, class... Monikers, class... Selects, class... ExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Monikers, Selects, ExplicitCols>...>
+    with(std::tuple<internal::common_table_expression<Monikers, Selects, ExplicitCols>...> cte, E expression) {
         return {std::move(cte), std::move(expression)};
     }
 
     /** A single CTE.
      *  Example : with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
      */
-    template<class E, class Label, class Select, class ExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Label, Select, ExplicitCols>>
-    with(internal::common_table_expression<Label, Select, ExplicitCols> cte, E expression) {
+    template<class E, class Moniker, class Select, class ExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Moniker, Select, ExplicitCols>>
+    with(internal::common_table_expression<Moniker, Select, ExplicitCols> cte, E expression) {
         return {std::make_tuple(std::move(cte)), std::move(expression)};
     }
 #endif
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index d8619ab37..d1c21e4e9 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -510,7 +510,7 @@ namespace sqlite_orm {
                 cteContext.use_parentheses = false;
 
                 std::stringstream ss;
-                ss << streaming_identifier(alias_extractor<cte_label_type_t<CTE>>::extract());
+                ss << streaming_identifier(alias_extractor<cte_moniker_type_t<CTE>>::extract());
                 {
                     std::vector<std::string> columnNames =
                         collect_cte_column_names(get_cte_driving_subselect(cte.subselect),
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index b663ce7b5..77f3b831e 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -57,7 +57,7 @@ namespace sqlite_orm {
         /**
          *  Materialize column pointer:
          *  1. by explicit object type and member pointer.
-         *  2. by label type and member pointer.
+         *  2. by moniker and member pointer.
          */
         template<class O, class F, class DBOs, satisfies<is_db_objects, DBOs> = true>
         constexpr decltype(auto) materialize_column_pointer(const DBOs&, const column_pointer<O, F>& cp) {
@@ -67,14 +67,14 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_WITH_CTE
         /**
          *  Materialize column pointer:
-         *  3. by label type and alias_holder<>.
+         *  3. by moniker and alias_holder<>.
          *  
          *  internal note: there's an overload for `find_column_name()` that avoids going through `table_t<>::find_column_name()`
          */
-        template<class Label, class ColAlias, class DBOs, satisfies<is_db_objects, DBOs> = true>
+        template<class Moniker, class ColAlias, class DBOs, satisfies<is_db_objects, DBOs> = true>
         constexpr decltype(auto) materialize_column_pointer(const DBOs&,
-                                                            const column_pointer<Label, alias_holder<ColAlias>>&) {
-            using table_type = storage_pick_table_t<Label, DBOs>;
+                                                            const column_pointer<Moniker, alias_holder<ColAlias>>&) {
+            using table_type = storage_pick_table_t<Moniker, DBOs>;
             using cte_mapper_type = cte_mapper_type_t<table_type>;
 
             // filter all column references [`alias_holder<>`]
@@ -92,7 +92,7 @@ namespace sqlite_orm {
         /**
          *  Find column name by:
          *  1. by explicit object type and member pointer.
-         *  2. by label type and member pointer.
+         *  2. by moniker and member pointer.
          */
         template<class O, class F, class DBOs, satisfies<is_db_objects, DBOs> = true>
         const std::string* find_column_name(const DBOs& dbObjects, const column_pointer<O, F>& cp) {
@@ -103,12 +103,12 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_WITH_CTE
         /**
          *  Find column name by:
-         *  3. by label type and alias_holder<>.
+         *  3. by moniker and alias_holder<>.
          */
-        template<class Label, class ColAlias, class DBOs, satisfies<is_db_objects, DBOs> = true>
+        template<class Moniker, class ColAlias, class DBOs, satisfies<is_db_objects, DBOs> = true>
         constexpr decltype(auto) find_column_name(const DBOs& dboObjects,
-                                                  const column_pointer<Label, alias_holder<ColAlias>>&) {
-            using table_type = storage_pick_table_t<Label, DBOs>;
+                                                  const column_pointer<Moniker, alias_holder<ColAlias>>&) {
+            using table_type = storage_pick_table_t<Moniker, DBOs>;
             using cte_mapper_type = cte_mapper_type_t<table_type>;
             using elements_t = typename table_type::elements_type;
             using column_idxs = filter_tuple_sequence_t<elements_t, is_column>;
@@ -126,7 +126,7 @@ namespace sqlite_orm {
             //       however we have the column index already.
             // lookup column in table_t<>'s elements
             constexpr size_t ColIdx = index_sequence_value(I, column_idxs{});
-            auto& table = pick_table<Label>(dboObjects);
+            auto& table = pick_table<Moniker>(dboObjects);
             return &std::get<ColIdx>(table.elements).name;
         }
 #endif
diff --git a/dev/storage_lookup.h b/dev/storage_lookup.h
index 4f51132b2..8a1c25ecb 100644
--- a/dev/storage_lookup.h
+++ b/dev/storage_lookup.h
@@ -4,7 +4,7 @@
 #include <tuple>
 #include <utility>  //  std::index_sequence, std::make_index_sequence
 
-#include "functional/cxx_universal.h"
+#include "functional/cxx_universal.h"  //  ::size_t
 #include "functional/cxx_type_traits_polyfill.h"
 #include "type_traits.h"
 
@@ -39,25 +39,25 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
         /**
-         *  A data type's label type, void otherwise.
+         *  A subselect mapper's CTE moniker, void otherwise.
          */
         template<typename O>
-        using label_of_or_void_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
+        using moniker_of_or_void_t = polyfill::detected_or_t<void, cte_moniker_type_t, O>;
 
         /**
-         *  A data type's CTE label, otherwise T itself is used as a CTE label.
+         *  A subselect mapper's CTE moniker, otherwise T itself.
          *
-         *  Note: This is useful if the cte object type `column_reuslts` gets ever looked up,
-         *  and we want to ensure that the lookup happens by label instead.
+         *  Note: This is useful if the cte object type `column_results` gets ever looked up,
+         *  and we want to ensure that the lookup happens by moniker instead.
          */
         template<typename T>
-        using cte_label_or_nested_t = polyfill::detected_or_t<T, cte_label_type_t, T>;
+        using cte_moniker_or_nested_t = polyfill::detected_or_t<T, cte_moniker_type_t, T>;
 #endif
 
         /**
-         *  std::true_type if given 'table' type matches, std::false_type otherwise.
+         *  `std::true_type` if given DBO type matches, `std::false_type` otherwise.
          *
-         *  A 'table' type is one of: table_t<>, index_t<> [, subselect_mapper<>]
+         *  A 'DBO' type is one of: table_t<>, index_t<>
          */
         template<typename DBO, typename T>
         using dbo_type_matches = polyfill::conjunction<std::is_same<T, DBO>,
@@ -66,7 +66,7 @@ namespace sqlite_orm {
                                                                              std::is_base_of<base_trigger, T>>>;
 
         /**
-         *  std::true_type if given object is mapped, std::false_type otherwise.
+         *  `std::true_type` if given object is mapped, `std::false_type` otherwise.
          * 
          *  Note: unlike table_t<>, index_t<>::object_type and trigger_t<>::object_type is always void.
          */
@@ -76,26 +76,26 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
         /**
-         *  std::true_type if given label is mapped, std::false_type otherwise
+         *  `std::true_type` if given moniker is mapped, `std::false_typ`e otherwise
          *
-         *  Note: unlike table_t<>, index_t<> doesn't have a nested index_t::cte_label_type typename,
-         *  that's why we use storage_label_of_t<> for a fallback to void.
+         *  Note: unlike table_t<>, index_t<> doesn't have a type named index_t::cte_moniker_type,
+         *  that's why we use moniker_of_or_void_t<> for a fallback to void.
          */
-        template<typename DBO, typename Label>
-        using cte_label_type_matches =
-            polyfill::conjunction<polyfill::negation<std::is_void<label_of_or_void_t<DBO>>>,
-                                  std::is_same<cte_label_or_nested_t<Label>, label_of_or_void_t<DBO>>>;
+        template<typename DBO, typename Moniker>
+        using cte_moniker_type_matches =
+            polyfill::conjunction<polyfill::negation<std::is_void<moniker_of_or_void_t<DBO>>>,
+                                  std::is_same<cte_moniker_or_nested_t<Moniker>, moniker_of_or_void_t<DBO>>>;
 #endif
 
         /**
-         *  std::true_type if given lookup type (object or label) is mapped, std::false_type otherwise.
+         *  std::true_type if given lookup type (object or moniker) is mapped, std::false_type otherwise.
          */
         template<typename DBO, typename Lookup>
         using lookup_type_matches = typename polyfill::disjunction<object_type_matches<DBO, Lookup>
 #ifdef SQLITE_ORM_WITH_CTE
                                                                    ,
                                                                    dbo_type_matches<DBO, Lookup>,
-                                                                   cte_label_type_matches<DBO, Lookup>
+                                                                   cte_moniker_type_matches<DBO, Lookup>
 #endif
                                                                    >::type;
     }
@@ -142,7 +142,7 @@ namespace sqlite_orm {
          *  Lookup - mapped data type
          */
         template<class Lookup, class DBOs>
-        struct storage_find_table : polyfill::detected_or<polyfill::nonesuch, storage_pick_table_t, Lookup, DBOs> {};
+        struct storage_find_table : polyfill::detected<storage_pick_table_t, Lookup, DBOs> {};
 
         /**
          *  Find a table definition (`table_t`) from a tuple of database objects;
diff --git a/dev/table.h b/dev/table.h
index 47583a06d..19b957091 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -28,17 +28,17 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
         /**
-         *  A data type's label type, void otherwise.
+         *  A subselect mapper's CTE moniker, void otherwise.
          */
         template<typename O>
-        using label_of_or_void_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
+        using moniker_of_or_void_t = polyfill::detected_or_t<void, cte_moniker_type_t, O>;
 
         /** 
-         *  If O is a subselect_mapper then returns its nested O::cte_object_type typename,
+         *  If O is a subselect_mapper then returns its nested type name O::cte_moniker_type,
          *  otherwise O itself is a regular object type to be mapped.
          */
         template<typename O>
-        using mapped_object_type_for_t = polyfill::detected_or_t<O, cte_label_type_t, O>;
+        using mapped_object_type_for_t = polyfill::detected_or_t<O, cte_moniker_type_t, O>;
 #endif
 
         struct basic_table {
@@ -58,7 +58,7 @@ namespace sqlite_orm {
             // this typename is used in contexts where it is known that the 'table' holds a subselect_mapper
             // instead of a regular object type
             using cte_mapper_type = O;
-            using cte_label_type = label_of_or_void_t<O>;
+            using cte_moniker_type = moniker_of_or_void_t<O>;
             using object_type = mapped_object_type_for_t<O>;
 #else
             using object_type = O;
diff --git a/dev/table_name_collector.h b/dev/table_name_collector.h
index 66e7cb3ea..2e052da7c 100644
--- a/dev/table_name_collector.h
+++ b/dev/table_name_collector.h
@@ -43,7 +43,7 @@ namespace sqlite_orm {
             template<class T, class F>
             void operator()(const column_pointer<T, F>&) {
                 auto tableName = lookup_table_name<mapped_type_proxy_t<T>>(this->db_objects);
-                table_names.emplace(std::move(tableName), alias_extractor<T>::as_alias());
+                this->table_names.emplace(std::move(tableName), alias_extractor<T>::as_alias());
             }
 
             template<class A, class C>
diff --git a/dev/type_traits.h b/dev/type_traits.h
index a856b7d01..d5402f81f 100644
--- a/dev/type_traits.h
+++ b/dev/type_traits.h
@@ -70,10 +70,7 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
         template<typename T>
-        using cte_label_type_t = typename T::cte_label_type;
-
-        template<typename T>
-        using cte_object_type_t = typename T::cte_object_type;
+        using cte_moniker_type_t = typename T::cte_moniker_type;
 
         template<typename T>
         using cte_mapper_type_t = typename T::cte_mapper_type;
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 9e59ece83..75a73ce0d 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -393,10 +393,7 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
         template<typename T>
-        using cte_label_type_t = typename T::cte_label_type;
-
-        template<typename T>
-        using cte_object_type_t = typename T::cte_object_type;
+        using cte_moniker_type_t = typename T::cte_moniker_type;
 
         template<typename T>
         using cte_mapper_type_t = typename T::cte_mapper_type;
@@ -2925,10 +2922,10 @@ namespace sqlite_orm {
         template<class A>
         using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
 
-        /** @short Alias of a CTE, see `orm_cte_alias`.
+        /** @short Alias of a CTE, see `orm_cte_moniker`.
          */
         template<class A>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_cte_alias_v =
+        SQLITE_ORM_INLINE_VAR constexpr bool is_cte_moniker_v =
 #ifdef SQLITE_ORM_WITH_CTE
             polyfill::conjunction_v<is_recordset_alias<A>,
                                     std::is_same<polyfill::detected_t<type_t, A>, std::remove_const_t<A>>>;
@@ -2937,7 +2934,7 @@ namespace sqlite_orm {
 #endif
 
         template<class A>
-        using is_cte_alias = polyfill::bool_constant<is_cte_alias_v<A>>;
+        using is_cte_moniker = polyfill::bool_constant<is_cte_moniker_v<A>>;
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
@@ -2971,14 +2968,14 @@ namespace sqlite_orm {
     template<class A>
     concept orm_table_alias = (orm_recordset_alias<A> && !std::same_as<typename A::type, std::remove_const_t<A>>);
 
-    /** @short Alias of a CTE.
+    /** @short Moniker of a CTE.
      *
-     *  A CTE alias has the following traits:
+     *  A CTE moniker has the following traits:
      *  - is derived from `alias_tag`.
      *  - has a `type` typename, which refers to itself.
      */
     template<class A>
-    concept orm_cte_alias = (orm_recordset_alias<A> && std::same_as<typename A::type, std::remove_const_t<A>>);
+    concept orm_cte_moniker = (orm_recordset_alias<A> && std::same_as<typename A::type, std::remove_const_t<A>>);
 #endif
 }
 
@@ -4498,7 +4495,7 @@ namespace sqlite_orm {
 
         template<class A>
         struct column_pointer_builder<A, match_if<is_alias, A>> {
-            static_assert(is_cte_alias_v<A>, "`A' must be a mapped table alias");
+            static_assert(is_cte_moniker_v<A>, "`A' must be a mapped table alias");
 
             using mapped_type = A;
 
@@ -4559,7 +4556,7 @@ namespace sqlite_orm {
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*&Object::id));
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*1_colalias));
      */
-    template<class A, class F, internal::satisfies<internal::is_cte_alias, A> = true>
+    template<class A, class F, internal::satisfies<internal::is_cte_moniker, A> = true>
     constexpr auto operator->*(const A& /*cteAlias*/, F field) {
         return column<A>(std::move(field));
     }
@@ -4572,7 +4569,7 @@ namespace sqlite_orm {
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
      */
-    template<class A, class F, internal::satisfies<internal::is_cte_alias, A> = true>
+    template<class A, class F, internal::satisfies<internal::is_cte_moniker, A> = true>
     constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
         return column<A>(std::move(field));
     }
@@ -4663,11 +4660,14 @@ namespace sqlite_orm {
             static std::string as_alias() {
                 return alias_extractor::extract();
             }
-            // for cte aliases -> empty
+
+#ifdef SQLITE_ORM_WITH_CTE
+            // for cte monikers -> empty
             template<class T = A, satisfies<std::is_same, polyfill::detected_t<type_t, T>, A> = true>
             static std::string as_alias() {
                 return {};
             }
+#endif
         };
 
         /**
@@ -4740,11 +4740,12 @@ namespace sqlite_orm {
      *  @return column with table alias attached. Place it instead of a column statement in case you need to specify a
      *  column with table alias prefix like 'a.column'.
      */
-    template<class A,
-             class C,
-             std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<A>,
-                                                      polyfill::negation<internal::is_cte_alias<internal::type_t<A>>>>,
-                              bool> = true>
+    template<
+        class A,
+        class C,
+        std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<A>,
+                                                 polyfill::negation<internal::is_cte_moniker<internal::type_t<A>>>>,
+                         bool> = true>
     internal::alias_column_t<A, C> alias_column(C c) {
         using aliased_type = internal::type_t<A>;
         static_assert(std::is_same<polyfill::detected_t<internal::table_type_of_t, C>, aliased_type>::value,
@@ -4754,7 +4755,7 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     template<orm_table_alias auto als, class C>
-        requires(!orm_cte_alias<internal::auto_type_t<als>>)
+        requires(!orm_cte_moniker<internal::auto_type_t<als>>)
     auto alias_column(C c) {
         using A = std::remove_const_t<decltype(als)>;
         using aliased_type = internal::type_t<A>;
@@ -4764,7 +4765,7 @@ namespace sqlite_orm {
     }
 
     template<orm_table_alias A, class F>
-        requires(!orm_cte_alias<internal::type_t<A>>)
+        requires(!orm_cte_moniker<internal::type_t<A>>)
     constexpr auto operator->*(const A&, F field) {
         return internal::alias_column_t<A, decltype(field)>{field};
     }
@@ -4774,16 +4775,16 @@ namespace sqlite_orm {
     template<class A,
              class C,
              std::enable_if_t<
-                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_alias<internal::type_t<A>>>,
+                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_moniker<internal::type_t<A>>>,
                  bool> = true>
     auto alias_column(C c) {
-        using cte_alias_t = internal::type_t<A>;
+        using cte_moniker_t = internal::type_t<A>;
         if constexpr(polyfill::is_specialization_of_v<C, internal::column_pointer>) {
-            static_assert(std::is_same<internal::table_type_of_t<C>, cte_alias_t>::value,
+            static_assert(std::is_same<internal::table_type_of_t<C>, cte_moniker_t>::value,
                           "Column pointer must match aliased CTE");
             return internal::alias_column_t<A, C>{c};
         } else {
-            auto cp = column<cte_alias_t>(c);
+            auto cp = column<cte_moniker_t>(c);
             return internal::alias_column_t<A, decltype(cp)>{cp};
         }
     }
@@ -4791,7 +4792,7 @@ namespace sqlite_orm {
     template<class A,
              class F,
              std::enable_if_t<
-                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_alias<internal::type_t<A>>>,
+                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_moniker<internal::type_t<A>>>,
                  bool> = true>
     constexpr auto operator->*(const A& /*tableAlias*/, F field) {
         return alias_column<A>(std::move(field));
@@ -4799,7 +4800,7 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     template<orm_table_alias auto als, class C>
-        requires(orm_cte_alias<internal::auto_type_t<als>>)
+        requires(orm_cte_moniker<internal::auto_type_t<als>>)
     auto alias_column(C c) {
         using A = std::remove_const_t<decltype(als)>;
         return alias_column<A>(std::move(c));
@@ -7475,11 +7476,11 @@ namespace sqlite_orm {
         using decay_explicit_column_t = typename decay_explicit_column<T>::type;
 
         /**
-         *  Labeled (aliased) CTE expression.
+         *  Monikered (aliased) CTE expression.
          */
-        template<class Label, class Select, class ExplicitCols>
+        template<class Moniker, class Select, class ExplicitCols>
         struct common_table_expression {
-            using cte_label_type = Label;
+            using cte_moniker_type = Moniker;
             using expression_type = Select;
             using explicit_colrefs_tuple = ExplicitCols;
             static constexpr size_t explicit_colref_count = std::tuple_size_v<ExplicitCols>;
@@ -7495,34 +7496,35 @@ namespace sqlite_orm {
         template<class... CTEs>
         using common_table_expressions = std::tuple<CTEs...>;
 
-        template<typename Label, class ExplicitCols>
+        template<typename Moniker, class ExplicitCols>
         struct cte_builder {
             ExplicitCols explicitColumns;
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols> operator()(select_t<T, Args...> sel) && {
+            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols>
+            operator()(select_t<T, Args...> sel) && {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols> operator()(Compound sel) && {
+            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> operator()(Compound sel) && {
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols> as(select_t<T, Args...> sel) && {
+            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols> as(select_t<T, Args...> sel) && {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols> as(Compound sel) && {
+            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> as(Compound sel) && {
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols>
+            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols>
             materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS MATERIALIZED` is unimplemented");
                 return {std::move(this->explicitColumns), std::move(sel)};
@@ -7530,13 +7532,13 @@ namespace sqlite_orm {
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols> materialized(Compound sel) && {
+            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS MATERIALIZED` is unimplemented");
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
 
             template<class T, class... Args>
-            common_table_expression<Label, select_t<T, Args...>, ExplicitCols>
+            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols>
             not_materialized(select_t<T, Args...> sel) && {
                 static_assert(polyfill::always_false_v<T>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
                 return {std::move(this->explicitColumns), std::move(sel)};
@@ -7544,7 +7546,7 @@ namespace sqlite_orm {
 
             template<class Compound,
                      std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
-            common_table_expression<Label, select_t<Compound>, ExplicitCols> not_materialized(Compound sel) && {
+            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> not_materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
@@ -7753,7 +7755,7 @@ namespace sqlite_orm {
      *  2. explicit columns
      *  3. fill in empty column names with column index
      */
-    template<class Label,
+    template<class Moniker,
              class... ExplicitCols,
              std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
                                   internal::is_column_alias<ExplicitCols>,
@@ -7763,18 +7765,18 @@ namespace sqlite_orm {
                                   std::is_convertible<ExplicitCols, std::string>>...>,
                               bool> = true>
     auto cte(ExplicitCols... explicitColumns) {
-        static_assert(internal::is_cte_alias_v<Label>, "Label must be a CTE alias");
+        static_assert(internal::is_cte_moniker_v<Moniker>, "Moniker must be a CTE moniker");
         static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
                       "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
 
         using builder_type = internal::cte_builder<
-            Label,
+            Moniker,
             internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column_t>>;
         return builder_type{{std::move(explicitColumns)...}};
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    template<orm_cte_alias auto label, class... ExplicitCols>
+    template<orm_cte_moniker auto moniker, class... ExplicitCols>
         requires((internal::is_column_alias_v<ExplicitCols> || std::is_member_pointer_v<ExplicitCols> ||
                   internal::is_column_v<ExplicitCols> ||
                   std::same_as<ExplicitCols, std::remove_cvref_t<decltype(std::ignore)>> ||
@@ -7785,25 +7787,25 @@ namespace sqlite_orm {
                       "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
 
         using builder_type = internal::cte_builder<
-            decltype(label),
+            decltype(moniker),
             internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column_t>>;
         return builder_type{{std::move(explicitColumns)...}};
     }
 #endif
 
     // tuple of CTEs
-    template<class E, class... Labels, class... Selects, class... ExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Labels, Selects, ExplicitCols>...>
-    with(std::tuple<internal::common_table_expression<Labels, Selects, ExplicitCols>...> cte, E expression) {
+    template<class E, class... Monikers, class... Selects, class... ExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Monikers, Selects, ExplicitCols>...>
+    with(std::tuple<internal::common_table_expression<Monikers, Selects, ExplicitCols>...> cte, E expression) {
         return {std::move(cte), std::move(expression)};
     }
 
     /** A single CTE.
      *  Example : with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
      */
-    template<class E, class Label, class Select, class ExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Label, Select, ExplicitCols>>
-    with(internal::common_table_expression<Label, Select, ExplicitCols> cte, E expression) {
+    template<class E, class Moniker, class Select, class ExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Moniker, Select, ExplicitCols>>
+    with(internal::common_table_expression<Moniker, Select, ExplicitCols> cte, E expression) {
         return {std::make_tuple(std::move(cte)), std::move(expression)};
     }
 #endif
@@ -10192,17 +10194,17 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
         /**
-         *  A data type's label type, void otherwise.
+         *  A subselect mapper's CTE moniker, void otherwise.
          */
         template<typename O>
-        using label_of_or_void_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
+        using moniker_of_or_void_t = polyfill::detected_or_t<void, cte_moniker_type_t, O>;
 
         /** 
-         *  If O is a subselect_mapper then returns its nested O::cte_object_type typename,
+         *  If O is a subselect_mapper then returns its nested type name O::cte_moniker_type,
          *  otherwise O itself is a regular object type to be mapped.
          */
         template<typename O>
-        using mapped_object_type_for_t = polyfill::detected_or_t<O, cte_label_type_t, O>;
+        using mapped_object_type_for_t = polyfill::detected_or_t<O, cte_moniker_type_t, O>;
 #endif
 
         struct basic_table {
@@ -10222,7 +10224,7 @@ namespace sqlite_orm {
             // this typename is used in contexts where it is known that the 'table' holds a subselect_mapper
             // instead of a regular object type
             using cte_mapper_type = O;
-            using cte_label_type = label_of_or_void_t<O>;
+            using cte_moniker_type = moniker_of_or_void_t<O>;
             using object_type = mapped_object_type_for_t<O>;
 #else
             using object_type = O;
@@ -10565,7 +10567,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<>.
          */
-        template<typename Label,
+        template<typename Moniker,
                  typename ExplicitColRefs,
                  typename Expression,
                  typename SubselectColRefs,
@@ -10575,8 +10577,8 @@ namespace sqlite_orm {
           public:
             subselect_mapper() = delete;
 
-            // this type name is used to detect the mapping from label to object
-            using cte_label_type = Label;
+            // this type name is used to detect the mapping from moniker to object
+            using cte_moniker_type = Moniker;
             using fields_type = std::tuple<Fs...>;
             // this type captures the expressions forming the columns in a subselect;
             // it is currently unused, however proves to be useful in compilation errors,
@@ -10602,7 +10604,7 @@ namespace sqlite_orm {
 #include <utility>  //  std::index_sequence, std::make_index_sequence
 
 // #include "functional/cxx_universal.h"
-
+//  ::size_t
 // #include "functional/cxx_type_traits_polyfill.h"
 
 // #include "type_traits.h"
@@ -10638,25 +10640,25 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
         /**
-         *  A data type's label type, void otherwise.
+         *  A subselect mapper's CTE moniker, void otherwise.
          */
         template<typename O>
-        using label_of_or_void_t = polyfill::detected_or_t<void, cte_label_type_t, O>;
+        using moniker_of_or_void_t = polyfill::detected_or_t<void, cte_moniker_type_t, O>;
 
         /**
-         *  A data type's CTE label, otherwise T itself is used as a CTE label.
+         *  A subselect mapper's CTE moniker, otherwise T itself.
          *
-         *  Note: This is useful if the cte object type `column_reuslts` gets ever looked up,
-         *  and we want to ensure that the lookup happens by label instead.
+         *  Note: This is useful if the cte object type `column_results` gets ever looked up,
+         *  and we want to ensure that the lookup happens by moniker instead.
          */
         template<typename T>
-        using cte_label_or_nested_t = polyfill::detected_or_t<T, cte_label_type_t, T>;
+        using cte_moniker_or_nested_t = polyfill::detected_or_t<T, cte_moniker_type_t, T>;
 #endif
 
         /**
-         *  std::true_type if given 'table' type matches, std::false_type otherwise.
+         *  `std::true_type` if given DBO type matches, `std::false_type` otherwise.
          *
-         *  A 'table' type is one of: table_t<>, index_t<> [, subselect_mapper<>]
+         *  A 'DBO' type is one of: table_t<>, index_t<>
          */
         template<typename DBO, typename T>
         using dbo_type_matches = polyfill::conjunction<std::is_same<T, DBO>,
@@ -10665,7 +10667,7 @@ namespace sqlite_orm {
                                                                              std::is_base_of<base_trigger, T>>>;
 
         /**
-         *  std::true_type if given object is mapped, std::false_type otherwise.
+         *  `std::true_type` if given object is mapped, `std::false_type` otherwise.
          * 
          *  Note: unlike table_t<>, index_t<>::object_type and trigger_t<>::object_type is always void.
          */
@@ -10675,26 +10677,26 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
         /**
-         *  std::true_type if given label is mapped, std::false_type otherwise
+         *  `std::true_type` if given moniker is mapped, `std::false_typ`e otherwise
          *
-         *  Note: unlike table_t<>, index_t<> doesn't have a nested index_t::cte_label_type typename,
-         *  that's why we use storage_label_of_t<> for a fallback to void.
+         *  Note: unlike table_t<>, index_t<> doesn't have a type named index_t::cte_moniker_type,
+         *  that's why we use moniker_of_or_void_t<> for a fallback to void.
          */
-        template<typename DBO, typename Label>
-        using cte_label_type_matches =
-            polyfill::conjunction<polyfill::negation<std::is_void<label_of_or_void_t<DBO>>>,
-                                  std::is_same<cte_label_or_nested_t<Label>, label_of_or_void_t<DBO>>>;
+        template<typename DBO, typename Moniker>
+        using cte_moniker_type_matches =
+            polyfill::conjunction<polyfill::negation<std::is_void<moniker_of_or_void_t<DBO>>>,
+                                  std::is_same<cte_moniker_or_nested_t<Moniker>, moniker_of_or_void_t<DBO>>>;
 #endif
 
         /**
-         *  std::true_type if given lookup type (object or label) is mapped, std::false_type otherwise.
+         *  std::true_type if given lookup type (object or moniker) is mapped, std::false_type otherwise.
          */
         template<typename DBO, typename Lookup>
         using lookup_type_matches = typename polyfill::disjunction<object_type_matches<DBO, Lookup>
 #ifdef SQLITE_ORM_WITH_CTE
                                                                    ,
                                                                    dbo_type_matches<DBO, Lookup>,
-                                                                   cte_label_type_matches<DBO, Lookup>
+                                                                   cte_moniker_type_matches<DBO, Lookup>
 #endif
                                                                    >::type;
     }
@@ -10741,7 +10743,7 @@ namespace sqlite_orm {
          *  Lookup - mapped data type
          */
         template<class Lookup, class DBOs>
-        struct storage_find_table : polyfill::detected_or<polyfill::nonesuch, storage_pick_table_t, Lookup, DBOs> {};
+        struct storage_find_table : polyfill::detected<storage_pick_table_t, Lookup, DBOs> {};
 
         /**
          *  Find a table definition (`table_t`) from a tuple of database objects;
@@ -10838,7 +10840,7 @@ namespace sqlite_orm {
         /**
          *  Materialize column pointer:
          *  1. by explicit object type and member pointer.
-         *  2. by label type and member pointer.
+         *  2. by moniker and member pointer.
          */
         template<class O, class F, class DBOs, satisfies<is_db_objects, DBOs> = true>
         constexpr decltype(auto) materialize_column_pointer(const DBOs&, const column_pointer<O, F>& cp) {
@@ -10848,14 +10850,14 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_WITH_CTE
         /**
          *  Materialize column pointer:
-         *  3. by label type and alias_holder<>.
+         *  3. by moniker and alias_holder<>.
          *  
          *  internal note: there's an overload for `find_column_name()` that avoids going through `table_t<>::find_column_name()`
          */
-        template<class Label, class ColAlias, class DBOs, satisfies<is_db_objects, DBOs> = true>
+        template<class Moniker, class ColAlias, class DBOs, satisfies<is_db_objects, DBOs> = true>
         constexpr decltype(auto) materialize_column_pointer(const DBOs&,
-                                                            const column_pointer<Label, alias_holder<ColAlias>>&) {
-            using table_type = storage_pick_table_t<Label, DBOs>;
+                                                            const column_pointer<Moniker, alias_holder<ColAlias>>&) {
+            using table_type = storage_pick_table_t<Moniker, DBOs>;
             using cte_mapper_type = cte_mapper_type_t<table_type>;
 
             // filter all column references [`alias_holder<>`]
@@ -10873,7 +10875,7 @@ namespace sqlite_orm {
         /**
          *  Find column name by:
          *  1. by explicit object type and member pointer.
-         *  2. by label type and member pointer.
+         *  2. by moniker and member pointer.
          */
         template<class O, class F, class DBOs, satisfies<is_db_objects, DBOs> = true>
         const std::string* find_column_name(const DBOs& dbObjects, const column_pointer<O, F>& cp) {
@@ -10884,12 +10886,12 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_WITH_CTE
         /**
          *  Find column name by:
-         *  3. by label type and alias_holder<>.
+         *  3. by moniker and alias_holder<>.
          */
-        template<class Label, class ColAlias, class DBOs, satisfies<is_db_objects, DBOs> = true>
+        template<class Moniker, class ColAlias, class DBOs, satisfies<is_db_objects, DBOs> = true>
         constexpr decltype(auto) find_column_name(const DBOs& dboObjects,
-                                                  const column_pointer<Label, alias_holder<ColAlias>>&) {
-            using table_type = storage_pick_table_t<Label, DBOs>;
+                                                  const column_pointer<Moniker, alias_holder<ColAlias>>&) {
+            using table_type = storage_pick_table_t<Moniker, DBOs>;
             using cte_mapper_type = cte_mapper_type_t<table_type>;
             using elements_t = typename table_type::elements_type;
             using column_idxs = filter_tuple_sequence_t<elements_t, is_column>;
@@ -10907,7 +10909,7 @@ namespace sqlite_orm {
             //       however we have the column index already.
             // lookup column in table_t<>'s elements
             constexpr size_t ColIdx = index_sequence_value(I, column_idxs{});
-            auto& table = pick_table<Label>(dboObjects);
+            auto& table = pick_table<Moniker>(dboObjects);
             return &std::get<ColIdx>(table.elements).name;
         }
 #endif
@@ -11658,9 +11660,9 @@ namespace sqlite_orm {
         struct column_result_t<DBOs, column_pointer<T, F>, void> : column_result_t<DBOs, F> {};
 
 #ifdef SQLITE_ORM_WITH_CTE
-        template<class DBOs, class Label, class ColAlias>
-        struct column_result_t<DBOs, column_pointer<Label, alias_holder<ColAlias>>, void> {
-            using table_type = storage_pick_table_t<Label, DBOs>;
+        template<class DBOs, class Moniker, class ColAlias>
+        struct column_result_t<DBOs, column_pointer<Moniker, alias_holder<ColAlias>>, void> {
+            using table_type = storage_pick_table_t<Moniker, DBOs>;
             using cte_mapper_type = cte_mapper_type_t<table_type>;
 
             // filter all column references being `alias_holder<>`
@@ -12170,7 +12172,7 @@ namespace sqlite_orm {
             template<class T, class F>
             void operator()(const column_pointer<T, F>&) {
                 auto tableName = lookup_table_name<mapped_type_proxy_t<T>>(this->db_objects);
-                table_names.emplace(std::move(tableName), alias_extractor<T>::as_alias());
+                this->table_names.emplace(std::move(tableName), alias_extractor<T>::as_alias());
             }
 
             template<class A, class C>
@@ -16937,7 +16939,7 @@ namespace sqlite_orm {
                 cteContext.use_parentheses = false;
 
                 std::stringstream ss;
-                ss << streaming_identifier(alias_extractor<cte_label_type_t<CTE>>::extract());
+                ss << streaming_identifier(alias_extractor<cte_moniker_type_t<CTE>>::extract());
                 {
                     std::vector<std::string> columnNames =
                         collect_cte_column_names(get_cte_driving_subselect(cte.subselect),
@@ -18668,7 +18670,7 @@ namespace sqlite_orm {
         struct column_expression_type<
             DBOs,
             asterisk_t<E>,
-            std::enable_if_t<polyfill::disjunction_v<polyfill::negation<is_recordset_alias<E>>, is_cte_alias<E>>>>
+            std::enable_if_t<polyfill::disjunction_v<polyfill::negation<is_recordset_alias<E>>, is_cte_moniker<E>>>>
             : storage_traits::storage_mapped_column_expressions<DBOs, E> {};
 
         template<class A>
@@ -18710,40 +18712,40 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
         // F = field_type
-        template<typename Label,
+        template<typename Moniker,
                  typename ExplicitColRefs,
                  typename Expression,
                  typename SubselectColRefs,
                  typename FinalColRefs,
                  typename F>
         struct create_cte_mapper {
-            using type = subselect_mapper<Label, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, F>;
+            using type = subselect_mapper<Moniker, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, F>;
         };
 
         // std::tuple<Fs...>
-        template<typename Label,
+        template<typename Moniker,
                  typename ExplicitColRefs,
                  typename Expression,
                  typename SubselectColRefs,
                  typename FinalColRefs,
                  typename... Fs>
-        struct create_cte_mapper<Label,
+        struct create_cte_mapper<Moniker,
                                  ExplicitColRefs,
                                  Expression,
                                  SubselectColRefs,
                                  FinalColRefs,
                                  std::tuple<Fs...>> {
-            using type = subselect_mapper<Label, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Fs...>;
+            using type = subselect_mapper<Moniker, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Fs...>;
         };
 
-        template<typename Label,
+        template<typename Moniker,
                  typename ExplicitColRefs,
                  typename Expression,
                  typename SubselectColRefs,
                  typename FinalColRefs,
                  typename Result>
         using create_cte_mapper_t =
-            typename create_cte_mapper<Label, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Result>::
+            typename create_cte_mapper<Moniker, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Result>::
                 type;
 
         // aliased column expressions, explicit or implicitly numbered
@@ -18850,9 +18852,9 @@ namespace sqlite_orm {
         }
 
         // column_pointer<>
-        template<class DBOs, class Label, class F, size_t Idx = 0>
+        template<class DBOs, class Moniker, class F, size_t Idx = 0>
         auto extract_colref_expressions(const DBOs& dbObjects,
-                                        const column_pointer<Label, F>& col,
+                                        const column_pointer<Moniker, F>& col,
                                         std::index_sequence<Idx> s = {}) {
             return extract_colref_expressions(dbObjects, col.field, s);
         }
@@ -18957,7 +18959,7 @@ namespace sqlite_orm {
                           "Number of explicit columns of common table expression doesn't match the number of columns "
                           "in the subselect.");
 
-            std::string tableName = alias_extractor<cte_label_type_t<cte_type>>::extract();
+            std::string tableName = alias_extractor<cte_moniker_type_t<cte_type>>::extract();
             auto subselectColRefs = extract_colref_expressions(dbObjects, subSelect.col);
             const auto& finalColRefs =
                 determine_cte_colrefs(dbObjects, subselectColRefs, cte.explicitColumns, index_sequence{});
@@ -18965,7 +18967,7 @@ namespace sqlite_orm {
             serializer_context context{dbObjects};
             std::vector<std::string> columnNames = collect_cte_column_names(subSelect, cte.explicitColumns, context);
 
-            using mapper_type = create_cte_mapper_t<cte_label_type_t<cte_type>,
+            using mapper_type = create_cte_mapper_t<cte_moniker_type_t<cte_type>,
                                                     typename cte_type::explicit_colrefs_tuple,
                                                     column_expression_of_t<DBOs, subselect_type>,
                                                     decltype(subselectColRefs),
@@ -20488,28 +20490,29 @@ namespace sqlite_orm {
          *  A special record set alias that is both, a storage lookup type (mapping type) and an alias.
          */
         template<char A, char... X>
-        struct cte_alias
-            : recordset_alias<cte_alias<A, X...> /* refer to self, since a label is both, an alias and a lookup type */,
-                              A,
-                              X...> {};
+        struct cte_moniker
+            : recordset_alias<
+                  cte_moniker<A, X...> /* refer to self, since a moniker is both, an alias and a mapped type */,
+                  A,
+                  X...> {};
     }
 
     /**
-     *  cte_alias<'n'> from a numeric literal.
+     *  cte_moniker<'n'> from a numeric literal.
      *  E.g. 1_ctealias, 2_ctealias
      */
     template<char... Chars>
     [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
-        return internal::cte_alias<Chars...>{};
+        return internal::cte_moniker<Chars...>{};
     }
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
-     *  cte_alias<'1'[, ...]> from a string literal.
+     *  cte_moniker<'1'[, ...]> from a string literal.
      *  E.g. "1"_cte, "2"_cte
      */
     template<internal::string_identifier_template t>
     [[nodiscard]] consteval auto operator"" _cte() {
-        return internal::to_alias<internal::cte_alias, t>(std::make_index_sequence<t.size()>{});
+        return internal::to_alias<internal::cte_moniker, t>(std::make_index_sequence<t.size()>{});
     }
 #endif
 

From 83783c95bf503c8791bd195ced4cce01111fb4a9 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 25 Feb 2023 14:45:30 +0100
Subject: [PATCH 110/161] Simplified storage lookup

---
 dev/storage_lookup.h            | 35 +++------------------------------
 include/sqlite_orm/sqlite_orm.h | 35 +++------------------------------
 2 files changed, 6 insertions(+), 64 deletions(-)

diff --git a/dev/storage_lookup.h b/dev/storage_lookup.h
index 8a1c25ecb..ab756d417 100644
--- a/dev/storage_lookup.h
+++ b/dev/storage_lookup.h
@@ -38,22 +38,6 @@ namespace sqlite_orm {
         struct is_db_objects<const db_objects_tuple<DBO...>> : std::true_type {};
 
 #ifdef SQLITE_ORM_WITH_CTE
-        /**
-         *  A subselect mapper's CTE moniker, void otherwise.
-         */
-        template<typename O>
-        using moniker_of_or_void_t = polyfill::detected_or_t<void, cte_moniker_type_t, O>;
-
-        /**
-         *  A subselect mapper's CTE moniker, otherwise T itself.
-         *
-         *  Note: This is useful if the cte object type `column_results` gets ever looked up,
-         *  and we want to ensure that the lookup happens by moniker instead.
-         */
-        template<typename T>
-        using cte_moniker_or_nested_t = polyfill::detected_or_t<T, cte_moniker_type_t, T>;
-#endif
-
         /**
          *  `std::true_type` if given DBO type matches, `std::false_type` otherwise.
          *
@@ -64,6 +48,7 @@ namespace sqlite_orm {
                                                        polyfill::disjunction<std::is_base_of<basic_table, T>,
                                                                              std::is_base_of<index_base, T>,
                                                                              std::is_base_of<base_trigger, T>>>;
+#endif
 
         /**
          *  `std::true_type` if given object is mapped, `std::false_type` otherwise.
@@ -74,28 +59,14 @@ namespace sqlite_orm {
         struct object_type_matches : polyfill::conjunction<polyfill::negation<std::is_void<object_type_t<DBO>>>,
                                                            std::is_same<Lookup, object_type_t<DBO>>> {};
 
-#ifdef SQLITE_ORM_WITH_CTE
-        /**
-         *  `std::true_type` if given moniker is mapped, `std::false_typ`e otherwise
-         *
-         *  Note: unlike table_t<>, index_t<> doesn't have a type named index_t::cte_moniker_type,
-         *  that's why we use moniker_of_or_void_t<> for a fallback to void.
-         */
-        template<typename DBO, typename Moniker>
-        using cte_moniker_type_matches =
-            polyfill::conjunction<polyfill::negation<std::is_void<moniker_of_or_void_t<DBO>>>,
-                                  std::is_same<cte_moniker_or_nested_t<Moniker>, moniker_of_or_void_t<DBO>>>;
-#endif
-
         /**
-         *  std::true_type if given lookup type (object or moniker) is mapped, std::false_type otherwise.
+         *  `std::true_type` if given lookup type (object or moniker) is mapped, `std::false_type` otherwise.
          */
         template<typename DBO, typename Lookup>
         using lookup_type_matches = typename polyfill::disjunction<object_type_matches<DBO, Lookup>
 #ifdef SQLITE_ORM_WITH_CTE
                                                                    ,
-                                                                   dbo_type_matches<DBO, Lookup>,
-                                                                   cte_moniker_type_matches<DBO, Lookup>
+                                                                   dbo_type_matches<DBO, Lookup>
 #endif
                                                                    >::type;
     }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 75a73ce0d..69c33e019 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -10639,22 +10639,6 @@ namespace sqlite_orm {
         struct is_db_objects<const db_objects_tuple<DBO...>> : std::true_type {};
 
 #ifdef SQLITE_ORM_WITH_CTE
-        /**
-         *  A subselect mapper's CTE moniker, void otherwise.
-         */
-        template<typename O>
-        using moniker_of_or_void_t = polyfill::detected_or_t<void, cte_moniker_type_t, O>;
-
-        /**
-         *  A subselect mapper's CTE moniker, otherwise T itself.
-         *
-         *  Note: This is useful if the cte object type `column_results` gets ever looked up,
-         *  and we want to ensure that the lookup happens by moniker instead.
-         */
-        template<typename T>
-        using cte_moniker_or_nested_t = polyfill::detected_or_t<T, cte_moniker_type_t, T>;
-#endif
-
         /**
          *  `std::true_type` if given DBO type matches, `std::false_type` otherwise.
          *
@@ -10665,6 +10649,7 @@ namespace sqlite_orm {
                                                        polyfill::disjunction<std::is_base_of<basic_table, T>,
                                                                              std::is_base_of<index_base, T>,
                                                                              std::is_base_of<base_trigger, T>>>;
+#endif
 
         /**
          *  `std::true_type` if given object is mapped, `std::false_type` otherwise.
@@ -10675,28 +10660,14 @@ namespace sqlite_orm {
         struct object_type_matches : polyfill::conjunction<polyfill::negation<std::is_void<object_type_t<DBO>>>,
                                                            std::is_same<Lookup, object_type_t<DBO>>> {};
 
-#ifdef SQLITE_ORM_WITH_CTE
-        /**
-         *  `std::true_type` if given moniker is mapped, `std::false_typ`e otherwise
-         *
-         *  Note: unlike table_t<>, index_t<> doesn't have a type named index_t::cte_moniker_type,
-         *  that's why we use moniker_of_or_void_t<> for a fallback to void.
-         */
-        template<typename DBO, typename Moniker>
-        using cte_moniker_type_matches =
-            polyfill::conjunction<polyfill::negation<std::is_void<moniker_of_or_void_t<DBO>>>,
-                                  std::is_same<cte_moniker_or_nested_t<Moniker>, moniker_of_or_void_t<DBO>>>;
-#endif
-
         /**
-         *  std::true_type if given lookup type (object or moniker) is mapped, std::false_type otherwise.
+         *  `std::true_type` if given lookup type (object or moniker) is mapped, `std::false_type` otherwise.
          */
         template<typename DBO, typename Lookup>
         using lookup_type_matches = typename polyfill::disjunction<object_type_matches<DBO, Lookup>
 #ifdef SQLITE_ORM_WITH_CTE
                                                                    ,
-                                                                   dbo_type_matches<DBO, Lookup>,
-                                                                   cte_moniker_type_matches<DBO, Lookup>
+                                                                   dbo_type_matches<DBO, Lookup>
 #endif
                                                                    >::type;
     }

From aefc77e85d503812ee7163e3af5e2a96208df2e6 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 25 Feb 2023 15:42:09 +0100
Subject: [PATCH 111/161] Fixed making CTE 'storage'

When the set of DBOs contained non-unique items (like multiple indexes having the same `index_t<>` type, `db_objects_cat()` didn't work
---
 dev/cte_storage.h               | 36 ++++++++++++---------
 dev/storage_lookup.h            | 20 +-----------
 include/sqlite_orm/sqlite_orm.h | 57 ++++++++++++---------------------
 tests/static_tests/cte.cpp      | 28 +++++++++++++---
 tests/storage_tests.cpp         | 10 +++---
 5 files changed, 71 insertions(+), 80 deletions(-)

diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index d91d57dd3..6ebab1e7e 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -7,9 +7,8 @@
 #include <vector>
 #endif
 
-#include "functional/cxx_universal.h"
+#include "functional/cxx_universal.h"  //  ::size_t
 #include "tuple_helper/tuple_fy.h"
-#include "is_base_of_template.h"
 #include "table_type_of.h"
 #include "column_result.h"
 #include "select_constraints.h"
@@ -79,13 +78,21 @@ namespace sqlite_orm {
         }
 
         /**
-         *  Concatenate newly created tables with those from an existing storage implementation,
-         *  forming a new storage implementation object.
+         *  Concatenate newly created tables with given DBOs, forming a new set of DBOs.
          */
-        template<typename... Ts, typename... CTETables>
-        db_objects_tuple<CTETables..., Ts...> db_objects_cat(const db_objects_tuple<Ts...>& storage,
-                                                             CTETables&&... cteTables) {
-            return {std::forward<CTETables>(cteTables)..., pick_table<Ts>(storage)...};
+        template<typename DBOs, size_t... Idx, typename... CTETables>
+        auto db_objects_cat(const DBOs& dbObjects, std::index_sequence<Idx...>, CTETables&&... cteTables) {
+            return std::tuple{std::forward<CTETables>(cteTables)..., get<Idx>(dbObjects)...};
+        }
+
+        /**
+         *  Concatenate newly created tables with given DBOs, forming a new set of DBOs.
+         */
+        template<typename DBOs, typename... CTETables>
+        auto db_objects_cat(const DBOs& dbObjects, CTETables&&... cteTables) {
+            return db_objects_cat(dbObjects,
+                                  std::make_index_sequence<std::tuple_size_v<DBOs>>{},
+                                  std::forward<CTETables>(cteTables)...);
         }
 
         /**
@@ -110,9 +117,7 @@ namespace sqlite_orm {
         /**
          *  Return left expression of compound statement.
          */
-        template<class Compound,
-                 class... Args,
-                 std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+        template<class Compound, class... Args, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
         decltype(auto) get_cte_driving_subselect(const select_t<Compound, Args...>& subSelect) {
             return subSelect.col.left;
         }
@@ -199,9 +204,8 @@ namespace sqlite_orm {
 
         template<class DBOs, class E, class... Args>
         void extract_colref_expressions(const DBOs& /*dbObjects*/, const select_t<E, Args...>& /*subSelect*/) = delete;
-        template<class DBOs,
-                 class Compound,
-                 std::enable_if_t<is_base_of_template_v<Compound, compound_operator>, bool> = true>
+
+        template<class DBOs, class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
         void extract_colref_expressions(const DBOs& /*dbObjects*/, const Compound& /*subSelect*/) = delete;
 
         /*
@@ -301,7 +305,7 @@ namespace sqlite_orm {
 
             if constexpr(sizeof...(In) > 0) {
                 return make_recursive_cte_db_objects(
-                    // Because CTEs can depend on their predecessor we recursively pass in a new storage object
+                    // Because CTEs can depend on their predecessor we recursively pass in a new set of DBOs
                     db_objects_cat(dbObjects, std::move(tbl)),
                     cte,
                     std::index_sequence<In...>{});
@@ -320,7 +324,7 @@ namespace sqlite_orm {
 #endif
 
         /**
-         *  Return DBOs of storage_t.
+         *  Return passed in DBOs.
          */
         template<class DBOs, class E, satisfies<is_db_objects, DBOs> = true>
         decltype(auto) db_objects_for_expression(DBOs& dbObjects, const E&) {
diff --git a/dev/storage_lookup.h b/dev/storage_lookup.h
index ab756d417..91ea00578 100644
--- a/dev/storage_lookup.h
+++ b/dev/storage_lookup.h
@@ -37,19 +37,6 @@ namespace sqlite_orm {
         template<class... DBO>
         struct is_db_objects<const db_objects_tuple<DBO...>> : std::true_type {};
 
-#ifdef SQLITE_ORM_WITH_CTE
-        /**
-         *  `std::true_type` if given DBO type matches, `std::false_type` otherwise.
-         *
-         *  A 'DBO' type is one of: table_t<>, index_t<>
-         */
-        template<typename DBO, typename T>
-        using dbo_type_matches = polyfill::conjunction<std::is_same<T, DBO>,
-                                                       polyfill::disjunction<std::is_base_of<basic_table, T>,
-                                                                             std::is_base_of<index_base, T>,
-                                                                             std::is_base_of<base_trigger, T>>>;
-#endif
-
         /**
          *  `std::true_type` if given object is mapped, `std::false_type` otherwise.
          * 
@@ -63,12 +50,7 @@ namespace sqlite_orm {
          *  `std::true_type` if given lookup type (object or moniker) is mapped, `std::false_type` otherwise.
          */
         template<typename DBO, typename Lookup>
-        using lookup_type_matches = typename polyfill::disjunction<object_type_matches<DBO, Lookup>
-#ifdef SQLITE_ORM_WITH_CTE
-                                                                   ,
-                                                                   dbo_type_matches<DBO, Lookup>
-#endif
-                                                                   >::type;
+        using lookup_type_matches = object_type_matches<DBO, Lookup>;
     }
 
     // pick/lookup metafunctions
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 69c33e019..9cf5d933f 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -10638,19 +10638,6 @@ namespace sqlite_orm {
         template<class... DBO>
         struct is_db_objects<const db_objects_tuple<DBO...>> : std::true_type {};
 
-#ifdef SQLITE_ORM_WITH_CTE
-        /**
-         *  `std::true_type` if given DBO type matches, `std::false_type` otherwise.
-         *
-         *  A 'DBO' type is one of: table_t<>, index_t<>
-         */
-        template<typename DBO, typename T>
-        using dbo_type_matches = polyfill::conjunction<std::is_same<T, DBO>,
-                                                       polyfill::disjunction<std::is_base_of<basic_table, T>,
-                                                                             std::is_base_of<index_base, T>,
-                                                                             std::is_base_of<base_trigger, T>>>;
-#endif
-
         /**
          *  `std::true_type` if given object is mapped, `std::false_type` otherwise.
          * 
@@ -10664,12 +10651,7 @@ namespace sqlite_orm {
          *  `std::true_type` if given lookup type (object or moniker) is mapped, `std::false_type` otherwise.
          */
         template<typename DBO, typename Lookup>
-        using lookup_type_matches = typename polyfill::disjunction<object_type_matches<DBO, Lookup>
-#ifdef SQLITE_ORM_WITH_CTE
-                                                                   ,
-                                                                   dbo_type_matches<DBO, Lookup>
-#endif
-                                                                   >::type;
+        using lookup_type_matches = object_type_matches<DBO, Lookup>;
     }
 
     // pick/lookup metafunctions
@@ -18552,11 +18534,9 @@ namespace sqlite_orm {
 #endif
 
 // #include "functional/cxx_universal.h"
-
+//  ::size_t
 // #include "tuple_helper/tuple_fy.h"
 
-// #include "is_base_of_template.h"
-
 // #include "table_type_of.h"
 
 // #include "column_result.h"
@@ -18737,13 +18717,21 @@ namespace sqlite_orm {
         }
 
         /**
-         *  Concatenate newly created tables with those from an existing storage implementation,
-         *  forming a new storage implementation object.
+         *  Concatenate newly created tables with given DBOs, forming a new set of DBOs.
          */
-        template<typename... Ts, typename... CTETables>
-        db_objects_tuple<CTETables..., Ts...> db_objects_cat(const db_objects_tuple<Ts...>& storage,
-                                                             CTETables&&... cteTables) {
-            return {std::forward<CTETables>(cteTables)..., pick_table<Ts>(storage)...};
+        template<typename DBOs, size_t... Idx, typename... CTETables>
+        auto db_objects_cat(const DBOs& dbObjects, std::index_sequence<Idx...>, CTETables&&... cteTables) {
+            return std::tuple{std::forward<CTETables>(cteTables)..., get<Idx>(dbObjects)...};
+        }
+
+        /**
+         *  Concatenate newly created tables with given DBOs, forming a new set of DBOs.
+         */
+        template<typename DBOs, typename... CTETables>
+        auto db_objects_cat(const DBOs& dbObjects, CTETables&&... cteTables) {
+            return db_objects_cat(dbObjects,
+                                  std::make_index_sequence<std::tuple_size_v<DBOs>>{},
+                                  std::forward<CTETables>(cteTables)...);
         }
 
         /**
@@ -18768,9 +18756,7 @@ namespace sqlite_orm {
         /**
          *  Return left expression of compound statement.
          */
-        template<class Compound,
-                 class... Args,
-                 std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+        template<class Compound, class... Args, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
         decltype(auto) get_cte_driving_subselect(const select_t<Compound, Args...>& subSelect) {
             return subSelect.col.left;
         }
@@ -18857,9 +18843,8 @@ namespace sqlite_orm {
 
         template<class DBOs, class E, class... Args>
         void extract_colref_expressions(const DBOs& /*dbObjects*/, const select_t<E, Args...>& /*subSelect*/) = delete;
-        template<class DBOs,
-                 class Compound,
-                 std::enable_if_t<is_base_of_template_v<Compound, compound_operator>, bool> = true>
+
+        template<class DBOs, class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
         void extract_colref_expressions(const DBOs& /*dbObjects*/, const Compound& /*subSelect*/) = delete;
 
         /*
@@ -18959,7 +18944,7 @@ namespace sqlite_orm {
 
             if constexpr(sizeof...(In) > 0) {
                 return make_recursive_cte_db_objects(
-                    // Because CTEs can depend on their predecessor we recursively pass in a new storage object
+                    // Because CTEs can depend on their predecessor we recursively pass in a new set of DBOs
                     db_objects_cat(dbObjects, std::move(tbl)),
                     cte,
                     std::index_sequence<In...>{});
@@ -18978,7 +18963,7 @@ namespace sqlite_orm {
 #endif
 
         /**
-         *  Return DBOs of storage_t.
+         *  Return passed in DBOs.
          */
         template<class DBOs, class E, satisfies<is_db_objects, DBOs> = true>
         decltype(auto) db_objects_for_expression(DBOs& dbObjects, const E&) {
diff --git a/tests/static_tests/cte.cpp b/tests/static_tests/cte.cpp
index cb26f1143..ee9a78583 100644
--- a/tests/static_tests/cte.cpp
+++ b/tests/static_tests/cte.cpp
@@ -6,14 +6,14 @@
 #include <catch2/catch_all.hpp>
 
 using namespace sqlite_orm;
-using internal::alias_holder;
-using internal::column_alias;
+using internal::alias_holder, internal::column_alias;
 using internal::column_t;
+using std::is_same, std::is_constructible;
 using std::tuple;
 
 template<class ColRefs, class E>
 void do_assert() {
-    STATIC_REQUIRE(std::is_same<ColRefs, E>::value);
+    STATIC_REQUIRE(is_same<ColRefs, E>::value);
 }
 
 template<class E, class ColRef>
@@ -30,7 +30,7 @@ TEST_CASE("CTE type traits") {
             }
         };
 
-        STATIC_REQUIRE(std::is_constructible<alias_holder<column_alias<'c'>>, column_alias<'c'>>::value);
+        STATIC_REQUIRE(is_constructible<alias_holder<column_alias<'c'>>, column_alias<'c'>>::value);
         runTest<tuple<decltype(&Org::id)>>(&Org::id);
         runTest<tuple<decltype(&Org::getId)>>(&Org::getId);
         runTest<tuple<alias_holder<column_alias<'1'>>>>(1_colalias);
@@ -42,4 +42,24 @@ TEST_CASE("CTE type traits") {
         runTest<tuple<std::string>>("");
     }
 }
+
+TEST_CASE("CTE storage") {
+    SECTION("db_objects_cat") {
+        struct Org {
+            int64 id = 0;
+        };
+
+        auto table = make_table("org", make_column("id", &Org::id));
+        auto idx1 = make_unique_index("idx1_org", &Org::id);
+        auto idx2 = make_index("idx2_org", &Org::id);
+        auto dbObjects = tuple{idx1, idx2, table};
+        auto cteTable = internal::make_cte_table(dbObjects, cte<cte_1>()(select(1)));
+        auto dbObjects2 = internal::db_objects_cat(dbObjects, cteTable);
+
+        // note: deliberately make indexes resulting in the same index_t<> type, such that we know `db_objects_cat()` is working properly
+        static_assert(is_same<decltype(idx1), decltype(idx2)>::value);
+        static_assert(is_same<decltype(dbObjects2),
+                              tuple<decltype(cteTable), decltype(idx1), decltype(idx2), decltype(table)>>::value);
+    }
+}
 #endif
diff --git a/tests/storage_tests.cpp b/tests/storage_tests.cpp
index e1feeb49b..0695cf1cc 100644
--- a/tests/storage_tests.cpp
+++ b/tests/storage_tests.cpp
@@ -185,17 +185,17 @@ namespace {
         using ID = std::uint64_t;
         using TimeMs = std::uint64_t;
 
-        inline ID id() const noexcept {
+        ID id() const noexcept {
             return m_id;
-        };
-        inline void setId(ID val) noexcept {
+        }
+        void setId(ID val) noexcept {
             m_id = val;
         }
 
-        inline TimeMs time() const noexcept {
+        TimeMs time() const noexcept {
             return m_time;
         }
-        inline void setTime(const TimeMs& val) noexcept {
+        void setTime(const TimeMs& val) noexcept {
             m_time = val;
         }
 

From b2c528ea389166307d44f0e7b33bcfa0f6c1856c Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 26 Feb 2023 17:33:50 +0100
Subject: [PATCH 112/161] Used `is_compound_operator` in more places

---
 dev/cte_column_names_collector.h |  3 +--
 dev/select_constraints.h         | 12 ++++--------
 include/sqlite_orm/sqlite_orm.h  | 16 +++++-----------
 3 files changed, 10 insertions(+), 21 deletions(-)

diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index 657dd7584..8cd4fc8ff 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -9,7 +9,6 @@
 
 #include "functional/cxx_universal.h"
 #include "functional/cxx_type_traits_polyfill.h"
-#include "is_base_of_template.h"
 #include "type_traits.h"
 #include "member_traits/member_traits.h"
 #include "error_code.h"
@@ -51,7 +50,7 @@ namespace sqlite_orm {
             using expression_type = T;
 
             // Compound statements are never passed in by db_objects_for_expression()
-            static_assert(!is_base_of_template_v<T, compound_operator>);
+            static_assert(!is_compound_operator_v<T>);
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type& t, const Ctx& context) const {
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 27564228d..29369d2e7 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -252,8 +252,7 @@ namespace sqlite_orm {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
-            template<class Compound,
-                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
             common_table_expression<Moniker, select_t<Compound>, ExplicitCols> operator()(Compound sel) && {
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
@@ -263,8 +262,7 @@ namespace sqlite_orm {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
-            template<class Compound,
-                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
             common_table_expression<Moniker, select_t<Compound>, ExplicitCols> as(Compound sel) && {
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
@@ -276,8 +274,7 @@ namespace sqlite_orm {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
-            template<class Compound,
-                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
             common_table_expression<Moniker, select_t<Compound>, ExplicitCols> materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS MATERIALIZED` is unimplemented");
                 return {std::move(this->explicitColumns), {std::move(sel)}};
@@ -290,8 +287,7 @@ namespace sqlite_orm {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
-            template<class Compound,
-                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
             common_table_expression<Moniker, select_t<Compound>, ExplicitCols> not_materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
                 return {std::move(this->explicitColumns), {std::move(sel)}};
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 9cf5d933f..ed05d6209 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -7506,8 +7506,7 @@ namespace sqlite_orm {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
-            template<class Compound,
-                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
             common_table_expression<Moniker, select_t<Compound>, ExplicitCols> operator()(Compound sel) && {
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
@@ -7517,8 +7516,7 @@ namespace sqlite_orm {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
-            template<class Compound,
-                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
             common_table_expression<Moniker, select_t<Compound>, ExplicitCols> as(Compound sel) && {
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
@@ -7530,8 +7528,7 @@ namespace sqlite_orm {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
-            template<class Compound,
-                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
             common_table_expression<Moniker, select_t<Compound>, ExplicitCols> materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS MATERIALIZED` is unimplemented");
                 return {std::move(this->explicitColumns), {std::move(sel)}};
@@ -7544,8 +7541,7 @@ namespace sqlite_orm {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
-            template<class Compound,
-                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
             common_table_expression<Moniker, select_t<Compound>, ExplicitCols> not_materialized(Compound sel) && {
                 static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
                 return {std::move(this->explicitColumns), {std::move(sel)}};
@@ -16133,8 +16129,6 @@ namespace sqlite_orm {
 
 // #include "functional/cxx_type_traits_polyfill.h"
 
-// #include "is_base_of_template.h"
-
 // #include "type_traits.h"
 
 // #include "member_traits/member_traits.h"
@@ -16181,7 +16175,7 @@ namespace sqlite_orm {
             using expression_type = T;
 
             // Compound statements are never passed in by db_objects_for_expression()
-            static_assert(!is_base_of_template_v<T, compound_operator>);
+            static_assert(!is_compound_operator_v<T>);
 
             template<class Ctx>
             std::vector<std::string> operator()(const expression_type& t, const Ctx& context) const {

From 1014cc9af6d54e1e8c3afd59e50355b5bf4f864e Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 20 Mar 2023 19:08:40 +0000
Subject: [PATCH 113/161] Improved performance of `index_sequence_value()`

---
 dev/functional/index_sequence_util.h | 12 ++++++++----
 include/sqlite_orm/sqlite_orm.h      | 12 ++++++++----
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/dev/functional/index_sequence_util.h b/dev/functional/index_sequence_util.h
index a4cd68319..8e03fc7a2 100644
--- a/dev/functional/index_sequence_util.h
+++ b/dev/functional/index_sequence_util.h
@@ -17,17 +17,21 @@ namespace sqlite_orm {
             return I;
         }
 
-#ifdef SQLITE_ORM_RELAXED_CONSTEXPR_SUPPORTED
+#ifdef SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
         /**
          *  Get the value of an index_sequence at a specific position.
          */
         template<size_t... Idx>
         SQLITE_ORM_CONSTEVAL size_t index_sequence_value(size_t pos, std::index_sequence<Idx...>) {
-            constexpr std::array<size_t, sizeof...(Idx)> values{Idx...};
-            static_assert(values.size() > 0, "");
-            return values[pos];
+            static_assert(sizeof...(Idx) > 0);
+            size_t result;
+            size_t i = 0;
+            ((result = Idx, i++ == pos) || ...);
+            return result;
         }
+#endif
 
+#ifdef SQLITE_ORM_RELAXED_CONSTEXPR_SUPPORTED
         /**
          *  Reorder the values of an index_sequence according to the positions from a second sequence.
          */
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 689f0e3f3..221798c1e 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -1189,17 +1189,21 @@ namespace sqlite_orm {
             return I;
         }
 
-#ifdef SQLITE_ORM_RELAXED_CONSTEXPR_SUPPORTED
+#ifdef SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
         /**
          *  Get the value of an index_sequence at a specific position.
          */
         template<size_t... Idx>
         SQLITE_ORM_CONSTEVAL size_t index_sequence_value(size_t pos, std::index_sequence<Idx...>) {
-            constexpr std::array<size_t, sizeof...(Idx)> values{Idx...};
-            static_assert(values.size() > 0, "");
-            return values[pos];
+            static_assert(sizeof...(Idx) > 0);
+            size_t result;
+            size_t i = 0;
+            ((result = Idx, i++ == pos) || ...);
+            return result;
         }
+#endif
 
+#ifdef SQLITE_ORM_RELAXED_CONSTEXPR_SUPPORTED
         /**
          *  Reorder the values of an index_sequence according to the positions from a second sequence.
          */

From d74bee264e85003bc91fd7903fa140b49ac1c38b Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 26 Mar 2023 23:24:29 +0100
Subject: [PATCH 114/161] Updated EOL sequence in CTE header files to LF

---
 dev/cte.h                        | 132 +++---
 dev/cte_column_names_collector.h | 408 +++++++++----------
 dev/cte_storage.h                | 668 +++++++++++++++----------------
 dev/cte_types.h                  | 122 +++---
 4 files changed, 665 insertions(+), 665 deletions(-)

diff --git a/dev/cte.h b/dev/cte.h
index 06cd1daa1..db7ff1c7f 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -1,66 +1,66 @@
-#pragma once
-
-#ifdef SQLITE_ORM_WITH_CTE
-#include <utility>  //  std::make_index_sequence
-#endif
-
-#include "functional/cxx_universal.h"
-#include "alias.h"
-
-#ifdef SQLITE_ORM_WITH_CTE
-namespace sqlite_orm {
-
-    namespace internal {
-        /** 
-         *  A special record set alias that is both, a storage lookup type (mapping type) and an alias.
-         */
-        template<char A, char... X>
-        struct cte_moniker
-            : recordset_alias<
-                  cte_moniker<A, X...> /* refer to self, since a moniker is both, an alias and a mapped type */,
-                  A,
-                  X...> {};
-    }
-
-    /**
-     *  cte_moniker<'n'> from a numeric literal.
-     *  E.g. 1_ctealias, 2_ctealias
-     */
-    template<char... Chars>
-    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
-        return internal::cte_moniker<Chars...>{};
-    }
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    /**
-     *  cte_moniker<'1'[, ...]> from a string literal.
-     *  E.g. "1"_cte, "2"_cte
-     */
-    template<internal::string_identifier_template t>
-    [[nodiscard]] consteval auto operator"" _cte() {
-        return internal::to_alias<internal::cte_moniker, t>(std::make_index_sequence<t.size()>{});
-    }
-#endif
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    using cte_1 = decltype("1"_cte);
-    using cte_2 = decltype("2"_cte);
-    using cte_3 = decltype("3"_cte);
-    using cte_4 = decltype("4"_cte);
-    using cte_5 = decltype("5"_cte);
-    using cte_6 = decltype("6"_cte);
-    using cte_7 = decltype("7"_cte);
-    using cte_8 = decltype("8"_cte);
-    using cte_9 = decltype("9"_cte);
-#else
-    using cte_1 = decltype(1_ctealias);
-    using cte_2 = decltype(2_ctealias);
-    using cte_3 = decltype(3_ctealias);
-    using cte_4 = decltype(4_ctealias);
-    using cte_5 = decltype(5_ctealias);
-    using cte_6 = decltype(6_ctealias);
-    using cte_7 = decltype(7_ctealias);
-    using cte_8 = decltype(8_ctealias);
-    using cte_9 = decltype(9_ctealias);
-#endif
-}
-#endif
+#pragma once
+
+#ifdef SQLITE_ORM_WITH_CTE
+#include <utility>  //  std::make_index_sequence
+#endif
+
+#include "functional/cxx_universal.h"
+#include "alias.h"
+
+#ifdef SQLITE_ORM_WITH_CTE
+namespace sqlite_orm {
+
+    namespace internal {
+        /** 
+         *  A special record set alias that is both, a storage lookup type (mapping type) and an alias.
+         */
+        template<char A, char... X>
+        struct cte_moniker
+            : recordset_alias<
+                  cte_moniker<A, X...> /* refer to self, since a moniker is both, an alias and a mapped type */,
+                  A,
+                  X...> {};
+    }
+
+    /**
+     *  cte_moniker<'n'> from a numeric literal.
+     *  E.g. 1_ctealias, 2_ctealias
+     */
+    template<char... Chars>
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
+        return internal::cte_moniker<Chars...>{};
+    }
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  cte_moniker<'1'[, ...]> from a string literal.
+     *  E.g. "1"_cte, "2"_cte
+     */
+    template<internal::string_identifier_template t>
+    [[nodiscard]] consteval auto operator"" _cte() {
+        return internal::to_alias<internal::cte_moniker, t>(std::make_index_sequence<t.size()>{});
+    }
+#endif
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    using cte_1 = decltype("1"_cte);
+    using cte_2 = decltype("2"_cte);
+    using cte_3 = decltype("3"_cte);
+    using cte_4 = decltype("4"_cte);
+    using cte_5 = decltype("5"_cte);
+    using cte_6 = decltype("6"_cte);
+    using cte_7 = decltype("7"_cte);
+    using cte_8 = decltype("8"_cte);
+    using cte_9 = decltype("9"_cte);
+#else
+    using cte_1 = decltype(1_ctealias);
+    using cte_2 = decltype(2_ctealias);
+    using cte_3 = decltype(3_ctealias);
+    using cte_4 = decltype(4_ctealias);
+    using cte_5 = decltype(5_ctealias);
+    using cte_6 = decltype(6_ctealias);
+    using cte_7 = decltype(7_ctealias);
+    using cte_8 = decltype(8_ctealias);
+    using cte_9 = decltype(9_ctealias);
+#endif
+}
+#endif
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index 8cd4fc8ff..7de7bb9c6 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -1,204 +1,204 @@
-#pragma once
-
-#ifdef SQLITE_ORM_WITH_CTE
-#include <string>
-#include <vector>
-#include <functional>  //  std::reference_wrapper
-#include <system_error>
-#endif
-
-#include "functional/cxx_universal.h"
-#include "functional/cxx_type_traits_polyfill.h"
-#include "type_traits.h"
-#include "member_traits/member_traits.h"
-#include "error_code.h"
-#include "alias.h"
-#include "select_constraints.h"
-#include "serializer_context.h"
-
-#ifdef SQLITE_ORM_WITH_CTE
-namespace sqlite_orm {
-    namespace internal {
-        // collecting column names utilizes the statement serializer
-        template<class T, class I>
-        std::string serialize(const T& t, const serializer_context<I>& context);
-
-        inline void unquote_identifier(std::string& identifier) {
-            if(!identifier.empty()) {
-                constexpr char quoteChar = '"';
-                constexpr char sqlEscaped[] = {quoteChar, quoteChar};
-                identifier.erase(identifier.end() - 1);
-                identifier.erase(identifier.begin());
-                for(size_t pos = 0; (pos = identifier.find(sqlEscaped, pos, 2)) != identifier.npos; ++pos) {
-                    identifier.erase(pos, 1);
-                }
-            }
-        }
-
-        inline void unquote_or_erase(std::string& name) {
-            constexpr char quoteChar = '"';
-            if(name.front() == quoteChar) {
-                unquote_identifier(name);
-            } else {
-                // unaliased expression - see 3. below
-                name.clear();
-            }
-        }
-
-        template<class T, class SFINAE = void>
-        struct cte_column_names_collector {
-            using expression_type = T;
-
-            // Compound statements are never passed in by db_objects_for_expression()
-            static_assert(!is_compound_operator_v<T>);
-
-            template<class Ctx>
-            std::vector<std::string> operator()(const expression_type& t, const Ctx& context) const {
-                auto newContext = context;
-                newContext.skip_table_name = true;
-                std::string columnName = serialize(t, newContext);
-                if(columnName.empty()) {
-                    throw std::system_error{orm_error_code::column_not_found};
-                }
-                unquote_or_erase(columnName);
-                return {std::move(columnName)};
-            }
-        };
-
-        template<class T, class Ctx>
-        std::vector<std::string> get_cte_column_names(const T& t, const Ctx& context) {
-            cte_column_names_collector<T> collector;
-            return collector(t, context);
-        }
-
-        template<class As>
-        struct cte_column_names_collector<As, match_specialization_of<As, as_t>> {
-            using expression_type = As;
-
-            template<class Ctx>
-            std::vector<std::string> operator()(const expression_type& /*expression*/, const Ctx& /*context*/) const {
-                return {alias_extractor<alias_type_t<As>>::extract()};
-            }
-        };
-
-        template<class Wrapper>
-        struct cte_column_names_collector<Wrapper, match_specialization_of<Wrapper, std::reference_wrapper>> {
-            using expression_type = Wrapper;
-
-            template<class Ctx>
-            std::vector<std::string> operator()(const expression_type& expression, const Ctx& context) const {
-                return get_cte_column_names(expression.get(), context);
-            }
-        };
-
-        template<class Asterisk>
-        struct cte_column_names_collector<Asterisk, match_specialization_of<Asterisk, asterisk_t>> {
-            using expression_type = Asterisk;
-            using T = typename Asterisk::type;
-
-            template<class Ctx>
-            std::vector<std::string> operator()(const expression_type&, const Ctx& context) const {
-                auto& table = pick_table<T>(context.db_objects);
-
-                std::vector<std::string> columnNames;
-                columnNames.reserve(size_t(table.count_columns_amount()));
-
-                table.for_each_column([&columnNames](const column_identifier& column) {
-                    columnNames.push_back(column.name);
-                });
-                return columnNames;
-            }
-        };
-
-        // No CTE for object expressions.
-        template<class Object>
-        struct cte_column_names_collector<Object, match_specialization_of<Object, object_t>> {
-            static_assert(polyfill::always_false_v<Object>, "Selecting an object in a subselect is not allowed.");
-        };
-
-        template<class Columns>
-        struct cte_column_names_collector<Columns, match_specialization_of<Columns, columns_t>> {
-            using expression_type = Columns;
-
-            template<class Ctx>
-            std::vector<std::string> operator()(const expression_type& cols, const Ctx& context) const {
-                std::vector<std::string> columnNames;
-                columnNames.reserve(size_t(cols.count));
-                auto newContext = context;
-                newContext.skip_table_name = true;
-                iterate_tuple(cols.columns, [&columnNames, &newContext](auto& m) {
-                    using value_type = polyfill::remove_cvref_t<decltype(m)>;
-
-                    if constexpr(polyfill::is_specialization_of_v<value_type, as_t>) {
-                        columnNames.push_back(alias_extractor<alias_type_t<value_type>>::extract());
-                    } else {
-                        std::string columnName = serialize(m, newContext);
-                        if(!columnName.empty()) {
-                            columnNames.push_back(std::move(columnName));
-                        } else {
-                            throw std::system_error{orm_error_code::column_not_found};
-                        }
-                        unquote_or_erase(columnNames.back());
-                    }
-                });
-                return columnNames;
-            }
-        };
-
-        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) {
-            // 1. determine column names from subselect
-            std::vector<std::string> columnNames = get_cte_column_names(sel.col, context);
-
-            // 2. override column names from cte expression
-            if(size_t n = std::tuple_size_v<ExplicitColRefs>) {
-                if(n != columnNames.size()) {
-                    throw std::system_error{orm_error_code::column_not_found};
-                }
-
-                size_t idx = 0;
-                iterate_tuple(explicitColRefs, [&idx, &columnNames, &context](auto& colRef) {
-                    using ColRef = polyfill::remove_cvref_t<decltype(colRef)>;
-
-                    if constexpr(polyfill::is_specialization_of_v<ColRef, alias_holder>) {
-                        columnNames[idx] = alias_extractor<type_t<ColRef>>::extract();
-                    } else if constexpr(std::is_member_pointer<ColRef>::value) {
-                        using O = table_type_of_t<ColRef>;
-                        if(auto* columnName = find_column_name<O>(context.db_objects, colRef)) {
-                            columnNames[idx] = *columnName;
-                        } else {
-                            // relaxed: allow any member pointer as column reference
-                            columnNames[idx] = typeid(ColRef).name();
-                        }
-                    } else if constexpr(polyfill::is_specialization_of_v<ColRef, column_t>) {
-                        columnNames[idx] = colRef.name;
-                    } else if constexpr(std::is_same_v<ColRef, std::string>) {
-                        if(!colRef.empty()) {
-                            columnNames[idx] = colRef;
-                        }
-                    } else if constexpr(std::is_same_v<ColRef, polyfill::remove_cvref_t<decltype(std::ignore)>>) {
-                        if(columnNames[idx].empty()) {
-                            columnNames[idx] = std::to_string(idx + 1);
-                        }
-                    } else {
-                        static_assert(polyfill::always_false_v<ColRef>, "Invalid explicit column reference specified");
-                    }
-                    ++idx;
-                });
-            }
-
-            // 3. fill in blanks with numerical column identifiers
-            {
-                for(size_t i = 0, n = columnNames.size(); i < n; ++i) {
-                    if(columnNames[i].empty()) {
-                        columnNames[i] = std::to_string(i + 1);
-                    }
-                }
-            }
-
-            return columnNames;
-        }
-    }
-}
-#endif
+#pragma once
+
+#ifdef SQLITE_ORM_WITH_CTE
+#include <string>
+#include <vector>
+#include <functional>  //  std::reference_wrapper
+#include <system_error>
+#endif
+
+#include "functional/cxx_universal.h"
+#include "functional/cxx_type_traits_polyfill.h"
+#include "type_traits.h"
+#include "member_traits/member_traits.h"
+#include "error_code.h"
+#include "alias.h"
+#include "select_constraints.h"
+#include "serializer_context.h"
+
+#ifdef SQLITE_ORM_WITH_CTE
+namespace sqlite_orm {
+    namespace internal {
+        // collecting column names utilizes the statement serializer
+        template<class T, class I>
+        std::string serialize(const T& t, const serializer_context<I>& context);
+
+        inline void unquote_identifier(std::string& identifier) {
+            if(!identifier.empty()) {
+                constexpr char quoteChar = '"';
+                constexpr char sqlEscaped[] = {quoteChar, quoteChar};
+                identifier.erase(identifier.end() - 1);
+                identifier.erase(identifier.begin());
+                for(size_t pos = 0; (pos = identifier.find(sqlEscaped, pos, 2)) != identifier.npos; ++pos) {
+                    identifier.erase(pos, 1);
+                }
+            }
+        }
+
+        inline void unquote_or_erase(std::string& name) {
+            constexpr char quoteChar = '"';
+            if(name.front() == quoteChar) {
+                unquote_identifier(name);
+            } else {
+                // unaliased expression - see 3. below
+                name.clear();
+            }
+        }
+
+        template<class T, class SFINAE = void>
+        struct cte_column_names_collector {
+            using expression_type = T;
+
+            // Compound statements are never passed in by db_objects_for_expression()
+            static_assert(!is_compound_operator_v<T>);
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& t, const Ctx& context) const {
+                auto newContext = context;
+                newContext.skip_table_name = true;
+                std::string columnName = serialize(t, newContext);
+                if(columnName.empty()) {
+                    throw std::system_error{orm_error_code::column_not_found};
+                }
+                unquote_or_erase(columnName);
+                return {std::move(columnName)};
+            }
+        };
+
+        template<class T, class Ctx>
+        std::vector<std::string> get_cte_column_names(const T& t, const Ctx& context) {
+            cte_column_names_collector<T> collector;
+            return collector(t, context);
+        }
+
+        template<class As>
+        struct cte_column_names_collector<As, match_specialization_of<As, as_t>> {
+            using expression_type = As;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& /*expression*/, const Ctx& /*context*/) const {
+                return {alias_extractor<alias_type_t<As>>::extract()};
+            }
+        };
+
+        template<class Wrapper>
+        struct cte_column_names_collector<Wrapper, match_specialization_of<Wrapper, std::reference_wrapper>> {
+            using expression_type = Wrapper;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& expression, const Ctx& context) const {
+                return get_cte_column_names(expression.get(), context);
+            }
+        };
+
+        template<class Asterisk>
+        struct cte_column_names_collector<Asterisk, match_specialization_of<Asterisk, asterisk_t>> {
+            using expression_type = Asterisk;
+            using T = typename Asterisk::type;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type&, const Ctx& context) const {
+                auto& table = pick_table<T>(context.db_objects);
+
+                std::vector<std::string> columnNames;
+                columnNames.reserve(size_t(table.count_columns_amount()));
+
+                table.for_each_column([&columnNames](const column_identifier& column) {
+                    columnNames.push_back(column.name);
+                });
+                return columnNames;
+            }
+        };
+
+        // No CTE for object expressions.
+        template<class Object>
+        struct cte_column_names_collector<Object, match_specialization_of<Object, object_t>> {
+            static_assert(polyfill::always_false_v<Object>, "Selecting an object in a subselect is not allowed.");
+        };
+
+        template<class Columns>
+        struct cte_column_names_collector<Columns, match_specialization_of<Columns, columns_t>> {
+            using expression_type = Columns;
+
+            template<class Ctx>
+            std::vector<std::string> operator()(const expression_type& cols, const Ctx& context) const {
+                std::vector<std::string> columnNames;
+                columnNames.reserve(size_t(cols.count));
+                auto newContext = context;
+                newContext.skip_table_name = true;
+                iterate_tuple(cols.columns, [&columnNames, &newContext](auto& m) {
+                    using value_type = polyfill::remove_cvref_t<decltype(m)>;
+
+                    if constexpr(polyfill::is_specialization_of_v<value_type, as_t>) {
+                        columnNames.push_back(alias_extractor<alias_type_t<value_type>>::extract());
+                    } else {
+                        std::string columnName = serialize(m, newContext);
+                        if(!columnName.empty()) {
+                            columnNames.push_back(std::move(columnName));
+                        } else {
+                            throw std::system_error{orm_error_code::column_not_found};
+                        }
+                        unquote_or_erase(columnNames.back());
+                    }
+                });
+                return columnNames;
+            }
+        };
+
+        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) {
+            // 1. determine column names from subselect
+            std::vector<std::string> columnNames = get_cte_column_names(sel.col, context);
+
+            // 2. override column names from cte expression
+            if(size_t n = std::tuple_size_v<ExplicitColRefs>) {
+                if(n != columnNames.size()) {
+                    throw std::system_error{orm_error_code::column_not_found};
+                }
+
+                size_t idx = 0;
+                iterate_tuple(explicitColRefs, [&idx, &columnNames, &context](auto& colRef) {
+                    using ColRef = polyfill::remove_cvref_t<decltype(colRef)>;
+
+                    if constexpr(polyfill::is_specialization_of_v<ColRef, alias_holder>) {
+                        columnNames[idx] = alias_extractor<type_t<ColRef>>::extract();
+                    } else if constexpr(std::is_member_pointer<ColRef>::value) {
+                        using O = table_type_of_t<ColRef>;
+                        if(auto* columnName = find_column_name<O>(context.db_objects, colRef)) {
+                            columnNames[idx] = *columnName;
+                        } else {
+                            // relaxed: allow any member pointer as column reference
+                            columnNames[idx] = typeid(ColRef).name();
+                        }
+                    } else if constexpr(polyfill::is_specialization_of_v<ColRef, column_t>) {
+                        columnNames[idx] = colRef.name;
+                    } else if constexpr(std::is_same_v<ColRef, std::string>) {
+                        if(!colRef.empty()) {
+                            columnNames[idx] = colRef;
+                        }
+                    } else if constexpr(std::is_same_v<ColRef, polyfill::remove_cvref_t<decltype(std::ignore)>>) {
+                        if(columnNames[idx].empty()) {
+                            columnNames[idx] = std::to_string(idx + 1);
+                        }
+                    } else {
+                        static_assert(polyfill::always_false_v<ColRef>, "Invalid explicit column reference specified");
+                    }
+                    ++idx;
+                });
+            }
+
+            // 3. fill in blanks with numerical column identifiers
+            {
+                for(size_t i = 0, n = columnNames.size(); i < n; ++i) {
+                    if(columnNames[i].empty()) {
+                        columnNames[i] = std::to_string(i + 1);
+                    }
+                }
+            }
+
+            return columnNames;
+        }
+    }
+}
+#endif
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 6ebab1e7e..672e68e63 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -1,334 +1,334 @@
-#pragma once
-
-#ifdef SQLITE_ORM_WITH_CTE
-#include <type_traits>
-#include <tuple>
-#include <string>
-#include <vector>
-#endif
-
-#include "functional/cxx_universal.h"  //  ::size_t
-#include "tuple_helper/tuple_fy.h"
-#include "table_type_of.h"
-#include "column_result.h"
-#include "select_constraints.h"
-#include "table.h"
-#include "alias.h"
-#include "cte_types.h"
-#include "cte_column_names_collector.h"
-#include "column_expression.h"
-#include "storage_lookup.h"
-
-namespace sqlite_orm {
-    namespace internal {
-
-#ifdef SQLITE_ORM_WITH_CTE
-        // F = field_type
-        template<typename Moniker,
-                 typename ExplicitColRefs,
-                 typename Expression,
-                 typename SubselectColRefs,
-                 typename FinalColRefs,
-                 typename F>
-        struct create_cte_mapper {
-            using type = subselect_mapper<Moniker, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, F>;
-        };
-
-        // std::tuple<Fs...>
-        template<typename Moniker,
-                 typename ExplicitColRefs,
-                 typename Expression,
-                 typename SubselectColRefs,
-                 typename FinalColRefs,
-                 typename... Fs>
-        struct create_cte_mapper<Moniker,
-                                 ExplicitColRefs,
-                                 Expression,
-                                 SubselectColRefs,
-                                 FinalColRefs,
-                                 std::tuple<Fs...>> {
-            using type = subselect_mapper<Moniker, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Fs...>;
-        };
-
-        template<typename Moniker,
-                 typename ExplicitColRefs,
-                 typename Expression,
-                 typename SubselectColRefs,
-                 typename FinalColRefs,
-                 typename Result>
-        using create_cte_mapper_t =
-            typename create_cte_mapper<Moniker, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Result>::
-                type;
-
-        // aliased column expressions, explicit or implicitly numbered
-        template<typename F, typename ColRef, satisfies_is_specialization_of<ColRef, alias_holder> = true>
-        static auto make_cte_column(std::string name, const ColRef& /*finalColRef*/) {
-            using object_type = aliased_field<type_t<ColRef>, F>;
-
-            return sqlite_orm::make_column<>(std::move(name), &object_type::field);
-        }
-
-        // F O::*
-        template<typename F, typename ColRef, satisfies<std::is_member_pointer, ColRef> = true>
-        static auto make_cte_column(std::string name, const ColRef& finalColRef) {
-            using object_type = table_type_of_t<ColRef>;
-            using column_type = column_t<ColRef, empty_setter>;
-
-            return column_type{std::move(name), finalColRef, empty_setter{}};
-        }
-
-        /**
-         *  Concatenate newly created tables with given DBOs, forming a new set of DBOs.
-         */
-        template<typename DBOs, size_t... Idx, typename... CTETables>
-        auto db_objects_cat(const DBOs& dbObjects, std::index_sequence<Idx...>, CTETables&&... cteTables) {
-            return std::tuple{std::forward<CTETables>(cteTables)..., get<Idx>(dbObjects)...};
-        }
-
-        /**
-         *  Concatenate newly created tables with given DBOs, forming a new set of DBOs.
-         */
-        template<typename DBOs, typename... CTETables>
-        auto db_objects_cat(const DBOs& dbObjects, CTETables&&... cteTables) {
-            return db_objects_cat(dbObjects,
-                                  std::make_index_sequence<std::tuple_size_v<DBOs>>{},
-                                  std::forward<CTETables>(cteTables)...);
-        }
-
-        /**
-         *  This function returns the expression contained in a subselect that is relevant for
-         *  creating the definition of a CTE table.
-         *  Because CTEs can recursively refer to themselves in a compound statement, parsing
-         *  the whole compound statement would lead to compiler errors if a column_pointer<>
-         *  can't be resolved. Therefore, at the time of building a CTE table, we are only
-         *  interested in the column results of the left expression.
-         */
-        template<class Select>
-        decltype(auto) get_cte_driving_subselect(const Select& subSelect);
-
-        /**
-         *  Return given select expression.
-         */
-        template<class Select>
-        decltype(auto) get_cte_driving_subselect(const Select& subSelect) {
-            return subSelect;
-        }
-
-        /**
-         *  Return left expression of compound statement.
-         */
-        template<class Compound, class... Args, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
-        decltype(auto) get_cte_driving_subselect(const select_t<Compound, Args...>& subSelect) {
-            return subSelect.col.left;
-        }
-
-        /**
-         *  Return a tuple of member pointers of all columns
-         */
-        template<class C, size_t... Idx>
-        auto get_table_columns_fields(const C& coldef, std::index_sequence<Idx...>) {
-            return std::make_tuple(get<Idx>(coldef).member_pointer...);
-        }
-
-        // any expression -> numeric column alias
-        template<class DBOs,
-                 class E,
-                 size_t Idx = 0,
-                 std::enable_if_t<polyfill::negation_v<polyfill::is_specialization_of<E, std::tuple>>, bool> = true>
-        auto extract_colref_expressions(const DBOs& /*dbObjects*/, const E& /*col*/, std::index_sequence<Idx> = {})
-            -> std::tuple<alias_holder<decltype(n_to_colalias<Idx>())>> {
-            return {};
-        }
-
-        // expression_t<>
-        template<class DBOs, class E, size_t Idx = 0>
-        auto
-        extract_colref_expressions(const DBOs& dbObjects, const expression_t<E>& col, std::index_sequence<Idx> s = {}) {
-            return extract_colref_expressions(dbObjects, col.value, s);
-        }
-
-        // F O::* (field/getter) -> field/getter
-        template<class DBOs, class F, class O, size_t Idx = 0>
-        auto extract_colref_expressions(const DBOs& /*dbObjects*/, F O::*col, std::index_sequence<Idx> = {}) {
-            return std::make_tuple(col);
-        }
-
-        // as_t<> (aliased expression) -> alias_holder
-        template<class DBOs, class A, class E, size_t Idx = 0>
-        std::tuple<alias_holder<A>> extract_colref_expressions(const DBOs& /*dbObjects*/,
-                                                               const as_t<A, E>& /*col*/,
-                                                               std::index_sequence<Idx> = {}) {
-            return {};
-        }
-
-        // alias_holder<> (colref) -> alias_holder
-        template<class DBOs, class A, size_t Idx = 0>
-        std::tuple<alias_holder<A>> extract_colref_expressions(const DBOs& /*dbObjects*/,
-                                                               const alias_holder<A>& /*col*/,
-                                                               std::index_sequence<Idx> = {}) {
-            return {};
-        }
-
-        // column_pointer<>
-        template<class DBOs, class Moniker, class F, size_t Idx = 0>
-        auto extract_colref_expressions(const DBOs& dbObjects,
-                                        const column_pointer<Moniker, F>& col,
-                                        std::index_sequence<Idx> s = {}) {
-            return extract_colref_expressions(dbObjects, col.field, s);
-        }
-
-        // column expression tuple
-        template<class DBOs, class... Args, size_t... Idx>
-        auto extract_colref_expressions(const DBOs& dbObjects,
-                                        const std::tuple<Args...>& cols,
-                                        std::index_sequence<Idx...>) {
-            return std::tuple_cat(extract_colref_expressions(dbObjects, get<Idx>(cols), std::index_sequence<Idx>{})...);
-        }
-
-        // columns_t<>
-        template<class DBOs, class... Args>
-        auto extract_colref_expressions(const DBOs& dbObjects, const columns_t<Args...>& cols) {
-            return extract_colref_expressions(dbObjects, cols.columns, std::index_sequence_for<Args...>{});
-        }
-
-        // asterisk_t<> -> fields
-        template<class DBOs, class O>
-        auto extract_colref_expressions(const DBOs& dbObjects, const asterisk_t<O>& /*col*/) {
-            using table_type = storage_pick_table_t<O, DBOs>;
-            using elements_t = typename table_type::elements_type;
-            using column_idxs = filter_tuple_sequence_t<elements_t, is_column>;
-
-            auto& table = pick_table<O>(dbObjects);
-            return get_table_columns_fields(table.elements, column_idxs{});
-        }
-
-        template<class DBOs, class E, class... Args>
-        void extract_colref_expressions(const DBOs& /*dbObjects*/, const select_t<E, Args...>& /*subSelect*/) = delete;
-
-        template<class DBOs, class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
-        void extract_colref_expressions(const DBOs& /*dbObjects*/, const Compound& /*subSelect*/) = delete;
-
-        /*
-         *  Depending on ExplicitColRef's type returns either the explicit column reference
-         *  or the expression's column reference otherwise.
-         */
-        template<typename DBOs, typename SubselectColRef, typename ExplicitColRef>
-        auto determine_cte_colref(const DBOs& /*dbObjects*/,
-                                  const SubselectColRef& subselectColRef,
-                                  const ExplicitColRef& explicitColRef) {
-            if constexpr(polyfill::is_specialization_of_v<ExplicitColRef, alias_holder>) {
-                return explicitColRef;
-            } else if constexpr(std::is_member_pointer<ExplicitColRef>::value) {
-                return explicitColRef;
-            } else if constexpr(std::is_base_of_v<column_identifier, ExplicitColRef>) {
-                return explicitColRef.member_pointer;
-            } else if constexpr(std::is_same_v<ExplicitColRef, std::string>) {
-                return subselectColRef;
-            } else if constexpr(std::is_same_v<ExplicitColRef, polyfill::remove_cvref_t<decltype(std::ignore)>>) {
-                return subselectColRef;
-            } else {
-                static_assert(polyfill::always_false_v<ExplicitColRef>, "Invalid explicit column reference specified");
-            }
-        }
-
-        template<typename DBOs, typename SubselectColRefs, typename ExplicitColRefs, size_t... Idx>
-        auto determine_cte_colrefs([[maybe_unused]] const DBOs& dbObjects,
-                                   const SubselectColRefs& subselectColRefs,
-                                   [[maybe_unused]] const ExplicitColRefs& explicitColRefs,
-                                   std::index_sequence<Idx...>) {
-            if constexpr(std::tuple_size_v < ExplicitColRefs >> 0) {
-                static_assert(
-                    (!internal::is_builtin_numeric_column_alias_v<
-                         alias_holder_type_or_none_t<std::tuple_element_t<Idx, ExplicitColRefs>>> &&
-                     ...),
-                    "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
-
-                return std::tuple{
-                    determine_cte_colref(dbObjects, get<Idx>(subselectColRefs), get<Idx>(explicitColRefs))...};
-            } else {
-                return subselectColRefs;
-            }
-        }
-
-        template<typename Mapper, typename DBOs, typename ColRefs, size_t... CIs>
-        auto make_cte_table_using_column_indices(const DBOs& /*dbObjects*/,
-                                                 std::string tableName,
-                                                 std::vector<std::string> columnNames,
-                                                 const ColRefs& finalColRefs,
-                                                 std::index_sequence<CIs...>) {
-            return make_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) {
-            using cte_type = CTE;
-
-            auto subSelect = get_cte_driving_subselect(cte.subselect);
-
-            using subselect_type = decltype(subSelect);
-            using column_results = column_result_of_t<DBOs, subselect_type>;
-            using index_sequence = std::make_index_sequence<std::tuple_size_v<tuplify_t<column_results>>>;
-            static_assert(cte_type::explicit_colref_count == 0 ||
-                              cte_type::explicit_colref_count == index_sequence::size(),
-                          "Number of explicit columns of common table expression doesn't match the number of columns "
-                          "in the subselect.");
-
-            std::string tableName = alias_extractor<cte_moniker_type_t<cte_type>>::extract();
-            auto subselectColRefs = extract_colref_expressions(dbObjects, subSelect.col);
-            const auto& finalColRefs =
-                determine_cte_colrefs(dbObjects, subselectColRefs, cte.explicitColumns, index_sequence{});
-
-            serializer_context context{dbObjects};
-            std::vector<std::string> columnNames = collect_cte_column_names(subSelect, cte.explicitColumns, context);
-
-            using mapper_type = create_cte_mapper_t<cte_moniker_type_t<cte_type>,
-                                                    typename cte_type::explicit_colrefs_tuple,
-                                                    column_expression_of_t<DBOs, subselect_type>,
-                                                    decltype(subselectColRefs),
-                                                    polyfill::remove_cvref_t<decltype(finalColRefs)>,
-                                                    column_results>;
-            return make_cte_table_using_column_indices<mapper_type>(dbObjects,
-                                                                    std::move(tableName),
-                                                                    std::move(columnNames),
-                                                                    finalColRefs,
-                                                                    index_sequence{});
-        }
-
-        template<typename DBOs, typename... CTEs, size_t Ii, size_t... In>
-        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));
-
-            if constexpr(sizeof...(In) > 0) {
-                return make_recursive_cte_db_objects(
-                    // Because CTEs can depend on their predecessor we recursively pass in a new set of DBOs
-                    db_objects_cat(dbObjects, std::move(tbl)),
-                    cte,
-                    std::index_sequence<In...>{});
-            } else {
-                return db_objects_cat(dbObjects, std::move(tbl));
-            }
-        }
-
-        /**
-         *  Return new DBOs for CTE expressions.
-         */
-        template<class DBOs, class E, class... CTEs, satisfies<is_db_objects, DBOs> = true>
-        decltype(auto) db_objects_for_expression(DBOs& dbObjects, const with_t<E, CTEs...>& e) {
-            return make_recursive_cte_db_objects(dbObjects, e.cte, std::index_sequence_for<CTEs...>{});
-        }
-#endif
-
-        /**
-         *  Return passed in DBOs.
-         */
-        template<class DBOs, class E, satisfies<is_db_objects, DBOs> = true>
-        decltype(auto) db_objects_for_expression(DBOs& dbObjects, const E&) {
-            return dbObjects;
-        }
-    }
-}
+#pragma once
+
+#ifdef SQLITE_ORM_WITH_CTE
+#include <type_traits>
+#include <tuple>
+#include <string>
+#include <vector>
+#endif
+
+#include "functional/cxx_universal.h"  //  ::size_t
+#include "tuple_helper/tuple_fy.h"
+#include "table_type_of.h"
+#include "column_result.h"
+#include "select_constraints.h"
+#include "table.h"
+#include "alias.h"
+#include "cte_types.h"
+#include "cte_column_names_collector.h"
+#include "column_expression.h"
+#include "storage_lookup.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+#ifdef SQLITE_ORM_WITH_CTE
+        // F = field_type
+        template<typename Moniker,
+                 typename ExplicitColRefs,
+                 typename Expression,
+                 typename SubselectColRefs,
+                 typename FinalColRefs,
+                 typename F>
+        struct create_cte_mapper {
+            using type = subselect_mapper<Moniker, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, F>;
+        };
+
+        // std::tuple<Fs...>
+        template<typename Moniker,
+                 typename ExplicitColRefs,
+                 typename Expression,
+                 typename SubselectColRefs,
+                 typename FinalColRefs,
+                 typename... Fs>
+        struct create_cte_mapper<Moniker,
+                                 ExplicitColRefs,
+                                 Expression,
+                                 SubselectColRefs,
+                                 FinalColRefs,
+                                 std::tuple<Fs...>> {
+            using type = subselect_mapper<Moniker, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Fs...>;
+        };
+
+        template<typename Moniker,
+                 typename ExplicitColRefs,
+                 typename Expression,
+                 typename SubselectColRefs,
+                 typename FinalColRefs,
+                 typename Result>
+        using create_cte_mapper_t =
+            typename create_cte_mapper<Moniker, ExplicitColRefs, Expression, SubselectColRefs, FinalColRefs, Result>::
+                type;
+
+        // aliased column expressions, explicit or implicitly numbered
+        template<typename F, typename ColRef, satisfies_is_specialization_of<ColRef, alias_holder> = true>
+        static auto make_cte_column(std::string name, const ColRef& /*finalColRef*/) {
+            using object_type = aliased_field<type_t<ColRef>, F>;
+
+            return sqlite_orm::make_column<>(std::move(name), &object_type::field);
+        }
+
+        // F O::*
+        template<typename F, typename ColRef, satisfies<std::is_member_pointer, ColRef> = true>
+        static auto make_cte_column(std::string name, const ColRef& finalColRef) {
+            using object_type = table_type_of_t<ColRef>;
+            using column_type = column_t<ColRef, empty_setter>;
+
+            return column_type{std::move(name), finalColRef, empty_setter{}};
+        }
+
+        /**
+         *  Concatenate newly created tables with given DBOs, forming a new set of DBOs.
+         */
+        template<typename DBOs, size_t... Idx, typename... CTETables>
+        auto db_objects_cat(const DBOs& dbObjects, std::index_sequence<Idx...>, CTETables&&... cteTables) {
+            return std::tuple{std::forward<CTETables>(cteTables)..., get<Idx>(dbObjects)...};
+        }
+
+        /**
+         *  Concatenate newly created tables with given DBOs, forming a new set of DBOs.
+         */
+        template<typename DBOs, typename... CTETables>
+        auto db_objects_cat(const DBOs& dbObjects, CTETables&&... cteTables) {
+            return db_objects_cat(dbObjects,
+                                  std::make_index_sequence<std::tuple_size_v<DBOs>>{},
+                                  std::forward<CTETables>(cteTables)...);
+        }
+
+        /**
+         *  This function returns the expression contained in a subselect that is relevant for
+         *  creating the definition of a CTE table.
+         *  Because CTEs can recursively refer to themselves in a compound statement, parsing
+         *  the whole compound statement would lead to compiler errors if a column_pointer<>
+         *  can't be resolved. Therefore, at the time of building a CTE table, we are only
+         *  interested in the column results of the left expression.
+         */
+        template<class Select>
+        decltype(auto) get_cte_driving_subselect(const Select& subSelect);
+
+        /**
+         *  Return given select expression.
+         */
+        template<class Select>
+        decltype(auto) get_cte_driving_subselect(const Select& subSelect) {
+            return subSelect;
+        }
+
+        /**
+         *  Return left expression of compound statement.
+         */
+        template<class Compound, class... Args, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
+        decltype(auto) get_cte_driving_subselect(const select_t<Compound, Args...>& subSelect) {
+            return subSelect.col.left;
+        }
+
+        /**
+         *  Return a tuple of member pointers of all columns
+         */
+        template<class C, size_t... Idx>
+        auto get_table_columns_fields(const C& coldef, std::index_sequence<Idx...>) {
+            return std::make_tuple(get<Idx>(coldef).member_pointer...);
+        }
+
+        // any expression -> numeric column alias
+        template<class DBOs,
+                 class E,
+                 size_t Idx = 0,
+                 std::enable_if_t<polyfill::negation_v<polyfill::is_specialization_of<E, std::tuple>>, bool> = true>
+        auto extract_colref_expressions(const DBOs& /*dbObjects*/, const E& /*col*/, std::index_sequence<Idx> = {})
+            -> std::tuple<alias_holder<decltype(n_to_colalias<Idx>())>> {
+            return {};
+        }
+
+        // expression_t<>
+        template<class DBOs, class E, size_t Idx = 0>
+        auto
+        extract_colref_expressions(const DBOs& dbObjects, const expression_t<E>& col, std::index_sequence<Idx> s = {}) {
+            return extract_colref_expressions(dbObjects, col.value, s);
+        }
+
+        // F O::* (field/getter) -> field/getter
+        template<class DBOs, class F, class O, size_t Idx = 0>
+        auto extract_colref_expressions(const DBOs& /*dbObjects*/, F O::*col, std::index_sequence<Idx> = {}) {
+            return std::make_tuple(col);
+        }
+
+        // as_t<> (aliased expression) -> alias_holder
+        template<class DBOs, class A, class E, size_t Idx = 0>
+        std::tuple<alias_holder<A>> extract_colref_expressions(const DBOs& /*dbObjects*/,
+                                                               const as_t<A, E>& /*col*/,
+                                                               std::index_sequence<Idx> = {}) {
+            return {};
+        }
+
+        // alias_holder<> (colref) -> alias_holder
+        template<class DBOs, class A, size_t Idx = 0>
+        std::tuple<alias_holder<A>> extract_colref_expressions(const DBOs& /*dbObjects*/,
+                                                               const alias_holder<A>& /*col*/,
+                                                               std::index_sequence<Idx> = {}) {
+            return {};
+        }
+
+        // column_pointer<>
+        template<class DBOs, class Moniker, class F, size_t Idx = 0>
+        auto extract_colref_expressions(const DBOs& dbObjects,
+                                        const column_pointer<Moniker, F>& col,
+                                        std::index_sequence<Idx> s = {}) {
+            return extract_colref_expressions(dbObjects, col.field, s);
+        }
+
+        // column expression tuple
+        template<class DBOs, class... Args, size_t... Idx>
+        auto extract_colref_expressions(const DBOs& dbObjects,
+                                        const std::tuple<Args...>& cols,
+                                        std::index_sequence<Idx...>) {
+            return std::tuple_cat(extract_colref_expressions(dbObjects, get<Idx>(cols), std::index_sequence<Idx>{})...);
+        }
+
+        // columns_t<>
+        template<class DBOs, class... Args>
+        auto extract_colref_expressions(const DBOs& dbObjects, const columns_t<Args...>& cols) {
+            return extract_colref_expressions(dbObjects, cols.columns, std::index_sequence_for<Args...>{});
+        }
+
+        // asterisk_t<> -> fields
+        template<class DBOs, class O>
+        auto extract_colref_expressions(const DBOs& dbObjects, const asterisk_t<O>& /*col*/) {
+            using table_type = storage_pick_table_t<O, DBOs>;
+            using elements_t = typename table_type::elements_type;
+            using column_idxs = filter_tuple_sequence_t<elements_t, is_column>;
+
+            auto& table = pick_table<O>(dbObjects);
+            return get_table_columns_fields(table.elements, column_idxs{});
+        }
+
+        template<class DBOs, class E, class... Args>
+        void extract_colref_expressions(const DBOs& /*dbObjects*/, const select_t<E, Args...>& /*subSelect*/) = delete;
+
+        template<class DBOs, class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
+        void extract_colref_expressions(const DBOs& /*dbObjects*/, const Compound& /*subSelect*/) = delete;
+
+        /*
+         *  Depending on ExplicitColRef's type returns either the explicit column reference
+         *  or the expression's column reference otherwise.
+         */
+        template<typename DBOs, typename SubselectColRef, typename ExplicitColRef>
+        auto determine_cte_colref(const DBOs& /*dbObjects*/,
+                                  const SubselectColRef& subselectColRef,
+                                  const ExplicitColRef& explicitColRef) {
+            if constexpr(polyfill::is_specialization_of_v<ExplicitColRef, alias_holder>) {
+                return explicitColRef;
+            } else if constexpr(std::is_member_pointer<ExplicitColRef>::value) {
+                return explicitColRef;
+            } else if constexpr(std::is_base_of_v<column_identifier, ExplicitColRef>) {
+                return explicitColRef.member_pointer;
+            } else if constexpr(std::is_same_v<ExplicitColRef, std::string>) {
+                return subselectColRef;
+            } else if constexpr(std::is_same_v<ExplicitColRef, polyfill::remove_cvref_t<decltype(std::ignore)>>) {
+                return subselectColRef;
+            } else {
+                static_assert(polyfill::always_false_v<ExplicitColRef>, "Invalid explicit column reference specified");
+            }
+        }
+
+        template<typename DBOs, typename SubselectColRefs, typename ExplicitColRefs, size_t... Idx>
+        auto determine_cte_colrefs([[maybe_unused]] const DBOs& dbObjects,
+                                   const SubselectColRefs& subselectColRefs,
+                                   [[maybe_unused]] const ExplicitColRefs& explicitColRefs,
+                                   std::index_sequence<Idx...>) {
+            if constexpr(std::tuple_size_v < ExplicitColRefs >> 0) {
+                static_assert(
+                    (!internal::is_builtin_numeric_column_alias_v<
+                         alias_holder_type_or_none_t<std::tuple_element_t<Idx, ExplicitColRefs>>> &&
+                     ...),
+                    "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
+
+                return std::tuple{
+                    determine_cte_colref(dbObjects, get<Idx>(subselectColRefs), get<Idx>(explicitColRefs))...};
+            } else {
+                return subselectColRefs;
+            }
+        }
+
+        template<typename Mapper, typename DBOs, typename ColRefs, size_t... CIs>
+        auto make_cte_table_using_column_indices(const DBOs& /*dbObjects*/,
+                                                 std::string tableName,
+                                                 std::vector<std::string> columnNames,
+                                                 const ColRefs& finalColRefs,
+                                                 std::index_sequence<CIs...>) {
+            return make_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) {
+            using cte_type = CTE;
+
+            auto subSelect = get_cte_driving_subselect(cte.subselect);
+
+            using subselect_type = decltype(subSelect);
+            using column_results = column_result_of_t<DBOs, subselect_type>;
+            using index_sequence = std::make_index_sequence<std::tuple_size_v<tuplify_t<column_results>>>;
+            static_assert(cte_type::explicit_colref_count == 0 ||
+                              cte_type::explicit_colref_count == index_sequence::size(),
+                          "Number of explicit columns of common table expression doesn't match the number of columns "
+                          "in the subselect.");
+
+            std::string tableName = alias_extractor<cte_moniker_type_t<cte_type>>::extract();
+            auto subselectColRefs = extract_colref_expressions(dbObjects, subSelect.col);
+            const auto& finalColRefs =
+                determine_cte_colrefs(dbObjects, subselectColRefs, cte.explicitColumns, index_sequence{});
+
+            serializer_context context{dbObjects};
+            std::vector<std::string> columnNames = collect_cte_column_names(subSelect, cte.explicitColumns, context);
+
+            using mapper_type = create_cte_mapper_t<cte_moniker_type_t<cte_type>,
+                                                    typename cte_type::explicit_colrefs_tuple,
+                                                    column_expression_of_t<DBOs, subselect_type>,
+                                                    decltype(subselectColRefs),
+                                                    polyfill::remove_cvref_t<decltype(finalColRefs)>,
+                                                    column_results>;
+            return make_cte_table_using_column_indices<mapper_type>(dbObjects,
+                                                                    std::move(tableName),
+                                                                    std::move(columnNames),
+                                                                    finalColRefs,
+                                                                    index_sequence{});
+        }
+
+        template<typename DBOs, typename... CTEs, size_t Ii, size_t... In>
+        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));
+
+            if constexpr(sizeof...(In) > 0) {
+                return make_recursive_cte_db_objects(
+                    // Because CTEs can depend on their predecessor we recursively pass in a new set of DBOs
+                    db_objects_cat(dbObjects, std::move(tbl)),
+                    cte,
+                    std::index_sequence<In...>{});
+            } else {
+                return db_objects_cat(dbObjects, std::move(tbl));
+            }
+        }
+
+        /**
+         *  Return new DBOs for CTE expressions.
+         */
+        template<class DBOs, class E, class... CTEs, satisfies<is_db_objects, DBOs> = true>
+        decltype(auto) db_objects_for_expression(DBOs& dbObjects, const with_t<E, CTEs...>& e) {
+            return make_recursive_cte_db_objects(dbObjects, e.cte, std::index_sequence_for<CTEs...>{});
+        }
+#endif
+
+        /**
+         *  Return passed in DBOs.
+         */
+        template<class DBOs, class E, satisfies<is_db_objects, DBOs> = true>
+        decltype(auto) db_objects_for_expression(DBOs& dbObjects, const E&) {
+            return dbObjects;
+        }
+    }
+}
diff --git a/dev/cte_types.h b/dev/cte_types.h
index 7d5636a8e..e8deb50d5 100644
--- a/dev/cte_types.h
+++ b/dev/cte_types.h
@@ -1,61 +1,61 @@
-#pragma once
-
-#ifdef SQLITE_ORM_WITH_CTE
-#include <type_traits>
-#include <tuple>
-#endif
-
-#include "functional/cxx_core_features.h"
-#include "functional/cxx_type_traits_polyfill.h"
-#include "tuple_helper/tuple_fy.h"
-
-#ifdef SQLITE_ORM_WITH_CTE
-namespace sqlite_orm {
-
-    namespace internal {
-
-        /**
-         *  Aliased column expression mapped into a CTE, stored as a field in a table column.
-         */
-        template<class A, class F>
-        struct aliased_field {
-            ~aliased_field() = delete;
-            aliased_field(const aliased_field&) = delete;
-            void operator=(const aliased_field&) = delete;
-
-            F field;
-        };
-
-        /**
-         *  This class captures various properties and aspects of a subselect's column expression,
-         *  and is used as a proxy in table_t<>.
-         */
-        template<typename Moniker,
-                 typename ExplicitColRefs,
-                 typename Expression,
-                 typename SubselectColRefs,
-                 typename FinalColRefs,
-                 typename... Fs>
-        class subselect_mapper {
-          public:
-            subselect_mapper() = delete;
-
-            // this type name is used to detect the mapping from moniker to object
-            using cte_moniker_type = Moniker;
-            using fields_type = std::tuple<Fs...>;
-            // this type captures the expressions forming the columns in a subselect;
-            // it is currently unused, however proves to be useful in compilation errors,
-            // as it simplifies recognizing errors in column expressions
-            using expressions_tuple = tuplify_t<Expression>;
-            // this type captures column reference expressions specified at CTE construction;
-            // those are: member pointers, alias holders
-            using explicit_colrefs_tuple = ExplicitColRefs;
-            // this type captures column reference expressions from the subselect;
-            // those are: member pointers, alias holders
-            using subselect_colrefs_tuple = SubselectColRefs;
-            // this type captures column reference expressions merged from SubselectColRefs and ExplicitColRefs
-            using final_colrefs_tuple = FinalColRefs;
-        };
-    }
-}
-#endif
+#pragma once
+
+#ifdef SQLITE_ORM_WITH_CTE
+#include <type_traits>
+#include <tuple>
+#endif
+
+#include "functional/cxx_core_features.h"
+#include "functional/cxx_type_traits_polyfill.h"
+#include "tuple_helper/tuple_fy.h"
+
+#ifdef SQLITE_ORM_WITH_CTE
+namespace sqlite_orm {
+
+    namespace internal {
+
+        /**
+         *  Aliased column expression mapped into a CTE, stored as a field in a table column.
+         */
+        template<class A, class F>
+        struct aliased_field {
+            ~aliased_field() = delete;
+            aliased_field(const aliased_field&) = delete;
+            void operator=(const aliased_field&) = delete;
+
+            F field;
+        };
+
+        /**
+         *  This class captures various properties and aspects of a subselect's column expression,
+         *  and is used as a proxy in table_t<>.
+         */
+        template<typename Moniker,
+                 typename ExplicitColRefs,
+                 typename Expression,
+                 typename SubselectColRefs,
+                 typename FinalColRefs,
+                 typename... Fs>
+        class subselect_mapper {
+          public:
+            subselect_mapper() = delete;
+
+            // this type name is used to detect the mapping from moniker to object
+            using cte_moniker_type = Moniker;
+            using fields_type = std::tuple<Fs...>;
+            // this type captures the expressions forming the columns in a subselect;
+            // it is currently unused, however proves to be useful in compilation errors,
+            // as it simplifies recognizing errors in column expressions
+            using expressions_tuple = tuplify_t<Expression>;
+            // this type captures column reference expressions specified at CTE construction;
+            // those are: member pointers, alias holders
+            using explicit_colrefs_tuple = ExplicitColRefs;
+            // this type captures column reference expressions from the subselect;
+            // those are: member pointers, alias holders
+            using subselect_colrefs_tuple = SubselectColRefs;
+            // this type captures column reference expressions merged from SubselectColRefs and ExplicitColRefs
+            using final_colrefs_tuple = FinalColRefs;
+        };
+    }
+}
+#endif

From 0c699f3f54c90ca955efffcac599832de4bd94fd Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 26 Mar 2023 23:28:19 +0100
Subject: [PATCH 115/161] Removed comment in index_sequence_util.h

---
 dev/functional/index_sequence_util.h | 2 +-
 include/sqlite_orm/sqlite_orm.h      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/dev/functional/index_sequence_util.h b/dev/functional/index_sequence_util.h
index caac3d5bc..95f99fbab 100644
--- a/dev/functional/index_sequence_util.h
+++ b/dev/functional/index_sequence_util.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <utility>  //  std::index_sequence, std::make_index_sequence
+#include <utility>  //  std::index_sequence
 
 #include "../functional/cxx_universal.h"
 
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index b37d67767..72f34bac4 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -1180,7 +1180,7 @@ namespace sqlite_orm {
 
 // #include "../functional/index_sequence_util.h"
 
-#include <utility>  //  std::index_sequence, std::make_index_sequence
+#include <utility>  //  std::index_sequence
 
 // #include "../functional/cxx_universal.h"
 

From c08a16a2c7e210678e2ecb85612d0b0e6b6551c4 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 27 Mar 2023 00:52:55 +0100
Subject: [PATCH 116/161] Guarded availability of `operator->*` for CTE
 monikers

---
 dev/column_pointer.h            | 2 ++
 include/sqlite_orm/sqlite_orm.h | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/dev/column_pointer.h b/dev/column_pointer.h
index 3e511a5a3..1c08d1e71 100644
--- a/dev/column_pointer.h
+++ b/dev/column_pointer.h
@@ -135,6 +135,7 @@ namespace sqlite_orm {
     template<class Lookup>
     SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer_builder<Lookup> column{};
 
+#ifdef SQLITE_ORM_WITH_CTE
     /**
      *  Explicitly refer to a column mapped into a CTE or subquery.
      *
@@ -160,4 +161,5 @@ namespace sqlite_orm {
     constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
         return column<A>(std::move(field));
     }
+#endif
 }
\ No newline at end of file
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 72f34bac4..262ee565b 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4536,6 +4536,7 @@ namespace sqlite_orm {
     template<class Lookup>
     SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer_builder<Lookup> column{};
 
+#ifdef SQLITE_ORM_WITH_CTE
     /**
      *  Explicitly refer to a column mapped into a CTE or subquery.
      *
@@ -4561,6 +4562,7 @@ namespace sqlite_orm {
     constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
         return column<A>(std::move(field));
     }
+#endif
 }
 
 namespace sqlite_orm {

From 11df357bf4f9ef428c0655f210cd06cddddb2193 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 27 Mar 2023 01:36:32 +0100
Subject: [PATCH 117/161] Fix warning in json1 unit test

---
 tests/json.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/json.cpp b/tests/json.cpp
index bf68ff3ae..dc1966733 100644
--- a/tests/json.cpp
+++ b/tests/json.cpp
@@ -419,7 +419,7 @@ TEST_CASE("json_quote") {
     {
         auto rows = storage.select(json_quote<float>(3.14159));
         decltype(rows) expected;
-        expected.push_back(3.14159);
+        expected.push_back(3.14159f);
         REQUIRE(rows == expected);
     }
     {

From d71260836a385841f4884c6fb2d0f5789f7128fb Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 27 Mar 2023 01:37:53 +0100
Subject: [PATCH 118/161] Fixed C++17 compiler error in
 `index_sequence_value()`

---
 dev/functional/index_sequence_util.h | 4 ++++
 include/sqlite_orm/sqlite_orm.h      | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/dev/functional/index_sequence_util.h b/dev/functional/index_sequence_util.h
index 95f99fbab..2109d52fc 100644
--- a/dev/functional/index_sequence_util.h
+++ b/dev/functional/index_sequence_util.h
@@ -21,7 +21,11 @@ namespace sqlite_orm {
         template<size_t... Idx>
         SQLITE_ORM_CONSTEVAL size_t index_sequence_value(size_t pos, std::index_sequence<Idx...>) {
             static_assert(sizeof...(Idx) > 0);
+#ifdef SQLITE_ORM_CONSTEVAL_SUPPORTED
             size_t result;
+#else
+            size_t result = 0;
+#endif
             size_t i = 0;
             ((result = Idx, i++ == pos) || ...);
             return result;
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 262ee565b..3251b7cd0 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -1201,7 +1201,11 @@ namespace sqlite_orm {
         template<size_t... Idx>
         SQLITE_ORM_CONSTEVAL size_t index_sequence_value(size_t pos, std::index_sequence<Idx...>) {
             static_assert(sizeof...(Idx) > 0);
+#ifdef SQLITE_ORM_CONSTEVAL_SUPPORTED
             size_t result;
+#else
+            size_t result = 0;
+#endif
             size_t i = 0;
             ((result = Idx, i++ == pos) || ...);
             return result;

From 205f533c0781551ceb13ca3e1f901488e1f1bbe3 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 27 Mar 2023 12:14:18 +0100
Subject: [PATCH 119/161] Turned `column<>` function object into function again

---
 dev/alias.h                                   |   8 +-
 dev/column_pointer.h                          | 153 ++++++++--------
 examples/common_table_expressions.cpp         |  40 ++---
 include/sqlite_orm/sqlite_orm.h               | 163 +++++++++---------
 tests/static_tests/column_expression_type.cpp |   4 +-
 tests/static_tests/column_result_t.cpp        |   6 +-
 6 files changed, 190 insertions(+), 184 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 71ba36e86..704911ac3 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -225,8 +225,8 @@ namespace sqlite_orm {
 
     template<orm_table_alias A, class F>
         requires(!orm_cte_moniker<internal::type_t<A>>)
-    constexpr auto operator->*(const A&, F field) {
-        return internal::alias_column_t<A, decltype(field)>{field};
+    constexpr auto operator->*(const A& /*tableAlias*/, F field) {
+        return internal::alias_column_t<A, F>{field};
     }
 #endif
 
@@ -299,8 +299,12 @@ namespace sqlite_orm {
     }
 #endif
 
+    /**
+     *  Wrap a column alias in an alias holder.
+     */
     template<class T>
     internal::alias_holder<T> get() {
+        static_assert(internal::is_column_alias_v<T>, "");
         return {};
     }
 
diff --git a/dev/column_pointer.h b/dev/column_pointer.h
index 1c08d1e71..bfe620d16 100644
--- a/dev/column_pointer.h
+++ b/dev/column_pointer.h
@@ -1,9 +1,11 @@
 #pragma once
 
-#include <string>  //  std::string
+#include <type_traits>  //  std::remove_const
 #include <utility>  //  std::move
 
 #include "functional/cxx_core_features.h"
+#include "functional/cxx_type_traits_polyfill.h"
+#include "type_traits.h"
 #include "conditions.h"
 #include "alias_traits.h"
 
@@ -58,108 +60,101 @@ namespace sqlite_orm {
         template<class T>
         using is_column_pointer = polyfill::bool_constant<is_column_pointer_v<T>>;
 
-        template<class O, class SFINAE = void>
-        struct column_pointer_builder {
-            using mapped_type = O;
-
-            /**
-             *  Explicitly refer to a column, used in contexts
-             *  where the automatic object mapping deduction needs to be overridden.
-             *
-             *  Example:
-             *  struct MyType : BaseType { ... };
-             *  storage.select(column<MyType>(&BaseType::id));
-             */
-            template<class F>
-            column_pointer<mapped_type, F> operator()(F field) const {
-                return {std::move(field)};
-            }
-        };
-
 #ifdef SQLITE_ORM_WITH_CTE
         template<class A>
         struct alias_holder;
-
-        template<class A>
-        struct column_pointer_builder<A, match_if<is_alias, A>> {
-            static_assert(is_cte_moniker_v<A>, "`A' must be a mapped table alias");
-
-            using mapped_type = A;
-
-            /**
-             *  Explicitly refer to a column alias mapped into a CTE or subquery.
-             *
-             *  Example:
-             *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
-             */
-            template<class F, satisfies_not<is_column_alias, F> = true>
-            constexpr column_pointer<mapped_type, F> operator()(F field) const {
-                return {std::move(field)};
-            }
-
-            /**
-             *  Explicitly refer to a column alias mapped into a CTE or subquery.
-             *
-             *  Example:
-             *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
-             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
-             *  storage.with(cte<cte_1>(colalias_a{})(select(&Object::id)), select(column<cte_1>(colalias_a{})));
-             */
-            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
-            constexpr column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
-                return {{}};
-            }
-
-            /**
-             *  Explicitly refer to a column alias mapped into a CTE or subquery.
-             *
-             *  Example:
-             *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
-             */
-            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
-            constexpr column_pointer<mapped_type, alias_holder<ColAlias>>
-            operator()(const alias_holder<ColAlias>&) const {
-                return {{}};
-            }
-        };
 #endif
-
     }
 
     /**
-     *  Explicit column references.
+     *  Explicitly refer to a column, used in contexts
+     *  where the automatic object mapping deduction needs to be overridden.
+     *
+     *  Example:
+     *  struct BaseType : { int64 id; };
+     *  struct MyType : BaseType { ... };
+     *  storage.select(column<MyType>(&BaseType::id));
      */
-    template<class Lookup>
-    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer_builder<Lookup> column{};
+    template<class Object, class F, internal::satisfies_not<internal::is_recordset_alias, Object> = true>
+    internal::column_pointer<Object, F> column(F field) {
+        return {std::move(field)};
+    }
 
 #ifdef SQLITE_ORM_WITH_CTE
+    /**
+     *  Explicitly refer to a column alias mapped into a CTE or subquery.
+     *
+     *  Example:
+     *  struct Object { ... };
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
+     *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
+     *  storage.with(cte<cte_1>(colalias_a{})(select(&Object::id)), select(column<cte_1>(colalias_a{})));
+     *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
+     */
+    template<class Moniker, class F, internal::satisfies<internal::is_recordset_alias, Moniker> = true>
+    constexpr auto column(F field) {
+        using namespace ::sqlite_orm::internal;
+
+        static_assert(is_cte_moniker_v<Moniker>, "`Moniker' must be a CTE moniker");
+
+        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
+            static_assert(is_column_alias_v<type_t<F>>);
+            return column_pointer<Moniker, F>{{}};
+        } else if constexpr(is_column_alias_v<F>) {
+            return column_pointer<Moniker, alias_holder<F>>{{}};
+        } else {
+            return column_pointer<Moniker, F>{std::move(field)};
+        }
+        (void)field;
+    }
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
      *  Explicitly refer to a column mapped into a CTE or subquery.
      *
      *  Example:
      *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*&Object::id));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*1_colalias));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select("z"_cte->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select("z"_cte->*"a"_col));
      */
-    template<class A, class F, internal::satisfies<internal::is_cte_moniker, A> = true>
-    constexpr auto operator->*(const A& /*cteAlias*/, F field) {
-        return column<A>(std::move(field));
+    template<orm_cte_moniker auto moniker, class F>
+    constexpr auto column([[maybe_unused]] F field) {
+        using namespace ::sqlite_orm::internal;
+        using Moniker = std::remove_const_t<decltype(moniker)>;
+
+        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
+            static_assert(is_column_alias_v<type_t<F>>);
+            return column_pointer<Moniker, F>{{}};
+        } else if constexpr(is_column_alias_v<F>) {
+            return column_pointer<Moniker, alias_holder<F>>{{}};
+        } else {
+            return column_pointer<Moniker, F>{std::move(field)};
+        }
     }
+#endif
 
     /**
-     *  Explicitly refer to an aliased column mapped into a CTE or subquery.
+     *  Explicitly refer to a column mapped into a CTE or subquery.
      *
-     *  Use it like this:
+     *  Example:
      *  struct Object { ... };
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
      */
-    template<class A, class F, internal::satisfies<internal::is_cte_moniker, A> = true>
-    constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
-        return column<A>(std::move(field));
+    template<class Moniker, class F, internal::satisfies<internal::is_cte_moniker, Moniker> = true>
+    constexpr auto operator->*(const Moniker& /*moniker*/, F field) {
+        using namespace ::sqlite_orm::internal;
+
+        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
+            static_assert(is_column_alias_v<type_t<F>>);
+            return column_pointer<Moniker, F>{{}};
+        } else if constexpr(is_column_alias_v<F>) {
+            return column_pointer<Moniker, alias_holder<F>>{{}};
+        } else {
+            return column_pointer<Moniker, F>{std::move(field)};
+        }
+        (void)field;
     }
 #endif
 }
\ No newline at end of file
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index c8716dc7e..950e7e4bf 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -80,8 +80,8 @@ void all_integers_between(int from, int end) {
                         select("cnt"_cte->*"y"_col));
 #else
         auto ast = with(cte<cte_1>()(union_all(select(as<colalias_f>(from)),
-                                               select(column<cte_1>->*colalias_f{} + c(1), limit(end)))),
-                        select(column<cte_1>->*colalias_f{}));
+                                               select(column<cte_1>(colalias_f{}) + c(1), limit(end)))),
+                        select(column<cte_1>(colalias_f{})));
 #endif
 
         string sql = storage.dump(ast);
@@ -102,8 +102,8 @@ void all_integers_between(int from, int end) {
              << "]"
                 "\n";
         for(int n: storage.with(cte<cte_1>().as(union_all(select(as<colalias_f>(from)),
-                                                          select(column<cte_1>->*colalias_f{} + c(1), limit(end)))),
-                                select(column<cte_1>->*colalias_f{}))) {
+                                                          select(column<cte_1>(colalias_f{}) + c(1), limit(end)))),
+                                select(column<cte_1>(colalias_f{})))) {
             cout << n << ", ";
         }
         cout << endl;
@@ -165,8 +165,8 @@ void supervisor_chain() {
         auto ast = with(cte<cte_1>()(union_all(
                             select(asterisk<Org>(), where(&Org::name == c("Fred"))),
                             select(asterisk<alias_a<Org>>(),
-                                   where(c(alias_column<alias_a<Org>>(&Org::name)) == column<cte_1>->*&Org::boss)))),
-                        select(column<cte_1>->*&Org::name));
+                                   where(c(alias_column<alias_a<Org>>(&Org::name)) == column<cte_1>(&Org::boss))))),
+                        select(column<cte_1>(&Org::name)));
 #endif
         string sql = storage.dump(ast);
 
@@ -230,8 +230,8 @@ void works_for_alice() {
 #else
         auto ast =
             with(cte<cte_1>()(
-                     union_(select("Alice"), select(&Org::name, where(c(&Org::boss) == column<cte_1>->*1_colalias)))),
-                 select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<cte_1>->*1_colalias)))));
+                     union_(select("Alice"), select(&Org::name, where(c(&Org::boss) == column<cte_1>(1_colalias))))),
+                 select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<cte_1>(1_colalias))))));
 #endif
 
         //WITH cte_1("n")
@@ -325,10 +325,10 @@ void family_tree() {
         make_tuple(cte<cte_1>("name", "parent")(union_(select(columns(&Family::name, &Family::mom >>= colalias_h{})),
                                                        select(columns(&Family::name, &Family::dad)))),
                    cte<cte_2>("name")(union_all(
-                       select(column<cte_1>->*colalias_h{}, where(column<cte_1>->*&Family::name == "Alice")),
-                       select(column<cte_1>->*colalias_h{}, join<cte_2>(using_(column<cte_1>->*&Family::name)))))),
+                       select(column<cte_1>(colalias_h{}), where(column<cte_1>(&Family::name) == "Alice")),
+                       select(column<cte_1>(colalias_h{}), join<cte_2>(using_(column<cte_1>(&Family::name))))))),
         select(&Family::name,
-               where(is_equal(column<cte_2>->*colalias_h{}, &Family::name) && is_null(&Family::died)),
+               where(is_equal(column<cte_2>(colalias_h{}), &Family::name) && is_null(&Family::died)),
                order_by(&Family::born)));
 #endif
 
@@ -436,10 +436,10 @@ void depth_or_breadth_first() {
 #else
         auto ast =
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
-                                                       select(columns(&Org::name, column<cte_1>->*2_colalias + c(1)),
-                                                              join<cte_1>(on(column<cte_1>->*1_colalias == &Org::boss)),
+                                                       select(columns(&Org::name, column<cte_1>(2_colalias) + c(1)),
+                                                              join<cte_1>(on(column<cte_1>(1_colalias) == &Org::boss)),
                                                               order_by(2)))),
-                 select(substr("..........", 1, column<cte_1>->*2_colalias * c(3)) || c(column<cte_1>->*1_colalias)));
+                 select(substr("..........", 1, column<cte_1>(2_colalias) * c(3)) || c(column<cte_1>(1_colalias))));
 #endif
 
         string sql = storage.dump(ast);
@@ -477,10 +477,10 @@ void depth_or_breadth_first() {
 #else
         auto ast =
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
-                                                       select(columns(&Org::name, column<cte_1>->*2_colalias + c(1)),
-                                                              join<cte_1>(on(column<cte_1>->*1_colalias == &Org::boss)),
+                                                       select(columns(&Org::name, column<cte_1>(2_colalias) + c(1)),
+                                                              join<cte_1>(on(column<cte_1>(1_colalias) == &Org::boss)),
                                                               order_by(2).desc()))),
-                 select(substr("..........", 1, column<cte_1>->*2_colalias * c(3)) || c(column<cte_1>->*1_colalias)));
+                 select(substr("..........", 1, column<cte_1>(2_colalias) * c(3)) || c(column<cte_1>(1_colalias))));
 #endif
 
         string sql = storage.dump(ast);
@@ -732,7 +732,7 @@ void show_mapping_and_backreferencing() {
 
     // back-reference via `column_pointer<cte_1, F O::*>`
     {
-        auto ast = with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*&Object::id));
+        auto ast = with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
 
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);
@@ -751,8 +751,8 @@ void show_mapping_and_backreferencing() {
     // map column via alias_holder into cte,
     // back-reference via `column_pointer<cte_1, alias_holder>`
     {
-        auto ast = with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(column<cte_1>->*cnt{} + c(1), limit(10)))),
-                        select(column<cte_1>->*cnt{}));
+        auto ast = with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(column<cte_1>(cnt{}) + c(1), limit(10)))),
+                        select(column<cte_1>(cnt{})));
 
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 3251b7cd0..bf832e4ed 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4403,11 +4403,15 @@ namespace sqlite_orm {
 
 // #include "column_pointer.h"
 
-#include <string>  //  std::string
+#include <type_traits>  //  std::remove_const
 #include <utility>  //  std::move
 
 // #include "functional/cxx_core_features.h"
 
+// #include "functional/cxx_type_traits_polyfill.h"
+
+// #include "type_traits.h"
+
 // #include "conditions.h"
 
 // #include "alias_traits.h"
@@ -4463,108 +4467,101 @@ namespace sqlite_orm {
         template<class T>
         using is_column_pointer = polyfill::bool_constant<is_column_pointer_v<T>>;
 
-        template<class O, class SFINAE = void>
-        struct column_pointer_builder {
-            using mapped_type = O;
-
-            /**
-             *  Explicitly refer to a column, used in contexts
-             *  where the automatic object mapping deduction needs to be overridden.
-             *
-             *  Example:
-             *  struct MyType : BaseType { ... };
-             *  storage.select(column<MyType>(&BaseType::id));
-             */
-            template<class F>
-            column_pointer<mapped_type, F> operator()(F field) const {
-                return {std::move(field)};
-            }
-        };
-
 #ifdef SQLITE_ORM_WITH_CTE
         template<class A>
         struct alias_holder;
-
-        template<class A>
-        struct column_pointer_builder<A, match_if<is_alias, A>> {
-            static_assert(is_cte_moniker_v<A>, "`A' must be a mapped table alias");
-
-            using mapped_type = A;
-
-            /**
-             *  Explicitly refer to a column alias mapped into a CTE or subquery.
-             *
-             *  Example:
-             *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
-             */
-            template<class F, satisfies_not<is_column_alias, F> = true>
-            constexpr column_pointer<mapped_type, F> operator()(F field) const {
-                return {std::move(field)};
-            }
-
-            /**
-             *  Explicitly refer to a column alias mapped into a CTE or subquery.
-             *
-             *  Example:
-             *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
-             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
-             *  storage.with(cte<cte_1>(colalias_a{})(select(&Object::id)), select(column<cte_1>(colalias_a{})));
-             */
-            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
-            constexpr column_pointer<mapped_type, alias_holder<ColAlias>> operator()(const ColAlias&) const {
-                return {{}};
-            }
-
-            /**
-             *  Explicitly refer to a column alias mapped into a CTE or subquery.
-             *
-             *  Example:
-             *  struct Object { ... };
-             *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
-             */
-            template<class ColAlias, satisfies<is_column_alias, ColAlias> = true>
-            constexpr column_pointer<mapped_type, alias_holder<ColAlias>>
-            operator()(const alias_holder<ColAlias>&) const {
-                return {{}};
-            }
-        };
 #endif
-
     }
 
     /**
-     *  Explicit column references.
+     *  Explicitly refer to a column, used in contexts
+     *  where the automatic object mapping deduction needs to be overridden.
+     *
+     *  Example:
+     *  struct BaseType : { int64 id; };
+     *  struct MyType : BaseType { ... };
+     *  storage.select(column<MyType>(&BaseType::id));
      */
-    template<class Lookup>
-    SQLITE_ORM_INLINE_VAR constexpr internal::column_pointer_builder<Lookup> column{};
+    template<class Object, class F, internal::satisfies_not<internal::is_recordset_alias, Object> = true>
+    internal::column_pointer<Object, F> column(F field) {
+        return {std::move(field)};
+    }
 
 #ifdef SQLITE_ORM_WITH_CTE
+    /**
+     *  Explicitly refer to a column alias mapped into a CTE or subquery.
+     *
+     *  Example:
+     *  struct Object { ... };
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
+     *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
+     *  storage.with(cte<cte_1>(colalias_a{})(select(&Object::id)), select(column<cte_1>(colalias_a{})));
+     *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
+     */
+    template<class Moniker, class F, internal::satisfies<internal::is_recordset_alias, Moniker> = true>
+    constexpr auto column(F field) {
+        using namespace ::sqlite_orm::internal;
+
+        static_assert(is_cte_moniker_v<Moniker>, "`Moniker' must be a CTE moniker");
+
+        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
+            static_assert(is_column_alias_v<type_t<F>>);
+            return column_pointer<Moniker, F>{{}};
+        } else if constexpr(is_column_alias_v<F>) {
+            return column_pointer<Moniker, alias_holder<F>>{{}};
+        } else {
+            return column_pointer<Moniker, F>{std::move(field)};
+        }
+        (void)field;
+    }
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
      *  Explicitly refer to a column mapped into a CTE or subquery.
      *
      *  Example:
      *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*&Object::id));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>->*1_colalias));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select("z"_cte->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select("z"_cte->*"a"_col));
      */
-    template<class A, class F, internal::satisfies<internal::is_cte_moniker, A> = true>
-    constexpr auto operator->*(const A& /*cteAlias*/, F field) {
-        return column<A>(std::move(field));
+    template<orm_cte_moniker auto moniker, class F>
+    constexpr auto column([[maybe_unused]] F field) {
+        using namespace ::sqlite_orm::internal;
+        using Moniker = std::remove_const_t<decltype(moniker)>;
+
+        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
+            static_assert(is_column_alias_v<type_t<F>>);
+            return column_pointer<Moniker, F>{{}};
+        } else if constexpr(is_column_alias_v<F>) {
+            return column_pointer<Moniker, alias_holder<F>>{{}};
+        } else {
+            return column_pointer<Moniker, F>{std::move(field)};
+        }
     }
+#endif
 
     /**
-     *  Explicitly refer to an aliased column mapped into a CTE or subquery.
+     *  Explicitly refer to a column mapped into a CTE or subquery.
      *
-     *  Use it like this:
+     *  Example:
      *  struct Object { ... };
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
      */
-    template<class A, class F, internal::satisfies<internal::is_cte_moniker, A> = true>
-    constexpr auto operator->*(const internal::column_pointer_builder<A>&, F field) {
-        return column<A>(std::move(field));
+    template<class Moniker, class F, internal::satisfies<internal::is_cte_moniker, Moniker> = true>
+    constexpr auto operator->*(const Moniker& /*moniker*/, F field) {
+        using namespace ::sqlite_orm::internal;
+
+        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
+            static_assert(is_column_alias_v<type_t<F>>);
+            return column_pointer<Moniker, F>{{}};
+        } else if constexpr(is_column_alias_v<F>) {
+            return column_pointer<Moniker, alias_holder<F>>{{}};
+        } else {
+            return column_pointer<Moniker, F>{std::move(field)};
+        }
+        (void)field;
     }
 #endif
 }
@@ -4778,8 +4775,8 @@ namespace sqlite_orm {
 
     template<orm_table_alias A, class F>
         requires(!orm_cte_moniker<internal::type_t<A>>)
-    constexpr auto operator->*(const A&, F field) {
-        return internal::alias_column_t<A, decltype(field)>{field};
+    constexpr auto operator->*(const A& /*tableAlias*/, F field) {
+        return internal::alias_column_t<A, F>{field};
     }
 #endif
 
@@ -4852,8 +4849,12 @@ namespace sqlite_orm {
     }
 #endif
 
+    /**
+     *  Wrap a column alias in an alias holder.
+     */
     template<class T>
     internal::alias_holder<T> get() {
+        static_assert(internal::is_column_alias_v<T>, "");
         return {};
     }
 
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index 463906d40..4937c94c4 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -55,7 +55,6 @@ TEST_CASE("column_expression_of_t") {
                                  internal::make_cte_table(dbObjects, cte<cte_1>()(select(columns(&Org::id, 1)))));
     using db_objects2_t = decltype(dbObjects2);
     runTest<db_objects_t, column_pointer<cte_1, int64 Org::*>>(column<cte_1>(&Org::id));
-    runTest<db_objects_t, column_pointer<cte_1, int64 Org::*>>(column<cte_1>->*&Org::id);
     runTest<db_objects_t, column_pointer<cte_1, int64 Org::*>>(cte_1{}->*&Org::id);
     runTest<db_objects_t, column_pointer<cte_1, alias_holder<column_alias<'1'>>>>(column<cte_1>(1_colalias));
     runTest<db_objects_t, column_pointer<cte_1, alias_holder<colalias_c>>>(1_ctealias->*colalias_c{});
@@ -70,6 +69,9 @@ TEST_CASE("column_expression_of_t") {
                        alias_column_t<alias_a<cte_1>, int internal::aliased_field<column_alias<'2'>, int>::*>>>(
         asterisk<alias_a<cte_1>>());
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    runTest<db_objects_t, column_pointer<cte_1, int64 Org::*>>(column<"1"_cte>(&Org::id));
+    runTest<db_objects_t, column_pointer<cte_1, alias_holder<colalias_c>>>(column<"1"_cte>("c"_col));
+    runTest<db_objects_t, column_pointer<cte_1, alias_holder<colalias_c>>>(column<"1"_cte>(get<"c"_col>()));
     runTest<db_objects_t, column_pointer<cte_1, alias_holder<colalias_c>>>("1"_cte->*"c"_col);
 #endif
 #endif
diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
index 75d627972..47d1fbb0b 100644
--- a/tests/static_tests/column_result_t.cpp
+++ b/tests/static_tests/column_result_t.cpp
@@ -121,13 +121,17 @@ TEST_CASE("column_result_of_t") {
     auto dbObjects2 = internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
     using db_objects2_t = decltype(dbObjects2);
     runTest<db_objects_t, int>(column<cte_1>(&User::id));
-    runTest<db_objects_t, int>(column<cte_1>->*&User::id);
+    runTest<db_objects2_t, int>(column<cte_1>(1_colalias));
+    runTest<db_objects2_t, int>(column<cte_1>(get<internal::column_alias<'1'>>()));
     runTest<db_objects_t, int>(1_ctealias->*&User::id);
     runTest<db_objects_t, int>(alias_column<alias_a<cte_1>>(&User::id));
     runTest<db_objects2_t, int>(alias_column<alias_a<cte_1>>(1_colalias));
     runTest<db_objects2_t, std::tuple<int>>(asterisk<cte_1>());
     runTest<db_objects2_t, std::tuple<int>>(asterisk<alias_a<cte_1>>());
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    runTest<db_objects_t, int>(column<"1"_cte>(&User::id));
+    runTest<db_objects2_t, int>(column<"1"_cte>(1_colalias));
+    runTest<db_objects2_t, int>(column<"1"_cte>(get<1_colalias>()));
     runTest<db_objects_t, int>("1"_cte->*&User::id);
 #endif
 #endif

From 8fda24cdbac1e21f687d9764a4d305eda73303f6 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 5 Oct 2023 21:35:56 +0200
Subject: [PATCH 120/161] Column pointers and overloading operators

---
 dev/column_pointer.h                  |  33 +----
 dev/conditions.h                      |  53 ++++++--
 dev/core_functions.h                  |  54 +++-----
 dev/error_code.h                      |   2 +-
 dev/expression.h                      |   1 +
 dev/row_extractor.h                   |   8 +-
 dev/storage.h                         |   2 +-
 dev/xdestroy_handling.h               |  24 ++--
 examples/common_table_expressions.cpp | 167 ++++++++++++------------
 include/sqlite_orm/sqlite_orm.h       | 179 ++++++++++++--------------
 10 files changed, 240 insertions(+), 283 deletions(-)

diff --git a/dev/column_pointer.h b/dev/column_pointer.h
index 67dd37380..07b45ab60 100644
--- a/dev/column_pointer.h
+++ b/dev/column_pointer.h
@@ -8,6 +8,7 @@
 #include "type_traits.h"
 #include "conditions.h"
 #include "alias_traits.h"
+#include "tags.h"
 
 namespace sqlite_orm {
     namespace internal {
@@ -16,42 +17,14 @@ namespace sqlite_orm {
          *  Is useful when mapped type is derived from other type and base class has members mapped to a storage.
          */
         template<class T, class F>
-        struct column_pointer {
+        struct column_pointer : condition_t {
             using self = column_pointer<T, F>;
             using type = T;
             using field_type = F;
 
             field_type field;
 
-            template<class R>
-            is_equal_t<self, R> operator==(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            is_not_equal_t<self, R> operator!=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            less_than_t<self, R> operator<(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            less_or_equal_t<self, R> operator<=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            greater_than_t<self, R> operator>(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            greater_or_equal_t<self, R> operator>=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
+            column_pointer(field_type field) : field{field} {}
         };
 
         template<class T>
diff --git a/dev/conditions.h b/dev/conditions.h
index 496705ea8..4e2300b35 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -25,6 +25,9 @@ namespace sqlite_orm {
 
     namespace internal {
 
+        template<class T, class F>
+        struct column_pointer;
+
         struct limit_string {
             operator std::string() const {
                 return "LIMIT";
@@ -617,7 +620,7 @@ namespace sqlite_orm {
         };
 
         template<class A, class T>
-        struct glob_t : condition_t, glob_string, internal::negatable_t {
+        struct glob_t : condition_t, glob_string, negatable_t {
             using self = glob_t<A, T>;
             using arg_t = A;
             using pattern_t = T;
@@ -834,7 +837,7 @@ namespace sqlite_orm {
         return {std::move(arg)};
     }
 
-    // Deliberately put operators for `expression_t` into the internal namespace
+    // Deliberately put operators for `expression_t`, `column_pointer` into the internal namespace
     // to facilitate ADL (Argument Dependent Lookup)
     namespace internal {
         /**
@@ -842,8 +845,12 @@ namespace sqlite_orm {
          */
         template<class L,
                  class R,
-                 std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
+                                                          std::is_base_of<arithmetic_t, R>,
+                                                          polyfill::is_specialization_of<L, expression_t>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         less_than_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator<(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -851,8 +858,12 @@ namespace sqlite_orm {
 
         template<class L,
                  class R,
-                 std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
+                                                          std::is_base_of<arithmetic_t, R>,
+                                                          polyfill::is_specialization_of<L, expression_t>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         less_or_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator<=(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -860,8 +871,12 @@ namespace sqlite_orm {
 
         template<class L,
                  class R,
-                 std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
+                                                          std::is_base_of<arithmetic_t, R>,
+                                                          polyfill::is_specialization_of<L, expression_t>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         greater_than_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator>(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -869,8 +884,12 @@ namespace sqlite_orm {
 
         template<class L,
                  class R,
-                 std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
+                                                          std::is_base_of<arithmetic_t, R>,
+                                                          polyfill::is_specialization_of<L, expression_t>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         greater_or_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator>=(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -879,7 +898,9 @@ namespace sqlite_orm {
         template<class L,
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         is_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator==(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -887,8 +908,12 @@ namespace sqlite_orm {
 
         template<class L,
                  class R,
-                 std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
+                                                          std::is_base_of<arithmetic_t, R>,
+                                                          polyfill::is_specialization_of<L, expression_t>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         is_not_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator!=(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -898,6 +923,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
                                                           polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>,
                                                           std::is_base_of<conc_string, L>,
                                                           std::is_base_of<conc_string, R>>,
                                   bool> = true>
diff --git a/dev/core_functions.h b/dev/core_functions.h
index 6412efd6f..d0d3b66dc 100644
--- a/dev/core_functions.h
+++ b/dev/core_functions.h
@@ -614,38 +614,6 @@ namespace sqlite_orm {
         using field_type_or_type_t = polyfill::detected_or_t<T, type_t, member_field_type<T>>;
     }
 
-    /**
-     *  Cute operators for core functions
-     */
-    template<class F, class R, internal::satisfies<internal::is_built_in_function, F> = true>
-    internal::less_than_t<F, R> operator<(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F, class R, internal::satisfies<internal::is_built_in_function, F> = true>
-    internal::less_or_equal_t<F, R> operator<=(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F, class R, internal::satisfies<internal::is_built_in_function, F> = true>
-    internal::greater_than_t<F, R> operator>(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F, class R, internal::satisfies<internal::is_built_in_function, F> = true>
-    internal::greater_or_equal_t<F, R> operator>=(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F, class R, internal::satisfies<internal::is_built_in_function, F> = true>
-    internal::is_equal_t<F, R> operator==(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F, class R, internal::satisfies<internal::is_built_in_function, F> = true>
-    internal::is_not_equal_t<F, R> operator!=(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS
 
     /**
@@ -2044,7 +2012,7 @@ namespace sqlite_orm {
     }
 #endif  //  SQLITE_ENABLE_JSON1
 
-    // Deliberately put operators for `arithmetic_t` or `expression_t` into the internal namespace
+    // Deliberately put operators for `arithmetic_t`, `expression_t`, `column_pointer` into the internal namespace
     // to facilitate ADL (Argument Dependent Lookup)
     namespace internal {
         template<class L,
@@ -2052,7 +2020,9 @@ namespace sqlite_orm {
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
                                                           polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         add_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator+(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -2063,7 +2033,9 @@ namespace sqlite_orm {
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
                                                           polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         sub_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator-(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -2074,7 +2046,9 @@ namespace sqlite_orm {
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
                                                           polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         mul_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator*(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -2085,7 +2059,9 @@ namespace sqlite_orm {
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
                                                           polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         div_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator/(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -2096,7 +2072,9 @@ namespace sqlite_orm {
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
                                                           polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         mod_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator%(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
diff --git a/dev/error_code.h b/dev/error_code.h
index ece9d1ad5..7410c2687 100644
--- a/dev/error_code.h
+++ b/dev/error_code.h
@@ -137,7 +137,7 @@ namespace sqlite_orm {
     std::string get_error_message(sqlite3* db, T&&... args) {
         std::ostringstream stream;
         using unpack = int[];
-        static_cast<void>(unpack{0, (static_cast<void>(static_cast<void>(stream << args)), 0)...});
+        (void)unpack{0, (stream << args, 0)...};
         stream << sqlite3_errmsg(db);
         return stream.str();
     }
diff --git a/dev/expression.h b/dev/expression.h
index 74dea3a23..3d3b3bbba 100644
--- a/dev/expression.h
+++ b/dev/expression.h
@@ -5,6 +5,7 @@
 #include "functional/cxx_optional.h"
 
 #include "functional/cxx_universal.h"
+#include "tags.h"
 #include "operators.h"
 
 namespace sqlite_orm {
diff --git a/dev/row_extractor.h b/dev/row_extractor.h
index 785c9834e..b8d3b9c87 100644
--- a/dev/row_extractor.h
+++ b/dev/row_extractor.h
@@ -62,8 +62,8 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_CPP20_CONCEPTS_SUPPORTED
     template<typename T>
     concept orm_column_text_extractable = requires(const row_extractor<T>& extractor, const char* columnText) {
-                                              { extractor.extract(columnText) } -> std::same_as<T>;
-                                          };
+        { extractor.extract(columnText) } -> std::same_as<T>;
+    };
 
     template<typename T>
     concept orm_row_value_extractable =
@@ -73,8 +73,8 @@ namespace sqlite_orm {
 
     template<typename T>
     concept orm_boxed_value_extractable = requires(const row_extractor<T>& extractor, sqlite3_value* value) {
-                                              { extractor.extract(value) } -> std::same_as<T>;
-                                          };
+        { extractor.extract(value) } -> std::same_as<T>;
+    };
 #endif
 
     namespace internal {
diff --git a/dev/storage.h b/dev/storage.h
index 3db0fe45c..628137e31 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -636,7 +636,7 @@ namespace sqlite_orm {
                 static_assert(is_preparable_v<self, Ex>, "Expression must be a high-level statement");
 
                 decltype(auto) e2 = static_if<is_select_v<Ex>>(
-                    [](auto expression) -> auto{
+                    [](auto expression) -> auto {
                         expression.highest_level = true;
                         return expression;
                     },
diff --git a/dev/xdestroy_handling.h b/dev/xdestroy_handling.h
index 7746f8402..b545e0c81 100644
--- a/dev/xdestroy_handling.h
+++ b/dev/xdestroy_handling.h
@@ -29,20 +29,20 @@ namespace sqlite_orm {
          */
         template<typename D>
         concept integral_fp_c = requires {
-                                    typename D::value_type;
-                                    D::value;
-                                    requires std::is_function_v<std::remove_pointer_t<typename D::value_type>>;
-                                };
+            typename D::value_type;
+            D::value;
+            requires std::is_function_v<std::remove_pointer_t<typename D::value_type>>;
+        };
 
         /**
          *  Constrains a deleter to be or to yield a function pointer.
          */
         template<typename D>
         concept yields_fp = requires(D d) {
-                                // yielding function pointer by using the plus trick
-                                { +d };
-                                requires std::is_function_v<std::remove_pointer_t<decltype(+d)>>;
-                            };
+            // yielding function pointer by using the plus trick
+            { +d };
+            requires std::is_function_v<std::remove_pointer_t<decltype(+d)>>;
+        };
 #endif
 
 #ifdef SQLITE_ORM_CPP20_CONCEPTS_SUPPORTED
@@ -97,8 +97,8 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_CPP20_CONCEPTS_SUPPORTED
         template<typename D>
-        concept is_unusable_for_xdestroy = (!stateless_deleter<D> &&
-                                            (yields_fp<D> && !std::convertible_to<yielded_fn_t<D>, xdestroy_fn_t>));
+        concept is_unusable_for_xdestroy =
+            (!stateless_deleter<D> && (yields_fp<D> && !std::convertible_to<yielded_fn_t<D>, xdestroy_fn_t>));
 
         /**
          *  This concept tests whether a deleter yields a function pointer, which is convertible to an xdestroy function pointer.
@@ -108,8 +108,8 @@ namespace sqlite_orm {
         concept yields_xdestroy = yields_fp<D> && std::convertible_to<yielded_fn_t<D>, xdestroy_fn_t>;
 
         template<typename D, typename P>
-        concept needs_xdestroy_proxy = (stateless_deleter<D> &&
-                                        (!yields_fp<D> || !std::convertible_to<yielded_fn_t<D>, xdestroy_fn_t>));
+        concept needs_xdestroy_proxy =
+            (stateless_deleter<D> && (!yields_fp<D> || !std::convertible_to<yielded_fn_t<D>, xdestroy_fn_t>));
 
         /**
          *  xDestroy function that constructs and invokes the stateless deleter.
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 950e7e4bf..efbe80286 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -34,21 +34,20 @@ void all_integers_between(int from, int end) {
         //    SELECT x FROM cnt;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto cnt_cte = "cnt"_cte;
-        auto ast =
-            with(cte<cnt_cte>()(
-                     union_all(select(from), select(cnt_cte->*1_colalias + c(1), where(cnt_cte->*1_colalias < end)))),
-                 select(cnt_cte->*1_colalias));
+        auto ast = with(cte<cnt_cte>()(union_all(select(from),
+                                                 select(cnt_cte->*1_colalias + 1, where(cnt_cte->*1_colalias < end)))),
+                        select(cnt_cte->*1_colalias));
 #else
         auto ast =
             with(cte<cte_1>()(union_all(select(from),
-                                        select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < end)))),
+                                        select(1_ctealias->*1_colalias + 1, where(1_ctealias->*1_colalias < end)))),
                  select(1_ctealias->*1_colalias));
 #endif
 // alternative
 #if 0
         auto ast = with(
             cte<cte_1>()(union_all(select(from >>= colalias_f{}),
-                                   select(1_ctealias->*colalias_f{} + c(1), where(1_ctealias->*colalias_f{} < end)))),
+                                   select(1_ctealias->*colalias_f{} + 1, where(1_ctealias->*colalias_f{} < end)))),
             select(1_ctealias->*colalias_f{}));
 #endif
 
@@ -75,13 +74,13 @@ void all_integers_between(int from, int end) {
         //    )
         //    SELECT x FROM cnt;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-        auto ast = with(cte<"cnt"_cte>("y"_col)(
-                            union_all(select(from >>= "x"_col), select("cnt"_cte->*"y"_col + c(1), limit(end)))),
-                        select("cnt"_cte->*"y"_col));
+        auto ast = with(
+            cte<"cnt"_cte>("y"_col)(union_all(select(from >>= "x"_col), select("cnt"_cte->*"y"_col + 1, limit(end)))),
+            select("cnt"_cte->*"y"_col));
 #else
-        auto ast = with(cte<cte_1>()(union_all(select(as<colalias_f>(from)),
-                                               select(column<cte_1>(colalias_f{}) + c(1), limit(end)))),
-                        select(column<cte_1>(colalias_f{})));
+        auto ast = with(
+            cte<cte_1>()(union_all(select(as<colalias_f>(from)), select(column<cte_1>(colalias_f{}) + 1, limit(end)))),
+            select(column<cte_1>(colalias_f{})));
 #endif
 
         string sql = storage.dump(ast);
@@ -102,7 +101,7 @@ void all_integers_between(int from, int end) {
              << "]"
                 "\n";
         for(int n: storage.with(cte<cte_1>().as(union_all(select(as<colalias_f>(from)),
-                                                          select(column<cte_1>(colalias_f{}) + c(1), limit(end)))),
+                                                          select(column<cte_1>(colalias_f{}) + 1, limit(end)))),
                                 select(column<cte_1>(colalias_f{})))) {
             cout << n << ", ";
         }
@@ -159,14 +158,14 @@ void supervisor_chain() {
         auto ast = with(cte<"chain"_cte>()(union_all(
                             select(asterisk<Org>(), where(&Org::name == c("Fred"))),
                             select(asterisk<alias_a<Org>>(),
-                                   where(c(alias_column<alias_a<Org>>(&Org::name)) == "chain"_cte->*&Org::boss)))),
+                                   where(alias_column<alias_a<Org>>(&Org::name) == "chain"_cte->*&Org::boss)))),
                         select("chain"_cte->*&Org::name));
 #else
-        auto ast = with(cte<cte_1>()(union_all(
-                            select(asterisk<Org>(), where(&Org::name == c("Fred"))),
-                            select(asterisk<alias_a<Org>>(),
-                                   where(c(alias_column<alias_a<Org>>(&Org::name)) == column<cte_1>(&Org::boss))))),
-                        select(column<cte_1>(&Org::name)));
+        auto ast = with(
+            cte<cte_1>()(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
+                                   select(asterisk<alias_a<Org>>(),
+                                          where(alias_column<alias_a<Org>>(&Org::name) == column<cte_1>(&Org::boss))))),
+            select(column<cte_1>(&Org::name)));
 #endif
         string sql = storage.dump(ast);
 
@@ -225,13 +224,12 @@ void works_for_alice() {
         constexpr auto works_for_alice = "works_for_alice"_cte;
         auto ast =
             with(cte<works_for_alice>("n"_col)(
-                     union_(select("Alice"), select(&Org::name, where(c(&Org::boss) == works_for_alice->*"n"_col)))),
+                     union_(select("Alice"), select(&Org::name, where(&Org::boss == works_for_alice->*"n"_col)))),
                  select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(works_for_alice->*"n"_col)))));
 #else
-        auto ast =
-            with(cte<cte_1>()(
-                     union_(select("Alice"), select(&Org::name, where(c(&Org::boss) == column<cte_1>(1_colalias))))),
-                 select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<cte_1>(1_colalias))))));
+        auto ast = with(
+            cte<cte_1>()(union_(select("Alice"), select(&Org::name, where(&Org::boss == column<cte_1>(1_colalias))))),
+            select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<cte_1>(1_colalias))))));
 #endif
 
         //WITH cte_1("n")
@@ -429,17 +427,17 @@ void depth_or_breadth_first() {
         constexpr auto level = "level"_col;
         auto ast = with(cte<under_alice>(&Org::name, level)(
                             union_all(select(columns("Alice", 0)),
-                                      select(columns(&Org::name, under_alice->*level + c(1)),
+                                      select(columns(&Org::name, under_alice->*level + 1),
                                              join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
                                              order_by(2)))),
-                        select(substr("..........", 1, under_alice->*level * c(3)) || c(under_alice->*&Org::name)));
+                        select(substr("..........", 1, under_alice->*level * 3) || c(under_alice->*&Org::name)));
 #else
         auto ast =
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
-                                                       select(columns(&Org::name, column<cte_1>(2_colalias) + c(1)),
+                                                       select(columns(&Org::name, column<cte_1>(2_colalias) + 1),
                                                               join<cte_1>(on(column<cte_1>(1_colalias) == &Org::boss)),
                                                               order_by(2)))),
-                 select(substr("..........", 1, column<cte_1>(2_colalias) * c(3)) || c(column<cte_1>(1_colalias))));
+                 select(substr("..........", 1, column<cte_1>(2_colalias) * 3) || c(column<cte_1>(1_colalias))));
 #endif
 
         string sql = storage.dump(ast);
@@ -470,17 +468,17 @@ void depth_or_breadth_first() {
         constexpr auto level = "level"_col;
         auto ast = with(cte<under_alice>(&Org::name, level)(
                             union_all(select(columns("Alice", 0)),
-                                      select(columns(&Org::name, under_alice->*level + c(1)),
+                                      select(columns(&Org::name, under_alice->*level + 1),
                                              join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
                                              order_by(2).desc()))),
-                        select(substr("..........", 1, under_alice->*level * c(3)) || c(under_alice->*&Org::name)));
+                        select(substr("..........", 1, under_alice->*level * 3) || c(under_alice->*&Org::name)));
 #else
         auto ast =
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
-                                                       select(columns(&Org::name, column<cte_1>(2_colalias) + c(1)),
+                                                       select(columns(&Org::name, column<cte_1>(2_colalias) + 1),
                                                               join<cte_1>(on(column<cte_1>(1_colalias) == &Org::boss)),
                                                               order_by(2).desc()))),
-                 select(substr("..........", 1, column<cte_1>(2_colalias) * c(3)) || c(column<cte_1>(1_colalias))));
+                 select(substr("..........", 1, column<cte_1>(2_colalias) * 3) || c(column<cte_1>(1_colalias))));
 #endif
 
         string sql = storage.dump(ast);
@@ -522,10 +520,10 @@ void select_from_subselect() {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     constexpr auto sub = "sub"_cte;
     auto expression = with(cte<sub>()(select(columns(&Employee::m_salary, &Employee::m_commission))),
-                           select(asterisk<sub>(), where(c(sub->*&Employee::m_salary) < 5000)));
+                           select(asterisk<sub>(), where(sub->*&Employee::m_salary < 5000)));
 #else
     auto expression = with(cte<cte_1>()(select(columns(&Employee::m_salary, &Employee::m_commission))),
-                           select(asterisk<cte_1>(), where(c(1_ctealias->*&Employee::m_salary) < 5000)));
+                           select(asterisk<cte_1>(), where(1_ctealias->*&Employee::m_salary < 5000)));
 #endif
 
     string sql = storage.dump(expression);
@@ -573,18 +571,18 @@ void apfelmaennchen() {
     constexpr auto cy = "cy"_col;
     constexpr auto t = "t"_col;
     auto ast = with(
-        make_tuple(cte<xaxis>(x)(union_all(select(-2.0), select(xaxis->*x + c(0.05), where(xaxis->*x < 1.2)))),
-                   cte<yaxis>(y)(union_all(select(-1.0), select(yaxis->*y + c(0.10), where(yaxis->*y < 1.0)))),
+        make_tuple(cte<xaxis>(x)(union_all(select(-2.0), select(xaxis->*x + 0.05, where(xaxis->*x < 1.2)))),
+                   cte<yaxis>(y)(union_all(select(-1.0), select(yaxis->*y + 0.10, where(yaxis->*y < 1.0)))),
                    cte<m>(iter, cx, cy, x, y)(
                        union_all(select(columns(0, xaxis->*x, yaxis->*y, 0.0, 0.0)),
-                                 select(columns(m->*iter + c(1),
+                                 select(columns(m->*iter + 1,
                                                 m->*cx,
                                                 m->*cy,
-                                                m->*x * c(m->*x) - m->*y * c(m->*y) + m->*cx,
-                                                c(2.0) * m->*x * m->*y + m->*cy),
-                                        where((m->*x * c(m->*x) + m->*y * c(m->*y)) < c(4.0) && m->*iter < 28)))),
+                                                m->*x * m->*x - m->*y * m->*y + m->*cx,
+                                                2.0 * m->*x * m->*y + m->*cy),
+                                        where((m->*x * m->*x + m->*y * m->*y) < 4.0 && m->*iter < 28)))),
                    cte<m2>(iter, cx, cy)(select(columns(max<>(m->*iter), m->*cx, m->*cy), group_by(m->*cx, m->*cy))),
-                   cte<a>(t)(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / c(7.0), 4.0), 1), ""),
+                   cte<a>(t)(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / 7.0, 4.0), 1), ""),
                                     group_by(m2->*cy)))),
         select(group_concat(rtrim(a->*t), "\n")));
 #else
@@ -605,21 +603,20 @@ void apfelmaennchen() {
     constexpr internal::column_alias<'c', 'y'> cy;
     constexpr internal::column_alias<'t'> t;
     auto ast = with(
-        make_tuple(
-            cte<cte_xaxis>("x")(union_all(select(-2.0 >>= x), select(xaxis->*x + c(0.05), where(xaxis->*x < 1.2)))),
-            cte<cte_yaxis>("y")(union_all(select(-1.0 >>= y), select(yaxis->*y + c(0.10), where(yaxis->*y < 1.0)))),
-            cte<cte_m>("iter", "cx", "cy", "x", "y")(
-                union_all(select(columns(0 >>= iter, xaxis->*x >>= cx, yaxis->*y >>= cy, 0.0 >>= x, 0.0 >>= y)),
-                          select(columns(m->*iter + c(1),
-                                         m->*cx,
-                                         m->*cy,
-                                         m->*x * c(m->*x) - m->*y * c(m->*y) + m->*cx,
-                                         c(2.0) * m->*x * m->*y + m->*cy),
-                                 where((m->*x * c(m->*x) + m->*y * c(m->*y)) < c(4.0) && m->*iter < 28)))),
-            cte<cte_m2>("iter", "cx", "cy")(
-                select(columns(max<>(m->*iter) >>= iter, m->*cx, m->*cy), group_by(m->*cx, m->*cy))),
-            cte<cte_a>("t")(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / c(7.0), 4.0), 1), "") >>= t,
-                                   group_by(m2->*cy)))),
+        make_tuple(cte<cte_xaxis>("x")(union_all(select(-2.0 >>= x), select(xaxis->*x + 0.05, where(xaxis->*x < 1.2)))),
+                   cte<cte_yaxis>("y")(union_all(select(-1.0 >>= y), select(yaxis->*y + 0.10, where(yaxis->*y < 1.0)))),
+                   cte<cte_m>("iter", "cx", "cy", "x", "y")(
+                       union_all(select(columns(0 >>= iter, xaxis->*x >>= cx, yaxis->*y >>= cy, 0.0 >>= x, 0.0 >>= y)),
+                                 select(columns(m->*iter + 1,
+                                                m->*cx,
+                                                m->*cy,
+                                                m->*x * m->*x - m->*y * m->*y + m->*cx,
+                                                2.0 * m->*x * m->*y + m->*cy),
+                                        where((m->*x * m->*x + m->*y * m->*y) < 4.0 && m->*iter < 28)))),
+                   cte<cte_m2>("iter", "cx", "cy")(
+                       select(columns(max<>(m->*iter) >>= iter, m->*cx, m->*cy), group_by(m->*cx, m->*cy))),
+                   cte<cte_a>("t")(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / 7.0, 4.0), 1), "") >>= t,
+                                          group_by(m2->*cy)))),
         select(group_concat(rtrim(a->*t), "\n")));
 #endif
 
@@ -677,30 +674,30 @@ void sudoku() {
     constexpr auto lp = "lp"_col;
     constexpr auto s = "s"_col;
     constexpr auto ind = "ind"_col;
-    auto ast = with(
-        make_tuple(
-            cte<input>(sud)(
-                select("53..7....6..195....98....6.8...6...34..8.3..17...2...6.6....28....419..5....8..79")),
-            cte<digits>(z, lp)(union_all(
-                select(columns("1", 1)),
-                select(columns(cast<string>(digits->*lp + c(1)), digits->*lp + c(1)), where(digits->*lp < 9)))),
-            cte<x>(s, ind)(union_all(
-                select(columns(input->*sud, instr(input->*sud, "."))),
-                select(columns(substr(x->*s, 1, x->*ind - c(1)) || c(z) || substr(x->*s, x->*ind + c(1)),
-                               instr(substr(x->*s, 1, x->*ind - c(1)) || c(z) || substr(x->*s, x->*ind + c(1)), ".")),
-                       where(x->*ind > 0 and
-                             not exists(select(
-                                 1 >>= lp,
-                                 from<digits>(),
-                                 where(is_equal(z_alias->*z, substr(x->*s, ((x->*ind - c(1)) / 9) * 9 + lp, 1)) or
-                                       is_equal(z_alias->*z,
-                                                substr(x->*s, ((x->*ind - c(1)) % 9) + (lp - c(1)) * 9 + 1, 1)) or
-                                       is_equal(z_alias->*z,
-                                                substr(x->*s,
-                                                       (((x->*ind - c(1)) / 3) % 3) * 3 + ((x->*ind - c(1)) / 27) * 27 +
-                                                           lp + ((lp - c(1)) / 3) * 6,
-                                                       1)))))))))),
-        select(x->*s, where(x->*ind == 0)));
+    auto ast =
+        with(make_tuple(
+                 cte<input>(sud)(
+                     select("53..7....6..195....98....6.8...6...34..8.3..17...2...6.6....28....419..5....8..79")),
+                 cte<digits>(z, lp)(union_all(
+                     select(columns("1", 1)),
+                     select(columns(cast<string>(digits->*lp + 1), digits->*lp + 1), where(digits->*lp < 9)))),
+                 cte<x>(s, ind)(union_all(
+                     select(columns(input->*sud, instr(input->*sud, "."))),
+                     select(columns(substr(x->*s, 1, x->*ind - 1) || c(z) || substr(x->*s, x->*ind + 1),
+                                    instr(substr(x->*s, 1, x->*ind - 1) || c(z) || substr(x->*s, x->*ind + 1), ".")),
+                            where(x->*ind > 0 and
+                                  not exists(select(
+                                      1 >>= lp,
+                                      from<digits>(),
+                                      where(is_equal(z_alias->*z, substr(x->*s, ((x->*ind - 1) / 9) * 9 + lp, 1)) or
+                                            is_equal(z_alias->*z,
+                                                     substr(x->*s, ((x->*ind - 1) % 9) + (lp - c(1)) * 9 + 1, 1)) or
+                                            is_equal(z_alias->*z,
+                                                     substr(x->*s,
+                                                            (((x->*ind - 1) / 3) % 3) * 3 + ((x->*ind - 1) / 27) * 27 +
+                                                                lp + ((lp - c(1)) / 3) * 6,
+                                                            1)))))))))),
+             select(x->*s, where(x->*ind == 0)));
 
     string sql = storage.dump(ast);
 
@@ -742,7 +739,7 @@ void show_mapping_and_backreferencing() {
     // back-reference via `column_pointer<cte_1, alias_holder>`
     {
         auto ast =
-            with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(column<cte_1>(get<cnt>()) + c(1), limit(10)))),
+            with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(column<cte_1>(get<cnt>()) + 1, limit(10)))),
                  select(column<cte_1>(get<cnt>())));
 
         string sql = storage.dump(ast);
@@ -751,7 +748,7 @@ void show_mapping_and_backreferencing() {
     // map column via alias_holder into cte,
     // back-reference via `column_pointer<cte_1, alias_holder>`
     {
-        auto ast = with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(column<cte_1>(cnt{}) + c(1), limit(10)))),
+        auto ast = with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(column<cte_1>(cnt{}) + 1, limit(10)))),
                         select(column<cte_1>(cnt{})));
 
         string sql = storage.dump(ast);
@@ -760,7 +757,7 @@ void show_mapping_and_backreferencing() {
     // map column via alias_holder into cte,
     // back-reference via `column_pointer<cte_1, alias_holder>`
     {
-        auto ast = with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(cte_1{}->*cnt{} + c(1), limit(10)))),
+        auto ast = with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(cte_1{}->*cnt{} + 1, limit(10)))),
                         select(cte_1{}->*cnt{}));
 
         string sql = storage.dump(ast);
@@ -961,8 +958,8 @@ void greatest_n_per_group() {
         with(cte<wnd>(&some_result::item_id, max_date)(
                  select(columns(&some_result::item_id, max(&some_result::timestamp)), group_by(&some_result::item_id))),
              select(object<some_result>(),
-                    inner_join<wnd>(on(c(&some_result::item_id) == wnd->*&some_result::item_id and
-                                       c(&some_result::timestamp) == wnd->*max_date)),
+                    inner_join<wnd>(on(&some_result::item_id == wnd->*&some_result::item_id and
+                                       &some_result::timestamp == wnd->*max_date)),
                     // additional conditions
                     where(c(&some_result::flag) == true)));
     string sql = storage.dump(expression);
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index bdf3d7b6d..4a2b688a1 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -589,7 +589,7 @@ namespace sqlite_orm {
     std::string get_error_message(sqlite3* db, T&&... args) {
         std::ostringstream stream;
         using unpack = int[];
-        static_cast<void>(unpack{0, (static_cast<void>(static_cast<void>(stream << args)), 0)...});
+        (void)unpack{0, (stream << args, 0)...};
         stream << sqlite3_errmsg(db);
         return stream.str();
     }
@@ -2985,6 +2985,8 @@ namespace sqlite_orm {
 
 // #include "functional/cxx_universal.h"
 
+// #include "tags.h"
+
 // #include "operators.h"
 
 namespace sqlite_orm {
@@ -3088,6 +3090,9 @@ namespace sqlite_orm {
 
     namespace internal {
 
+        template<class T, class F>
+        struct column_pointer;
+
         struct limit_string {
             operator std::string() const {
                 return "LIMIT";
@@ -3680,7 +3685,7 @@ namespace sqlite_orm {
         };
 
         template<class A, class T>
-        struct glob_t : condition_t, glob_string, internal::negatable_t {
+        struct glob_t : condition_t, glob_string, negatable_t {
             using self = glob_t<A, T>;
             using arg_t = A;
             using pattern_t = T;
@@ -3897,7 +3902,7 @@ namespace sqlite_orm {
         return {std::move(arg)};
     }
 
-    // Deliberately put operators for `expression_t` into the internal namespace
+    // Deliberately put operators for `expression_t`, `column_pointer` into the internal namespace
     // to facilitate ADL (Argument Dependent Lookup)
     namespace internal {
         /**
@@ -3905,8 +3910,12 @@ namespace sqlite_orm {
          */
         template<class L,
                  class R,
-                 std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
+                                                          std::is_base_of<arithmetic_t, R>,
+                                                          polyfill::is_specialization_of<L, expression_t>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         less_than_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator<(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -3914,8 +3923,12 @@ namespace sqlite_orm {
 
         template<class L,
                  class R,
-                 std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
+                                                          std::is_base_of<arithmetic_t, R>,
+                                                          polyfill::is_specialization_of<L, expression_t>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         less_or_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator<=(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -3923,8 +3936,12 @@ namespace sqlite_orm {
 
         template<class L,
                  class R,
-                 std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
+                                                          std::is_base_of<arithmetic_t, R>,
+                                                          polyfill::is_specialization_of<L, expression_t>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         greater_than_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator>(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -3932,8 +3949,12 @@ namespace sqlite_orm {
 
         template<class L,
                  class R,
-                 std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
+                                                          std::is_base_of<arithmetic_t, R>,
+                                                          polyfill::is_specialization_of<L, expression_t>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         greater_or_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator>=(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -3942,7 +3963,9 @@ namespace sqlite_orm {
         template<class L,
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         is_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator==(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -3950,8 +3973,12 @@ namespace sqlite_orm {
 
         template<class L,
                  class R,
-                 std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
+                                                          std::is_base_of<arithmetic_t, R>,
+                                                          polyfill::is_specialization_of<L, expression_t>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         is_not_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator!=(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -3961,6 +3988,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
                                                           polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>,
                                                           std::is_base_of<conc_string, L>,
                                                           std::is_base_of<conc_string, R>>,
                                   bool> = true>
@@ -4347,6 +4376,8 @@ namespace sqlite_orm {
 
 // #include "alias_traits.h"
 
+// #include "tags.h"
+
 namespace sqlite_orm {
     namespace internal {
         /**
@@ -4354,42 +4385,14 @@ namespace sqlite_orm {
          *  Is useful when mapped type is derived from other type and base class has members mapped to a storage.
          */
         template<class T, class F>
-        struct column_pointer {
+        struct column_pointer : condition_t {
             using self = column_pointer<T, F>;
             using type = T;
             using field_type = F;
 
             field_type field;
 
-            template<class R>
-            is_equal_t<self, R> operator==(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            is_not_equal_t<self, R> operator!=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            less_than_t<self, R> operator<(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            less_or_equal_t<self, R> operator<=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            greater_than_t<self, R> operator>(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
-
-            template<class R>
-            greater_or_equal_t<self, R> operator>=(R rhs) const {
-                return {*this, std::move(rhs)};
-            }
+            column_pointer(field_type field) : field{field} {}
         };
 
         template<class T>
@@ -5545,38 +5548,6 @@ namespace sqlite_orm {
         using field_type_or_type_t = polyfill::detected_or_t<T, type_t, member_field_type<T>>;
     }
 
-    /**
-     *  Cute operators for core functions
-     */
-    template<class F, class R, internal::satisfies<internal::is_built_in_function, F> = true>
-    internal::less_than_t<F, R> operator<(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F, class R, internal::satisfies<internal::is_built_in_function, F> = true>
-    internal::less_or_equal_t<F, R> operator<=(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F, class R, internal::satisfies<internal::is_built_in_function, F> = true>
-    internal::greater_than_t<F, R> operator>(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F, class R, internal::satisfies<internal::is_built_in_function, F> = true>
-    internal::greater_or_equal_t<F, R> operator>=(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F, class R, internal::satisfies<internal::is_built_in_function, F> = true>
-    internal::is_equal_t<F, R> operator==(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
-
-    template<class F, class R, internal::satisfies<internal::is_built_in_function, F> = true>
-    internal::is_not_equal_t<F, R> operator!=(F f, R r) {
-        return {std::move(f), std::move(r)};
-    }
 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS
 
     /**
@@ -6975,7 +6946,7 @@ namespace sqlite_orm {
     }
 #endif  //  SQLITE_ENABLE_JSON1
 
-    // Deliberately put operators for `arithmetic_t` or `expression_t` into the internal namespace
+    // Deliberately put operators for `arithmetic_t`, `expression_t`, `column_pointer` into the internal namespace
     // to facilitate ADL (Argument Dependent Lookup)
     namespace internal {
         template<class L,
@@ -6983,7 +6954,9 @@ namespace sqlite_orm {
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
                                                           polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         add_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator+(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -6994,7 +6967,9 @@ namespace sqlite_orm {
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
                                                           polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         sub_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator-(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -7005,7 +6980,9 @@ namespace sqlite_orm {
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
                                                           polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         mul_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator*(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -7016,7 +6993,9 @@ namespace sqlite_orm {
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
                                                           polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         div_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator/(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -7027,7 +7006,9 @@ namespace sqlite_orm {
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
                                                           polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>>,
+                                                          polyfill::is_specialization_of<R, expression_t>,
+                                                          polyfill::is_specialization_of<L, column_pointer>,
+                                                          polyfill::is_specialization_of<R, column_pointer>>,
                                   bool> = true>
         mod_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator%(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -8220,20 +8201,20 @@ namespace sqlite_orm {
          */
         template<typename D>
         concept integral_fp_c = requires {
-                                    typename D::value_type;
-                                    D::value;
-                                    requires std::is_function_v<std::remove_pointer_t<typename D::value_type>>;
-                                };
+            typename D::value_type;
+            D::value;
+            requires std::is_function_v<std::remove_pointer_t<typename D::value_type>>;
+        };
 
         /**
          *  Constrains a deleter to be or to yield a function pointer.
          */
         template<typename D>
         concept yields_fp = requires(D d) {
-                                // yielding function pointer by using the plus trick
-                                { +d };
-                                requires std::is_function_v<std::remove_pointer_t<decltype(+d)>>;
-                            };
+            // yielding function pointer by using the plus trick
+            { +d };
+            requires std::is_function_v<std::remove_pointer_t<decltype(+d)>>;
+        };
 #endif
 
 #ifdef SQLITE_ORM_CPP20_CONCEPTS_SUPPORTED
@@ -8288,8 +8269,8 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_CPP20_CONCEPTS_SUPPORTED
         template<typename D>
-        concept is_unusable_for_xdestroy = (!stateless_deleter<D> &&
-                                            (yields_fp<D> && !std::convertible_to<yielded_fn_t<D>, xdestroy_fn_t>));
+        concept is_unusable_for_xdestroy =
+            (!stateless_deleter<D> && (yields_fp<D> && !std::convertible_to<yielded_fn_t<D>, xdestroy_fn_t>));
 
         /**
          *  This concept tests whether a deleter yields a function pointer, which is convertible to an xdestroy function pointer.
@@ -8299,8 +8280,8 @@ namespace sqlite_orm {
         concept yields_xdestroy = yields_fp<D> && std::convertible_to<yielded_fn_t<D>, xdestroy_fn_t>;
 
         template<typename D, typename P>
-        concept needs_xdestroy_proxy = (stateless_deleter<D> &&
-                                        (!yields_fp<D> || !std::convertible_to<yielded_fn_t<D>, xdestroy_fn_t>));
+        concept needs_xdestroy_proxy =
+            (stateless_deleter<D> && (!yields_fp<D> || !std::convertible_to<yielded_fn_t<D>, xdestroy_fn_t>));
 
         /**
          *  xDestroy function that constructs and invokes the stateless deleter.
@@ -9202,8 +9183,8 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_CPP20_CONCEPTS_SUPPORTED
     template<typename T>
     concept orm_column_text_extractable = requires(const row_extractor<T>& extractor, const char* columnText) {
-                                              { extractor.extract(columnText) } -> std::same_as<T>;
-                                          };
+        { extractor.extract(columnText) } -> std::same_as<T>;
+    };
 
     template<typename T>
     concept orm_row_value_extractable =
@@ -9213,8 +9194,8 @@ namespace sqlite_orm {
 
     template<typename T>
     concept orm_boxed_value_extractable = requires(const row_extractor<T>& extractor, sqlite3_value* value) {
-                                              { extractor.extract(value) } -> std::same_as<T>;
-                                          };
+        { extractor.extract(value) } -> std::same_as<T>;
+    };
 #endif
 
     namespace internal {
@@ -19360,7 +19341,7 @@ namespace sqlite_orm {
                 static_assert(is_preparable_v<self, Ex>, "Expression must be a high-level statement");
 
                 decltype(auto) e2 = static_if<is_select_v<Ex>>(
-                    [](auto expression) -> auto{
+                    [](auto expression) -> auto {
                         expression.highest_level = true;
                         return expression;
                     },

From dbe1784636eeb04f8688c207af6bd70074faea09 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 8 Oct 2023 00:39:08 +0200
Subject: [PATCH 121/161] Overhauled operator overloading

* proper ADL for `operator !()` (moved into `internal` namespace)
* `expression_t` (from `c()`) is now negatable
* column pointers and column aliases now participate as arguments to overloaded operators as well
* extended unit tests for overloaded operators
---
 dev/alias.h                           |  13 +-
 dev/column_pointer.h                  |  12 +-
 dev/conditions.h                      |  93 ++-
 dev/core_functions.h                  |  34 +-
 dev/expression.h                      |  22 +-
 dev/operators.h                       |   9 -
 dev/select_constraints.h              |   1 -
 dev/tags.h                            |  16 +
 examples/common_table_expressions.cpp |  56 +-
 include/sqlite_orm/sqlite_orm.h       | 816 +++++++++++++-------------
 tests/static_tests/operators_adl.cpp  | 158 ++---
 11 files changed, 628 insertions(+), 602 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 704911ac3..827aaeec2 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -14,6 +14,7 @@
 #include "functional/cxx_type_traits_polyfill.h"
 #include "type_traits.h"
 #include "alias_traits.h"
+#include "tags.h"
 #include "column_pointer.h"
 
 namespace sqlite_orm {
@@ -41,6 +42,9 @@ namespace sqlite_orm {
         consteval auto to_alias(std::index_sequence<Idx...>) {
             return Alias<t.id[Idx]...>{};
         }
+
+        template<class T>
+        inline constexpr bool is_operator_argument_v<T, std::enable_if_t<orm_column_alias<T>>> = true;
 #endif
 
         /**
@@ -141,7 +145,7 @@ namespace sqlite_orm {
         };
 
         /**
-         *  This is a common built-in class used for custom single-character column aliases.
+         *  Built-in column alias.
          *  For convenience there exist type aliases `colalias_a`, `colalias_b`, ...
          *  The easiest way to create a column alias is using `"xyz"_col`.
          */
@@ -161,6 +165,10 @@ namespace sqlite_orm {
             alias_holder(const T&) noexcept {}
         };
 
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool
+            is_operator_argument_v<T, std::enable_if_t<polyfill::is_specialization_of_v<T, alias_holder>>> = true;
+
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         template<char A, char... X>
         struct recordset_alias_builder {
@@ -276,6 +284,9 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /** 
+     *  Alias a column expression.
+     */
     template<orm_column_alias auto als, class E>
     auto as(E expression) {
         using A = std::remove_const_t<decltype(als)>;
diff --git a/dev/column_pointer.h b/dev/column_pointer.h
index 07b45ab60..fdd65149f 100644
--- a/dev/column_pointer.h
+++ b/dev/column_pointer.h
@@ -1,12 +1,11 @@
 #pragma once
 
-#include <type_traits>  //  std::remove_const
-#include <utility>  //  std::move
+#include <type_traits>  //  std::enable_if, std::remove_const
+#include <utility>  // std::move
 
 #include "functional/cxx_core_features.h"
 #include "functional/cxx_type_traits_polyfill.h"
 #include "type_traits.h"
-#include "conditions.h"
 #include "alias_traits.h"
 #include "tags.h"
 
@@ -17,14 +16,12 @@ namespace sqlite_orm {
          *  Is useful when mapped type is derived from other type and base class has members mapped to a storage.
          */
         template<class T, class F>
-        struct column_pointer : condition_t {
+        struct column_pointer {
             using self = column_pointer<T, F>;
             using type = T;
             using field_type = F;
 
             field_type field;
-
-            column_pointer(field_type field) : field{field} {}
         };
 
         template<class T>
@@ -33,6 +30,9 @@ namespace sqlite_orm {
         template<class T>
         using is_column_pointer = polyfill::bool_constant<is_column_pointer_v<T>>;
 
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_operator_argument_v<T, std::enable_if_t<is_column_pointer_v<T>>> = true;
+
 #ifdef SQLITE_ORM_WITH_CTE
         template<class A>
         struct alias_holder;
diff --git a/dev/conditions.h b/dev/conditions.h
index 4e2300b35..289caa10e 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -18,6 +18,8 @@
 #include "tags.h"
 #include "alias_traits.h"
 #include "expression.h"
+#include "column_pointer.h"
+#include "tags.h"
 #include "type_printer.h"
 #include "literal.h"
 
@@ -25,9 +27,6 @@ namespace sqlite_orm {
 
     namespace internal {
 
-        template<class T, class F>
-        struct column_pointer;
-
         struct limit_string {
             operator std::string() const {
                 return "LIMIT";
@@ -832,25 +831,22 @@ namespace sqlite_orm {
     }
 #endif
 
-    template<class T, internal::satisfies<std::is_base_of, internal::negatable_t, T> = true>
-    internal::negated_condition_t<T> operator!(T arg) {
-        return {std::move(arg)};
-    }
-
-    // Deliberately put operators for `expression_t`, `column_pointer` into the internal namespace
+    // Intentionally place operators for types classified as arithmetic or general operator arguments in the internal namespace
     // to facilitate ADL (Argument Dependent Lookup)
     namespace internal {
-        /**
-         *  Cute operators for columns
-         */
+        template<class T,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<negatable_t, T>, is_operator_argument<T>>,
+                                  bool> = true>
+        negated_condition_t<T> operator!(T arg) {
+            return {std::move(arg)};
+        }
+
         template<class L,
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         less_than_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator<(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -860,10 +856,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         less_or_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator<=(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -873,10 +867,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         greater_than_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator>(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -886,10 +878,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         greater_or_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator>=(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -897,10 +887,10 @@ namespace sqlite_orm {
 
         template<class L,
                  class R,
-                 std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
+                                                          std::is_base_of<arithmetic_t, R>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         is_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator==(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -910,10 +900,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         is_not_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator!=(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -921,14 +909,12 @@ namespace sqlite_orm {
 
         template<class L,
                  class R,
-                 std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>,
-                                                          std::is_base_of<conc_string, L>,
-                                                          std::is_base_of<conc_string, R>>,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<condition_t, L>,
+                                                          std::is_base_of<condition_t, R>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
-        conc_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator||(L l, R r) {
+        and_condition_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator&&(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
         }
 
@@ -937,23 +923,24 @@ namespace sqlite_orm {
             class R,
             std::enable_if_t<polyfill::disjunction_v<std::is_base_of<condition_t, L>, std::is_base_of<condition_t, R>>,
                              bool> = true>
-        and_condition_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator&&(L l, R r) {
+        or_condition_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator||(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
         }
 
         template<class L,
                  class R,
-                 std::enable_if_t<
-                     polyfill::conjunction_v<
-                         polyfill::disjunction<std::is_base_of<condition_t, L>, std::is_base_of<condition_t, R>>,
-                         // exclude concatenated expressions
-                         polyfill::negation<polyfill::disjunction<polyfill::is_specialization_of<L, expression_t>,
-                                                                  polyfill::is_specialization_of<R, expression_t>>>>,
-                     bool> = true>
-        or_condition_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator||(L l, R r) {
+                 std::enable_if_t<polyfill::conjunction_v<
+                                      polyfill::disjunction<std::is_base_of<conc_string, L>,
+                                                            std::is_base_of<conc_string, R>,
+                                                            is_operator_argument<L>,
+                                                            is_operator_argument<R>>,
+                                      // exclude conditions
+                                      polyfill::negation<polyfill::disjunction<std::is_base_of<condition_t, L>,
+                                                                               std::is_base_of<condition_t, R>>>>,
+                                  bool> = true>
+        conc_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator||(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
         }
-
     }
 
     template<class F, class O>
diff --git a/dev/core_functions.h b/dev/core_functions.h
index d0d3b66dc..853fdec51 100644
--- a/dev/core_functions.h
+++ b/dev/core_functions.h
@@ -12,7 +12,7 @@
 #include "conditions.h"
 #include "serialize_result_type.h"
 #include "operators.h"
-#include "expression.h"
+#include "tags.h"
 #include "ast/into.h"
 
 namespace sqlite_orm {
@@ -2012,17 +2012,15 @@ namespace sqlite_orm {
     }
 #endif  //  SQLITE_ENABLE_JSON1
 
-    // Deliberately put operators for `arithmetic_t`, `expression_t`, `column_pointer` into the internal namespace
+    // Intentionally place operators for types classified as arithmetic or general operator arguments in the internal namespace
     // to facilitate ADL (Argument Dependent Lookup)
     namespace internal {
         template<class L,
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         add_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator+(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -2032,10 +2030,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         sub_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator-(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -2045,10 +2041,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         mul_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator*(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -2058,10 +2052,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         div_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator/(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -2071,10 +2063,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         mod_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator%(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
diff --git a/dev/expression.h b/dev/expression.h
index 3d3b3bbba..9b0234bbb 100644
--- a/dev/expression.h
+++ b/dev/expression.h
@@ -1,17 +1,21 @@
 #pragma once
 
 #include <tuple>
-#include <utility>  //  std::move, std::forward
+#include <type_traits>  //  std::enable_if
+#include <utility>  //  std::move, std::forward, std::declval
 #include "functional/cxx_optional.h"
 
 #include "functional/cxx_universal.h"
+#include "functional/cxx_type_traits_polyfill.h"
 #include "tags.h"
-#include "operators.h"
 
 namespace sqlite_orm {
 
     namespace internal {
 
+        template<class L, class... Args>
+        struct in_t;
+
         template<class L, class R>
         struct and_condition_t;
 
@@ -19,14 +23,12 @@ namespace sqlite_orm {
         struct or_condition_t;
 
         /**
-         *  Is not an operator but a result of c(...) function. Has operator= overloaded which returns assign_t
+         *  Result of c(...) function. Has operator= overloaded which returns assign_t
          */
         template<class T>
-        struct expression_t : condition_t {
+        struct expression_t {
             T value;
 
-            expression_t(T value_) : value(std::move(value_)) {}
-
             template<class R>
             assign_t<T, R> operator=(R r) const {
                 return {this->value, std::move(r)};
@@ -42,12 +44,12 @@ namespace sqlite_orm {
 #endif
             template<class... Args>
             in_t<T, Args...> in(Args... args) const {
-                return {this->value, std::make_tuple(std::forward<Args>(args)...), false};
+                return {this->value, {std::forward<Args>(args)...}, false};
             }
 
             template<class... Args>
             in_t<T, Args...> not_in(Args... args) const {
-                return {this->value, std::make_tuple(std::forward<Args>(args)...), true};
+                return {this->value, {std::forward<Args>(args)...}, true};
             }
 
             template<class R>
@@ -61,6 +63,10 @@ namespace sqlite_orm {
             }
         };
 
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool
+            is_operator_argument_v<T, std::enable_if_t<polyfill::is_specialization_of_v<T, expression_t>>> = true;
+
         template<class T>
         T get_from_expression(T value) {
             return std::move(value);
diff --git a/dev/operators.h b/dev/operators.h
index 446487d42..3b81a6ce0 100644
--- a/dev/operators.h
+++ b/dev/operators.h
@@ -10,11 +10,6 @@ namespace sqlite_orm {
 
     namespace internal {
 
-        /**
-         *  Inherit this class to support arithmetic types overloading
-         */
-        struct arithmetic_t {};
-
         template<class L, class R, class... Ds>
         struct binary_operator : Ds... {
             using left_type = L;
@@ -187,10 +182,6 @@ namespace sqlite_orm {
          */
         template<class L, class R>
         struct is_assign_t<assign_t<L, R>> : public std::true_type {};
-
-        template<class L, class... Args>
-        struct in_t;
-
     }
 
     /**
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 29369d2e7..444a8b643 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -16,7 +16,6 @@
 #include "ast/group_by.h"
 #include "core_functions.h"
 #include "alias_traits.h"
-#include "column_pointer.h"
 
 namespace sqlite_orm {
 
diff --git a/dev/tags.h b/dev/tags.h
index bc77292ea..4e9514963 100644
--- a/dev/tags.h
+++ b/dev/tags.h
@@ -1,12 +1,28 @@
 #pragma once
 
+#include "functional/cxx_functional_polyfill.h"
+
 namespace sqlite_orm {
     namespace internal {
         struct negatable_t {};
 
+        /**
+         *  Inherit from this class to support arithmetic types overloading
+         */
+        struct arithmetic_t {};
+
         /**
          *  Inherit from this class if target class can be chained with other conditions with '&&' and '||' operators
          */
         struct condition_t {};
+
+        /**
+         *  Specialize if a type participates as an argument to overloaded operators (arithmetic, conditional, negation, chaining)
+         */
+        template<class T, class SFINAE = void>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_operator_argument_v = false;
+
+        template<class T>
+        using is_operator_argument = polyfill::bool_constant<is_operator_argument_v<T>>;
     }
 }
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index efbe80286..9abe0a912 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -430,14 +430,14 @@ void depth_or_breadth_first() {
                                       select(columns(&Org::name, under_alice->*level + 1),
                                              join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
                                              order_by(2)))),
-                        select(substr("..........", 1, under_alice->*level * 3) || c(under_alice->*&Org::name)));
+                        select(substr("..........", 1, under_alice->*level * 3) || under_alice->*&Org::name));
 #else
         auto ast =
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
                                                        select(columns(&Org::name, column<cte_1>(2_colalias) + 1),
                                                               join<cte_1>(on(column<cte_1>(1_colalias) == &Org::boss)),
                                                               order_by(2)))),
-                 select(substr("..........", 1, column<cte_1>(2_colalias) * 3) || c(column<cte_1>(1_colalias))));
+                 select(substr("..........", 1, column<cte_1>(2_colalias) * 3) || column<cte_1>(1_colalias)));
 #endif
 
         string sql = storage.dump(ast);
@@ -471,14 +471,14 @@ void depth_or_breadth_first() {
                                       select(columns(&Org::name, under_alice->*level + 1),
                                              join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
                                              order_by(2).desc()))),
-                        select(substr("..........", 1, under_alice->*level * 3) || c(under_alice->*&Org::name)));
+                        select(substr("..........", 1, under_alice->*level * 3) || under_alice->*&Org::name));
 #else
         auto ast =
             with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
                                                        select(columns(&Org::name, column<cte_1>(2_colalias) + 1),
                                                               join<cte_1>(on(column<cte_1>(1_colalias) == &Org::boss)),
                                                               order_by(2).desc()))),
-                 select(substr("..........", 1, column<cte_1>(2_colalias) * 3) || c(column<cte_1>(1_colalias))));
+                 select(substr("..........", 1, column<cte_1>(2_colalias) * 3) || column<cte_1>(1_colalias)));
 #endif
 
         string sql = storage.dump(ast);
@@ -674,30 +674,30 @@ void sudoku() {
     constexpr auto lp = "lp"_col;
     constexpr auto s = "s"_col;
     constexpr auto ind = "ind"_col;
-    auto ast =
-        with(make_tuple(
-                 cte<input>(sud)(
-                     select("53..7....6..195....98....6.8...6...34..8.3..17...2...6.6....28....419..5....8..79")),
-                 cte<digits>(z, lp)(union_all(
-                     select(columns("1", 1)),
-                     select(columns(cast<string>(digits->*lp + 1), digits->*lp + 1), where(digits->*lp < 9)))),
-                 cte<x>(s, ind)(union_all(
-                     select(columns(input->*sud, instr(input->*sud, "."))),
-                     select(columns(substr(x->*s, 1, x->*ind - 1) || c(z) || substr(x->*s, x->*ind + 1),
-                                    instr(substr(x->*s, 1, x->*ind - 1) || c(z) || substr(x->*s, x->*ind + 1), ".")),
-                            where(x->*ind > 0 and
-                                  not exists(select(
-                                      1 >>= lp,
-                                      from<digits>(),
-                                      where(is_equal(z_alias->*z, substr(x->*s, ((x->*ind - 1) / 9) * 9 + lp, 1)) or
-                                            is_equal(z_alias->*z,
-                                                     substr(x->*s, ((x->*ind - 1) % 9) + (lp - c(1)) * 9 + 1, 1)) or
-                                            is_equal(z_alias->*z,
-                                                     substr(x->*s,
-                                                            (((x->*ind - 1) / 3) % 3) * 3 + ((x->*ind - 1) / 27) * 27 +
-                                                                lp + ((lp - c(1)) / 3) * 6,
-                                                            1)))))))))),
-             select(x->*s, where(x->*ind == 0)));
+    auto ast = with(
+        make_tuple(
+            cte<input>(sud)(
+                select("53..7....6..195....98....6.8...6...34..8.3..17...2...6.6....28....419..5....8..79")),
+            cte<digits>(z, lp)(
+                union_all(select(columns("1", 1)),
+                          select(columns(cast<string>(digits->*lp + 1), digits->*lp + 1), where(digits->*lp < 9)))),
+            cte<x>(s, ind)(union_all(
+                select(columns(input->*sud, instr(input->*sud, "."))),
+                select(
+                    columns(substr(x->*s, 1, x->*ind - 1) || z || substr(x->*s, x->*ind + 1),
+                            instr(substr(x->*s, 1, x->*ind - 1) || z || substr(x->*s, x->*ind + 1), ".")),
+                    where(x->*ind > 0 and
+                          not exists(select(
+                              1 >>= lp,
+                              from<digits>(),
+                              where(is_equal(z_alias->*z, substr(x->*s, ((x->*ind - 1) / 9) * 9 + lp, 1)) or
+                                    is_equal(z_alias->*z, substr(x->*s, ((x->*ind - 1) % 9) + (lp - 1) * 9 + 1, 1)) or
+                                    is_equal(z_alias->*z,
+                                             substr(x->*s,
+                                                    (((x->*ind - 1) / 3) % 3) * 3 + ((x->*ind - 1) / 27) * 27 + lp +
+                                                        ((lp - 1) / 3) * 6,
+                                                    1)))))))))),
+        select(x->*s, where(x->*ind == 0)));
 
     string sql = storage.dump(ast);
 
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 4a2b688a1..b8daf1fda 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -1950,14 +1950,206 @@ namespace sqlite_orm {
 
 // #include "tags.h"
 
+// #include "functional/cxx_functional_polyfill.h"
+
+#include <functional>
+#if __cpp_lib_invoke < 201411L
+#include <type_traits>  //  std::enable_if, std::is_member_object_pointer, std::is_member_function_pointer
+#endif
+#include <utility>  //  std::forward
+
+#if __cpp_lib_invoke < 201411L
+// #include "cxx_type_traits_polyfill.h"
+
+#endif
+// #include "../member_traits/member_traits.h"
+
+#include <type_traits>  //  std::enable_if, std::is_function, std::true_type, std::false_type
+
+// #include "../functional/cxx_universal.h"
+
+// #include "../functional/cxx_type_traits_polyfill.h"
+
+namespace sqlite_orm {
+    namespace internal {
+        // SFINAE friendly trait to get a member object pointer's field type
+        template<class T>
+        struct object_field_type {};
+
+        template<class T>
+        using object_field_type_t = typename object_field_type<T>::type;
+
+        template<class F, class O>
+        struct object_field_type<F O::*> : std::enable_if<!std::is_function<F>::value, F> {};
+
+        // SFINAE friendly trait to get a member function pointer's field type (i.e. unqualified return type)
+        template<class T>
+        struct getter_field_type {};
+
+        template<class T>
+        using getter_field_type_t = typename getter_field_type<T>::type;
+
+        template<class T, class O>
+        struct getter_field_type<T O::*> : getter_field_type<T> {};
+
+        template<class F>
+        struct getter_field_type<F(void) const> : polyfill::remove_cvref<F> {};
+
+        template<class F>
+        struct getter_field_type<F(void)> : polyfill::remove_cvref<F> {};
+
+#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
+        template<class F>
+        struct getter_field_type<F(void) const noexcept> : polyfill::remove_cvref<F> {};
+
+        template<class F>
+        struct getter_field_type<F(void) noexcept> : polyfill::remove_cvref<F> {};
+#endif
+
+        // SFINAE friendly trait to get a member function pointer's field type (i.e. unqualified parameter type)
+        template<class T>
+        struct setter_field_type {};
+
+        template<class T>
+        using setter_field_type_t = typename setter_field_type<T>::type;
+
+        template<class T, class O>
+        struct setter_field_type<T O::*> : setter_field_type<T> {};
+
+        template<class F>
+        struct setter_field_type<void(F)> : polyfill::remove_cvref<F> {};
+
+#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
+        template<class F>
+        struct setter_field_type<void(F) noexcept> : polyfill::remove_cvref<F> {};
+#endif
+
+        template<class T, class SFINAE = void>
+        struct is_getter : std::false_type {};
+        template<class T>
+        struct is_getter<T, polyfill::void_t<getter_field_type_t<T>>> : std::true_type {};
+
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_getter_v = is_getter<T>::value;
+
+        template<class T, class SFINAE = void>
+        struct is_setter : std::false_type {};
+        template<class T>
+        struct is_setter<T, polyfill::void_t<setter_field_type_t<T>>> : std::true_type {};
+
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_setter_v = is_setter<T>::value;
+
+        template<class T>
+        struct member_field_type : object_field_type<T>, getter_field_type<T>, setter_field_type<T> {};
+
+        template<class T>
+        using member_field_type_t = typename member_field_type<T>::type;
+
+        template<class T>
+        struct member_object_type {};
+
+        template<class F, class O>
+        struct member_object_type<F O::*> : polyfill::type_identity<O> {};
+
+        template<class T>
+        using member_object_type_t = typename member_object_type<T>::type;
+    }
+}
+
+namespace sqlite_orm {
+    namespace internal {
+        namespace polyfill {
+            // C++20 or later (unfortunately there's no feature test macro).
+            // Stupidly, clang says C++20, but `std::identity` was only implemented in libc++ 13 and libstd++-v3 10
+            // (the latter is used on Linux).
+            // gcc got it right and reports C++20 only starting with v10.
+            // The check here doesn't care and checks the library versions in use.
+            //
+            // Another way of detection would be the constrained algorithms feature macro __cpp_lib_ranges
+#if(__cplusplus >= 202002L) &&                                                                                         \
+    ((!_LIBCPP_VERSION || _LIBCPP_VERSION >= 13000) && (!_GLIBCXX_RELEASE || _GLIBCXX_RELEASE >= 10))
+            using std::identity;
+#else
+            struct identity {
+                template<class T>
+                constexpr T&& operator()(T&& v) const noexcept {
+                    return std::forward<T>(v);
+                }
+
+                using is_transparent = int;
+            };
+#endif
+
+#if __cpp_lib_invoke >= 201411L
+            using std::invoke;
+#else
+            // pointer-to-data-member+object
+            template<class Callable,
+                     class Object,
+                     class... Args,
+                     class Unqualified = remove_cvref_t<Callable>,
+                     std::enable_if_t<std::is_member_object_pointer<Unqualified>::value, bool> = true>
+            decltype(auto) invoke(Callable&& callable, Object&& object, Args&&... args) {
+                return std::forward<Object>(object).*callable;
+            }
+
+            // pointer-to-member-function+object
+            template<class Callable,
+                     class Object,
+                     class... Args,
+                     class Unqualified = remove_cvref_t<Callable>,
+                     std::enable_if_t<std::is_member_function_pointer<Unqualified>::value, bool> = true>
+            decltype(auto) invoke(Callable&& callable, Object&& object, Args&&... args) {
+                return (std::forward<Object>(object).*callable)(std::forward<Args>(args)...);
+            }
+
+            // pointer-to-member+reference-wrapped object (expect `reference_wrapper::*`)
+            template<class Callable,
+                     class Object,
+                     class... Args,
+                     std::enable_if_t<polyfill::negation_v<polyfill::is_specialization_of<
+                                          member_object_type_t<std::remove_reference_t<Callable>>,
+                                          std::reference_wrapper>>,
+                                      bool> = true>
+            decltype(auto) invoke(Callable&& callable, std::reference_wrapper<Object> wrapper, Args&&... args) {
+                return invoke(std::forward<Callable>(callable), wrapper.get(), std::forward<Args>(args)...);
+            }
+
+            // functor
+            template<class Callable, class... Args>
+            decltype(auto) invoke(Callable&& callable, Args&&... args) {
+                return std::forward<Callable>(callable)(std::forward<Args>(args)...);
+            }
+#endif
+        }
+    }
+
+    namespace polyfill = internal::polyfill;
+}
+
 namespace sqlite_orm {
     namespace internal {
         struct negatable_t {};
 
+        /**
+         *  Inherit from this class to support arithmetic types overloading
+         */
+        struct arithmetic_t {};
+
         /**
          *  Inherit from this class if target class can be chained with other conditions with '&&' and '||' operators
          */
         struct condition_t {};
+
+        /**
+         *  Specialize if a type participates as an argument to overloaded operators (arithmetic, conditional, negation, chaining)
+         */
+        template<class T, class SFINAE = void>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_operator_argument_v = false;
+
+        template<class T>
+        using is_operator_argument = polyfill::bool_constant<is_operator_argument_v<T>>;
     }
 }
 
@@ -1995,11 +2187,6 @@ namespace sqlite_orm {
 
     namespace internal {
 
-        /**
-         *  Inherit this class to support arithmetic types overloading
-         */
-        struct arithmetic_t {};
-
         template<class L, class R, class... Ds>
         struct binary_operator : Ds... {
             using left_type = L;
@@ -2172,10 +2359,6 @@ namespace sqlite_orm {
          */
         template<class L, class R>
         struct is_assign_t<assign_t<L, R>> : public std::true_type {};
-
-        template<class L, class... Args>
-        struct in_t;
-
     }
 
     /**
@@ -2280,99 +2463,6 @@ namespace sqlite_orm {
 
 // #include "member_traits/member_traits.h"
 
-#include <type_traits>  //  std::enable_if, std::is_function, std::true_type, std::false_type
-
-// #include "../functional/cxx_universal.h"
-
-// #include "../functional/cxx_type_traits_polyfill.h"
-
-namespace sqlite_orm {
-    namespace internal {
-        // SFINAE friendly trait to get a member object pointer's field type
-        template<class T>
-        struct object_field_type {};
-
-        template<class T>
-        using object_field_type_t = typename object_field_type<T>::type;
-
-        template<class F, class O>
-        struct object_field_type<F O::*> : std::enable_if<!std::is_function<F>::value, F> {};
-
-        // SFINAE friendly trait to get a member function pointer's field type (i.e. unqualified return type)
-        template<class T>
-        struct getter_field_type {};
-
-        template<class T>
-        using getter_field_type_t = typename getter_field_type<T>::type;
-
-        template<class T, class O>
-        struct getter_field_type<T O::*> : getter_field_type<T> {};
-
-        template<class F>
-        struct getter_field_type<F(void) const> : polyfill::remove_cvref<F> {};
-
-        template<class F>
-        struct getter_field_type<F(void)> : polyfill::remove_cvref<F> {};
-
-#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
-        template<class F>
-        struct getter_field_type<F(void) const noexcept> : polyfill::remove_cvref<F> {};
-
-        template<class F>
-        struct getter_field_type<F(void) noexcept> : polyfill::remove_cvref<F> {};
-#endif
-
-        // SFINAE friendly trait to get a member function pointer's field type (i.e. unqualified parameter type)
-        template<class T>
-        struct setter_field_type {};
-
-        template<class T>
-        using setter_field_type_t = typename setter_field_type<T>::type;
-
-        template<class T, class O>
-        struct setter_field_type<T O::*> : setter_field_type<T> {};
-
-        template<class F>
-        struct setter_field_type<void(F)> : polyfill::remove_cvref<F> {};
-
-#ifdef SQLITE_ORM_NOTHROW_ALIASES_SUPPORTED
-        template<class F>
-        struct setter_field_type<void(F) noexcept> : polyfill::remove_cvref<F> {};
-#endif
-
-        template<class T, class SFINAE = void>
-        struct is_getter : std::false_type {};
-        template<class T>
-        struct is_getter<T, polyfill::void_t<getter_field_type_t<T>>> : std::true_type {};
-
-        template<class T>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_getter_v = is_getter<T>::value;
-
-        template<class T, class SFINAE = void>
-        struct is_setter : std::false_type {};
-        template<class T>
-        struct is_setter<T, polyfill::void_t<setter_field_type_t<T>>> : std::true_type {};
-
-        template<class T>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_setter_v = is_setter<T>::value;
-
-        template<class T>
-        struct member_field_type : object_field_type<T>, getter_field_type<T>, setter_field_type<T> {};
-
-        template<class T>
-        using member_field_type_t = typename member_field_type<T>::type;
-
-        template<class T>
-        struct member_object_type {};
-
-        template<class F, class O>
-        struct member_object_type<F O::*> : polyfill::type_identity<O> {};
-
-        template<class T>
-        using member_object_type_t = typename member_object_type<T>::type;
-    }
-}
-
 // #include "type_is_nullable.h"
 
 // #include "constraints.h"
@@ -2980,19 +3070,23 @@ namespace sqlite_orm {
 // #include "expression.h"
 
 #include <tuple>
-#include <utility>  //  std::move, std::forward
+#include <type_traits>  //  std::enable_if
+#include <utility>  //  std::move, std::forward, std::declval
 // #include "functional/cxx_optional.h"
 
 // #include "functional/cxx_universal.h"
 
-// #include "tags.h"
+// #include "functional/cxx_type_traits_polyfill.h"
 
-// #include "operators.h"
+// #include "tags.h"
 
 namespace sqlite_orm {
 
     namespace internal {
 
+        template<class L, class... Args>
+        struct in_t;
+
         template<class L, class R>
         struct and_condition_t;
 
@@ -3000,14 +3094,12 @@ namespace sqlite_orm {
         struct or_condition_t;
 
         /**
-         *  Is not an operator but a result of c(...) function. Has operator= overloaded which returns assign_t
+         *  Result of c(...) function. Has operator= overloaded which returns assign_t
          */
         template<class T>
-        struct expression_t : condition_t {
+        struct expression_t {
             T value;
 
-            expression_t(T value_) : value(std::move(value_)) {}
-
             template<class R>
             assign_t<T, R> operator=(R r) const {
                 return {this->value, std::move(r)};
@@ -3023,12 +3115,12 @@ namespace sqlite_orm {
 #endif
             template<class... Args>
             in_t<T, Args...> in(Args... args) const {
-                return {this->value, std::make_tuple(std::forward<Args>(args)...), false};
+                return {this->value, {std::forward<Args>(args)...}, false};
             }
 
             template<class... Args>
             in_t<T, Args...> not_in(Args... args) const {
-                return {this->value, std::make_tuple(std::forward<Args>(args)...), true};
+                return {this->value, {std::forward<Args>(args)...}, true};
             }
 
             template<class R>
@@ -3042,6 +3134,10 @@ namespace sqlite_orm {
             }
         };
 
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool
+            is_operator_argument_v<T, std::enable_if_t<polyfill::is_specialization_of_v<T, expression_t>>> = true;
+
         template<class T>
         T get_from_expression(T value) {
             return std::move(value);
@@ -3066,6 +3162,145 @@ namespace sqlite_orm {
     }
 }
 
+// #include "column_pointer.h"
+
+#include <type_traits>  //  std::enable_if, std::remove_const
+#include <utility>  // std::move
+
+// #include "functional/cxx_core_features.h"
+
+// #include "functional/cxx_type_traits_polyfill.h"
+
+// #include "type_traits.h"
+
+// #include "alias_traits.h"
+
+// #include "tags.h"
+
+namespace sqlite_orm {
+    namespace internal {
+        /**
+         *  This class is used to store explicit mapped type T and its column descriptor (member pointer/getter/setter).
+         *  Is useful when mapped type is derived from other type and base class has members mapped to a storage.
+         */
+        template<class T, class F>
+        struct column_pointer {
+            using self = column_pointer<T, F>;
+            using type = T;
+            using field_type = F;
+
+            field_type field;
+        };
+
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_column_pointer_v = polyfill::is_specialization_of_v<T, column_pointer>;
+
+        template<class T>
+        using is_column_pointer = polyfill::bool_constant<is_column_pointer_v<T>>;
+
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_operator_argument_v<T, std::enable_if_t<is_column_pointer_v<T>>> = true;
+
+#ifdef SQLITE_ORM_WITH_CTE
+        template<class A>
+        struct alias_holder;
+#endif
+    }
+
+    /**
+     *  Explicitly refer to a column, used in contexts
+     *  where the automatic object mapping deduction needs to be overridden.
+     *
+     *  Example:
+     *  struct BaseType : { int64 id; };
+     *  struct MyType : BaseType { ... };
+     *  storage.select(column<MyType>(&BaseType::id));
+     */
+    template<class Object, class F, internal::satisfies_not<internal::is_recordset_alias, Object> = true>
+    internal::column_pointer<Object, F> column(F field) {
+        return {std::move(field)};
+    }
+
+#ifdef SQLITE_ORM_WITH_CTE
+    /**
+     *  Explicitly refer to a column alias mapped into a CTE or subquery.
+     *
+     *  Example:
+     *  struct Object { ... };
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
+     *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
+     *  storage.with(cte<cte_1>(colalias_a{})(select(&Object::id)), select(column<cte_1>(colalias_a{})));
+     *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
+     */
+    template<class Moniker, class F, internal::satisfies<internal::is_recordset_alias, Moniker> = true>
+    constexpr auto column(F field) {
+        using namespace ::sqlite_orm::internal;
+
+        static_assert(is_cte_moniker_v<Moniker>, "`Moniker' must be a CTE moniker");
+
+        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
+            static_assert(is_column_alias_v<type_t<F>>);
+            return column_pointer<Moniker, F>{{}};
+        } else if constexpr(is_column_alias_v<F>) {
+            return column_pointer<Moniker, alias_holder<F>>{{}};
+        } else {
+            return column_pointer<Moniker, F>{std::move(field)};
+        }
+        (void)field;
+    }
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Explicitly refer to a column mapped into a CTE or subquery.
+     *
+     *  Example:
+     *  struct Object { ... };
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select("z"_cte->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select("z"_cte->*"a"_col));
+     */
+    template<orm_cte_moniker auto moniker, class F>
+    constexpr auto column([[maybe_unused]] F field) {
+        using namespace ::sqlite_orm::internal;
+        using Moniker = std::remove_const_t<decltype(moniker)>;
+
+        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
+            static_assert(is_column_alias_v<type_t<F>>);
+            return column_pointer<Moniker, F>{{}};
+        } else if constexpr(is_column_alias_v<F>) {
+            return column_pointer<Moniker, alias_holder<F>>{{}};
+        } else {
+            return column_pointer<Moniker, F>{std::move(field)};
+        }
+    }
+#endif
+
+    /**
+     *  Explicitly refer to a column mapped into a CTE or subquery.
+     *
+     *  Example:
+     *  struct Object { ... };
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
+     */
+    template<class Moniker, class F, internal::satisfies<internal::is_cte_moniker, Moniker> = true>
+    constexpr auto operator->*(const Moniker& /*moniker*/, F field) {
+        using namespace ::sqlite_orm::internal;
+
+        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
+            static_assert(is_column_alias_v<type_t<F>>);
+            return column_pointer<Moniker, F>{{}};
+        } else if constexpr(is_column_alias_v<F>) {
+            return column_pointer<Moniker, alias_holder<F>>{{}};
+        } else {
+            return column_pointer<Moniker, F>{std::move(field)};
+        }
+        (void)field;
+    }
+#endif
+}
+// #include "tags.h"
+
 // #include "type_printer.h"
 
 // #include "literal.h"
@@ -3090,9 +3325,6 @@ namespace sqlite_orm {
 
     namespace internal {
 
-        template<class T, class F>
-        struct column_pointer;
-
         struct limit_string {
             operator std::string() const {
                 return "LIMIT";
@@ -3897,25 +4129,22 @@ namespace sqlite_orm {
     }
 #endif
 
-    template<class T, internal::satisfies<std::is_base_of, internal::negatable_t, T> = true>
-    internal::negated_condition_t<T> operator!(T arg) {
-        return {std::move(arg)};
-    }
-
-    // Deliberately put operators for `expression_t`, `column_pointer` into the internal namespace
+    // Intentionally place operators for types classified as arithmetic or general operator arguments in the internal namespace
     // to facilitate ADL (Argument Dependent Lookup)
     namespace internal {
-        /**
-         *  Cute operators for columns
-         */
+        template<class T,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<negatable_t, T>, is_operator_argument<T>>,
+                                  bool> = true>
+        negated_condition_t<T> operator!(T arg) {
+            return {std::move(arg)};
+        }
+
         template<class L,
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         less_than_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator<(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -3925,10 +4154,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         less_or_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator<=(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -3938,10 +4165,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         greater_than_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator>(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -3951,10 +4176,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         greater_or_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator>=(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -3962,10 +4185,10 @@ namespace sqlite_orm {
 
         template<class L,
                  class R,
-                 std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
+                                                          std::is_base_of<arithmetic_t, R>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         is_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator==(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -3975,10 +4198,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         is_not_equal_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator!=(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -3986,14 +4207,12 @@ namespace sqlite_orm {
 
         template<class L,
                  class R,
-                 std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>,
-                                                          std::is_base_of<conc_string, L>,
-                                                          std::is_base_of<conc_string, R>>,
+                 std::enable_if_t<polyfill::disjunction_v<std::is_base_of<condition_t, L>,
+                                                          std::is_base_of<condition_t, R>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
-        conc_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator||(L l, R r) {
+        and_condition_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator&&(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
         }
 
@@ -4002,23 +4221,24 @@ namespace sqlite_orm {
             class R,
             std::enable_if_t<polyfill::disjunction_v<std::is_base_of<condition_t, L>, std::is_base_of<condition_t, R>>,
                              bool> = true>
-        and_condition_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator&&(L l, R r) {
+        or_condition_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator||(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
         }
 
         template<class L,
                  class R,
-                 std::enable_if_t<
-                     polyfill::conjunction_v<
-                         polyfill::disjunction<std::is_base_of<condition_t, L>, std::is_base_of<condition_t, R>>,
-                         // exclude concatenated expressions
-                         polyfill::negation<polyfill::disjunction<polyfill::is_specialization_of<L, expression_t>,
-                                                                  polyfill::is_specialization_of<R, expression_t>>>>,
-                     bool> = true>
-        or_condition_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator||(L l, R r) {
+                 std::enable_if_t<polyfill::conjunction_v<
+                                      polyfill::disjunction<std::is_base_of<conc_string, L>,
+                                                            std::is_base_of<conc_string, R>,
+                                                            is_operator_argument<L>,
+                                                            is_operator_argument<R>>,
+                                      // exclude conditions
+                                      polyfill::negation<polyfill::disjunction<std::is_base_of<condition_t, L>,
+                                                                               std::is_base_of<condition_t, R>>>>,
+                                  bool> = true>
+        conc_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator||(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
         }
-
     }
 
     template<class F, class O>
@@ -4361,144 +4581,9 @@ namespace sqlite_orm {
 
 // #include "alias_traits.h"
 
-// #include "column_pointer.h"
-
-#include <type_traits>  //  std::remove_const
-#include <utility>  //  std::move
-
-// #include "functional/cxx_core_features.h"
-
-// #include "functional/cxx_type_traits_polyfill.h"
-
-// #include "type_traits.h"
-
-// #include "conditions.h"
-
-// #include "alias_traits.h"
-
 // #include "tags.h"
 
-namespace sqlite_orm {
-    namespace internal {
-        /**
-         *  This class is used to store explicit mapped type T and its column descriptor (member pointer/getter/setter).
-         *  Is useful when mapped type is derived from other type and base class has members mapped to a storage.
-         */
-        template<class T, class F>
-        struct column_pointer : condition_t {
-            using self = column_pointer<T, F>;
-            using type = T;
-            using field_type = F;
-
-            field_type field;
-
-            column_pointer(field_type field) : field{field} {}
-        };
-
-        template<class T>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_column_pointer_v = polyfill::is_specialization_of_v<T, column_pointer>;
-
-        template<class T>
-        using is_column_pointer = polyfill::bool_constant<is_column_pointer_v<T>>;
-
-#ifdef SQLITE_ORM_WITH_CTE
-        template<class A>
-        struct alias_holder;
-#endif
-    }
-
-    /**
-     *  Explicitly refer to a column, used in contexts
-     *  where the automatic object mapping deduction needs to be overridden.
-     *
-     *  Example:
-     *  struct BaseType : { int64 id; };
-     *  struct MyType : BaseType { ... };
-     *  storage.select(column<MyType>(&BaseType::id));
-     */
-    template<class Object, class F, internal::satisfies_not<internal::is_recordset_alias, Object> = true>
-    internal::column_pointer<Object, F> column(F field) {
-        return {std::move(field)};
-    }
-
-#ifdef SQLITE_ORM_WITH_CTE
-    /**
-     *  Explicitly refer to a column alias mapped into a CTE or subquery.
-     *
-     *  Example:
-     *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
-     *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
-     *  storage.with(cte<cte_1>(colalias_a{})(select(&Object::id)), select(column<cte_1>(colalias_a{})));
-     *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
-     */
-    template<class Moniker, class F, internal::satisfies<internal::is_recordset_alias, Moniker> = true>
-    constexpr auto column(F field) {
-        using namespace ::sqlite_orm::internal;
-
-        static_assert(is_cte_moniker_v<Moniker>, "`Moniker' must be a CTE moniker");
-
-        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
-            static_assert(is_column_alias_v<type_t<F>>);
-            return column_pointer<Moniker, F>{{}};
-        } else if constexpr(is_column_alias_v<F>) {
-            return column_pointer<Moniker, alias_holder<F>>{{}};
-        } else {
-            return column_pointer<Moniker, F>{std::move(field)};
-        }
-        (void)field;
-    }
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    /**
-     *  Explicitly refer to a column mapped into a CTE or subquery.
-     *
-     *  Example:
-     *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select("z"_cte->*&Object::id));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select("z"_cte->*"a"_col));
-     */
-    template<orm_cte_moniker auto moniker, class F>
-    constexpr auto column([[maybe_unused]] F field) {
-        using namespace ::sqlite_orm::internal;
-        using Moniker = std::remove_const_t<decltype(moniker)>;
-
-        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
-            static_assert(is_column_alias_v<type_t<F>>);
-            return column_pointer<Moniker, F>{{}};
-        } else if constexpr(is_column_alias_v<F>) {
-            return column_pointer<Moniker, alias_holder<F>>{{}};
-        } else {
-            return column_pointer<Moniker, F>{std::move(field)};
-        }
-    }
-#endif
-
-    /**
-     *  Explicitly refer to a column mapped into a CTE or subquery.
-     *
-     *  Example:
-     *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
-     */
-    template<class Moniker, class F, internal::satisfies<internal::is_cte_moniker, Moniker> = true>
-    constexpr auto operator->*(const Moniker& /*moniker*/, F field) {
-        using namespace ::sqlite_orm::internal;
-
-        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
-            static_assert(is_column_alias_v<type_t<F>>);
-            return column_pointer<Moniker, F>{{}};
-        } else if constexpr(is_column_alias_v<F>) {
-            return column_pointer<Moniker, alias_holder<F>>{{}};
-        } else {
-            return column_pointer<Moniker, F>{std::move(field)};
-        }
-        (void)field;
-    }
-#endif
-}
+// #include "column_pointer.h"
 
 namespace sqlite_orm {
 
@@ -4525,6 +4610,9 @@ namespace sqlite_orm {
         consteval auto to_alias(std::index_sequence<Idx...>) {
             return Alias<t.id[Idx]...>{};
         }
+
+        template<class T>
+        inline constexpr bool is_operator_argument_v<T, std::enable_if_t<orm_column_alias<T>>> = true;
 #endif
 
         /**
@@ -4625,7 +4713,7 @@ namespace sqlite_orm {
         };
 
         /**
-         *  This is a common built-in class used for custom single-character column aliases.
+         *  Built-in column alias.
          *  For convenience there exist type aliases `colalias_a`, `colalias_b`, ...
          *  The easiest way to create a column alias is using `"xyz"_col`.
          */
@@ -4645,6 +4733,10 @@ namespace sqlite_orm {
             alias_holder(const T&) noexcept {}
         };
 
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool
+            is_operator_argument_v<T, std::enable_if_t<polyfill::is_specialization_of_v<T, alias_holder>>> = true;
+
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         template<char A, char... X>
         struct recordset_alias_builder {
@@ -4760,6 +4852,9 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /** 
+     *  Alias a column expression.
+     */
     template<orm_column_alias auto als, class E>
     auto as(E expression) {
         using A = std::remove_const_t<decltype(als)>;
@@ -4925,7 +5020,7 @@ namespace sqlite_orm {
 
 // #include "operators.h"
 
-// #include "expression.h"
+// #include "tags.h"
 
 // #include "ast/into.h"
 
@@ -6946,17 +7041,15 @@ namespace sqlite_orm {
     }
 #endif  //  SQLITE_ENABLE_JSON1
 
-    // Deliberately put operators for `arithmetic_t`, `expression_t`, `column_pointer` into the internal namespace
+    // Intentionally place operators for types classified as arithmetic or general operator arguments in the internal namespace
     // to facilitate ADL (Argument Dependent Lookup)
     namespace internal {
         template<class L,
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         add_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator+(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -6966,10 +7059,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         sub_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator-(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -6979,10 +7070,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         mul_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator*(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -6992,10 +7081,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         div_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator/(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -7005,10 +7092,8 @@ namespace sqlite_orm {
                  class R,
                  std::enable_if_t<polyfill::disjunction_v<std::is_base_of<arithmetic_t, L>,
                                                           std::is_base_of<arithmetic_t, R>,
-                                                          polyfill::is_specialization_of<L, expression_t>,
-                                                          polyfill::is_specialization_of<R, expression_t>,
-                                                          polyfill::is_specialization_of<L, column_pointer>,
-                                                          polyfill::is_specialization_of<R, column_pointer>>,
+                                                          is_operator_argument<L>,
+                                                          is_operator_argument<R>>,
                                   bool> = true>
         mod_t<unwrap_expression_t<L>, unwrap_expression_t<R>> operator%(L l, R r) {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
@@ -7186,8 +7271,6 @@ namespace sqlite_orm {
 
 // #include "alias_traits.h"
 
-// #include "column_pointer.h"
-
 namespace sqlite_orm {
 
     namespace internal {
@@ -8605,89 +8688,6 @@ namespace sqlite_orm {
 
 // #include "functional/cxx_functional_polyfill.h"
 
-#include <functional>
-#if __cpp_lib_invoke < 201411L
-#include <type_traits>  //  std::enable_if, std::is_member_object_pointer, std::is_member_function_pointer
-#endif
-#include <utility>  //  std::forward
-
-#if __cpp_lib_invoke < 201411L
-// #include "cxx_type_traits_polyfill.h"
-
-#endif
-// #include "../member_traits/member_traits.h"
-
-namespace sqlite_orm {
-    namespace internal {
-        namespace polyfill {
-            // C++20 or later (unfortunately there's no feature test macro).
-            // Stupidly, clang says C++20, but `std::identity` was only implemented in libc++ 13 and libstd++-v3 10
-            // (the latter is used on Linux).
-            // gcc got it right and reports C++20 only starting with v10.
-            // The check here doesn't care and checks the library versions in use.
-            //
-            // Another way of detection would be the constrained algorithms feature macro __cpp_lib_ranges
-#if(__cplusplus >= 202002L) &&                                                                                         \
-    ((!_LIBCPP_VERSION || _LIBCPP_VERSION >= 13000) && (!_GLIBCXX_RELEASE || _GLIBCXX_RELEASE >= 10))
-            using std::identity;
-#else
-            struct identity {
-                template<class T>
-                constexpr T&& operator()(T&& v) const noexcept {
-                    return std::forward<T>(v);
-                }
-
-                using is_transparent = int;
-            };
-#endif
-
-#if __cpp_lib_invoke >= 201411L
-            using std::invoke;
-#else
-            // pointer-to-data-member+object
-            template<class Callable,
-                     class Object,
-                     class... Args,
-                     class Unqualified = remove_cvref_t<Callable>,
-                     std::enable_if_t<std::is_member_object_pointer<Unqualified>::value, bool> = true>
-            decltype(auto) invoke(Callable&& callable, Object&& object, Args&&... args) {
-                return std::forward<Object>(object).*callable;
-            }
-
-            // pointer-to-member-function+object
-            template<class Callable,
-                     class Object,
-                     class... Args,
-                     class Unqualified = remove_cvref_t<Callable>,
-                     std::enable_if_t<std::is_member_function_pointer<Unqualified>::value, bool> = true>
-            decltype(auto) invoke(Callable&& callable, Object&& object, Args&&... args) {
-                return (std::forward<Object>(object).*callable)(std::forward<Args>(args)...);
-            }
-
-            // pointer-to-member+reference-wrapped object (expect `reference_wrapper::*`)
-            template<class Callable,
-                     class Object,
-                     class... Args,
-                     std::enable_if_t<polyfill::negation_v<polyfill::is_specialization_of<
-                                          member_object_type_t<std::remove_reference_t<Callable>>,
-                                          std::reference_wrapper>>,
-                                      bool> = true>
-            decltype(auto) invoke(Callable&& callable, std::reference_wrapper<Object> wrapper, Args&&... args) {
-                return invoke(std::forward<Callable>(callable), wrapper.get(), std::forward<Args>(args)...);
-            }
-
-            // functor
-            template<class Callable, class... Args>
-            decltype(auto) invoke(Callable&& callable, Args&&... args) {
-                return std::forward<Callable>(callable)(std::forward<Args>(args)...);
-            }
-#endif
-        }
-    }
-
-    namespace polyfill = internal::polyfill;
-}
-
 // #include "is_std_ptr.h"
 
 // #include "tuple_helper/tuple_filter.h"
diff --git a/tests/static_tests/operators_adl.cpp b/tests/static_tests/operators_adl.cpp
index 3d08a1981..757ae8813 100644
--- a/tests/static_tests/operators_adl.cpp
+++ b/tests/static_tests/operators_adl.cpp
@@ -1,8 +1,14 @@
 #include <sqlite_orm/sqlite_orm.h>
 #include <catch2/catch_all.hpp>
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+using sqlite_orm::operator"" _col;
+#endif
 using sqlite_orm::and_;
 using sqlite_orm::c;
+using sqlite_orm::colalias_a;
+using sqlite_orm::column;
+using sqlite_orm::get;
 using sqlite_orm::or_;
 using sqlite_orm::internal::and_condition_t;
 using sqlite_orm::internal::binary_operator;
@@ -12,78 +18,98 @@ using sqlite_orm::internal::is_equal_t;
 using sqlite_orm::internal::is_not_equal_t;
 using sqlite_orm::internal::less_or_equal_t;
 using sqlite_orm::internal::less_than_t;
+using sqlite_orm::internal::negated_condition_t;
 using sqlite_orm::internal::or_condition_t;
 using sqlite_orm::polyfill::is_specialization_of_v;
 
+template<class E>
+void runTests(E expression) {
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression < 42), less_than_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 < expression), less_than_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression < expression), less_than_t>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression <= 42), less_or_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 <= expression), less_or_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression <= expression), less_or_equal_t>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression > 42), greater_than_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 > expression), greater_than_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression > expression), greater_than_t>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression >= 42), greater_or_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 >= expression), greater_or_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression >= expression), greater_or_equal_t>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression == 42), is_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 == expression), is_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression == expression), is_equal_t>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression != 42), is_not_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 != expression), is_not_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression != expression), is_not_equal_t>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression || 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 || expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression || expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression || 42 || 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression || 42 || c(42)), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 || (expression || 42)), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(c(42) || (expression || 42)), binary_operator>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression + 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 + expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression + expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 + expression + 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 + (expression + 42)), binary_operator>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression - 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 - expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression - expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 - expression - 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 - (expression - 42)), binary_operator>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression * 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 * expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression * expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 * expression * 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 * (expression * 42)), binary_operator>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression / 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 / expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression / expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 / expression / 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 / (expression / 42)), binary_operator>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression % 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 % expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression % expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 % expression % 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 % (expression % 42)), binary_operator>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression), negated_condition_t>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression || expression), or_condition_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression || 42), or_condition_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 || !expression), or_condition_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression && 43), and_condition_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression && expression), and_condition_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression && 42), and_condition_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 && !expression), and_condition_t>);
+
+    // conc_t + condition_t yield or_condition_t
+    STATIC_REQUIRE(is_specialization_of_v<decltype((expression && 42) || !expression), or_condition_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression || (expression && 42)), or_condition_t>);
+}
+
 TEST_CASE("ADL and expression operators") {
     struct User {
         int id;
     };
 
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) < 42), less_than_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 < c(&User::id)), less_than_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) < c(&User::id)), less_than_t>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) <= 42), less_or_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 <= c(&User::id)), less_or_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) <= c(&User::id)), less_or_equal_t>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) > 42), greater_than_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 > c(&User::id)), greater_than_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) > c(&User::id)), greater_than_t>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) >= 42), greater_or_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 >= c(&User::id)), greater_or_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) >= c(&User::id)), greater_or_equal_t>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) == 42), is_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 == c(&User::id)), is_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) == c(&User::id)), is_equal_t>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) != 42), is_not_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 != c(&User::id)), is_not_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) != c(&User::id)), is_not_equal_t>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) || 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 || c(&User::id)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) || c(&User::id)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) || 42 || 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) || 42 || c(42)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 || (c(&User::id) || 42)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(42) || (c(&User::id) || 42)), binary_operator>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) + 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 + c(&User::id)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) + c(&User::id)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 + c(&User::id) + 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 + (c(&User::id) + 42)), binary_operator>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) - 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 - c(&User::id)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) - c(&User::id)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 - c(&User::id) - 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 - (c(&User::id) - 42)), binary_operator>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) * 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 * c(&User::id)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) * c(&User::id)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 * c(&User::id) * 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 * (c(&User::id) * 42)), binary_operator>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) / 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 / c(&User::id)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) / c(&User::id)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 / c(&User::id) / 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 / (c(&User::id) / 42)), binary_operator>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) % 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 % c(&User::id)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(&User::id) % c(&User::id)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 % c(&User::id) % 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 % (c(&User::id) % 42)), binary_operator>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(or_(&User::id, 42) || 43), or_condition_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(43 || or_(&User::id, 42)), or_condition_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(and_(&User::id, 42) && 43), and_condition_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(43 && and_(&User::id, 42)), and_condition_t>);
+    runTests(c(&User::id));
+    runTests(column<User>(&User::id));
+    runTests(get<colalias_a>());
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    runTests("a"_col);
+#endif
 }

From 4bc87f6501d04dbb5dcd61cf90908e22fcfcba8d Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 9 Oct 2023 00:19:28 +0200
Subject: [PATCH 122/161] Added schema subfolder

---
 dev/cte_storage.h                             |  2 +-
 dev/eponymous_vtabs/dbstat.h                  |  4 +-
 dev/implementations/column_definitions.h      |  2 +-
 dev/implementations/table_definitions.h       |  4 +-
 dev/{ => schema}/column.h                     | 16 ++--
 dev/{ => schema}/index.h                      |  8 +-
 dev/{ => schema}/table.h                      | 28 +++---
 dev/{ => schema}/triggers.h                   |  4 +-
 dev/sqlite_schema_table.h                     |  4 +-
 dev/statement_serializer.h                    |  6 +-
 dev/storage.h                                 |  8 +-
 dev/storage_traits.h                          |  2 +-
 include/sqlite_orm/sqlite_orm.h               | 88 +++++++++----------
 .../sqlite_orm/sqlite_orm.h                   |  8 +-
 tests/CMakeLists.txt                          |  8 +-
 tests/{ => schema}/column_tests.cpp           |  0
 tests/{ => schema}/explicit_columns.cpp       |  0
 tests/{ => schema}/index_tests.cpp            |  0
 tests/{ => schema}/table_tests.cpp            |  0
 third_party/amalgamate/config.json            |  8 +-
 20 files changed, 100 insertions(+), 100 deletions(-)
 rename dev/{ => schema}/column.h (96%)
 rename dev/{ => schema}/index.h (95%)
 rename dev/{ => schema}/table.h (96%)
 rename dev/{ => schema}/triggers.h (99%)
 rename tests/{ => schema}/column_tests.cpp (100%)
 rename tests/{ => schema}/explicit_columns.cpp (100%)
 rename tests/{ => schema}/index_tests.cpp (100%)
 rename tests/{ => schema}/table_tests.cpp (100%)

diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index 672e68e63..3b9c7d18f 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -12,7 +12,7 @@
 #include "table_type_of.h"
 #include "column_result.h"
 #include "select_constraints.h"
-#include "table.h"
+#include "schema/table.h"
 #include "alias.h"
 #include "cte_types.h"
 #include "cte_column_names_collector.h"
diff --git a/dev/eponymous_vtabs/dbstat.h b/dev/eponymous_vtabs/dbstat.h
index 7ac28a428..1b674ed9b 100644
--- a/dev/eponymous_vtabs/dbstat.h
+++ b/dev/eponymous_vtabs/dbstat.h
@@ -4,8 +4,8 @@
 #include <string>  //  std::string
 #endif
 
-#include "../column.h"
-#include "../table.h"
+#include "../schema/column.h"
+#include "../schema/table.h"
 
 namespace sqlite_orm {
 #ifdef SQLITE_ENABLE_DBSTAT_VTAB
diff --git a/dev/implementations/column_definitions.h b/dev/implementations/column_definitions.h
index e98d99dce..f8b70f508 100644
--- a/dev/implementations/column_definitions.h
+++ b/dev/implementations/column_definitions.h
@@ -12,7 +12,7 @@
 #include "../tuple_helper/tuple_filter.h"
 #include "../tuple_helper/tuple_traits.h"
 #include "../default_value_extractor.h"
-#include "../column.h"
+#include "../schema/column.h"
 
 namespace sqlite_orm {
     namespace internal {
diff --git a/dev/implementations/table_definitions.h b/dev/implementations/table_definitions.h
index e94c50fdd..8e3c24268 100644
--- a/dev/implementations/table_definitions.h
+++ b/dev/implementations/table_definitions.h
@@ -9,8 +9,8 @@
 
 #include "../functional/cxx_universal.h"  //  ::size_t
 #include "../type_printer.h"
-#include "../column.h"
-#include "../table.h"
+#include "../schema/column.h"
+#include "../schema/table.h"
 
 namespace sqlite_orm {
     namespace internal {
diff --git a/dev/column.h b/dev/schema/column.h
similarity index 96%
rename from dev/column.h
rename to dev/schema/column.h
index a82c0a4dd..39d605834 100644
--- a/dev/column.h
+++ b/dev/schema/column.h
@@ -6,14 +6,14 @@
 #include <type_traits>  //  std::is_same, std::is_member_object_pointer
 #include <utility>  //  std::move
 
-#include "functional/cxx_universal.h"
-#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_is_nullable.h"
-#include "constraints.h"
+#include "../functional/cxx_universal.h"
+#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_is_nullable.h"
+#include "../constraints.h"
 
 namespace sqlite_orm {
 
diff --git a/dev/index.h b/dev/schema/index.h
similarity index 95%
rename from dev/index.h
rename to dev/schema/index.h
index efa5a9ff5..627c3fa6b 100644
--- a/dev/index.h
+++ b/dev/schema/index.h
@@ -4,10 +4,10 @@
 #include <string>  //  std::string
 #include <utility>  //  std::forward
 
-#include "functional/cxx_universal.h"
-#include "tuple_helper/tuple_filter.h"
-#include "indexed_column.h"
-#include "table_type_of.h"
+#include "../functional/cxx_universal.h"
+#include "../tuple_helper/tuple_filter.h"
+#include "../indexed_column.h"
+#include "../table_type_of.h"
 
 namespace sqlite_orm {
 
diff --git a/dev/table.h b/dev/schema/table.h
similarity index 96%
rename from dev/table.h
rename to dev/schema/table.h
index d7e9e6c60..fc6904465 100644
--- a/dev/table.h
+++ b/dev/schema/table.h
@@ -6,20 +6,20 @@
 #include <tuple>  //  std::tuple_element
 #include <utility>  //  std::forward, std::move
 
-#include "functional/cxx_universal.h"  //  ::size_t
-#include "functional/cxx_type_traits_polyfill.h"
-#include "functional/cxx_functional_polyfill.h"
-#include "functional/static_magic.h"
-#include "functional/mpl.h"
-#include "functional/index_sequence_util.h"
-#include "tuple_helper/tuple_filter.h"
-#include "tuple_helper/tuple_traits.h"
-#include "tuple_helper/tuple_iteration.h"
-#include "member_traits/member_traits.h"
-#include "typed_comparator.h"
-#include "type_traits.h"
-#include "constraints.h"
-#include "table_info.h"
+#include "../functional/cxx_universal.h"  //  ::size_t
+#include "../functional/cxx_type_traits_polyfill.h"
+#include "../functional/cxx_functional_polyfill.h"
+#include "../functional/static_magic.h"
+#include "../functional/mpl.h"
+#include "../functional/index_sequence_util.h"
+#include "../tuple_helper/tuple_filter.h"
+#include "../tuple_helper/tuple_traits.h"
+#include "../tuple_helper/tuple_iteration.h"
+#include "../member_traits/member_traits.h"
+#include "../typed_comparator.h"
+#include "../type_traits.h"
+#include "../constraints.h"
+#include "../table_info.h"
 #include "column.h"
 
 namespace sqlite_orm {
diff --git a/dev/triggers.h b/dev/schema/triggers.h
similarity index 99%
rename from dev/triggers.h
rename to dev/schema/triggers.h
index c85e65a13..a090c4015 100644
--- a/dev/triggers.h
+++ b/dev/schema/triggers.h
@@ -5,8 +5,8 @@
 #include <string>
 #include <tuple>
 
-#include "functional/cxx_universal.h"
-#include "optional_container.h"
+#include "../functional/cxx_universal.h"
+#include "../optional_container.h"
 
 // NOTE Idea : Maybe also implement a custom trigger system to call a c++ callback when a trigger triggers ?
 // (Could be implemented with a normal trigger that insert or update an internal table and then retreive
diff --git a/dev/sqlite_schema_table.h b/dev/sqlite_schema_table.h
index d84a6c030..8063fa072 100644
--- a/dev/sqlite_schema_table.h
+++ b/dev/sqlite_schema_table.h
@@ -2,8 +2,8 @@
 
 #include <string>  //  std::string
 
-#include "column.h"
-#include "table.h"
+#include "schema/column.h"
+#include "schema/table.h"
 #include "alias.h"
 
 namespace sqlite_orm {
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index bc4931089..7c27bee53 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -24,7 +24,7 @@
 #include "core_functions.h"
 #include "constraints.h"
 #include "conditions.h"
-#include "column.h"
+#include "schema/column.h"
 #include "indexed_column.h"
 #include "function.h"
 #include "prepared_statement.h"
@@ -40,9 +40,9 @@
 #include "serializing_util.h"
 #include "statement_binder.h"
 #include "values.h"
-#include "triggers.h"
+#include "schema/triggers.h"
 #include "table_type_of.h"
-#include "index.h"
+#include "schema/index.h"
 #include "util.h"
 
 namespace sqlite_orm {
diff --git a/dev/storage.h b/dev/storage.h
index 628137e31..fd21e06a1 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -45,11 +45,11 @@
 #include "prepared_statement.h"
 #include "expression_object_type.h"
 #include "statement_serializer.h"
-#include "triggers.h"
+#include "schema/triggers.h"
 #include "object_from_column_builder.h"
-#include "table.h"
-#include "column.h"
-#include "index.h"
+#include "schema/table.h"
+#include "schema/column.h"
+#include "schema/index.h"
 #include "cte_storage.h"
 #include "util.h"
 #include "serializing_util.h"
diff --git a/dev/storage_traits.h b/dev/storage_traits.h
index 109db5a01..4fc1f33ed 100644
--- a/dev/storage_traits.h
+++ b/dev/storage_traits.h
@@ -7,7 +7,7 @@
 #include "tuple_helper/tuple_transformer.h"
 #include "type_traits.h"
 #include "storage_lookup.h"
-#include "column.h"
+#include "schema/column.h"
 
 namespace sqlite_orm {
     namespace internal {
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index b8daf1fda..7e9127315 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -2451,21 +2451,21 @@ namespace sqlite_orm {
 #include <type_traits>  //  std::is_same, std::is_member_object_pointer
 #include <utility>  //  std::move
 
-// #include "functional/cxx_universal.h"
+// #include "../functional/cxx_universal.h"
 
-// #include "functional/cxx_type_traits_polyfill.h"
+// #include "../functional/cxx_type_traits_polyfill.h"
 
-// #include "tuple_helper/tuple_traits.h"
+// #include "../tuple_helper/tuple_traits.h"
 
-// #include "tuple_helper/tuple_filter.h"
+// #include "../tuple_helper/tuple_filter.h"
 
-// #include "type_traits.h"
+// #include "../type_traits.h"
 
-// #include "member_traits/member_traits.h"
+// #include "../member_traits/member_traits.h"
 
-// #include "type_is_nullable.h"
+// #include "../type_is_nullable.h"
 
-// #include "constraints.h"
+// #include "../constraints.h"
 
 namespace sqlite_orm {
 
@@ -7927,9 +7927,9 @@ namespace sqlite_orm {
 #include <string>
 #include <tuple>
 
-// #include "functional/cxx_universal.h"
+// #include "../functional/cxx_universal.h"
 
-// #include "optional_container.h"
+// #include "../optional_container.h"
 
 // NOTE Idea : Maybe also implement a custom trigger system to call a c++ callback when a trigger triggers ?
 // (Could be implemented with a normal trigger that insert or update an internal table and then retreive
@@ -9765,11 +9765,11 @@ namespace sqlite_orm {
 #include <string>  //  std::string
 #include <utility>  //  std::forward
 
-// #include "functional/cxx_universal.h"
+// #include "../functional/cxx_universal.h"
 
-// #include "tuple_helper/tuple_filter.h"
+// #include "../tuple_helper/tuple_filter.h"
 
-// #include "indexed_column.h"
+// #include "../indexed_column.h"
 
 #include <string>  //  std::string
 #include <utility>  //  std::move
@@ -9841,7 +9841,7 @@ namespace sqlite_orm {
 
 }
 
-// #include "table_type_of.h"
+// #include "../table_type_of.h"
 
 namespace sqlite_orm {
 
@@ -9980,13 +9980,13 @@ namespace sqlite_orm {
 #include <tuple>  //  std::tuple_element
 #include <utility>  //  std::forward, std::move
 
-// #include "functional/cxx_universal.h"
+// #include "../functional/cxx_universal.h"
 //  ::size_t
-// #include "functional/cxx_type_traits_polyfill.h"
+// #include "../functional/cxx_type_traits_polyfill.h"
 
-// #include "functional/cxx_functional_polyfill.h"
+// #include "../functional/cxx_functional_polyfill.h"
 
-// #include "functional/static_magic.h"
+// #include "../functional/static_magic.h"
 
 #ifndef SQLITE_ORM_IF_CONSTEXPR_SUPPORTED
 #include <type_traits>  //  std::false_type, std::true_type, std::integral_constant
@@ -10062,15 +10062,15 @@ namespace sqlite_orm {
 
 }
 
-// #include "functional/mpl.h"
+// #include "../functional/mpl.h"
 
-// #include "functional/index_sequence_util.h"
+// #include "../functional/index_sequence_util.h"
 
-// #include "tuple_helper/tuple_filter.h"
+// #include "../tuple_helper/tuple_filter.h"
 
-// #include "tuple_helper/tuple_traits.h"
+// #include "../tuple_helper/tuple_traits.h"
 
-// #include "tuple_helper/tuple_iteration.h"
+// #include "../tuple_helper/tuple_iteration.h"
 
 #include <tuple>  //  std::tuple, std::get, std::tuple_element, std::tuple_size
 #include <type_traits>  //  std::remove_reference, std::index_sequence, std::make_index_sequence
@@ -10208,15 +10208,15 @@ namespace sqlite_orm {
     }
 }
 
-// #include "member_traits/member_traits.h"
+// #include "../member_traits/member_traits.h"
 
-// #include "typed_comparator.h"
+// #include "../typed_comparator.h"
 
-// #include "type_traits.h"
+// #include "../type_traits.h"
 
-// #include "constraints.h"
+// #include "../constraints.h"
 
-// #include "table_info.h"
+// #include "../table_info.h"
 
 // #include "column.h"
 
@@ -11045,7 +11045,7 @@ namespace sqlite_orm {
 
 // #include "storage_lookup.h"
 
-// #include "column.h"
+// #include "schema/column.h"
 
 namespace sqlite_orm {
     namespace internal {
@@ -15842,7 +15842,7 @@ namespace sqlite_orm {
 
 // #include "conditions.h"
 
-// #include "column.h"
+// #include "schema/column.h"
 
 // #include "indexed_column.h"
 
@@ -16286,11 +16286,11 @@ namespace sqlite_orm {
 
 // #include "values.h"
 
-// #include "triggers.h"
+// #include "schema/triggers.h"
 
 // #include "table_type_of.h"
 
-// #include "index.h"
+// #include "schema/index.h"
 
 // #include "util.h"
 
@@ -18297,15 +18297,15 @@ namespace sqlite_orm {
     }
 }
 
-// #include "triggers.h"
+// #include "schema/triggers.h"
 
 // #include "object_from_column_builder.h"
 
-// #include "table.h"
+// #include "schema/table.h"
 
-// #include "column.h"
+// #include "schema/column.h"
 
-// #include "index.h"
+// #include "schema/index.h"
 
 // #include "cte_storage.h"
 
@@ -18326,7 +18326,7 @@ namespace sqlite_orm {
 
 // #include "select_constraints.h"
 
-// #include "table.h"
+// #include "schema/table.h"
 
 // #include "alias.h"
 
@@ -20925,9 +20925,9 @@ namespace sqlite_orm {
 
 #include <string>  //  std::string
 
-// #include "column.h"
+// #include "schema/column.h"
 
-// #include "table.h"
+// #include "schema/table.h"
 
 // #include "alias.h"
 
@@ -20972,9 +20972,9 @@ namespace sqlite_orm {
 #include <string>  //  std::string
 #endif
 
-// #include "../column.h"
+// #include "../schema/column.h"
 
-// #include "../table.h"
+// #include "../schema/table.h"
 
 namespace sqlite_orm {
 #ifdef SQLITE_ENABLE_DBSTAT_VTAB
@@ -21032,7 +21032,7 @@ namespace sqlite_orm {
 
 // #include "../default_value_extractor.h"
 
-// #include "../column.h"
+// #include "../schema/column.h"
 
 namespace sqlite_orm {
     namespace internal {
@@ -21071,9 +21071,9 @@ namespace sqlite_orm {
 //  ::size_t
 // #include "../type_printer.h"
 
-// #include "../column.h"
+// #include "../schema/column.h"
 
-// #include "../table.h"
+// #include "../schema/table.h"
 
 namespace sqlite_orm {
     namespace internal {
diff --git a/not_single_header_include/sqlite_orm/sqlite_orm.h b/not_single_header_include/sqlite_orm/sqlite_orm.h
index 6ba6cd655..62aa27967 100644
--- a/not_single_header_include/sqlite_orm/sqlite_orm.h
+++ b/not_single_header_include/sqlite_orm/sqlite_orm.h
@@ -11,23 +11,23 @@
 #include "../../dev/constraints.h"
 #include "../../dev/type_is_nullable.h"
 #include "../../dev/operators.h"
-#include "../../dev/column.h"
+#include "../../dev/schema/column.h"
 #include "../../dev/field_printer.h"
 #include "../../dev/conditions.h"
 #include "../../dev/alias.h"
 #include "../../dev/core_functions.h"
 #include "../../dev/select_constraints.h"
 #include "../../dev/table_info.h"
-#include "../../dev/triggers.h"
+#include "../../dev/schema/triggers.h"
 #include "../../dev/statement_finalizer.h"
 #include "../../dev/arithmetic_tag.h"
 #include "../../dev/pointer_value.h"
 #include "../../dev/statement_binder.h"
 #include "../../dev/row_extractor.h"
 #include "../../dev/sync_schema_result.h"
-#include "../../dev/index.h"
+#include "../../dev/schema/index.h"
 #include "../../dev/rowid.h"
-#include "../../dev/table.h"
+#include "../../dev/schema/table.h"
 #include "../../dev/storage_impl.h"
 #include "../../dev/default_value_extractor.h"
 #include "../../dev/storage.h"
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 99775cc64..21e16195a 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -41,14 +41,15 @@ add_executable(unit_tests
     tests3.cpp
     tests4.cpp
     tests5.cpp
-    column_tests.cpp
+    schema/column_tests.cpp
+    schema/index_tests.cpp
+    schema/table_tests.cpp
+    schema/explicit_columns.cpp
     private_getters_tests.cpp
     pragma_tests.cpp
-    explicit_columns.cpp
     built_in_functions_tests/core_functions_tests.cpp
     built_in_functions_tests/datetime_function_tests.cpp
     built_in_functions_tests/math_functions.cpp
-    index_tests.cpp
     constraints/composite_key.cpp
     operators/arithmetic_operators.cpp
     operators/like.cpp
@@ -82,7 +83,6 @@ add_executable(unit_tests
     constraints/unique.cpp
     constraints/foreign_key.cpp
     constraints/check.cpp
-    table_tests.cpp
     statement_serializer_tests/column_constraints/generated.cpp
     statement_serializer_tests/column_constraints/default.cpp
     statement_serializer_tests/column_constraints/primary_key.cpp
diff --git a/tests/column_tests.cpp b/tests/schema/column_tests.cpp
similarity index 100%
rename from tests/column_tests.cpp
rename to tests/schema/column_tests.cpp
diff --git a/tests/explicit_columns.cpp b/tests/schema/explicit_columns.cpp
similarity index 100%
rename from tests/explicit_columns.cpp
rename to tests/schema/explicit_columns.cpp
diff --git a/tests/index_tests.cpp b/tests/schema/index_tests.cpp
similarity index 100%
rename from tests/index_tests.cpp
rename to tests/schema/index_tests.cpp
diff --git a/tests/table_tests.cpp b/tests/schema/table_tests.cpp
similarity index 100%
rename from tests/table_tests.cpp
rename to tests/schema/table_tests.cpp
diff --git a/third_party/amalgamate/config.json b/third_party/amalgamate/config.json
index 31cf5a976..ca2292de8 100755
--- a/third_party/amalgamate/config.json
+++ b/third_party/amalgamate/config.json
@@ -11,7 +11,7 @@
     "dev/constraints.h",
     "dev/type_is_nullable.h",
     "dev/operators.h",
-    "dev/column.h",
+    "dev/schema/column.h",
     "dev/field_printer.h",
     "dev/conditions.h",
     "dev/alias.h",
@@ -19,7 +19,7 @@
     "dev/typed_comparator.h",
     "dev/select_constraints.h",
     "dev/table_info.h",
-    "dev/triggers.h",
+    "dev/schema/triggers.h",
     "dev/statement_finalizer.h",
     "dev/arithmetic_tag.h",
     "dev/pointer_value.h",
@@ -27,9 +27,9 @@
     "dev/row_extractor.h",
     "dev/util.h",
     "dev/sync_schema_result.h",
-    "dev/index.h",
+    "dev/schema/index.h",
     "dev/rowid.h",
-    "dev/table.h",
+    "dev/schema/table.h",
     "dev/storage_impl.h",
     "dev/default_value_extractor.h",
     "dev/storage.h",

From 4cb7237bafb0f1fa0137a11afee266874d1c953c Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 9 Oct 2023 00:24:11 +0200
Subject: [PATCH 123/161] Updated clang-format lint action to v0.16.2

---
 .github/workflows/clang-format-lint.yaml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/clang-format-lint.yaml b/.github/workflows/clang-format-lint.yaml
index 3916bbbff..49fdc4db4 100644
--- a/.github/workflows/clang-format-lint.yaml
+++ b/.github/workflows/clang-format-lint.yaml
@@ -9,6 +9,6 @@ jobs:
     steps:
     - uses: actions/checkout@v1
     - name: clang-format lint
-      uses: DoozyX/clang-format-lint-action@v0.15
+      uses: DoozyX/clang-format-lint-action@v0.16.2
       with:
-        clangFormatVersion: 15
+        clangFormatVersion: 16

From ed1d4463d2f4c3cf31510ca44e7a241ed53d60dd Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 9 Oct 2023 00:43:32 +0200
Subject: [PATCH 124/161] Small improvements to CTE examples

---
 dev/alias.h                           |  2 +-
 examples/common_table_expressions.cpp | 79 +++++++++++++++------------
 include/sqlite_orm/sqlite_orm.h       |  2 +-
 3 files changed, 47 insertions(+), 36 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 827aaeec2..1b95af186 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -246,7 +246,7 @@ namespace sqlite_orm {
                  bool> = true>
     auto alias_column(C c) {
         using cte_moniker_t = internal::type_t<A>;
-        if constexpr(polyfill::is_specialization_of_v<C, internal::column_pointer>) {
+        if constexpr(internal::is_column_pointer_v<C>) {
             static_assert(std::is_same<internal::table_type_of_t<C>, cte_moniker_t>::value,
                           "Column pointer must match aliased CTE");
             return internal::alias_column_t<A, C>{c};
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 9abe0a912..422879807 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -33,10 +33,10 @@ void all_integers_between(int from, int end) {
         //    cnt(x) AS(VALUES(1) UNION ALL SELECT x + 1 FROM cnt WHERE x < 1000000)
         //    SELECT x FROM cnt;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-        constexpr auto cnt_cte = "cnt"_cte;
-        auto ast = with(cte<cnt_cte>()(union_all(select(from),
-                                                 select(cnt_cte->*1_colalias + 1, where(cnt_cte->*1_colalias < end)))),
-                        select(cnt_cte->*1_colalias));
+        constexpr auto cnt = "cnt"_cte;
+        auto ast =
+            with(cte<cnt>()(union_all(select(from), select(cnt->*1_colalias + 1, where(cnt->*1_colalias < end)))),
+                 select(cnt->*1_colalias));
 #else
         auto ast =
             with(cte<cte_1>()(union_all(select(from),
@@ -46,9 +46,9 @@ void all_integers_between(int from, int end) {
 // alternative
 #if 0
         auto ast = with(
-            cte<cte_1>()(union_all(select(from >>= colalias_f{}),
-                                   select(1_ctealias->*colalias_f{} + 1, where(1_ctealias->*colalias_f{} < end)))),
-            select(1_ctealias->*colalias_f{}));
+            cte<cte_1>()(union_all(select(from >>= colalias_i{}),
+                                   select(1_ctealias->*colalias_i{} + 1, where(1_ctealias->*colalias_i{} < end)))),
+            select(1_ctealias->*colalias_i{}));
 #endif
 
         string sql = storage.dump(ast);
@@ -74,13 +74,13 @@ void all_integers_between(int from, int end) {
         //    )
         //    SELECT x FROM cnt;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-        auto ast = with(
-            cte<"cnt"_cte>("y"_col)(union_all(select(from >>= "x"_col), select("cnt"_cte->*"y"_col + 1, limit(end)))),
-            select("cnt"_cte->*"y"_col));
+        constexpr auto cnt = "cnt"_cte;
+        auto ast = with(cte<cnt>("y"_col)(union_all(select(from >>= "x"_col), select(cnt->*"y"_col + 1, limit(end)))),
+                        select(cnt->*"y"_col));
 #else
         auto ast = with(
-            cte<cte_1>()(union_all(select(as<colalias_f>(from)), select(column<cte_1>(colalias_f{}) + 1, limit(end)))),
-            select(column<cte_1>(colalias_f{})));
+            cte<cte_1>()(union_all(select(as<colalias_i>(from)), select(column<cte_1>(colalias_i{}) + 1, limit(end)))),
+            select(column<cte_1>(colalias_i{})));
 #endif
 
         string sql = storage.dump(ast);
@@ -97,12 +97,24 @@ void all_integers_between(int from, int end) {
 
     // variant 3, limit-clause, explicit as() call
     {
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        constexpr auto cnt = "cnt"_cte;
+        auto ast =
+            with(cte<cnt>().as(union_all(select(as<"i"_col>(from)), select(column<cnt>("i"_col) + 1, limit(end)))),
+                 select(column<cnt>("i"_col)));
+#else
+        auto ast = with(cte<cte_1>().as(union_all(select(as<colalias_i>(from)),
+                                                  select(column<cte_1>(colalias_i{}) + 1, limit(end)))),
+                        select(column<cte_1>(colalias_i{})));
+#endif
+
+        string sql = storage.dump(ast);
+
+        auto stmt = storage.prepare(ast);
         cout << "Integer range (limit-clause) [" << from << ", " << end
              << "]"
                 "\n";
-        for(int n: storage.with(cte<cte_1>().as(union_all(select(as<colalias_f>(from)),
-                                                          select(column<cte_1>(colalias_f{}) + 1, limit(end)))),
-                                select(column<cte_1>(colalias_f{})))) {
+        for(int n: storage.execute(stmt)) {
             cout << n << ", ";
         }
         cout << endl;
@@ -155,11 +167,12 @@ void supervisor_chain() {
         //    )
         //    SELECT name FROM chain;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-        auto ast = with(cte<"chain"_cte>()(union_all(
-                            select(asterisk<Org>(), where(&Org::name == c("Fred"))),
-                            select(asterisk<alias_a<Org>>(),
-                                   where(alias_column<alias_a<Org>>(&Org::name) == "chain"_cte->*&Org::boss)))),
-                        select("chain"_cte->*&Org::name));
+        constexpr auto chain = "chain"_cte;
+        auto ast =
+            with(cte<chain>()(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
+                                        select(asterisk<alias_a<Org>>(),
+                                               where(alias_column<alias_a<Org>>(&Org::name) == chain->*&Org::boss)))),
+                 select(chain->*&Org::name));
 #else
         auto ast = with(
             cte<cte_1>()(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
@@ -683,20 +696,18 @@ void sudoku() {
                           select(columns(cast<string>(digits->*lp + 1), digits->*lp + 1), where(digits->*lp < 9)))),
             cte<x>(s, ind)(union_all(
                 select(columns(input->*sud, instr(input->*sud, "."))),
-                select(
-                    columns(substr(x->*s, 1, x->*ind - 1) || z || substr(x->*s, x->*ind + 1),
-                            instr(substr(x->*s, 1, x->*ind - 1) || z || substr(x->*s, x->*ind + 1), ".")),
-                    where(x->*ind > 0 and
-                          not exists(select(
-                              1 >>= lp,
-                              from<digits>(),
-                              where(is_equal(z_alias->*z, substr(x->*s, ((x->*ind - 1) / 9) * 9 + lp, 1)) or
-                                    is_equal(z_alias->*z, substr(x->*s, ((x->*ind - 1) % 9) + (lp - 1) * 9 + 1, 1)) or
-                                    is_equal(z_alias->*z,
-                                             substr(x->*s,
-                                                    (((x->*ind - 1) / 3) % 3) * 3 + ((x->*ind - 1) / 27) * 27 + lp +
-                                                        ((lp - 1) / 3) * 6,
-                                                    1)))))))))),
+                select(columns(substr(x->*s, 1, x->*ind - 1) || z || substr(x->*s, x->*ind + 1),
+                               instr(substr(x->*s, 1, x->*ind - 1) || z || substr(x->*s, x->*ind + 1), ".")),
+                       where(x->*ind > 0 and
+                             not exists(select(
+                                 1 >>= lp,
+                                 from<digits>(),
+                                 where(z_alias->*z == substr(x->*s, ((x->*ind - 1) / 9) * 9 + lp, 1) or
+                                       z_alias->*z == substr(x->*s, ((x->*ind - 1) % 9) + (lp - 1) * 9 + 1, 1) or
+                                       z_alias->*z == substr(x->*s,
+                                                             (((x->*ind - 1) / 3) % 3) * 3 + ((x->*ind - 1) / 27) * 27 +
+                                                                 lp + ((lp - 1) / 3) * 6,
+                                                             1))))))))),
         select(x->*s, where(x->*ind == 0)));
 
     string sql = storage.dump(ast);
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 7e9127315..cf4ad36b2 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4814,7 +4814,7 @@ namespace sqlite_orm {
                  bool> = true>
     auto alias_column(C c) {
         using cte_moniker_t = internal::type_t<A>;
-        if constexpr(polyfill::is_specialization_of_v<C, internal::column_pointer>) {
+        if constexpr(internal::is_column_pointer_v<C>) {
             static_assert(std::is_same<internal::table_type_of_t<C>, cte_moniker_t>::value,
                           "Column pointer must match aliased CTE");
             return internal::alias_column_t<A, C>{c};

From ffcfc30114505a24e68a046a09d30e15b8ec244d Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 9 Oct 2023 14:18:27 +0200
Subject: [PATCH 125/161] Merge remote-tracking branch 'upstream/dev' into CTEs

---
 .gitignore                                    |   1 +
 appveyor.yml                                  |   6 +-
 dev/ast/match.h                               |  21 +
 dev/ast/rank.h                                |  11 +
 dev/ast_iterator.h                            |  40 +-
 dev/column_names_getter.h                     |   4 +-
 dev/column_result.h                           |   5 +
 dev/conditions.h                              |  15 +
 dev/core_functions.h                          |  20 +
 dev/cte_column_names_collector.h              |   4 +-
 dev/default_value_extractor.h                 |   4 +-
 dev/node_tuple.h                              |  16 +-
 dev/pragma.h                                  |   4 +
 dev/schema/column.h                           | 410 ++++-----
 dev/schema/table.h                            | 775 ++++++++++--------
 dev/serializer_context.h                      |   2 +-
 dev/serializing_util.h                        |  13 +-
 dev/statement_serializer.h                    | 192 ++++-
 dev/storage.h                                 |  33 +-
 dev/table_name_collector.h                    |   5 +
 dev/type_is_nullable.h                        |   1 -
 include/sqlite_orm/sqlite_orm.h               | 540 ++++++++++--
 tests/CMakeLists.txt                          |   6 +
 tests/ast_iterator_tests.cpp                  |  18 +
 tests/pragma_tests.cpp                        |   6 +
 tests/private_getters_tests.cpp               |   1 -
 tests/schema/column_tests.cpp                 |  15 +
 tests/schema/virtual_table.cpp                |  78 ++
 .../statement_serializer_tests/ast/match.cpp  |  20 +
 tests/statement_serializer_tests/ast/rank.cpp |  24 +
 tests/statement_serializer_tests/collate.cpp  |  21 +-
 .../comparison_operators.cpp                  |  15 +-
 .../logical_operators.cpp                     |  16 +-
 .../schema/column.cpp                         |  48 ++
 .../schema/using_fts5.cpp                     |  16 +
 .../schema/virtual_table.cpp                  |  17 +
 tests/static_tests/column.cpp                 |  11 +
 tests/static_tests/node_tuple.cpp             |  14 +
 tests/static_tests/static_tests_common.h      |   4 +
 tests/sync_schema_tests.cpp                   |   1 -
 tests/table_name_collector.cpp                |  18 +-
 tests/tests4.cpp                              |   6 +-
 42 files changed, 1762 insertions(+), 715 deletions(-)
 create mode 100644 dev/ast/match.h
 create mode 100644 dev/ast/rank.h
 create mode 100644 tests/schema/virtual_table.cpp
 create mode 100644 tests/statement_serializer_tests/ast/match.cpp
 create mode 100644 tests/statement_serializer_tests/ast/rank.cpp
 create mode 100644 tests/statement_serializer_tests/schema/column.cpp
 create mode 100644 tests/statement_serializer_tests/schema/using_fts5.cpp
 create mode 100644 tests/statement_serializer_tests/schema/virtual_table.cpp

diff --git a/.gitignore b/.gitignore
index f5cff1a34..1876c6a58 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,3 +6,4 @@ cmake-build-debug/
 .idea/
 
 /compile
+build
diff --git a/appveyor.yml b/appveyor.yml
index 2a8acd69e..34ac3fa5e 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -112,7 +112,7 @@ for:
       C:\Tools\vcpkg\bootstrap-vcpkg.bat -disableMetrics
       C:\Tools\vcpkg\vcpkg integrate install
       set VCPKG_DEFAULT_TRIPLET=%platform%-windows
-      vcpkg install sqlite3[core,dbstat,math,json1]
+      vcpkg install sqlite3[core,dbstat,math,json1,fts5]
       rem The Visual Studio 2017 build worker image comes with CMake 3.16 only, and sqlite_orm will build the Catch2 dependency from source
       if not "%appveyor_build_worker_image%"=="Visual Studio 2017" (vcpkg install catch2)
   before_build:
@@ -144,7 +144,7 @@ for:
       popd
       $HOME/vcpkg/bootstrap-vcpkg.sh -disableMetrics
       $HOME/vcpkg/vcpkg integrate install --overlay-triplets=vcpkg/triplets
-      vcpkg install sqlite3[core,dbstat,math,json1] catch2 --overlay-triplets=vcpkg/triplets
+      vcpkg install sqlite3[core,dbstat,math,json1,fts5] catch2 --overlay-triplets=vcpkg/triplets
   before_build:
     - |-
       mkdir compile
@@ -171,7 +171,7 @@ for:
       git clone --depth 1 --branch 2023.06.20 https://github.com/microsoft/vcpkg.git $HOME/vcpkg
       $HOME/vcpkg/bootstrap-vcpkg.sh -disableMetrics
       $HOME/vcpkg/vcpkg integrate install --overlay-triplets=vcpkg/triplets
-      vcpkg install sqlite3[core,dbstat,math,json1] catch2 --overlay-triplets=vcpkg/triplets
+      vcpkg install sqlite3[core,dbstat,math,json1,fts5] catch2 --overlay-triplets=vcpkg/triplets
   before_build:
     - |-
       mkdir compile
diff --git a/dev/ast/match.h b/dev/ast/match.h
new file mode 100644
index 000000000..5500e2820
--- /dev/null
+++ b/dev/ast/match.h
@@ -0,0 +1,21 @@
+#pragma once
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T, class X>
+        struct match_t {
+            using mapped_type = T;
+            using argument_type = X;
+
+            argument_type argument;
+
+            match_t(argument_type argument) : argument(std::move(argument)) {}
+        };
+    }
+
+    template<class T, class X>
+    internal::match_t<T, X> match(X argument) {
+        return {std::move(argument)};
+    }
+}
diff --git a/dev/ast/rank.h b/dev/ast/rank.h
new file mode 100644
index 000000000..e71ec8723
--- /dev/null
+++ b/dev/ast/rank.h
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace sqlite_orm {
+    namespace internal {
+        struct rank_t {};
+    }
+
+    inline internal::rank_t rank() {
+        return {};
+    }
+}
diff --git a/dev/ast_iterator.h b/dev/ast_iterator.h
index d72e073c4..ff0bcca79 100644
--- a/dev/ast_iterator.h
+++ b/dev/ast_iterator.h
@@ -20,6 +20,7 @@
 #include "ast/group_by.h"
 #include "ast/exists.h"
 #include "ast/set.h"
+#include "ast/match.h"
 
 namespace sqlite_orm {
 
@@ -85,6 +86,16 @@ namespace sqlite_orm {
             }
         };
 
+        template<class T, class X>
+        struct ast_iterator<match_t<T, X>, void> {
+            using node_type = match_t<T, X>;
+
+            template<class L>
+            void operator()(const node_type& node, L& lambda) const {
+                iterate_ast(node.argument, lambda);
+            }
+        };
+
         template<class... Args>
         struct ast_iterator<group_by_t<Args...>, void> {
             using node_type = group_by_t<Args...>;
@@ -95,6 +106,19 @@ namespace sqlite_orm {
             }
         };
 
+        template<class T, class X, class Y, class Z>
+        struct ast_iterator<highlight_t<T, X, Y, Z>, void> {
+            using node_type = highlight_t<T, X, Y, Z>;
+
+            template<class L>
+            void operator()(const node_type& expression, L& lambda) const {
+                lambda(expression);
+                iterate_ast(expression.argument0, lambda);
+                iterate_ast(expression.argument1, lambda);
+                iterate_ast(expression.argument2, lambda);
+            }
+        };
+
         template<class T>
         struct ast_iterator<excluded_t<T>, void> {
             using node_type = excluded_t<T>;
@@ -141,9 +165,19 @@ namespace sqlite_orm {
             using node_type = binary_operator<L, R, Ds...>;
 
             template<class C>
-            void operator()(const node_type& binaryOperator, C& lambda) const {
-                iterate_ast(binaryOperator.lhs, lambda);
-                iterate_ast(binaryOperator.rhs, lambda);
+            void operator()(const node_type& node, C& lambda) const {
+                iterate_ast(node.lhs, lambda);
+                iterate_ast(node.rhs, lambda);
+            }
+        };
+
+        template<class L, class R>
+        struct ast_iterator<is_equal_with_table_t<L, R>, void> {
+            using node_type = is_equal_with_table_t<L, R>;
+
+            template<class C>
+            void operator()(const node_type& node, C& lambda) const {
+                iterate_ast(node.rhs, lambda);
             }
         };
 
diff --git a/dev/column_names_getter.h b/dev/column_names_getter.h
index b35a4e359..63ea1082a 100644
--- a/dev/column_names_getter.h
+++ b/dev/column_names_getter.h
@@ -21,8 +21,8 @@ namespace sqlite_orm {
 
     namespace internal {
 
-        template<class T, class DBOs>
-        std::string serialize(const T&, const serializer_context<DBOs>&);
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context);
 
         template<class T, class Ctx>
         std::vector<std::string>& collect_table_column_names(std::vector<std::string>& collectedExpressions,
diff --git a/dev/column_result.h b/dev/column_result.h
index c96be9ee9..717df8cc3 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -244,6 +244,11 @@ namespace sqlite_orm {
             using type = typename T::result_type;
         };
 
+        template<class DBOs, class T, class X, class Y, class Z>
+        struct column_result_t<DBOs, highlight_t<T, X, Y, Z>, void> {
+            using type = std::string;
+        };
+
         /**
          *  Result for the most simple queries like `SELECT 1`
          */
diff --git a/dev/conditions.h b/dev/conditions.h
index 289caa10e..1de8de6ad 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -212,6 +212,16 @@ namespace sqlite_orm {
             }
         };
 
+        template<class L, class R>
+        struct is_equal_with_table_t : negatable_t {
+            using left_type = L;
+            using right_type = R;
+
+            right_type rhs;
+
+            is_equal_with_table_t(right_type rhs) : rhs(std::move(rhs)) {}
+        };
+
         struct is_not_equal_string {
             operator std::string() const {
                 return "!=";
@@ -1099,6 +1109,11 @@ namespace sqlite_orm {
         return {std::move(l), std::move(r)};
     }
 
+    template<class L, class R>
+    internal::is_equal_with_table_t<L, R> is_equal(R rhs) {
+        return {std::move(rhs)};
+    }
+
     template<class L, class R>
     internal::is_not_equal_t<L, R> is_not_equal(L l, R r) {
         return {std::move(l), std::move(r)};
diff --git a/dev/core_functions.h b/dev/core_functions.h
index 853fdec51..d6b467877 100644
--- a/dev/core_functions.h
+++ b/dev/core_functions.h
@@ -612,6 +612,21 @@ namespace sqlite_orm {
 
         template<class T>
         using field_type_or_type_t = polyfill::detected_or_t<T, type_t, member_field_type<T>>;
+
+        template<class T, class X, class Y, class Z>
+        struct highlight_t {
+            using table_type = T;
+            using argument0_type = X;
+            using argument1_type = Y;
+            using argument2_type = Z;
+
+            argument0_type argument0;
+            argument1_type argument1;
+            argument2_type argument2;
+
+            highlight_t(argument0_type argument0, argument1_type argument1, argument2_type argument2) :
+                argument0(std::move(argument0)), argument1(std::move(argument1)), argument2(std::move(argument2)) {}
+        };
     }
 
 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS
@@ -2070,4 +2085,9 @@ namespace sqlite_orm {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
         }
     }
+
+    template<class T, class X, class Y, class Z>
+    internal::highlight_t<T, X, Y, Z> highlight(X x, Y y, Z z) {
+        return {std::move(x), std::move(y), std::move(z)};
+    }
 }
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index 7de7bb9c6..7f373860e 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -20,8 +20,8 @@
 namespace sqlite_orm {
     namespace internal {
         // collecting column names utilizes the statement serializer
-        template<class T, class I>
-        std::string serialize(const T& t, const serializer_context<I>& context);
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context);
 
         inline void unquote_identifier(std::string& identifier) {
             if(!identifier.empty()) {
diff --git a/dev/default_value_extractor.h b/dev/default_value_extractor.h
index ae8d90e20..071a20387 100644
--- a/dev/default_value_extractor.h
+++ b/dev/default_value_extractor.h
@@ -10,8 +10,8 @@ namespace sqlite_orm {
 
     namespace internal {
 
-        template<class T, class DBOs>
-        std::string serialize(const T&, const serializer_context<DBOs>&);
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context);
 
         /**
          *  Serialize default value of a column's default valu
diff --git a/dev/node_tuple.h b/dev/node_tuple.h
index 88248b4e6..45c1d4a6f 100644
--- a/dev/node_tuple.h
+++ b/dev/node_tuple.h
@@ -20,9 +20,9 @@
 #include "ast/where.h"
 #include "ast/into.h"
 #include "ast/group_by.h"
+#include "ast/match.h"
 
 namespace sqlite_orm {
-
     namespace internal {
 
         template<class T, class SFINAE = void>
@@ -62,12 +62,23 @@ namespace sqlite_orm {
             using type = tuple_cat_t<node_tuple_t<Args>...>;
         };
 
+        template<class T, class X, class Y, class Z>
+        struct node_tuple<highlight_t<T, X, Y, Z>, void> {
+            using x_node_tuple = node_tuple_t<X>;
+            using y_node_tuple = node_tuple_t<Y>;
+            using z_node_tuple = node_tuple_t<Z>;
+            using type = tuple_cat_t<x_node_tuple, y_node_tuple, z_node_tuple>;
+        };
+
         template<class T>
         struct node_tuple<excluded_t<T>, void> : node_tuple<T> {};
 
         template<class C>
         struct node_tuple<where_t<C>, void> : node_tuple<C> {};
 
+        template<class T, class X>
+        struct node_tuple<match_t<T, X>, void> : node_tuple<X> {};
+
         /**
          *  Column alias
          */
@@ -89,6 +100,9 @@ namespace sqlite_orm {
         template<class E>
         struct node_tuple<order_by_t<E>, void> : node_tuple<E> {};
 
+        template<class L, class R>
+        struct node_tuple<is_equal_with_table_t<L, R>, void> : node_tuple<R> {};
+
         template<class T>
         struct node_tuple<T, match_if<is_binary_condition, T>> {
             using node_type = T;
diff --git a/dev/pragma.h b/dev/pragma.h
index 37de02201..42c604994 100644
--- a/dev/pragma.h
+++ b/dev/pragma.h
@@ -41,6 +41,10 @@ namespace sqlite_orm {
 
             pragma_t(get_connection_t get_connection_) : get_connection(std::move(get_connection_)) {}
 
+            std::vector<std::string> module_list() {
+                return this->get_pragma<std::vector<std::string>>("module_list");
+            }
+
             void busy_timeout(int value) {
                 this->set_pragma("busy_timeout", value);
             }
diff --git a/dev/schema/column.h b/dev/schema/column.h
index 39d605834..8623edbe4 100644
--- a/dev/schema/column.h
+++ b/dev/schema/column.h
@@ -1,205 +1,205 @@
-#pragma once
-
-#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 <utility>  //  std::move
-
-#include "../functional/cxx_universal.h"
-#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_is_nullable.h"
-#include "../constraints.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-        struct column_identifier {
-
-            /**
-             *  Column name.
-             */
-            std::string name;
-        };
-
-        struct empty_setter {};
-
-        /*
-         *  Encapsulates object member pointers that are used as column fields,
-         *  and whose object is mapped to storage.
-         *  
-         *  G is a member object pointer or member function pointer
-         *  S is a member function pointer or `empty_setter`
-         */
-        template<class G, class S>
-        struct column_field {
-            using member_pointer_t = G;
-            using setter_type = S;
-            using object_type = member_object_type_t<G>;
-            using field_type = member_field_type_t<G>;
-
-            /**
-             *  Member pointer used to read a field value.
-             *  If it is a object member pointer it is also used to write a field value.
-             */
-            const member_pointer_t member_pointer;
-
-            /**
-             *  Setter member function to write a field value
-             */
-            SQLITE_ORM_NOUNIQUEADDRESS
-            const setter_type setter;
-
-            /**
-             *  Simplified interface for `NOT NULL` constraint
-             */
-            constexpr bool is_not_null() const {
-                return !type_is_nullable<field_type>::value;
-            }
-        };
-
-        /*
-         *  Encapsulates a tuple of column constraints.
-         *  
-         *  Op... is a constraints pack, e.g. primary_key_t, unique_t etc
-         */
-        template<class... Op>
-        struct column_constraints {
-            using constraints_type = std::tuple<Op...>;
-
-            SQLITE_ORM_NOUNIQUEADDRESS
-            constraints_type constraints;
-
-            /**
-             *  Checks whether contraints are of trait `Trait`
-             */
-            template<template<class...> class Trait>
-            constexpr bool is() const {
-                return tuple_has<Trait, constraints_type>::value;
-            }
-
-            constexpr bool is_generated() const {
-#if SQLITE_VERSION_NUMBER >= 3031000
-                return is<is_generated_always>();
-#else
-                return false;
-#endif
-            }
-
-            /**
-             *  Simplified interface for `DEFAULT` constraint
-             *  @return string representation of default value if it exists otherwise nullptr
-             */
-            std::unique_ptr<std::string> default_value() const;
-        };
-
-        /**
-         *  Column definition.
-         *  
-         *  It is a composition of orthogonal information stored in different base classes.
-         */
-        template<class G, class S, class... Op>
-        struct column_t : column_identifier, column_field<G, S>, column_constraints<Op...> {
-#ifndef SQLITE_ORM_AGGREGATE_BASES_SUPPORTED
-            column_t(std::string name, G memberPointer, S setter, std::tuple<Op...> op) :
-                column_identifier{std::move(name)}, column_field<G, S>{memberPointer, setter},
-                column_constraints<Op...>{std::move(op)} {}
-#endif
-        };
-
-        template<class T, class SFINAE = void>
-        struct column_field_expression {
-            using type = void;
-        };
-
-        template<class G, class S, class... Op>
-        struct column_field_expression<column_t<G, S, Op...>, void> {
-            using type = typename column_t<G, S, Op...>::member_pointer_t;
-        };
-
-        template<typename T>
-        using column_field_expression_t = typename column_field_expression<T>::type;
-
-        template<class T>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_column_v = polyfill::is_specialization_of_v<T, column_t>;
-
-        template<class T>
-        using is_column = polyfill::bool_constant<is_column_v<T>>;
-
-        template<class Elements, class F>
-        using col_index_sequence_with_field_type =
-            filter_tuple_sequence_t<Elements,
-                                    check_if_is_type<F>::template fn,
-                                    field_type_t,
-                                    filter_tuple_sequence_t<Elements, is_column>>;
-
-        template<class Elements, template<class...> class TraitFn>
-        using col_index_sequence_with = filter_tuple_sequence_t<Elements,
-                                                                check_if_tuple_has<TraitFn>::template fn,
-                                                                constraints_type_t,
-                                                                filter_tuple_sequence_t<Elements, is_column>>;
-
-        template<class Elements, template<class...> class TraitFn>
-        using col_index_sequence_excluding = filter_tuple_sequence_t<Elements,
-                                                                     check_if_tuple_has_not<TraitFn>::template fn,
-                                                                     constraints_type_t,
-                                                                     filter_tuple_sequence_t<Elements, is_column>>;
-    }
-
-    /**
-     *  Factory function for a column definition from a member object pointer of the object to be mapped.
-     */
-    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_constraint<Op>...>, "Incorrect constraints pack");
-
-        // 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!
-        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(
-            return {std::move(name), memberPointer, {}, std::tuple<Op...>{std::move(constraints)...}});
-    }
-
-    /**
-     *  Factory function for a column definition from "setter" and "getter" member function pointers of the object to be mapped.
-     */
-    template<class G,
-             class S,
-             class... Op,
-             internal::satisfies<internal::is_getter, G> = true,
-             internal::satisfies<internal::is_setter, S> = true>
-    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_constraint<Op>...>, "Incorrect constraints pack");
-
-        // 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!
-        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(
-            return {std::move(name), getter, setter, std::tuple<Op...>{std::move(constraints)...}});
-    }
-
-    /**
-     *  Factory function for a column definition from "getter" and "setter" member function pointers of the object to be mapped.
-     */
-    template<class G,
-             class S,
-             class... Op,
-             internal::satisfies<internal::is_getter, G> = true,
-             internal::satisfies<internal::is_setter, S> = true>
-    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_constraint<Op>...>, "Incorrect constraints pack");
-
-        // 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!
-        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(
-            return {std::move(name), getter, setter, std::tuple<Op...>{std::move(constraints)...}});
-    }
-}
+#pragma once
+
+#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 <utility>  //  std::move
+
+#include "../functional/cxx_universal.h"
+#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_is_nullable.h"
+#include "../constraints.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+        struct column_identifier {
+
+            /**
+             *  Column name.
+             */
+            std::string name;
+        };
+
+        struct empty_setter {};
+
+        /*
+         *  Encapsulates object member pointers that are used as column fields,
+         *  and whose object is mapped to storage.
+         *  
+         *  G is a member object pointer or member function pointer
+         *  S is a member function pointer or `empty_setter`
+         */
+        template<class G, class S>
+        struct column_field {
+            using member_pointer_t = G;
+            using setter_type = S;
+            using object_type = member_object_type_t<G>;
+            using field_type = member_field_type_t<G>;
+
+            /**
+             *  Member pointer used to read a field value.
+             *  If it is a object member pointer it is also used to write a field value.
+             */
+            const member_pointer_t member_pointer;
+
+            /**
+             *  Setter member function to write a field value
+             */
+            SQLITE_ORM_NOUNIQUEADDRESS
+            const setter_type setter;
+
+            /**
+             *  Simplified interface for `NOT NULL` constraint
+             */
+            constexpr bool is_not_null() const {
+                return !type_is_nullable<field_type>::value;
+            }
+        };
+
+        /*
+         *  Encapsulates a tuple of column constraints.
+         *  
+         *  Op... is a constraints pack, e.g. primary_key_t, unique_t etc
+         */
+        template<class... Op>
+        struct column_constraints {
+            using constraints_type = std::tuple<Op...>;
+
+            SQLITE_ORM_NOUNIQUEADDRESS
+            constraints_type constraints;
+
+            /**
+             *  Checks whether contraints are of trait `Trait`
+             */
+            template<template<class...> class Trait>
+            constexpr bool is() const {
+                return tuple_has<Trait, constraints_type>::value;
+            }
+
+            constexpr bool is_generated() const {
+#if SQLITE_VERSION_NUMBER >= 3031000
+                return is<is_generated_always>();
+#else
+                return false;
+#endif
+            }
+
+            /**
+             *  Simplified interface for `DEFAULT` constraint
+             *  @return string representation of default value if it exists otherwise nullptr
+             */
+            std::unique_ptr<std::string> default_value() const;
+        };
+
+        /**
+         *  Column definition.
+         *  
+         *  It is a composition of orthogonal information stored in different base classes.
+         */
+        template<class G, class S, class... Op>
+        struct column_t : column_identifier, column_field<G, S>, column_constraints<Op...> {
+#ifndef SQLITE_ORM_AGGREGATE_BASES_SUPPORTED
+            column_t(std::string name, G memberPointer, S setter, std::tuple<Op...> op) :
+                column_identifier{std::move(name)}, column_field<G, S>{memberPointer, setter},
+                column_constraints<Op...>{std::move(op)} {}
+#endif
+        };
+
+        template<class T, class SFINAE = void>
+        struct column_field_expression {
+            using type = void;
+        };
+
+        template<class G, class S, class... Op>
+        struct column_field_expression<column_t<G, S, Op...>, void> {
+            using type = typename column_t<G, S, Op...>::member_pointer_t;
+        };
+
+        template<typename T>
+        using column_field_expression_t = typename column_field_expression<T>::type;
+
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_column_v = polyfill::is_specialization_of_v<T, column_t>;
+
+        template<class T>
+        using is_column = polyfill::bool_constant<is_column_v<T>>;
+
+        template<class Elements, class F>
+        using col_index_sequence_with_field_type =
+            filter_tuple_sequence_t<Elements,
+                                    check_if_is_type<F>::template fn,
+                                    field_type_t,
+                                    filter_tuple_sequence_t<Elements, is_column>>;
+
+        template<class Elements, template<class...> class TraitFn>
+        using col_index_sequence_with = filter_tuple_sequence_t<Elements,
+                                                                check_if_tuple_has<TraitFn>::template fn,
+                                                                constraints_type_t,
+                                                                filter_tuple_sequence_t<Elements, is_column>>;
+
+        template<class Elements, template<class...> class TraitFn>
+        using col_index_sequence_excluding = filter_tuple_sequence_t<Elements,
+                                                                     check_if_tuple_has_not<TraitFn>::template fn,
+                                                                     constraints_type_t,
+                                                                     filter_tuple_sequence_t<Elements, is_column>>;
+    }
+
+    /**
+     *  Factory function for a column definition from a member object pointer of the object to be mapped.
+     */
+    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_constraint<Op>...>, "Incorrect constraints pack");
+
+        // 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!
+        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(
+            return {std::move(name), memberPointer, {}, std::tuple<Op...>{std::move(constraints)...}});
+    }
+
+    /**
+     *  Factory function for a column definition from "setter" and "getter" member function pointers of the object to be mapped.
+     */
+    template<class G,
+             class S,
+             class... Op,
+             internal::satisfies<internal::is_getter, G> = true,
+             internal::satisfies<internal::is_setter, S> = true>
+    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_constraint<Op>...>, "Incorrect constraints pack");
+
+        // 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!
+        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(
+            return {std::move(name), getter, setter, std::tuple<Op...>{std::move(constraints)...}});
+    }
+
+    /**
+     *  Factory function for a column definition from "getter" and "setter" member function pointers of the object to be mapped.
+     */
+    template<class G,
+             class S,
+             class... Op,
+             internal::satisfies<internal::is_getter, G> = true,
+             internal::satisfies<internal::is_setter, S> = true>
+    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_constraint<Op>...>, "Incorrect constraints pack");
+
+        // 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!
+        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(
+            return {std::move(name), getter, setter, std::tuple<Op...>{std::move(constraints)...}});
+    }
+}
diff --git a/dev/schema/table.h b/dev/schema/table.h
index fc6904465..dc335e051 100644
--- a/dev/schema/table.h
+++ b/dev/schema/table.h
@@ -1,333 +1,442 @@
-#pragma once
-
-#include <string>  //  std::string
-#include <type_traits>  //  std::remove_const, std::is_member_pointer, std::true_type, std::false_type
-#include <vector>  //  std::vector
-#include <tuple>  //  std::tuple_element
-#include <utility>  //  std::forward, std::move
-
-#include "../functional/cxx_universal.h"  //  ::size_t
-#include "../functional/cxx_type_traits_polyfill.h"
-#include "../functional/cxx_functional_polyfill.h"
-#include "../functional/static_magic.h"
-#include "../functional/mpl.h"
-#include "../functional/index_sequence_util.h"
-#include "../tuple_helper/tuple_filter.h"
-#include "../tuple_helper/tuple_traits.h"
-#include "../tuple_helper/tuple_iteration.h"
-#include "../member_traits/member_traits.h"
-#include "../typed_comparator.h"
-#include "../type_traits.h"
-#include "../constraints.h"
-#include "../table_info.h"
-#include "column.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-
-#ifdef SQLITE_ORM_WITH_CTE
-        /**
-         *  A subselect mapper's CTE moniker, void otherwise.
-         */
-        template<typename O>
-        using moniker_of_or_void_t = polyfill::detected_or_t<void, cte_moniker_type_t, O>;
-
-        /** 
-         *  If O is a subselect_mapper then returns its nested type name O::cte_moniker_type,
-         *  otherwise O itself is a regular object type to be mapped.
-         */
-        template<typename O>
-        using mapped_object_type_for_t = polyfill::detected_or_t<O, cte_moniker_type_t, O>;
-#endif
-
-        struct basic_table {
-
-            /**
-             *  Table name.
-             */
-            std::string name;
-        };
-
-        /**
-         *  Table definition.
-         */
-        template<class O, bool WithoutRowId, class... Cs>
-        struct table_t : basic_table {
-#ifdef SQLITE_ORM_WITH_CTE
-            // this typename is used in contexts where it is known that the 'table' holds a subselect_mapper
-            // instead of a regular object type
-            using cte_mapper_type = O;
-            using cte_moniker_type = moniker_of_or_void_t<O>;
-            using object_type = mapped_object_type_for_t<O>;
-#else
-            using object_type = O;
-#endif
-            using elements_type = std::tuple<Cs...>;
-
-            static constexpr bool is_without_rowid_v = WithoutRowId;
-            using is_without_rowid = polyfill::bool_constant<is_without_rowid_v>;
-
-            elements_type elements;
-
-#ifndef SQLITE_ORM_AGGREGATE_BASES_SUPPORTED
-            table_t(std::string name_, elements_type elements_) :
-                basic_table{std::move(name_)}, elements{std::move(elements_)} {}
-#endif
-
-            table_t<O, true, Cs...> without_rowid() const {
-                return {this->name, this->elements};
-            }
-
-            /**
-             *  Returns foreign keys count in table definition
-             */
-            constexpr int foreign_keys_count() const {
-#if SQLITE_VERSION_NUMBER >= 3006019
-                using fk_index_sequence = filter_tuple_sequence_t<elements_type, is_foreign_key>;
-                return int(fk_index_sequence::size());
-#else
-                return 0;
-#endif
-            }
-
-            /**
-             *  Function used to get field value from object by mapped member pointer/setter/getter.
-             *  
-             *  For a setter the corresponding getter has to be searched,
-             *  so the method returns a pointer to the field as returned by the found getter.
-             *  Otherwise the method invokes the member pointer and returns its result.
-             */
-            template<class M, satisfies_not<is_setter, M> = true>
-            decltype(auto) object_field_value(const object_type& object, M memberPointer) const {
-                return polyfill::invoke(memberPointer, object);
-            }
-
-            template<class M, satisfies<is_setter, M> = true>
-            const member_field_type_t<M>* object_field_value(const object_type& object, M memberPointer) const {
-                using field_type = member_field_type_t<M>;
-                const field_type* res = nullptr;
-                iterate_tuple(this->elements,
-                              col_index_sequence_with_field_type<elements_type, field_type>{},
-                              call_as_template_base<column_field>([&res, &memberPointer, &object](const auto& column) {
-                                  if(compare_any(column.setter, memberPointer)) {
-                                      res = &polyfill::invoke(column.member_pointer, object);
-                                  }
-                              }));
-                return res;
-            }
-
-            const basic_generated_always::storage_type*
-            find_column_generated_storage_type(const std::string& name) const {
-                const basic_generated_always::storage_type* result = nullptr;
-#if SQLITE_VERSION_NUMBER >= 3031000
-                iterate_tuple(this->elements,
-                              col_index_sequence_with<elements_type, is_generated_always>{},
-                              [&result, &name](auto& column) {
-                                  if(column.name != name) {
-                                      return;
-                                  }
-                                  using generated_op_index_sequence =
-                                      filter_tuple_sequence_t<std::remove_const_t<decltype(column.constraints)>,
-                                                              is_generated_always>;
-                                  constexpr size_t opIndex = first_index_sequence_value(generated_op_index_sequence{});
-                                  result = &get<opIndex>(column.constraints).storage;
-                              });
-#else
-                (void)name;
-#endif
-                return result;
-            }
-
-            template<class G, class S>
-            bool exists_in_composite_primary_key(const column_field<G, S>& column) const {
-                bool res = false;
-                this->for_each_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_any(memberPointer, column.member_pointer) ||
-                           compare_any(memberPointer, column.setter)) {
-                            res = true;
-                        }
-                    });
-                });
-                return res;
-            }
-
-            /**
-             *  Call passed lambda with all defined primary keys.
-             */
-            template<class L>
-            void for_each_primary_key(L&& lambda) const {
-                using pk_index_sequence = filter_tuple_sequence_t<elements_type, is_primary_key>;
-                iterate_tuple(this->elements, pk_index_sequence{}, lambda);
-            }
-
-            std::vector<std::string> composite_key_columns_names() const {
-                std::vector<std::string> res;
-                this->for_each_primary_key([this, &res](auto& primaryKey) {
-                    res = this->composite_key_columns_names(primaryKey);
-                });
-                return res;
-            }
-
-            std::vector<std::string> primary_key_column_names() const {
-                using pkcol_index_sequence = col_index_sequence_with<elements_type, is_primary_key>;
-
-                if(pkcol_index_sequence::size() > 0) {
-                    return create_from_tuple<std::vector<std::string>>(this->elements,
-                                                                       pkcol_index_sequence{},
-                                                                       &column_identifier::name);
-                } else {
-                    return this->composite_key_columns_names();
-                }
-            }
-
-            template<class L>
-            void for_each_primary_key_column(L&& lambda) const {
-                iterate_tuple(this->elements,
-                              col_index_sequence_with<elements_type, is_primary_key>{},
-                              call_as_template_base<column_field>([&lambda](const auto& column) {
-                                  lambda(column.member_pointer);
-                              }));
-                this->for_each_primary_key([&lambda](auto& primaryKey) {
-                    iterate_tuple(primaryKey.columns, lambda);
-                });
-            }
-
-            template<class... Args>
-            std::vector<std::string> composite_key_columns_names(const primary_key_t<Args...>& primaryKey) const {
-                return create_from_tuple<std::vector<std::string>>(primaryKey.columns,
-                                                                   [this, empty = std::string{}](auto& memberPointer) {
-                                                                       if(const std::string* columnName =
-                                                                              this->find_column_name(memberPointer)) {
-                                                                           return *columnName;
-                                                                       } else {
-                                                                           return empty;
-                                                                       }
-                                                                   });
-            }
-
-            /**
-             *  Searches column name by class member pointer passed as the first argument.
-             *  @return column name or empty string if nothing found.
-             */
-            template<class M, satisfies<std::is_member_pointer, M> = true>
-            const std::string* find_column_name(M m) const {
-                const std::string* res = nullptr;
-                using field_type = member_field_type_t<M>;
-                iterate_tuple(this->elements,
-                              col_index_sequence_with_field_type<elements_type, field_type>{},
-                              [&res, m](auto& c) {
-                                  if(compare_any(c.member_pointer, m) || compare_any(c.setter, m)) {
-                                      res = &c.name;
-                                  }
-                              });
-                return res;
-            }
-
-            /**
-             *  Counts and returns amount of columns without GENERATED ALWAYS constraints. Skips table constraints.
-             */
-            constexpr int non_generated_columns_count() const {
-#if SQLITE_VERSION_NUMBER >= 3031000
-                using non_generated_col_index_sequence =
-                    col_index_sequence_excluding<elements_type, is_generated_always>;
-                return int(non_generated_col_index_sequence::size());
-#else
-                return this->count_columns_amount();
-#endif
-            }
-
-            /**
-             *  Counts and returns amount of columns. Skips constraints.
-             */
-            constexpr int count_columns_amount() const {
-                using col_index_sequence = filter_tuple_sequence_t<elements_type, is_column>;
-                return int(col_index_sequence::size());
-            }
-
-            /**
-             *  Call passed lambda with all defined foreign keys.
-             *  @param lambda Lambda called for each column. Function signature: `void(auto& column)`
-             */
-            template<class L>
-            void for_each_foreign_key(L&& lambda) const {
-                using fk_index_sequence = filter_tuple_sequence_t<elements_type, is_foreign_key>;
-                iterate_tuple(this->elements, fk_index_sequence{}, lambda);
-            }
-
-            template<class Target, class L>
-            void for_each_foreign_key_to(L&& lambda) const {
-                using fk_index_sequence = filter_tuple_sequence_t<elements_type, is_foreign_key>;
-                using filtered_index_sequence = filter_tuple_sequence_t<elements_type,
-                                                                        check_if_is_type<Target>::template fn,
-                                                                        target_type_t,
-                                                                        fk_index_sequence>;
-                iterate_tuple(this->elements, filtered_index_sequence{}, lambda);
-            }
-
-            /**
-             *  Call passed lambda with all defined columns.
-             *  @param lambda Lambda called for each column. Function signature: `void(auto& column)`
-             */
-            template<class L>
-            void for_each_column(L&& lambda) const {
-                using col_index_sequence = filter_tuple_sequence_t<elements_type, is_column>;
-                iterate_tuple(this->elements, col_index_sequence{}, lambda);
-            }
-
-            /**
-             *  Call passed lambda with columns not having the specified constraint trait `OpTrait`.
-             *  @param lambda Lambda called for each column.
-             */
-            template<template<class...> class OpTraitFn, class L>
-            void for_each_column_excluding(L&& lambda) const {
-                iterate_tuple(this->elements, col_index_sequence_excluding<elements_type, OpTraitFn>{}, lambda);
-            }
-
-            /**
-             *  Call passed lambda with columns not having the specified constraint trait `OpTrait`.
-             *  @param lambda Lambda called for each column.
-             */
-            template<class OpTraitFnCls, class L, satisfies<mpl::is_metafunction_class, OpTraitFnCls> = true>
-            void for_each_column_excluding(L&& lambda) const {
-                this->for_each_column_excluding<OpTraitFnCls::template fn>(lambda);
-            }
-
-            std::vector<table_xinfo> get_table_info() const;
-        };
-
-        template<class T>
-        struct is_table : std::false_type {};
-
-        template<class O, bool W, class... Cs>
-        struct is_table<table_t<O, W, Cs...>> : std::true_type {};
-    }
-
-    /**
-     *  Factory function for a table definition.
-     *
-     *  The mapped object type is determined implicitly from the first column definition.
-     */
-    template<class... Cs, class T = typename std::tuple_element_t<0, std::tuple<Cs...>>::object_type>
-    internal::table_t<T, false, Cs...> make_table(std::string name, Cs... args) {
-        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(
-            return {std::move(name), std::make_tuple<Cs...>(std::forward<Cs>(args)...)});
-    }
-
-    /**
-     *  Factory function for a table definition.
-     * 
-     *  The mapped object type is explicitly specified.
-     */
-    template<class T, class... Cs>
-    internal::table_t<T, false, Cs...> make_table(std::string name, Cs... args) {
-        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(
-            return {std::move(name), std::make_tuple<Cs...>(std::forward<Cs>(args)...)});
-    }
-}
+#pragma once
+
+#include <string>  //  std::string
+#include <type_traits>  //  std::remove_const, std::is_member_pointer, std::true_type, std::false_type
+#include <vector>  //  std::vector
+#include <tuple>  //  std::tuple_element
+#include <utility>  //  std::forward, std::move
+
+#include "../functional/cxx_universal.h"  //  ::size_t
+#include "../functional/cxx_type_traits_polyfill.h"
+#include "../functional/cxx_functional_polyfill.h"
+#include "../functional/static_magic.h"
+#include "../functional/mpl.h"
+#include "../functional/index_sequence_util.h"
+#include "../tuple_helper/tuple_filter.h"
+#include "../tuple_helper/tuple_traits.h"
+#include "../tuple_helper/tuple_iteration.h"
+#include "../member_traits/member_traits.h"
+#include "../typed_comparator.h"
+#include "../type_traits.h"
+#include "../constraints.h"
+#include "../table_info.h"
+#include "column.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+
+#ifdef SQLITE_ORM_WITH_CTE
+        /**
+         *  A subselect mapper's CTE moniker, void otherwise.
+         */
+        template<typename O>
+        using moniker_of_or_void_t = polyfill::detected_or_t<void, cte_moniker_type_t, O>;
+
+        /** 
+         *  If O is a subselect_mapper then returns its nested type name O::cte_moniker_type,
+         *  otherwise O itself is a regular object type to be mapped.
+         */
+        template<typename O>
+        using mapped_object_type_for_t = polyfill::detected_or_t<O, cte_moniker_type_t, O>;
+#endif
+
+        struct basic_table {
+
+            /**
+             *  Table name.
+             */
+            std::string name;
+        };
+
+        /**
+         *  Table definition.
+         */
+        template<class O, bool WithoutRowId, class... Cs>
+        struct table_t : basic_table {
+#ifdef SQLITE_ORM_WITH_CTE
+            // this typename is used in contexts where it is known that the 'table' holds a subselect_mapper
+            // instead of a regular object type
+            using cte_mapper_type = O;
+            using cte_moniker_type = moniker_of_or_void_t<O>;
+            using object_type = mapped_object_type_for_t<O>;
+#else
+            using object_type = O;
+#endif
+            using elements_type = std::tuple<Cs...>;
+
+            static constexpr bool is_without_rowid_v = WithoutRowId;
+            using is_without_rowid = polyfill::bool_constant<is_without_rowid_v>;
+
+            elements_type elements;
+
+#ifndef SQLITE_ORM_AGGREGATE_BASES_SUPPORTED
+            table_t(std::string name_, elements_type elements_) :
+                basic_table{std::move(name_)}, elements{std::move(elements_)} {}
+#endif
+
+            table_t<O, true, Cs...> without_rowid() const {
+                return {this->name, this->elements};
+            }
+
+            /**
+             *  Returns foreign keys count in table definition
+             */
+            constexpr int foreign_keys_count() const {
+#if SQLITE_VERSION_NUMBER >= 3006019
+                using fk_index_sequence = filter_tuple_sequence_t<elements_type, is_foreign_key>;
+                return int(fk_index_sequence::size());
+#else
+                return 0;
+#endif
+            }
+
+            /**
+             *  Function used to get field value from object by mapped member pointer/setter/getter.
+             *  
+             *  For a setter the corresponding getter has to be searched,
+             *  so the method returns a pointer to the field as returned by the found getter.
+             *  Otherwise the method invokes the member pointer and returns its result.
+             */
+            template<class M, satisfies_not<is_setter, M> = true>
+            decltype(auto) object_field_value(const object_type& object, M memberPointer) const {
+                return polyfill::invoke(memberPointer, object);
+            }
+
+            template<class M, satisfies<is_setter, M> = true>
+            const member_field_type_t<M>* object_field_value(const object_type& object, M memberPointer) const {
+                using field_type = member_field_type_t<M>;
+                const field_type* res = nullptr;
+                iterate_tuple(this->elements,
+                              col_index_sequence_with_field_type<elements_type, field_type>{},
+                              call_as_template_base<column_field>([&res, &memberPointer, &object](const auto& column) {
+                                  if(compare_any(column.setter, memberPointer)) {
+                                      res = &polyfill::invoke(column.member_pointer, object);
+                                  }
+                              }));
+                return res;
+            }
+
+            const basic_generated_always::storage_type*
+            find_column_generated_storage_type(const std::string& name) const {
+                const basic_generated_always::storage_type* result = nullptr;
+#if SQLITE_VERSION_NUMBER >= 3031000
+                iterate_tuple(this->elements,
+                              col_index_sequence_with<elements_type, is_generated_always>{},
+                              [&result, &name](auto& column) {
+                                  if(column.name != name) {
+                                      return;
+                                  }
+                                  using generated_op_index_sequence =
+                                      filter_tuple_sequence_t<std::remove_const_t<decltype(column.constraints)>,
+                                                              is_generated_always>;
+                                  constexpr size_t opIndex = first_index_sequence_value(generated_op_index_sequence{});
+                                  result = &get<opIndex>(column.constraints).storage;
+                              });
+#else
+                (void)name;
+#endif
+                return result;
+            }
+
+            /**
+             *  Call passed lambda with all defined primary keys.
+             */
+            template<class L>
+            void for_each_primary_key(L&& lambda) const {
+                using pk_index_sequence = filter_tuple_sequence_t<elements_type, is_primary_key>;
+                iterate_tuple(this->elements, pk_index_sequence{}, lambda);
+            }
+
+            std::vector<std::string> composite_key_columns_names() const {
+                std::vector<std::string> res;
+                this->for_each_primary_key([this, &res](auto& primaryKey) {
+                    res = this->composite_key_columns_names(primaryKey);
+                });
+                return res;
+            }
+
+            std::vector<std::string> primary_key_column_names() const {
+                using pkcol_index_sequence = col_index_sequence_with<elements_type, is_primary_key>;
+
+                if(pkcol_index_sequence::size() > 0) {
+                    return create_from_tuple<std::vector<std::string>>(this->elements,
+                                                                       pkcol_index_sequence{},
+                                                                       &column_identifier::name);
+                } else {
+                    return this->composite_key_columns_names();
+                }
+            }
+
+            template<class L>
+            void for_each_primary_key_column(L&& lambda) const {
+                iterate_tuple(this->elements,
+                              col_index_sequence_with<elements_type, is_primary_key>{},
+                              call_as_template_base<column_field>([&lambda](const auto& column) {
+                                  lambda(column.member_pointer);
+                              }));
+                this->for_each_primary_key([&lambda](auto& primaryKey) {
+                    iterate_tuple(primaryKey.columns, lambda);
+                });
+            }
+
+            template<class... Args>
+            std::vector<std::string> composite_key_columns_names(const primary_key_t<Args...>& primaryKey) const {
+                return create_from_tuple<std::vector<std::string>>(primaryKey.columns,
+                                                                   [this, empty = std::string{}](auto& memberPointer) {
+                                                                       if(const std::string* columnName =
+                                                                              this->find_column_name(memberPointer)) {
+                                                                           return *columnName;
+                                                                       } else {
+                                                                           return empty;
+                                                                       }
+                                                                   });
+            }
+
+            /**
+             *  Searches column name by class member pointer passed as the first argument.
+             *  @return column name or empty string if nothing found.
+             */
+            template<class M, satisfies<std::is_member_pointer, M> = true>
+            const std::string* find_column_name(M m) const {
+                const std::string* res = nullptr;
+                using field_type = member_field_type_t<M>;
+                iterate_tuple(this->elements,
+                              col_index_sequence_with_field_type<elements_type, field_type>{},
+                              [&res, m](auto& c) {
+                                  if(compare_any(c.member_pointer, m) || compare_any(c.setter, m)) {
+                                      res = &c.name;
+                                  }
+                              });
+                return res;
+            }
+
+            /**
+             *  Counts and returns amount of columns without GENERATED ALWAYS constraints. Skips table constraints.
+             */
+            constexpr int non_generated_columns_count() const {
+#if SQLITE_VERSION_NUMBER >= 3031000
+                using non_generated_col_index_sequence =
+                    col_index_sequence_excluding<elements_type, is_generated_always>;
+                return int(non_generated_col_index_sequence::size());
+#else
+                return this->count_columns_amount();
+#endif
+            }
+
+            /**
+             *  Counts and returns amount of columns. Skips constraints.
+             */
+            constexpr int count_columns_amount() const {
+                using col_index_sequence = filter_tuple_sequence_t<elements_type, is_column>;
+                return int(col_index_sequence::size());
+            }
+
+            /**
+             *  Call passed lambda with all defined foreign keys.
+             *  @param lambda Lambda called for each column. Function signature: `void(auto& column)`
+             */
+            template<class L>
+            void for_each_foreign_key(L&& lambda) const {
+                using fk_index_sequence = filter_tuple_sequence_t<elements_type, is_foreign_key>;
+                iterate_tuple(this->elements, fk_index_sequence{}, lambda);
+            }
+
+            template<class Target, class L>
+            void for_each_foreign_key_to(L&& lambda) const {
+                using fk_index_sequence = filter_tuple_sequence_t<elements_type, is_foreign_key>;
+                using filtered_index_sequence = filter_tuple_sequence_t<elements_type,
+                                                                        check_if_is_type<Target>::template fn,
+                                                                        target_type_t,
+                                                                        fk_index_sequence>;
+                iterate_tuple(this->elements, filtered_index_sequence{}, lambda);
+            }
+
+            /**
+             *  Call passed lambda with all defined columns.
+             *  @param lambda Lambda called for each column. Function signature: `void(auto& column)`
+             */
+            template<class L>
+            void for_each_column(L&& lambda) const {
+                using col_index_sequence = filter_tuple_sequence_t<elements_type, is_column>;
+                iterate_tuple(this->elements, col_index_sequence{}, lambda);
+            }
+
+            /**
+             *  Call passed lambda with columns not having the specified constraint trait `OpTrait`.
+             *  @param lambda Lambda called for each column.
+             */
+            template<template<class...> class OpTraitFn, class L>
+            void for_each_column_excluding(L&& lambda) const {
+                iterate_tuple(this->elements, col_index_sequence_excluding<elements_type, OpTraitFn>{}, lambda);
+            }
+
+            /**
+             *  Call passed lambda with columns not having the specified constraint trait `OpTrait`.
+             *  @param lambda Lambda called for each column.
+             */
+            template<class OpTraitFnCls, class L, satisfies<mpl::is_metafunction_class, OpTraitFnCls> = true>
+            void for_each_column_excluding(L&& lambda) const {
+                this->for_each_column_excluding<OpTraitFnCls::template fn>(lambda);
+            }
+
+            std::vector<table_xinfo> get_table_info() const;
+        };
+
+        template<class T>
+        struct is_table : std::false_type {};
+
+        template<class O, bool W, class... Cs>
+        struct is_table<table_t<O, W, Cs...>> : std::true_type {};
+
+        template<class M>
+        struct virtual_table_t : basic_table {
+            using module_details_type = M;
+            using object_type = typename module_details_type::object_type;
+            using elements_type = typename module_details_type::columns_type;
+
+            static constexpr bool is_without_rowid_v = false;
+            using is_without_rowid = polyfill::bool_constant<is_without_rowid_v>;
+
+            module_details_type module_details;
+
+#ifndef SQLITE_ORM_AGGREGATE_BASES_SUPPORTED
+            virtual_table_t(std::string name, module_details_type module_details) :
+                basic_table{std::move(name)}, module_details{std::move(module_details)} {}
+#endif
+
+            /**
+             *  Call passed lambda with columns not having the specified constraint trait `OpTrait`.
+             *  @param lambda Lambda called for each column.
+             */
+            template<template<class...> class OpTraitFn, class L>
+            void for_each_column_excluding(L&& lambda) const {
+                this->module_details.template for_each_column_excluding<OpTraitFn>(lambda);
+            }
+
+            /**
+             *  Call passed lambda with columns not having the specified constraint trait `OpTrait`.
+             *  @param lambda Lambda called for each column.
+             */
+            template<class OpTraitFnCls, class L, satisfies<mpl::is_metafunction_class, OpTraitFnCls> = true>
+            void for_each_column_excluding(L&& lambda) const {
+                this->module_details.template for_each_column_excluding<OpTraitFnCls>(lambda);
+            }
+
+            /**
+             *  Call passed lambda with all defined columns.
+             *  @param lambda Lambda called for each column. Function signature: `void(auto& column)`
+             */
+            template<class L>
+            void for_each_column(L&& lambda) const {
+                this->module_details.for_each_column(lambda);
+            }
+        };
+
+        template<class T>
+        struct is_virtual_table : std::false_type {};
+
+        template<class M>
+        struct is_virtual_table<virtual_table_t<M>> : std::true_type {};
+
+        template<class T, class... Cs>
+        struct using_fts5_t {
+            using object_type = T;
+            using columns_type = std::tuple<Cs...>;
+
+            columns_type columns;
+
+            using_fts5_t(columns_type columns) : columns(std::move(columns)) {}
+
+            /**
+             *  Call passed lambda with columns not having the specified constraint trait `OpTrait`.
+             *  @param lambda Lambda called for each column.
+             */
+            template<template<class...> class OpTraitFn, class L>
+            void for_each_column_excluding(L&& lambda) const {
+                iterate_tuple(this->columns, col_index_sequence_excluding<columns_type, OpTraitFn>{}, lambda);
+            }
+
+            /**
+             *  Call passed lambda with columns not having the specified constraint trait `OpTrait`.
+             *  @param lambda Lambda called for each column.
+             */
+            template<class OpTraitFnCls, class L, satisfies<mpl::is_metafunction_class, OpTraitFnCls> = true>
+            void for_each_column_excluding(L&& lambda) const {
+                this->for_each_column_excluding<OpTraitFnCls::template fn>(lambda);
+            }
+
+            /**
+             *  Call passed lambda with all defined columns.
+             *  @param lambda Lambda called for each column. Function signature: `void(auto& column)`
+             */
+            template<class L>
+            void for_each_column(L&& lambda) const {
+                using col_index_sequence = filter_tuple_sequence_t<columns_type, is_column>;
+                iterate_tuple(this->columns, col_index_sequence{}, lambda);
+            }
+        };
+
+        template<class O, bool WithoutRowId, class... Cs, class G, class S>
+        bool exists_in_composite_primary_key(const table_t<O, WithoutRowId, Cs...>& table,
+                                             const column_field<G, S>& column) {
+            bool res = false;
+            table.for_each_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_any(memberPointer, column.member_pointer) || compare_any(memberPointer, column.setter)) {
+                        res = true;
+                    }
+                });
+            });
+            return res;
+        }
+
+        template<class M, class G, class S>
+        bool exists_in_composite_primary_key(const virtual_table_t<M>& /*virtualTable*/,
+                                             const column_field<G, S>& /*column*/) {
+            return false;
+        }
+    }
+
+    template<class... Cs, class T = typename std::tuple_element_t<0, std::tuple<Cs...>>::object_type>
+    internal::using_fts5_t<T, Cs...> using_fts5(Cs... columns) {
+        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(return {std::make_tuple(std::forward<Cs>(columns)...)});
+    }
+
+    template<class T, class... Cs>
+    internal::using_fts5_t<T, Cs...> using_fts5(Cs... columns) {
+        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(return {std::make_tuple(std::forward<Cs>(columns)...)});
+    }
+
+    /**
+     *  Factory function for a table definition.
+     *
+     *  The mapped object type is determined implicitly from the first column definition.
+     */
+    template<class... Cs, class T = typename std::tuple_element_t<0, std::tuple<Cs...>>::object_type>
+    internal::table_t<T, false, Cs...> make_table(std::string name, Cs... args) {
+        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(
+            return {std::move(name), std::make_tuple<Cs...>(std::forward<Cs>(args)...)});
+    }
+
+    /**
+     *  Factory function for a table definition.
+     * 
+     *  The mapped object type is explicitly specified.
+     */
+    template<class T, class... Cs>
+    internal::table_t<T, false, Cs...> make_table(std::string name, Cs... args) {
+        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(
+            return {std::move(name), std::make_tuple<Cs...>(std::forward<Cs>(args)...)});
+    }
+
+    template<class M>
+    internal::virtual_table_t<M> make_virtual_table(std::string name, M module_details) {
+        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(return {std::move(name), std::move(module_details)});
+    }
+}
diff --git a/dev/serializer_context.h b/dev/serializer_context.h
index 8536f3d9f..a4c235028 100644
--- a/dev/serializer_context.h
+++ b/dev/serializer_context.h
@@ -8,6 +8,7 @@ namespace sqlite_orm {
             bool replace_bindable_with_question = false;
             bool skip_table_name = true;
             bool use_parentheses = true;
+            bool skip_types_and_constraints = false;
         };
 
         template<class DBOs>
@@ -32,7 +33,6 @@ namespace sqlite_orm {
 
             const storage_type& storage;
         };
-
     }
 
 }
diff --git a/dev/serializing_util.h b/dev/serializing_util.h
index ef7dca0c0..08be5f6ab 100644
--- a/dev/serializing_util.h
+++ b/dev/serializing_util.h
@@ -20,8 +20,8 @@ namespace sqlite_orm {
         template<class O>
         struct order_by_t;
 
-        template<class T, class DBOs>
-        std::string serialize(const T&, const serializer_context<DBOs>&);
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context);
 
         template<class T, class Ctx>
         std::string serialize_order_by(const T&, const Ctx&);
@@ -188,7 +188,7 @@ namespace sqlite_orm {
             return ss;
         }
 
-        // serialize and stream a vector of expressions;
+        // serialize and stream a vector or any other STL container of expressions;
         // comma-separated
         template<class C, class Ctx>
         std::ostream& operator<<(std::ostream& ss,
@@ -197,8 +197,9 @@ namespace sqlite_orm {
             auto& context = get<2>(tpl);
 
             constexpr std::array<const char*, 2> sep = {", ", ""};
-            for(size_t i = 0, first = true; i < args.size(); ++i) {
-                ss << sep[std::exchange(first, false)] << serialize(args[i], context);
+            bool first = true;
+            for(auto& argument: args) {
+                ss << sep[std::exchange(first, false)] << serialize(argument, context);
             }
             return ss;
         }
@@ -369,7 +370,7 @@ namespace sqlite_orm {
                 ss << serialize(constraint, context) << ' ';
             });
             if(isNotNull) {
-                ss << "NOT NULL ";
+                ss << "NOT NULL";
             }
 
             return ss;
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index 7c27bee53..efa8f08a4 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -10,6 +10,7 @@
 #endif  //  SQLITE_ORM_OMITS_CODECVT
 #include <memory>
 #include <array>
+#include <list>  //  std::list
 #include "functional/cxx_string_view.h"
 #include "functional/cxx_optional.h"
 
@@ -21,6 +22,8 @@
 #include "ast/excluded.h"
 #include "ast/group_by.h"
 #include "ast/into.h"
+#include "ast/match.h"
+#include "ast/rank.h"
 #include "core_functions.h"
 #include "constraints.h"
 #include "conditions.h"
@@ -43,6 +46,7 @@
 #include "schema/triggers.h"
 #include "table_type_of.h"
 #include "schema/index.h"
+#include "schema/table.h"
 #include "util.h"
 
 namespace sqlite_orm {
@@ -52,8 +56,8 @@ namespace sqlite_orm {
         template<class T, class SFINAE = void>
         struct statement_serializer;
 
-        template<class T, class DBOs>
-        std::string serialize(const T& t, const serializer_context<DBOs>& context) {
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context) {
             statement_serializer<T> serializer;
             return serializer(t, context);
         }
@@ -133,6 +137,43 @@ namespace sqlite_orm {
             }
         };
 
+        template<class O, bool WithoutRowId, class... Cs>
+        struct statement_serializer<table_t<O, WithoutRowId, Cs...>, void> {
+            using statement_type = table_t<O, WithoutRowId, Cs...>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& statement, const Ctx& context) {
+                return this->serialize(statement, context, statement.name);
+            }
+
+            template<class Ctx>
+            std::string serialize(const statement_type& statement, const Ctx& context, const std::string& tableName) {
+                std::stringstream ss;
+                ss << "CREATE TABLE " << streaming_identifier(tableName) << " ( "
+                   << streaming_expressions_tuple(statement.elements, context) << ")";
+                if(statement_type::is_without_rowid_v) {
+                    ss << " WITHOUT ROWID";
+                }
+                return ss.str();
+            }
+        };
+
+        template<class T, class X, class Y, class Z>
+        struct statement_serializer<highlight_t<T, X, Y, Z>, void> {
+            using statement_type = highlight_t<T, X, Y, Z>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& statement, const Ctx& context) {
+                std::stringstream ss;
+                auto& tableName = lookup_table_name<T>(context.db_objects);
+                ss << "HIGHLIGHT (" << streaming_identifier(tableName);
+                ss << ", " << serialize(statement.argument0, context);
+                ss << ", " << serialize(statement.argument1, context);
+                ss << ", " << serialize(statement.argument2, context) << ")";
+                return ss.str();
+            }
+        };
+
         /**
          *  Serializer for literal values.
          */
@@ -141,12 +182,12 @@ namespace sqlite_orm {
             using statement_type = T;
 
             template<class Ctx>
-            std::string operator()(const T& literal, const Ctx& context) const {
-                static_assert(is_bindable_v<type_t<T>>, "A literal value must be also bindable");
+            std::string operator()(const statement_type& literal, const Ctx& context) const {
+                static_assert(is_bindable_v<type_t<statement_type>>, "A literal value must be also bindable");
 
                 Ctx literalCtx = context;
                 literalCtx.replace_bindable_with_question = false;
-                statement_serializer<type_t<T>> serializer{};
+                statement_serializer<type_t<statement_type>> serializer{};
                 return serializer(literal.value, literalCtx);
             }
         };
@@ -213,6 +254,19 @@ namespace sqlite_orm {
             }
         };
 
+        template<class T, class X>
+        struct statement_serializer<match_t<T, X>, void> {
+            using statement_type = match_t<T, X>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& statement, const Ctx& context) const {
+                auto& table = pick_table<T>(context.db_objects);
+                std::stringstream ss;
+                ss << streaming_identifier(table.name) << " MATCH " << serialize(statement.argument, context);
+                return ss.str();
+            }
+        };
+
         template<char... C>
         struct statement_serializer<column_alias<C...>, void> {
             using statement_type = column_alias<C...>;
@@ -341,13 +395,23 @@ namespace sqlite_orm {
             }
         };
 
+        template<>
+        struct statement_serializer<rank_t, void> {
+            using statement_type = rank_t;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& /*statement*/, const Ctx&) const {
+                return "rank";
+            }
+        };
+
         template<>
         struct statement_serializer<rowid_t, void> {
             using statement_type = rowid_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& s, const Ctx&) const {
-                return static_cast<std::string>(s);
+            std::string operator()(const statement_type& statement, const Ctx&) const {
+                return static_cast<std::string>(statement);
             }
         };
 
@@ -356,8 +420,8 @@ namespace sqlite_orm {
             using statement_type = oid_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& s, const Ctx&) const {
-                return static_cast<std::string>(s);
+            std::string operator()(const statement_type& statement, const Ctx&) const {
+                return static_cast<std::string>(statement);
             }
         };
 
@@ -366,8 +430,8 @@ namespace sqlite_orm {
             using statement_type = _rowid_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& s, const Ctx&) const {
-                return static_cast<std::string>(s);
+            std::string operator()(const statement_type& statement, const Ctx&) const {
+                return static_cast<std::string>(statement);
             }
         };
 
@@ -376,12 +440,12 @@ namespace sqlite_orm {
             using statement_type = table_rowid_t<O>;
 
             template<class Ctx>
-            std::string operator()(const statement_type& s, const Ctx& context) const {
+            std::string operator()(const statement_type& statement, const Ctx& context) const {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
                     ss << streaming_identifier(lookup_table_name<O>(context.db_objects)) << ".";
                 }
-                ss << static_cast<std::string>(s);
+                ss << static_cast<std::string>(statement);
                 return ss.str();
             }
         };
@@ -391,12 +455,12 @@ namespace sqlite_orm {
             using statement_type = table_oid_t<O>;
 
             template<class Ctx>
-            std::string operator()(const statement_type& s, const Ctx& context) const {
+            std::string operator()(const statement_type& statement, const Ctx& context) const {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
                     ss << streaming_identifier(lookup_table_name<O>(context.db_objects)) << ".";
                 }
-                ss << static_cast<std::string>(s);
+                ss << static_cast<std::string>(statement);
                 return ss.str();
             }
         };
@@ -406,12 +470,27 @@ namespace sqlite_orm {
             using statement_type = table__rowid_t<O>;
 
             template<class Ctx>
-            std::string operator()(const statement_type& s, const Ctx& context) const {
+            std::string operator()(const statement_type& statement, const Ctx& context) const {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
                     ss << streaming_identifier(lookup_table_name<O>(context.db_objects)) << ".";
                 }
-                ss << static_cast<std::string>(s);
+                ss << static_cast<std::string>(statement);
+                return ss.str();
+            }
+        };
+
+        template<class L, class R>
+        struct statement_serializer<is_equal_with_table_t<L, R>, void> {
+            using statement_type = is_equal_with_table_t<L, R>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& statement, const Ctx& context) const {
+                std::stringstream ss;
+                const auto tableName = lookup_table_name<L>(context.db_objects);
+                ss << streaming_identifier(tableName);
+                ss << " = ";
+                ss << serialize(statement.rhs, context);
                 return ss.str();
             }
         };
@@ -676,9 +755,12 @@ namespace sqlite_orm {
             }
         };
 
-        template<class L, class A>
-        struct statement_serializer<dynamic_in_t<L, A>, void> {
-            using statement_type = dynamic_in_t<L, A>;
+        template<class L, class C>
+        struct statement_serializer<
+            dynamic_in_t<L, C>,
+            std::enable_if_t<!polyfill::disjunction_v<polyfill::is_specialization_of<C, std::vector>,
+                                                      polyfill::is_specialization_of<C, std::list>>>> {
+            using statement_type = dynamic_in_t<L, C>;
 
             template<class Ctx>
             std::string operator()(const statement_type& statement, const Ctx& context) const {
@@ -691,22 +773,25 @@ namespace sqlite_orm {
                     ss << "NOT IN";
                 }
                 ss << " ";
-                if(is_compound_operator_v<A>) {
+                if(is_compound_operator_v<C>) {
                     ss << '(';
                 }
                 auto newContext = context;
                 newContext.use_parentheses = true;
                 ss << serialize(statement.argument, newContext);
-                if(is_compound_operator_v<A>) {
+                if(is_compound_operator_v<C>) {
                     ss << ')';
                 }
                 return ss.str();
             }
         };
 
-        template<class L, class E>
-        struct statement_serializer<dynamic_in_t<L, std::vector<E>>, void> {
-            using statement_type = dynamic_in_t<L, std::vector<E>>;
+        template<class L, class C>
+        struct statement_serializer<
+            dynamic_in_t<L, C>,
+            std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<C, std::vector>,
+                                                     polyfill::is_specialization_of<C, std::list>>>> {
+            using statement_type = dynamic_in_t<L, C>;
 
             template<class Ctx>
             std::string operator()(const statement_type& statement, const Ctx& context) const {
@@ -986,12 +1071,18 @@ namespace sqlite_orm {
                 using column_type = statement_type;
 
                 std::stringstream ss;
-                ss << streaming_identifier(column.name) << " " << type_printer<field_type_t<column_type>>().print()
-                   << " "
-                   << streaming_column_constraints(
-                          call_as_template_base<column_constraints>(polyfill::identity{})(column),
-                          column.is_not_null(),
-                          context);
+                ss << streaming_identifier(column.name);
+                if(!context.skip_types_and_constraints) {
+                    ss << " " << type_printer<field_type_t<column_type>>().print();
+                    const bool columnIsNotNull = column.is_not_null();
+                    auto constraintsTuple = streaming_column_constraints(
+                        call_as_template_base<column_constraints>(polyfill::identity{})(column),
+                        columnIsNotNull,
+                        context);
+                    if(std::tuple_size<decltype(constraintsTuple)>::value > 0) {
+                        ss << " " << constraintsTuple;
+                    }
+                }
                 return ss.str();
             }
         };
@@ -1077,7 +1168,7 @@ namespace sqlite_orm {
                 ss << "UPDATE " << streaming_identifier(table.name) << " SET ";
                 table.template for_each_column_excluding<mpl::disjunction_fn<is_primary_key, is_generated_always>>(
                     [&table, &ss, &context, &object = get_ref(statement.object), first = true](auto& column) mutable {
-                        if(table.exists_in_composite_primary_key(column)) {
+                        if(exists_in_composite_primary_key(table, column)) {
                             return;
                         }
 
@@ -1088,7 +1179,7 @@ namespace sqlite_orm {
                 ss << " WHERE ";
                 table.for_each_column(
                     [&table, &context, &ss, &object = get_ref(statement.object), first = true](auto& column) mutable {
-                        if(!column.template is<is_primary_key>() && !table.exists_in_composite_primary_key(column)) {
+                        if(!column.template is<is_primary_key>() && !exists_in_composite_primary_key(table, column)) {
                             return;
                         }
 
@@ -1194,7 +1285,7 @@ namespace sqlite_orm {
                     mpl::conjunction<mpl::not_<mpl::always<is_without_rowid>>,
                                      mpl::disjunction_fn<is_primary_key, is_generated_always>>>(
                     [&table, &columnNames](auto& column) {
-                        if(table.exists_in_composite_primary_key(column)) {
+                        if(exists_in_composite_primary_key(table, column)) {
                             return;
                         }
 
@@ -1216,7 +1307,7 @@ namespace sqlite_orm {
                               mpl::conjunction<mpl::not_<mpl::always<is_without_rowid>>,
                                                mpl::disjunction_fn<is_primary_key, is_generated_always>>{},
                               [&table](auto& column) {
-                                  return table.exists_in_composite_primary_key(column);
+                                  return exists_in_composite_primary_key(table, column);
                               },
                               context,
                               get_ref(statement.object))
@@ -1356,7 +1447,7 @@ namespace sqlite_orm {
                     mpl::conjunction<mpl::not_<mpl::always<is_without_rowid>>,
                                      mpl::disjunction_fn<is_primary_key, is_generated_always>>>(
                     [&table, &columnNames](auto& column) {
-                        if(table.exists_in_composite_primary_key(column)) {
+                        if(exists_in_composite_primary_key(table, column)) {
                             return;
                         }
 
@@ -1587,6 +1678,35 @@ namespace sqlite_orm {
             }
         };
 
+        template<class... Cs>
+        struct statement_serializer<using_fts5_t<Cs...>, void> {
+            using statement_type = using_fts5_t<Cs...>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& statement, const Ctx& context) const {
+                std::stringstream ss;
+                ss << "USING FTS5(";
+                auto subContext = context;
+                subContext.skip_types_and_constraints = true;
+                ss << streaming_expressions_tuple(statement.columns, subContext) << ")";
+                return ss.str();
+            }
+        };
+
+        template<class M>
+        struct statement_serializer<virtual_table_t<M>, void> {
+            using statement_type = virtual_table_t<M>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& statement, const Ctx& context) const {
+                std::stringstream ss;
+                ss << "CREATE VIRTUAL TABLE IF NOT EXISTS ";
+                ss << streaming_identifier(statement.name) << ' ';
+                ss << serialize(statement.module_details, context);
+                return ss.str();
+            }
+        };
+
         template<class T, class... Cols>
         struct statement_serializer<index_t<T, Cols...>, void> {
             using statement_type = index_t<T, Cols...>;
diff --git a/dev/storage.h b/dev/storage.h
index fd21e06a1..13c16bd45 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -107,15 +107,10 @@ namespace sqlite_orm {
                 using table_type = std::decay_t<decltype(table)>;
                 using context_t = serializer_context<db_objects_type>;
 
-                std::stringstream ss;
                 context_t context{this->db_objects};
-                ss << "CREATE TABLE " << streaming_identifier(tableName) << " ( "
-                   << streaming_expressions_tuple(table.elements, context) << ")";
-                if(table_type::is_without_rowid_v) {
-                    ss << " WITHOUT ROWID";
-                }
-                ss.flush();
-                perform_void_exec(db, ss.str());
+                statement_serializer<Table, void> serializer;
+                const auto sql = serializer.serialize(table, context, tableName);
+                perform_void_exec(db, sql);
             }
 
             /**
@@ -959,6 +954,16 @@ namespace sqlite_orm {
                 return res;
             }
 
+            template<class M>
+            sync_schema_result sync_table(const virtual_table_t<M>& virtualTable, sqlite3* db, bool) {
+                auto res = sync_schema_result::already_in_sync;
+                using context_t = serializer_context<db_objects_type>;
+                context_t context{this->db_objects};
+                auto query = serialize(virtualTable, context);
+                perform_void_exec(db, query);
+                return res;
+            }
+
             template<class... Cols>
             sync_schema_result sync_table(const index_t<Cols...>& index, sqlite3* db, bool) {
                 auto res = sync_schema_result::already_in_sync;
@@ -974,7 +979,8 @@ namespace sqlite_orm {
                 auto res = sync_schema_result::already_in_sync;  // TODO Change accordingly
                 using context_t = serializer_context<db_objects_type>;
                 context_t context{this->db_objects};
-                perform_void_exec(db, serialize(trigger, context));
+                auto query = serialize(trigger, context);
+                perform_void_exec(db, query);
                 return res;
             }
 
@@ -1001,7 +1007,8 @@ namespace sqlite_orm {
                 context.replace_bindable_with_question = true;
 
                 auto con = this->get_connection();
-                sqlite3_stmt* stmt = prepare_stmt(con.get(), serialize(statement, context));
+                const auto sql = serialize(statement, context);
+                sqlite3_stmt* stmt = prepare_stmt(con.get(), sql);
                 return prepared_statement_t<S>{std::forward<S>(statement), stmt, con};
             }
 
@@ -1265,7 +1272,7 @@ namespace sqlite_orm {
                         mpl::conjunction<mpl::not_<mpl::always<is_without_rowid>>,
                                          mpl::disjunction_fn<is_primary_key, is_generated_always>>>(
                         call_as_template_base<column_field>([&table, &bindValue, &object](auto& column) {
-                            if(!table.exists_in_composite_primary_key(column)) {
+                            if(!exists_in_composite_primary_key(table, column)) {
                                 bindValue(polyfill::invoke(column.member_pointer, object));
                             }
                         }));
@@ -1317,12 +1324,12 @@ namespace sqlite_orm {
                 auto& object = get_object(statement.expression);
                 table.template for_each_column_excluding<mpl::disjunction_fn<is_primary_key, is_generated_always>>(
                     call_as_template_base<column_field>([&table, &bindValue, &object](auto& column) {
-                        if(!table.exists_in_composite_primary_key(column)) {
+                        if(!exists_in_composite_primary_key(table, column)) {
                             bindValue(polyfill::invoke(column.member_pointer, object));
                         }
                     }));
                 table.for_each_column([&table, &bindValue, &object](auto& column) {
-                    if(column.template is<is_primary_key>() || table.exists_in_composite_primary_key(column)) {
+                    if(column.template is<is_primary_key>() || exists_in_composite_primary_key(table, column)) {
                         bindValue(polyfill::invoke(column.member_pointer, object));
                     }
                 });
diff --git a/dev/table_name_collector.h b/dev/table_name_collector.h
index 2e052da7c..47429675f 100644
--- a/dev/table_name_collector.h
+++ b/dev/table_name_collector.h
@@ -86,6 +86,11 @@ namespace sqlite_orm {
             void operator()(const table__rowid_t<T>&) {
                 this->table_names.emplace(lookup_table_name<T>(this->db_objects), "");
             }
+
+            template<class T, class X, class Y, class Z>
+            void operator()(const highlight_t<T, X, Y, Z>&) {
+                this->table_names.emplace(lookup_table_name<T>(this->db_objects), "");
+            }
         };
 
         template<class DBOs, satisfies<is_db_objects, DBOs> = true>
diff --git a/dev/type_is_nullable.h b/dev/type_is_nullable.h
index 1f77b95cf..9b59beb55 100644
--- a/dev/type_is_nullable.h
+++ b/dev/type_is_nullable.h
@@ -37,5 +37,4 @@ namespace sqlite_orm {
             return static_cast<bool>(t);
         }
     };
-
 }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index cf4ad36b2..eaa50d0c0 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -1941,7 +1941,6 @@ namespace sqlite_orm {
             return static_cast<bool>(t);
         }
     };
-
 }
 #pragma once
 
@@ -2924,6 +2923,7 @@ namespace sqlite_orm {
             bool replace_bindable_with_question = false;
             bool skip_table_name = true;
             bool use_parentheses = true;
+            bool skip_types_and_constraints = false;
         };
 
         template<class DBOs>
@@ -2948,7 +2948,6 @@ namespace sqlite_orm {
 
             const storage_type& storage;
         };
-
     }
 
 }
@@ -3510,6 +3509,16 @@ namespace sqlite_orm {
             }
         };
 
+        template<class L, class R>
+        struct is_equal_with_table_t : negatable_t {
+            using left_type = L;
+            using right_type = R;
+
+            right_type rhs;
+
+            is_equal_with_table_t(right_type rhs) : rhs(std::move(rhs)) {}
+        };
+
         struct is_not_equal_string {
             operator std::string() const {
                 return "!=";
@@ -4397,6 +4406,11 @@ namespace sqlite_orm {
         return {std::move(l), std::move(r)};
     }
 
+    template<class L, class R>
+    internal::is_equal_with_table_t<L, R> is_equal(R rhs) {
+        return {std::move(rhs)};
+    }
+
     template<class L, class R>
     internal::is_not_equal_t<L, R> is_not_equal(L l, R r) {
         return {std::move(l), std::move(r)};
@@ -5641,6 +5655,21 @@ namespace sqlite_orm {
 
         template<class T>
         using field_type_or_type_t = polyfill::detected_or_t<T, type_t, member_field_type<T>>;
+
+        template<class T, class X, class Y, class Z>
+        struct highlight_t {
+            using table_type = T;
+            using argument0_type = X;
+            using argument1_type = Y;
+            using argument2_type = Z;
+
+            argument0_type argument0;
+            argument1_type argument1;
+            argument2_type argument2;
+
+            highlight_t(argument0_type argument0, argument1_type argument1, argument2_type argument2) :
+                argument0(std::move(argument0)), argument1(std::move(argument1)), argument2(std::move(argument2)) {}
+        };
     }
 
 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS
@@ -7099,6 +7128,11 @@ namespace sqlite_orm {
             return {get_from_expression(std::forward<L>(l)), get_from_expression(std::forward<R>(r))};
         }
     }
+
+    template<class T, class X, class Y, class Z>
+    internal::highlight_t<T, X, Y, Z> highlight(X x, Y y, Z z) {
+        return {std::move(x), std::move(y), std::move(z)};
+    }
 }
 #pragma once
 
@@ -10337,25 +10371,6 @@ namespace sqlite_orm {
                 return result;
             }
 
-            template<class G, class S>
-            bool exists_in_composite_primary_key(const column_field<G, S>& column) const {
-                bool res = false;
-                this->for_each_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_any(memberPointer, column.member_pointer) ||
-                           compare_any(memberPointer, column.setter)) {
-                            res = true;
-                        }
-                    });
-                });
-                return res;
-            }
-
             /**
              *  Call passed lambda with all defined primary keys.
              */
@@ -10505,6 +10520,129 @@ namespace sqlite_orm {
 
         template<class O, bool W, class... Cs>
         struct is_table<table_t<O, W, Cs...>> : std::true_type {};
+
+        template<class M>
+        struct virtual_table_t : basic_table {
+            using module_details_type = M;
+            using object_type = typename module_details_type::object_type;
+            using elements_type = typename module_details_type::columns_type;
+
+            static constexpr bool is_without_rowid_v = false;
+            using is_without_rowid = polyfill::bool_constant<is_without_rowid_v>;
+
+            module_details_type module_details;
+
+#ifndef SQLITE_ORM_AGGREGATE_BASES_SUPPORTED
+            virtual_table_t(std::string name, module_details_type module_details) :
+                basic_table{std::move(name)}, module_details{std::move(module_details)} {}
+#endif
+
+            /**
+             *  Call passed lambda with columns not having the specified constraint trait `OpTrait`.
+             *  @param lambda Lambda called for each column.
+             */
+            template<template<class...> class OpTraitFn, class L>
+            void for_each_column_excluding(L&& lambda) const {
+                this->module_details.template for_each_column_excluding<OpTraitFn>(lambda);
+            }
+
+            /**
+             *  Call passed lambda with columns not having the specified constraint trait `OpTrait`.
+             *  @param lambda Lambda called for each column.
+             */
+            template<class OpTraitFnCls, class L, satisfies<mpl::is_metafunction_class, OpTraitFnCls> = true>
+            void for_each_column_excluding(L&& lambda) const {
+                this->module_details.template for_each_column_excluding<OpTraitFnCls>(lambda);
+            }
+
+            /**
+             *  Call passed lambda with all defined columns.
+             *  @param lambda Lambda called for each column. Function signature: `void(auto& column)`
+             */
+            template<class L>
+            void for_each_column(L&& lambda) const {
+                this->module_details.for_each_column(lambda);
+            }
+        };
+
+        template<class T>
+        struct is_virtual_table : std::false_type {};
+
+        template<class M>
+        struct is_virtual_table<virtual_table_t<M>> : std::true_type {};
+
+        template<class T, class... Cs>
+        struct using_fts5_t {
+            using object_type = T;
+            using columns_type = std::tuple<Cs...>;
+
+            columns_type columns;
+
+            using_fts5_t(columns_type columns) : columns(std::move(columns)) {}
+
+            /**
+             *  Call passed lambda with columns not having the specified constraint trait `OpTrait`.
+             *  @param lambda Lambda called for each column.
+             */
+            template<template<class...> class OpTraitFn, class L>
+            void for_each_column_excluding(L&& lambda) const {
+                iterate_tuple(this->columns, col_index_sequence_excluding<columns_type, OpTraitFn>{}, lambda);
+            }
+
+            /**
+             *  Call passed lambda with columns not having the specified constraint trait `OpTrait`.
+             *  @param lambda Lambda called for each column.
+             */
+            template<class OpTraitFnCls, class L, satisfies<mpl::is_metafunction_class, OpTraitFnCls> = true>
+            void for_each_column_excluding(L&& lambda) const {
+                this->for_each_column_excluding<OpTraitFnCls::template fn>(lambda);
+            }
+
+            /**
+             *  Call passed lambda with all defined columns.
+             *  @param lambda Lambda called for each column. Function signature: `void(auto& column)`
+             */
+            template<class L>
+            void for_each_column(L&& lambda) const {
+                using col_index_sequence = filter_tuple_sequence_t<columns_type, is_column>;
+                iterate_tuple(this->columns, col_index_sequence{}, lambda);
+            }
+        };
+
+        template<class O, bool WithoutRowId, class... Cs, class G, class S>
+        bool exists_in_composite_primary_key(const table_t<O, WithoutRowId, Cs...>& table,
+                                             const column_field<G, S>& column) {
+            bool res = false;
+            table.for_each_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_any(memberPointer, column.member_pointer) || compare_any(memberPointer, column.setter)) {
+                        res = true;
+                    }
+                });
+            });
+            return res;
+        }
+
+        template<class M, class G, class S>
+        bool exists_in_composite_primary_key(const virtual_table_t<M>& /*virtualTable*/,
+                                             const column_field<G, S>& /*column*/) {
+            return false;
+        }
+    }
+
+    template<class... Cs, class T = typename std::tuple_element_t<0, std::tuple<Cs...>>::object_type>
+    internal::using_fts5_t<T, Cs...> using_fts5(Cs... columns) {
+        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(return {std::make_tuple(std::forward<Cs>(columns)...)});
+    }
+
+    template<class T, class... Cs>
+    internal::using_fts5_t<T, Cs...> using_fts5(Cs... columns) {
+        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(return {std::make_tuple(std::forward<Cs>(columns)...)});
     }
 
     /**
@@ -10528,6 +10666,11 @@ namespace sqlite_orm {
         SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(
             return {std::move(name), std::make_tuple<Cs...>(std::forward<Cs>(args)...)});
     }
+
+    template<class M>
+    internal::virtual_table_t<M> make_virtual_table(std::string name, M module_details) {
+        SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(return {std::move(name), std::move(module_details)});
+    }
 }
 #pragma once
 
@@ -10904,8 +11047,8 @@ namespace sqlite_orm {
 
     namespace internal {
 
-        template<class T, class DBOs>
-        std::string serialize(const T&, const serializer_context<DBOs>&);
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context);
 
         /**
          *  Serialize default value of a column's default valu
@@ -11566,6 +11709,11 @@ namespace sqlite_orm {
             using type = typename T::result_type;
         };
 
+        template<class DBOs, class T, class X, class Y, class Z>
+        struct column_result_t<DBOs, highlight_t<T, X, Y, Z>, void> {
+            using type = std::string;
+        };
+
         /**
          *  Result for the most simple queries like `SELECT 1`
          */
@@ -12138,6 +12286,11 @@ namespace sqlite_orm {
             void operator()(const table__rowid_t<T>&) {
                 this->table_names.emplace(lookup_table_name<T>(this->db_objects), "");
             }
+
+            template<class T, class X, class Y, class Z>
+            void operator()(const highlight_t<T, X, Y, Z>&) {
+                this->table_names.emplace(lookup_table_name<T>(this->db_objects), "");
+            }
         };
 
         template<class DBOs, satisfies<is_db_objects, DBOs> = true>
@@ -13028,6 +13181,28 @@ namespace sqlite_orm {
 
 // #include "ast/set.h"
 
+// #include "ast/match.h"
+
+namespace sqlite_orm {
+    namespace internal {
+
+        template<class T, class X>
+        struct match_t {
+            using mapped_type = T;
+            using argument_type = X;
+
+            argument_type argument;
+
+            match_t(argument_type argument) : argument(std::move(argument)) {}
+        };
+    }
+
+    template<class T, class X>
+    internal::match_t<T, X> match(X argument) {
+        return {std::move(argument)};
+    }
+}
+
 namespace sqlite_orm {
 
     namespace internal {
@@ -13092,6 +13267,16 @@ namespace sqlite_orm {
             }
         };
 
+        template<class T, class X>
+        struct ast_iterator<match_t<T, X>, void> {
+            using node_type = match_t<T, X>;
+
+            template<class L>
+            void operator()(const node_type& node, L& lambda) const {
+                iterate_ast(node.argument, lambda);
+            }
+        };
+
         template<class... Args>
         struct ast_iterator<group_by_t<Args...>, void> {
             using node_type = group_by_t<Args...>;
@@ -13102,6 +13287,19 @@ namespace sqlite_orm {
             }
         };
 
+        template<class T, class X, class Y, class Z>
+        struct ast_iterator<highlight_t<T, X, Y, Z>, void> {
+            using node_type = highlight_t<T, X, Y, Z>;
+
+            template<class L>
+            void operator()(const node_type& expression, L& lambda) const {
+                lambda(expression);
+                iterate_ast(expression.argument0, lambda);
+                iterate_ast(expression.argument1, lambda);
+                iterate_ast(expression.argument2, lambda);
+            }
+        };
+
         template<class T>
         struct ast_iterator<excluded_t<T>, void> {
             using node_type = excluded_t<T>;
@@ -13148,9 +13346,19 @@ namespace sqlite_orm {
             using node_type = binary_operator<L, R, Ds...>;
 
             template<class C>
-            void operator()(const node_type& binaryOperator, C& lambda) const {
-                iterate_ast(binaryOperator.lhs, lambda);
-                iterate_ast(binaryOperator.rhs, lambda);
+            void operator()(const node_type& node, C& lambda) const {
+                iterate_ast(node.lhs, lambda);
+                iterate_ast(node.rhs, lambda);
+            }
+        };
+
+        template<class L, class R>
+        struct ast_iterator<is_equal_with_table_t<L, R>, void> {
+            using node_type = is_equal_with_table_t<L, R>;
+
+            template<class C>
+            void operator()(const node_type& node, C& lambda) const {
+                iterate_ast(node.rhs, lambda);
             }
         };
 
@@ -13826,8 +14034,8 @@ namespace sqlite_orm {
         template<class O>
         struct order_by_t;
 
-        template<class T, class DBOs>
-        std::string serialize(const T&, const serializer_context<DBOs>&);
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context);
 
         template<class T, class Ctx>
         std::string serialize_order_by(const T&, const Ctx&);
@@ -13994,7 +14202,7 @@ namespace sqlite_orm {
             return ss;
         }
 
-        // serialize and stream a vector of expressions;
+        // serialize and stream a vector or any other STL container of expressions;
         // comma-separated
         template<class C, class Ctx>
         std::ostream& operator<<(std::ostream& ss,
@@ -14003,8 +14211,9 @@ namespace sqlite_orm {
             auto& context = get<2>(tpl);
 
             constexpr std::array<const char*, 2> sep = {", ", ""};
-            for(size_t i = 0, first = true; i < args.size(); ++i) {
-                ss << sep[std::exchange(first, false)] << serialize(args[i], context);
+            bool first = true;
+            for(auto& argument: args) {
+                ss << sep[std::exchange(first, false)] << serialize(argument, context);
             }
             return ss;
         }
@@ -14175,7 +14384,7 @@ namespace sqlite_orm {
                 ss << serialize(constraint, context) << ' ';
             });
             if(isNotNull) {
-                ss << "NOT NULL ";
+                ss << "NOT NULL";
             }
 
             return ss;
@@ -14210,6 +14419,10 @@ namespace sqlite_orm {
 
             pragma_t(get_connection_t get_connection_) : get_connection(std::move(get_connection_)) {}
 
+            std::vector<std::string> module_list() {
+                return this->get_pragma<std::vector<std::string>>("module_list");
+            }
+
             void busy_timeout(int value) {
                 this->set_pragma("busy_timeout", value);
             }
@@ -15816,6 +16029,7 @@ namespace sqlite_orm {
 #endif  //  SQLITE_ORM_OMITS_CODECVT
 #include <memory>
 #include <array>
+#include <list>  //  std::list
 // #include "functional/cxx_string_view.h"
 
 // #include "functional/cxx_optional.h"
@@ -15836,6 +16050,20 @@ namespace sqlite_orm {
 
 // #include "ast/into.h"
 
+// #include "ast/match.h"
+
+// #include "ast/rank.h"
+
+namespace sqlite_orm {
+    namespace internal {
+        struct rank_t {};
+    }
+
+    inline internal::rank_t rank() {
+        return {};
+    }
+}
+
 // #include "core_functions.h"
 
 // #include "constraints.h"
@@ -15893,8 +16121,8 @@ namespace sqlite_orm {
 
     namespace internal {
 
-        template<class T, class DBOs>
-        std::string serialize(const T&, const serializer_context<DBOs>&);
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context);
 
         template<class T, class Ctx>
         std::vector<std::string>& collect_table_column_names(std::vector<std::string>& collectedExpressions,
@@ -16018,8 +16246,8 @@ namespace sqlite_orm {
 namespace sqlite_orm {
     namespace internal {
         // collecting column names utilizes the statement serializer
-        template<class T, class I>
-        std::string serialize(const T& t, const serializer_context<I>& context);
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context);
 
         inline void unquote_identifier(std::string& identifier) {
             if(!identifier.empty()) {
@@ -16292,6 +16520,8 @@ namespace sqlite_orm {
 
 // #include "schema/index.h"
 
+// #include "schema/table.h"
+
 // #include "util.h"
 
 namespace sqlite_orm {
@@ -16301,8 +16531,8 @@ namespace sqlite_orm {
         template<class T, class SFINAE = void>
         struct statement_serializer;
 
-        template<class T, class DBOs>
-        std::string serialize(const T& t, const serializer_context<DBOs>& context) {
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context) {
             statement_serializer<T> serializer;
             return serializer(t, context);
         }
@@ -16382,6 +16612,43 @@ namespace sqlite_orm {
             }
         };
 
+        template<class O, bool WithoutRowId, class... Cs>
+        struct statement_serializer<table_t<O, WithoutRowId, Cs...>, void> {
+            using statement_type = table_t<O, WithoutRowId, Cs...>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& statement, const Ctx& context) {
+                return this->serialize(statement, context, statement.name);
+            }
+
+            template<class Ctx>
+            std::string serialize(const statement_type& statement, const Ctx& context, const std::string& tableName) {
+                std::stringstream ss;
+                ss << "CREATE TABLE " << streaming_identifier(tableName) << " ( "
+                   << streaming_expressions_tuple(statement.elements, context) << ")";
+                if(statement_type::is_without_rowid_v) {
+                    ss << " WITHOUT ROWID";
+                }
+                return ss.str();
+            }
+        };
+
+        template<class T, class X, class Y, class Z>
+        struct statement_serializer<highlight_t<T, X, Y, Z>, void> {
+            using statement_type = highlight_t<T, X, Y, Z>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& statement, const Ctx& context) {
+                std::stringstream ss;
+                auto& tableName = lookup_table_name<T>(context.db_objects);
+                ss << "HIGHLIGHT (" << streaming_identifier(tableName);
+                ss << ", " << serialize(statement.argument0, context);
+                ss << ", " << serialize(statement.argument1, context);
+                ss << ", " << serialize(statement.argument2, context) << ")";
+                return ss.str();
+            }
+        };
+
         /**
          *  Serializer for literal values.
          */
@@ -16390,12 +16657,12 @@ namespace sqlite_orm {
             using statement_type = T;
 
             template<class Ctx>
-            std::string operator()(const T& literal, const Ctx& context) const {
-                static_assert(is_bindable_v<type_t<T>>, "A literal value must be also bindable");
+            std::string operator()(const statement_type& literal, const Ctx& context) const {
+                static_assert(is_bindable_v<type_t<statement_type>>, "A literal value must be also bindable");
 
                 Ctx literalCtx = context;
                 literalCtx.replace_bindable_with_question = false;
-                statement_serializer<type_t<T>> serializer{};
+                statement_serializer<type_t<statement_type>> serializer{};
                 return serializer(literal.value, literalCtx);
             }
         };
@@ -16462,6 +16729,19 @@ namespace sqlite_orm {
             }
         };
 
+        template<class T, class X>
+        struct statement_serializer<match_t<T, X>, void> {
+            using statement_type = match_t<T, X>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& statement, const Ctx& context) const {
+                auto& table = pick_table<T>(context.db_objects);
+                std::stringstream ss;
+                ss << streaming_identifier(table.name) << " MATCH " << serialize(statement.argument, context);
+                return ss.str();
+            }
+        };
+
         template<char... C>
         struct statement_serializer<column_alias<C...>, void> {
             using statement_type = column_alias<C...>;
@@ -16590,13 +16870,23 @@ namespace sqlite_orm {
             }
         };
 
+        template<>
+        struct statement_serializer<rank_t, void> {
+            using statement_type = rank_t;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& /*statement*/, const Ctx&) const {
+                return "rank";
+            }
+        };
+
         template<>
         struct statement_serializer<rowid_t, void> {
             using statement_type = rowid_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& s, const Ctx&) const {
-                return static_cast<std::string>(s);
+            std::string operator()(const statement_type& statement, const Ctx&) const {
+                return static_cast<std::string>(statement);
             }
         };
 
@@ -16605,8 +16895,8 @@ namespace sqlite_orm {
             using statement_type = oid_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& s, const Ctx&) const {
-                return static_cast<std::string>(s);
+            std::string operator()(const statement_type& statement, const Ctx&) const {
+                return static_cast<std::string>(statement);
             }
         };
 
@@ -16615,8 +16905,8 @@ namespace sqlite_orm {
             using statement_type = _rowid_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& s, const Ctx&) const {
-                return static_cast<std::string>(s);
+            std::string operator()(const statement_type& statement, const Ctx&) const {
+                return static_cast<std::string>(statement);
             }
         };
 
@@ -16625,12 +16915,12 @@ namespace sqlite_orm {
             using statement_type = table_rowid_t<O>;
 
             template<class Ctx>
-            std::string operator()(const statement_type& s, const Ctx& context) const {
+            std::string operator()(const statement_type& statement, const Ctx& context) const {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
                     ss << streaming_identifier(lookup_table_name<O>(context.db_objects)) << ".";
                 }
-                ss << static_cast<std::string>(s);
+                ss << static_cast<std::string>(statement);
                 return ss.str();
             }
         };
@@ -16640,12 +16930,12 @@ namespace sqlite_orm {
             using statement_type = table_oid_t<O>;
 
             template<class Ctx>
-            std::string operator()(const statement_type& s, const Ctx& context) const {
+            std::string operator()(const statement_type& statement, const Ctx& context) const {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
                     ss << streaming_identifier(lookup_table_name<O>(context.db_objects)) << ".";
                 }
-                ss << static_cast<std::string>(s);
+                ss << static_cast<std::string>(statement);
                 return ss.str();
             }
         };
@@ -16655,12 +16945,27 @@ namespace sqlite_orm {
             using statement_type = table__rowid_t<O>;
 
             template<class Ctx>
-            std::string operator()(const statement_type& s, const Ctx& context) const {
+            std::string operator()(const statement_type& statement, const Ctx& context) const {
                 std::stringstream ss;
                 if(!context.skip_table_name) {
                     ss << streaming_identifier(lookup_table_name<O>(context.db_objects)) << ".";
                 }
-                ss << static_cast<std::string>(s);
+                ss << static_cast<std::string>(statement);
+                return ss.str();
+            }
+        };
+
+        template<class L, class R>
+        struct statement_serializer<is_equal_with_table_t<L, R>, void> {
+            using statement_type = is_equal_with_table_t<L, R>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& statement, const Ctx& context) const {
+                std::stringstream ss;
+                const auto tableName = lookup_table_name<L>(context.db_objects);
+                ss << streaming_identifier(tableName);
+                ss << " = ";
+                ss << serialize(statement.rhs, context);
                 return ss.str();
             }
         };
@@ -16925,9 +17230,12 @@ namespace sqlite_orm {
             }
         };
 
-        template<class L, class A>
-        struct statement_serializer<dynamic_in_t<L, A>, void> {
-            using statement_type = dynamic_in_t<L, A>;
+        template<class L, class C>
+        struct statement_serializer<
+            dynamic_in_t<L, C>,
+            std::enable_if_t<!polyfill::disjunction_v<polyfill::is_specialization_of<C, std::vector>,
+                                                      polyfill::is_specialization_of<C, std::list>>>> {
+            using statement_type = dynamic_in_t<L, C>;
 
             template<class Ctx>
             std::string operator()(const statement_type& statement, const Ctx& context) const {
@@ -16940,22 +17248,25 @@ namespace sqlite_orm {
                     ss << "NOT IN";
                 }
                 ss << " ";
-                if(is_compound_operator_v<A>) {
+                if(is_compound_operator_v<C>) {
                     ss << '(';
                 }
                 auto newContext = context;
                 newContext.use_parentheses = true;
                 ss << serialize(statement.argument, newContext);
-                if(is_compound_operator_v<A>) {
+                if(is_compound_operator_v<C>) {
                     ss << ')';
                 }
                 return ss.str();
             }
         };
 
-        template<class L, class E>
-        struct statement_serializer<dynamic_in_t<L, std::vector<E>>, void> {
-            using statement_type = dynamic_in_t<L, std::vector<E>>;
+        template<class L, class C>
+        struct statement_serializer<
+            dynamic_in_t<L, C>,
+            std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<C, std::vector>,
+                                                     polyfill::is_specialization_of<C, std::list>>>> {
+            using statement_type = dynamic_in_t<L, C>;
 
             template<class Ctx>
             std::string operator()(const statement_type& statement, const Ctx& context) const {
@@ -17235,12 +17546,18 @@ namespace sqlite_orm {
                 using column_type = statement_type;
 
                 std::stringstream ss;
-                ss << streaming_identifier(column.name) << " " << type_printer<field_type_t<column_type>>().print()
-                   << " "
-                   << streaming_column_constraints(
-                          call_as_template_base<column_constraints>(polyfill::identity{})(column),
-                          column.is_not_null(),
-                          context);
+                ss << streaming_identifier(column.name);
+                if(!context.skip_types_and_constraints) {
+                    ss << " " << type_printer<field_type_t<column_type>>().print();
+                    const bool columnIsNotNull = column.is_not_null();
+                    auto constraintsTuple = streaming_column_constraints(
+                        call_as_template_base<column_constraints>(polyfill::identity{})(column),
+                        columnIsNotNull,
+                        context);
+                    if(std::tuple_size<decltype(constraintsTuple)>::value > 0) {
+                        ss << " " << constraintsTuple;
+                    }
+                }
                 return ss.str();
             }
         };
@@ -17326,7 +17643,7 @@ namespace sqlite_orm {
                 ss << "UPDATE " << streaming_identifier(table.name) << " SET ";
                 table.template for_each_column_excluding<mpl::disjunction_fn<is_primary_key, is_generated_always>>(
                     [&table, &ss, &context, &object = get_ref(statement.object), first = true](auto& column) mutable {
-                        if(table.exists_in_composite_primary_key(column)) {
+                        if(exists_in_composite_primary_key(table, column)) {
                             return;
                         }
 
@@ -17337,7 +17654,7 @@ namespace sqlite_orm {
                 ss << " WHERE ";
                 table.for_each_column(
                     [&table, &context, &ss, &object = get_ref(statement.object), first = true](auto& column) mutable {
-                        if(!column.template is<is_primary_key>() && !table.exists_in_composite_primary_key(column)) {
+                        if(!column.template is<is_primary_key>() && !exists_in_composite_primary_key(table, column)) {
                             return;
                         }
 
@@ -17443,7 +17760,7 @@ namespace sqlite_orm {
                     mpl::conjunction<mpl::not_<mpl::always<is_without_rowid>>,
                                      mpl::disjunction_fn<is_primary_key, is_generated_always>>>(
                     [&table, &columnNames](auto& column) {
-                        if(table.exists_in_composite_primary_key(column)) {
+                        if(exists_in_composite_primary_key(table, column)) {
                             return;
                         }
 
@@ -17465,7 +17782,7 @@ namespace sqlite_orm {
                               mpl::conjunction<mpl::not_<mpl::always<is_without_rowid>>,
                                                mpl::disjunction_fn<is_primary_key, is_generated_always>>{},
                               [&table](auto& column) {
-                                  return table.exists_in_composite_primary_key(column);
+                                  return exists_in_composite_primary_key(table, column);
                               },
                               context,
                               get_ref(statement.object))
@@ -17605,7 +17922,7 @@ namespace sqlite_orm {
                     mpl::conjunction<mpl::not_<mpl::always<is_without_rowid>>,
                                      mpl::disjunction_fn<is_primary_key, is_generated_always>>>(
                     [&table, &columnNames](auto& column) {
-                        if(table.exists_in_composite_primary_key(column)) {
+                        if(exists_in_composite_primary_key(table, column)) {
                             return;
                         }
 
@@ -17836,6 +18153,35 @@ namespace sqlite_orm {
             }
         };
 
+        template<class... Cs>
+        struct statement_serializer<using_fts5_t<Cs...>, void> {
+            using statement_type = using_fts5_t<Cs...>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& statement, const Ctx& context) const {
+                std::stringstream ss;
+                ss << "USING FTS5(";
+                auto subContext = context;
+                subContext.skip_types_and_constraints = true;
+                ss << streaming_expressions_tuple(statement.columns, subContext) << ")";
+                return ss.str();
+            }
+        };
+
+        template<class M>
+        struct statement_serializer<virtual_table_t<M>, void> {
+            using statement_type = virtual_table_t<M>;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& statement, const Ctx& context) const {
+                std::stringstream ss;
+                ss << "CREATE VIRTUAL TABLE IF NOT EXISTS ";
+                ss << streaming_identifier(statement.name) << ' ';
+                ss << serialize(statement.module_details, context);
+                return ss.str();
+            }
+        };
+
         template<class T, class... Cols>
         struct statement_serializer<index_t<T, Cols...>, void> {
             using statement_type = index_t<T, Cols...>;
@@ -18812,15 +19158,10 @@ namespace sqlite_orm {
                 using table_type = std::decay_t<decltype(table)>;
                 using context_t = serializer_context<db_objects_type>;
 
-                std::stringstream ss;
                 context_t context{this->db_objects};
-                ss << "CREATE TABLE " << streaming_identifier(tableName) << " ( "
-                   << streaming_expressions_tuple(table.elements, context) << ")";
-                if(table_type::is_without_rowid_v) {
-                    ss << " WITHOUT ROWID";
-                }
-                ss.flush();
-                perform_void_exec(db, ss.str());
+                statement_serializer<Table, void> serializer;
+                const auto sql = serializer.serialize(table, context, tableName);
+                perform_void_exec(db, sql);
             }
 
             /**
@@ -19664,6 +20005,16 @@ namespace sqlite_orm {
                 return res;
             }
 
+            template<class M>
+            sync_schema_result sync_table(const virtual_table_t<M>& virtualTable, sqlite3* db, bool) {
+                auto res = sync_schema_result::already_in_sync;
+                using context_t = serializer_context<db_objects_type>;
+                context_t context{this->db_objects};
+                auto query = serialize(virtualTable, context);
+                perform_void_exec(db, query);
+                return res;
+            }
+
             template<class... Cols>
             sync_schema_result sync_table(const index_t<Cols...>& index, sqlite3* db, bool) {
                 auto res = sync_schema_result::already_in_sync;
@@ -19679,7 +20030,8 @@ namespace sqlite_orm {
                 auto res = sync_schema_result::already_in_sync;  // TODO Change accordingly
                 using context_t = serializer_context<db_objects_type>;
                 context_t context{this->db_objects};
-                perform_void_exec(db, serialize(trigger, context));
+                auto query = serialize(trigger, context);
+                perform_void_exec(db, query);
                 return res;
             }
 
@@ -19706,7 +20058,8 @@ namespace sqlite_orm {
                 context.replace_bindable_with_question = true;
 
                 auto con = this->get_connection();
-                sqlite3_stmt* stmt = prepare_stmt(con.get(), serialize(statement, context));
+                const auto sql = serialize(statement, context);
+                sqlite3_stmt* stmt = prepare_stmt(con.get(), sql);
                 return prepared_statement_t<S>{std::forward<S>(statement), stmt, con};
             }
 
@@ -19970,7 +20323,7 @@ namespace sqlite_orm {
                         mpl::conjunction<mpl::not_<mpl::always<is_without_rowid>>,
                                          mpl::disjunction_fn<is_primary_key, is_generated_always>>>(
                         call_as_template_base<column_field>([&table, &bindValue, &object](auto& column) {
-                            if(!table.exists_in_composite_primary_key(column)) {
+                            if(!exists_in_composite_primary_key(table, column)) {
                                 bindValue(polyfill::invoke(column.member_pointer, object));
                             }
                         }));
@@ -20022,12 +20375,12 @@ namespace sqlite_orm {
                 auto& object = get_object(statement.expression);
                 table.template for_each_column_excluding<mpl::disjunction_fn<is_primary_key, is_generated_always>>(
                     call_as_template_base<column_field>([&table, &bindValue, &object](auto& column) {
-                        if(!table.exists_in_composite_primary_key(column)) {
+                        if(!exists_in_composite_primary_key(table, column)) {
                             bindValue(polyfill::invoke(column.member_pointer, object));
                         }
                     }));
                 table.for_each_column([&table, &bindValue, &object](auto& column) {
-                    if(column.template is<is_primary_key>() || table.exists_in_composite_primary_key(column)) {
+                    if(column.template is<is_primary_key>() || exists_in_composite_primary_key(table, column)) {
                         bindValue(polyfill::invoke(column.member_pointer, object));
                     }
                 });
@@ -20365,8 +20718,9 @@ namespace sqlite_orm {
 
 // #include "ast/group_by.h"
 
-namespace sqlite_orm {
+// #include "ast/match.h"
 
+namespace sqlite_orm {
     namespace internal {
 
         template<class T, class SFINAE = void>
@@ -20406,12 +20760,23 @@ namespace sqlite_orm {
             using type = tuple_cat_t<node_tuple_t<Args>...>;
         };
 
+        template<class T, class X, class Y, class Z>
+        struct node_tuple<highlight_t<T, X, Y, Z>, void> {
+            using x_node_tuple = node_tuple_t<X>;
+            using y_node_tuple = node_tuple_t<Y>;
+            using z_node_tuple = node_tuple_t<Z>;
+            using type = tuple_cat_t<x_node_tuple, y_node_tuple, z_node_tuple>;
+        };
+
         template<class T>
         struct node_tuple<excluded_t<T>, void> : node_tuple<T> {};
 
         template<class C>
         struct node_tuple<where_t<C>, void> : node_tuple<C> {};
 
+        template<class T, class X>
+        struct node_tuple<match_t<T, X>, void> : node_tuple<X> {};
+
         /**
          *  Column alias
          */
@@ -20433,6 +20798,9 @@ namespace sqlite_orm {
         template<class E>
         struct node_tuple<order_by_t<E>, void> : node_tuple<E> {};
 
+        template<class L, class R>
+        struct node_tuple<is_equal_with_table_t<L, R>, void> : node_tuple<R> {};
+
         template<class T>
         struct node_tuple<T, match_if<is_binary_condition, T>> {
             using node_type = T;
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 21e16195a..a0640deff 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -45,6 +45,7 @@ add_executable(unit_tests
     schema/index_tests.cpp
     schema/table_tests.cpp
     schema/explicit_columns.cpp
+    schema/virtual_table.cpp
     private_getters_tests.cpp
     pragma_tests.cpp
     built_in_functions_tests/core_functions_tests.cpp
@@ -92,6 +93,8 @@ add_executable(unit_tests
     statement_serializer_tests/ast/upsert_clause.cpp
     statement_serializer_tests/ast/excluded.cpp
     statement_serializer_tests/ast/set.cpp
+    statement_serializer_tests/ast/match.cpp
+    statement_serializer_tests/ast/rank.cpp
     statement_serializer_tests/arithmetic_operators.cpp
     statement_serializer_tests/base_types.cpp
     statement_serializer_tests/collate.cpp
@@ -104,6 +107,9 @@ add_executable(unit_tests
     statement_serializer_tests/schema/trigger.cpp
     statement_serializer_tests/schema/new_old.cpp
     statement_serializer_tests/schema/raise.cpp
+    statement_serializer_tests/schema/using_fts5.cpp
+    statement_serializer_tests/schema/virtual_table.cpp
+    statement_serializer_tests/schema/column.cpp
     statement_serializer_tests/indexed_column.cpp
     statement_serializer_tests/logical_operators.cpp
     statement_serializer_tests/statements/select.cpp
diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index e97de9266..51d22d3f2 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -219,6 +219,11 @@ TEST_CASE("ast_iterator") {
         auto node = into<User>();
         iterate_ast(node, lambda);
     }
+    SECTION("match") {
+        auto node = match<User>(std::string("Plazma"));
+        expected.push_back(typeid(std::string));
+        iterate_ast(node, lambda);
+    }
     SECTION("replace") {
         auto node =
             replace(into<User>(), columns(&User::id, &User::name), values(std::make_tuple(1, std::string("Ellie"))));
@@ -293,6 +298,11 @@ TEST_CASE("ast_iterator") {
         }
 #endif
     }
+    SECTION("is_equal_with_table_t") {
+        auto expression = is_equal<User>(std::string("Claude"));
+        expected.push_back(typeid(std::string));
+        iterate_ast(expression, lambda);
+    }
     SECTION("aliased regular column") {
         using als = alias_z<User>;
         auto expression = alias_column<als>(&User::id);
@@ -352,5 +362,13 @@ TEST_CASE("ast_iterator") {
     }
 #endif
 #endif
+    SECTION("highlight") {
+        auto expression = highlight<User>(0, std::string("<b>"), std::string("</b>"));
+        expected.push_back(typeid(expression));
+        expected.push_back(typeid(int));
+        expected.push_back(typeid(std::string));
+        expected.push_back(typeid(std::string));
+        iterate_ast(expression, lambda);
+    }
     REQUIRE(typeIndexes == expected);
 }
diff --git a/tests/pragma_tests.cpp b/tests/pragma_tests.cpp
index 691e9cb42..94995650a 100644
--- a/tests/pragma_tests.cpp
+++ b/tests/pragma_tests.cpp
@@ -4,6 +4,12 @@
 
 using namespace sqlite_orm;
 
+TEST_CASE("module_list") {
+    auto storage = make_storage({});
+
+    std::ignore = storage.pragma.module_list();
+}
+
 TEST_CASE("Journal mode") {
     auto filename = "journal_mode.sqlite";
     ::remove(filename);
diff --git a/tests/private_getters_tests.cpp b/tests/private_getters_tests.cpp
index b5a138cff..94e591bc6 100644
--- a/tests/private_getters_tests.cpp
+++ b/tests/private_getters_tests.cpp
@@ -1,5 +1,4 @@
 #include <sqlite_orm/sqlite_orm.h>
-#include <iostream>
 #include <catch2/catch_all.hpp>
 
 using namespace sqlite_orm;
diff --git a/tests/schema/column_tests.cpp b/tests/schema/column_tests.cpp
index e93f10438..fa31c5038 100644
--- a/tests/schema/column_tests.cpp
+++ b/tests/schema/column_tests.cpp
@@ -30,3 +30,18 @@ TEST_CASE("column tests is_generated") {
         REQUIRE_FALSE(column.is_generated());
     }
 }
+
+TEST_CASE("column is_not_null") {
+    struct User {
+        int id = 0;
+        std::unique_ptr<std::string> name;
+    };
+    SECTION("not null") {
+        auto column = make_column("id", &User::id);
+        REQUIRE(column.is_not_null());
+    }
+    SECTION("null") {
+        auto column = make_column("name", &User::name);
+        REQUIRE(!column.is_not_null());
+    }
+}
diff --git a/tests/schema/virtual_table.cpp b/tests/schema/virtual_table.cpp
new file mode 100644
index 000000000..6fa1f84cb
--- /dev/null
+++ b/tests/schema/virtual_table.cpp
@@ -0,0 +1,78 @@
+#include <sqlite_orm/sqlite_orm.h>
+#include <catch2/catch_all.hpp>
+
+using namespace sqlite_orm;
+
+TEST_CASE("virtual table") {
+    using Catch::Matchers::UnorderedEquals;
+
+    struct Post {
+        std::string title;
+        std::string body;
+
+        bool operator==(const Post& other) const {
+            return this->title == other.title && this->body == other.body;
+        }
+    };
+
+    /// CREATE VIRTUAL TABLE posts
+    /// USING FTS5(title, body);
+    auto storage = make_storage(
+        "",
+        make_virtual_table("posts", using_fts5(make_column("title", &Post::title), make_column("body", &Post::body))));
+
+    storage.sync_schema();
+    REQUIRE(storage.table_exists("posts"));
+
+    const std::vector<Post> postsToInsert = {
+        Post{"Learn SQlite FTS5", "This tutorial teaches you how to perform full-text search in SQLite using FTS5"},
+        Post{"Advanced SQlite Full-text Search", "Show you some advanced techniques in SQLite full-text searching"},
+        Post{"SQLite Tutorial", "Help you learn SQLite quickly and effectively"},
+    };
+
+    //    storage.remove_all<Post>();
+
+    /// INSERT INTO posts(title,body)
+    /// VALUES('Learn SQlite FTS5','This tutorial teaches you how to perform full-text search in SQLite using FTS5'),
+    /// ('Advanced SQlite Full-text Search','Show you some advanced techniques in SQLite full-text searching'),
+    /// ('SQLite Tutorial','Help you learn SQLite quickly and effectively');
+    storage.insert_range(postsToInsert.begin(), postsToInsert.end());
+
+    /// SELECT * FROM posts;
+    auto posts = storage.get_all<Post>();
+
+    //  check that all the posts are there
+    REQUIRE_THAT(posts, UnorderedEquals(postsToInsert));
+
+    /// SELECT *
+    /// FROM posts
+    /// WHERE posts MATCH 'fts5';
+    auto specificPosts = storage.get_all<Post>(where(match<Post>("fts5")));
+    decltype(specificPosts) expectedSpecificPosts = {
+        {"Learn SQlite FTS5", "This tutorial teaches you how to perform full-text search in SQLite using FTS5"},
+    };
+    REQUIRE(specificPosts == expectedSpecificPosts);
+
+    ///    SELECT *
+    ///    FROM posts
+    ///    WHERE posts = 'fts5';
+    auto specificPosts2 = storage.get_all<Post>(where(is_equal<Post>("fts5")));
+    REQUIRE(specificPosts2 == specificPosts);
+
+    ///    SELECT *
+    ///    FROM posts
+    ///    WHERE posts MATCH 'text'
+    ///    ORDER BY rank;
+    auto orderedPosts = storage.get_all<Post>(where(match<Post>("fts5")), order_by(rank()));
+
+    ///    SELECT highlight(posts,0, '<b>', '</b>'),
+    ///           highlight(posts,1, '<b>', '</b>')
+    ///    FROM posts
+    ///    WHERE posts MATCH 'SQLite'
+    ///    ORDER BY rank;
+    ///
+    auto highlightedPosts =
+        storage.select(columns(highlight<Post>(0, "<b>", "</b>"), highlight<Post>(1, "<b>", "</b>")),
+                       where(match<Post>("SQLite")),
+                       order_by(rank()));
+}
diff --git a/tests/statement_serializer_tests/ast/match.cpp b/tests/statement_serializer_tests/ast/match.cpp
new file mode 100644
index 000000000..0a9cba24b
--- /dev/null
+++ b/tests/statement_serializer_tests/ast/match.cpp
@@ -0,0 +1,20 @@
+#include <sqlite_orm/sqlite_orm.h>
+#include <catch2/catch_all.hpp>
+
+using namespace sqlite_orm;
+
+TEST_CASE("statement_serializer match") {
+    struct User {
+        int id = 0;
+        std::string name;
+    };
+    auto table =
+        make_virtual_table("users", using_fts5(make_column("id", &User::id), make_column("name", &User::name)));
+    using db_objects_t = internal::db_objects_tuple<decltype(table)>;
+    auto dbObjects = db_objects_t{table};
+    using context_t = internal::serializer_context<db_objects_t>;
+    context_t context{dbObjects};
+    auto node = match<User>("Claude");
+    auto value = serialize(node, context);
+    REQUIRE(value == "\"users\" MATCH 'Claude'");
+}
diff --git a/tests/statement_serializer_tests/ast/rank.cpp b/tests/statement_serializer_tests/ast/rank.cpp
new file mode 100644
index 000000000..2e735ceaa
--- /dev/null
+++ b/tests/statement_serializer_tests/ast/rank.cpp
@@ -0,0 +1,24 @@
+#include <sqlite_orm/sqlite_orm.h>
+#include <catch2/catch_all.hpp>
+
+using namespace sqlite_orm;
+
+TEST_CASE("statement_serializer rank") {
+    using db_objects_t = internal::db_objects_tuple<>;
+    auto dbObjects = db_objects_t{};
+    using context_t = internal::serializer_context<db_objects_t>;
+    context_t context{dbObjects};
+    std::string value;
+    std::string expected;
+    SECTION("rank") {
+        auto node = rank();
+        value = serialize(node, context);
+        expected = "rank";
+    }
+    SECTION("order by rank") {
+        auto node = order_by(rank());
+        value = serialize(node, context);
+        expected = "ORDER BY rank";
+    }
+    REQUIRE(value == expected);
+}
diff --git a/tests/statement_serializer_tests/collate.cpp b/tests/statement_serializer_tests/collate.cpp
index df60624f5..056cf78ac 100644
--- a/tests/statement_serializer_tests/collate.cpp
+++ b/tests/statement_serializer_tests/collate.cpp
@@ -6,19 +6,22 @@ using namespace sqlite_orm;
 TEST_CASE("statement_serializer collate") {
     internal::db_objects_tuple<> storage;
     internal::serializer_context<internal::db_objects_tuple<>> context{storage};
-    {
+    std::string value;
+    std::string expected;
+    SECTION("COLLATE NOCASE") {
         auto col = collate_nocase();
-        auto value = serialize(col, context);
-        REQUIRE(value == "COLLATE NOCASE");
+        value = serialize(col, context);
+        expected = "COLLATE NOCASE";
     }
-    {
+    SECTION("COLLATE BINARY") {
         auto col = collate_binary();
-        auto value = serialize(col, context);
-        REQUIRE(value == "COLLATE BINARY");
+        value = serialize(col, context);
+        expected = "COLLATE BINARY";
     }
-    {
+    SECTION("COLLATE RTRIM") {
         auto col = collate_rtrim();
-        auto value = serialize(col, context);
-        REQUIRE(value == "COLLATE RTRIM");
+        value = serialize(col, context);
+        expected = "COLLATE RTRIM";
     }
+    REQUIRE(value == expected);
 }
diff --git a/tests/statement_serializer_tests/comparison_operators.cpp b/tests/statement_serializer_tests/comparison_operators.cpp
index 125d72540..af53eec0c 100644
--- a/tests/statement_serializer_tests/comparison_operators.cpp
+++ b/tests/statement_serializer_tests/comparison_operators.cpp
@@ -4,8 +4,15 @@
 using namespace sqlite_orm;
 
 TEST_CASE("statement_serializer comparison operators") {
-    internal::db_objects_tuple<> storage;
-    internal::serializer_context<internal::db_objects_tuple<>> context{storage};
+    struct User {
+        int id = 0;
+        std::string name;
+    };
+    auto table = make_table("users", make_column("id", &User::id), make_column("name", &User::name));
+    using db_objects_t = internal::db_objects_tuple<decltype(table)>;
+    auto dbObjects = db_objects_t{table};
+    using context_t = internal::serializer_context<db_objects_t>;
+    context_t context{dbObjects};
     std::string value;
     std::string expected;
     SECTION("less_than") {
@@ -80,5 +87,9 @@ TEST_CASE("statement_serializer comparison operators") {
         }
         expected = "('lala' != 7)";
     }
+    SECTION("is_equal_with_table_t") {
+        value = serialize(is_equal<User>("Tom Gregory"), context);
+        expected = "\"users\" = 'Tom Gregory'";
+    }
     REQUIRE(value == expected);
 }
diff --git a/tests/statement_serializer_tests/logical_operators.cpp b/tests/statement_serializer_tests/logical_operators.cpp
index 679252b14..c62e4ddd8 100644
--- a/tests/statement_serializer_tests/logical_operators.cpp
+++ b/tests/statement_serializer_tests/logical_operators.cpp
@@ -75,8 +75,20 @@ TEST_CASE("statement_serializer logical operators") {
             expected = R"("id" NOT IN (1, 2, 3))";
         }
         SECTION("dynamic in") {
-            auto inValue = in(&User::id, {1, 2, 3});
-            stringValue = internal::serialize(inValue, context);
+            SECTION("initializer list") {
+                auto inValue = in(&User::id, {1, 2, 3});
+                stringValue = internal::serialize(inValue, context);
+            }
+            SECTION("vector") {
+                std::vector<int> vector{1, 2, 3};
+                auto inValue = in(&User::id, vector);
+                stringValue = internal::serialize(inValue, context);
+            }
+            SECTION("list") {
+                std::list<int> list{1, 2, 3};
+                auto inValue = in(&User::id, list);
+                stringValue = internal::serialize(inValue, context);
+            }
             expected = R"("id" IN (1, 2, 3))";
         }
         SECTION("dynamic not in") {
diff --git a/tests/statement_serializer_tests/schema/column.cpp b/tests/statement_serializer_tests/schema/column.cpp
new file mode 100644
index 000000000..78eae98fd
--- /dev/null
+++ b/tests/statement_serializer_tests/schema/column.cpp
@@ -0,0 +1,48 @@
+#include <sqlite_orm/sqlite_orm.h>
+#include <catch2/catch_all.hpp>
+
+using namespace sqlite_orm;
+
+TEST_CASE("statement_serializer column") {
+    struct User {
+        int id = 0;
+        std::string name;
+        std::unique_ptr<std::string> nullableText;
+    };
+    internal::db_objects_tuple<> storage;
+    internal::serializer_context<internal::db_objects_tuple<>> context{storage};
+    std::string value;
+    std::string expected;
+    SECTION("with types and constraints") {
+        context.skip_types_and_constraints = false;
+        SECTION("id INTEGER NOT NULL") {
+            auto column = make_column("id", &User::id);
+            value = serialize(column, context);
+            expected = "\"id\" INTEGER NOT NULL";
+        }
+        SECTION("name TEXT NOT NULL") {
+            auto column = make_column("name", &User::name);
+            value = serialize(column, context);
+            expected = "\"name\" TEXT NOT NULL";
+        }
+        SECTION("nullable text") {
+            auto column = make_column("nullable_text", &User::nullableText);
+            value = serialize(column, context);
+            expected = "\"nullable_text\" TEXT ";
+        }
+    }
+    SECTION("without types and constraints") {
+        context.skip_types_and_constraints = true;
+        SECTION("id INTEGER NOT NULL") {
+            auto column = make_column("id", &User::id);
+            value = serialize(column, context);
+            expected = "\"id\"";
+        }
+        SECTION("name TEXT NOT NULL") {
+            auto column = make_column("name", &User::name);
+            value = serialize(column, context);
+            expected = "\"name\"";
+        }
+    }
+    REQUIRE(value == expected);
+}
diff --git a/tests/statement_serializer_tests/schema/using_fts5.cpp b/tests/statement_serializer_tests/schema/using_fts5.cpp
new file mode 100644
index 000000000..cec6b2d9e
--- /dev/null
+++ b/tests/statement_serializer_tests/schema/using_fts5.cpp
@@ -0,0 +1,16 @@
+#include <sqlite_orm/sqlite_orm.h>
+#include <catch2/catch_all.hpp>
+
+using namespace sqlite_orm;
+
+TEST_CASE("statement_serializer using_fts5") {
+    struct Post {
+        std::string title;
+        std::string body;
+    };
+    internal::db_objects_tuple<> storage;
+    internal::serializer_context<internal::db_objects_tuple<>> context{storage};
+    auto node = using_fts5(make_column("title", &Post::title), make_column("body", &Post::body));
+    auto value = serialize(node, context);
+    REQUIRE(value == "USING FTS5(\"title\", \"body\")");
+}
diff --git a/tests/statement_serializer_tests/schema/virtual_table.cpp b/tests/statement_serializer_tests/schema/virtual_table.cpp
new file mode 100644
index 000000000..e64b4d89b
--- /dev/null
+++ b/tests/statement_serializer_tests/schema/virtual_table.cpp
@@ -0,0 +1,17 @@
+#include <sqlite_orm/sqlite_orm.h>
+#include <catch2/catch_all.hpp>
+
+using namespace sqlite_orm;
+
+TEST_CASE("statement_serializer FTS5") {
+    struct Post {
+        std::string title;
+        std::string body;
+    };
+    internal::db_objects_tuple<> storage;
+    internal::serializer_context<internal::db_objects_tuple<>> context{storage};
+    auto node =
+        make_virtual_table("posts", using_fts5(make_column("title", &Post::title), make_column("body", &Post::body)));
+    auto value = serialize(node, context);
+    REQUIRE(value == "CREATE VIRTUAL TABLE IF NOT EXISTS \"posts\" USING FTS5(\"title\", \"body\")");
+}
diff --git a/tests/static_tests/column.cpp b/tests/static_tests/column.cpp
index e2f976ba0..8348f70d0 100644
--- a/tests/static_tests/column.cpp
+++ b/tests/static_tests/column.cpp
@@ -6,6 +6,17 @@
 using namespace sqlite_orm;
 
 TEST_CASE("Column") {
+    {
+        using column_type = decltype(make_column("name", &User::name));
+        STATIC_REQUIRE(std::tuple_size<column_type::constraints_type>::value == 0);
+        STATIC_REQUIRE(std::is_same<column_type::object_type, User>::value);
+        STATIC_REQUIRE(std::is_same<column_type::field_type, std::unique_ptr<std::string>>::value);
+        STATIC_REQUIRE(std::is_same<column_type::member_pointer_t, std::unique_ptr<std::string> User::*>::value);
+        STATIC_REQUIRE(std::is_same<column_type::setter_type, internal::empty_setter>::value);
+
+        using field_type = column_type::field_type;
+        STATIC_REQUIRE(type_is_nullable<field_type>::value);
+    }
     {
         using column_type = decltype(make_column("id", &User::id));
         STATIC_REQUIRE(std::tuple_size<column_type::constraints_type>::value == 0);
diff --git a/tests/static_tests/node_tuple.cpp b/tests/static_tests/node_tuple.cpp
index f6a0b0330..3a6759258 100644
--- a/tests/static_tests/node_tuple.cpp
+++ b/tests/static_tests/node_tuple.cpp
@@ -52,6 +52,14 @@ TEST_CASE("Node tuple") {
         static_assert(is_same<Tuple, Expected>::value, "literal int");
         STATIC_REQUIRE(is_same<bindable_filter_t<Tuple>, tuple<>>::value);
     }
+    SECTION("is_equal_with_table_t") {
+        auto node = is_equal<User>(std::string("Claude"));
+        using Node = decltype(node);
+        using Tuple = node_tuple_t<Node>;
+        using Expected = tuple<std::string>;
+        static_assert(is_same<Tuple, Expected>::value, "is_equal_with_table_t");
+        STATIC_REQUIRE(is_same<bindable_filter_t<Tuple>, tuple<std::string>>::value);
+    }
     SECTION("binary_condition") {
         using namespace internal;
         SECTION("5 < 6.0f") {
@@ -433,6 +441,12 @@ TEST_CASE("Node tuple") {
         using Tuple = node_tuple_t<Expression>;
         STATIC_REQUIRE(is_same<Tuple, tuple<>>::value);
     }
+    SECTION("match") {
+        auto expression = match<User>(std::string("Plazma"));
+        using Expression = decltype(expression);
+        using Tuple = node_tuple_t<Expression>;
+        STATIC_REQUIRE(is_same<Tuple, tuple<std::string>>::value);
+    }
     SECTION("select") {
         SECTION("select(&User::id)") {
             auto sel = select(&User::id);
diff --git a/tests/static_tests/static_tests_common.h b/tests/static_tests/static_tests_common.h
index 366440f31..6e5c70451 100644
--- a/tests/static_tests/static_tests_common.h
+++ b/tests/static_tests/static_tests_common.h
@@ -1,7 +1,11 @@
 #pragma once
 
+#include <memory>  //  std::unique_ptr
+#include <string>  //  std::string
+
 struct User {
     int id;
+    std::unique_ptr<std::string> name;
 
     const int& getIdByRefConst() const {
         return this->id;
diff --git a/tests/sync_schema_tests.cpp b/tests/sync_schema_tests.cpp
index 4b5edb5fc..eb245a520 100644
--- a/tests/sync_schema_tests.cpp
+++ b/tests/sync_schema_tests.cpp
@@ -1,5 +1,4 @@
 #include <sqlite_orm/sqlite_orm.h>
-#include <iostream>
 #include <catch2/catch_all.hpp>
 
 using namespace sqlite_orm;
diff --git a/tests/table_name_collector.cpp b/tests/table_name_collector.cpp
index a38c21ffc..16d90a242 100644
--- a/tests/table_name_collector.cpp
+++ b/tests/table_name_collector.cpp
@@ -15,10 +15,10 @@ TEST_CASE("table name collector") {
     auto dbObjects = db_objects_t{table};
     internal::table_name_collector_base::table_name_set expected;
 
-    SECTION("from table") {
-        internal::serializer_context<db_objects_t> context{dbObjects};
-        auto collector = internal::make_table_name_collector(context.db_objects);
+    internal::serializer_context<db_objects_t> context{dbObjects};
+    auto collector = internal::make_table_name_collector(context.db_objects);
 
+    SECTION("from table") {
         SECTION("regular column") {
             using als = alias_z<User>;
             auto expression = &User::id;
@@ -84,4 +84,16 @@ TEST_CASE("table name collector") {
         REQUIRE(collector.table_names == expected);
     }
 #endif
+    SECTION("highlight") {
+        SECTION("simple") {
+            auto expression = highlight<User>(0, "<b>", "</b>");
+            expected.emplace(table.name, "");
+            iterate_ast(expression, collector);
+        }
+        SECTION("in columns") {
+            auto expression = columns(highlight<User>(0, "<b>", "</b>"));
+            expected.emplace(table.name, "");
+            iterate_ast(expression, collector);
+        }
+    }
 }
diff --git a/tests/tests4.cpp b/tests/tests4.cpp
index 3a690df26..3475267b0 100644
--- a/tests/tests4.cpp
+++ b/tests/tests4.cpp
@@ -14,9 +14,9 @@ TEST_CASE("Unique ptr in update") {
         std::unique_ptr<std::string> name;
     };
 
-    auto storage = make_storage(
-        {},
-        make_table("users", make_column("id", &User::id, primary_key()), make_column("name", &User::name)));
+    auto nameColumn = make_column("name", &User::name);
+    auto nameTable = make_table("users", make_column("id", &User::id, primary_key()), nameColumn);
+    auto storage = make_storage({}, nameTable);
     storage.sync_schema();
 
     storage.insert(User{});

From bb95d1041b03684a641b9e1fc9ad1f25bad70835 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 9 Oct 2023 21:52:27 +0200
Subject: [PATCH 126/161] Removed global numbered CTE moniker types

---
 dev/column_pointer.h                          |   6 +-
 dev/cte.h                                     |  22 ----
 dev/select_constraints.h                      |  17 ++-
 examples/common_table_expressions.cpp         | 119 ++++++++++--------
 include/sqlite_orm/sqlite_orm.h               |  45 +++----
 tests/ast_iterator_tests.cpp                  |  11 +-
 .../alias_extractor.cpp                       |   1 +
 .../select_constraints.cpp                    |   1 +
 tests/static_tests/alias.cpp                  |   1 +
 tests/static_tests/column_expression_type.cpp |   1 +
 tests/static_tests/column_result_t.cpp        |   1 +
 tests/static_tests/cte.cpp                    |   1 +
 tests/static_tests/node_tuple.cpp             |   1 +
 tests/table_name_collector.cpp                |   1 +
 14 files changed, 113 insertions(+), 115 deletions(-)

diff --git a/dev/column_pointer.h b/dev/column_pointer.h
index fdd65149f..de80ce400 100644
--- a/dev/column_pointer.h
+++ b/dev/column_pointer.h
@@ -59,6 +59,7 @@ namespace sqlite_orm {
      *
      *  Example:
      *  struct Object { ... };
+     *  using cte_1 = decltype(1_ctealias);
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
      *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
@@ -88,8 +89,8 @@ namespace sqlite_orm {
      *
      *  Example:
      *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select("z"_cte->*&Object::id));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select("z"_cte->*"a"_col));
+     *  storage.with(cte<"z"_cte>()(select(&Object::id)), select(column<"z"_cte>(&Object::id)));
+     *  storage.with(cte<"z"_cte>()(select(&Object::id)), select(column<"z"_cte>(1_colalias)));
      */
     template<orm_cte_moniker auto moniker, class F>
     constexpr auto column([[maybe_unused]] F field) {
@@ -112,6 +113,7 @@ namespace sqlite_orm {
      *
      *  Example:
      *  struct Object { ... };
+     *  using cte_1 = decltype(1_ctealias);
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
      */
diff --git a/dev/cte.h b/dev/cte.h
index db7ff1c7f..a91042c27 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -40,27 +40,5 @@ namespace sqlite_orm {
         return internal::to_alias<internal::cte_moniker, t>(std::make_index_sequence<t.size()>{});
     }
 #endif
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    using cte_1 = decltype("1"_cte);
-    using cte_2 = decltype("2"_cte);
-    using cte_3 = decltype("3"_cte);
-    using cte_4 = decltype("4"_cte);
-    using cte_5 = decltype("5"_cte);
-    using cte_6 = decltype("6"_cte);
-    using cte_7 = decltype("7"_cte);
-    using cte_8 = decltype("8"_cte);
-    using cte_9 = decltype("9"_cte);
-#else
-    using cte_1 = decltype(1_ctealias);
-    using cte_2 = decltype(2_ctealias);
-    using cte_3 = decltype(3_ctealias);
-    using cte_4 = decltype(4_ctealias);
-    using cte_5 = decltype(5_ctealias);
-    using cte_6 = decltype(6_ctealias);
-    using cte_7 = decltype(7_ctealias);
-    using cte_8 = decltype(8_ctealias);
-    using cte_9 = decltype(9_ctealias);
-#endif
 }
 #endif
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 444a8b643..e95fdfa25 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -488,13 +488,16 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
     /**
-     *  Example : cte<cte_1>()(select(&Object::id));
      *  The list of explicit columns is optional;
      *  if provided the number of columns must match the number of columns of the subselect.
      *  The column names will be merged with the subselect:
      *  1. column names of subselect
      *  2. explicit columns
      *  3. fill in empty column names with column index
+     *  
+     *  Example:
+     *  using cte_1 = decltype(1_ctealias);
+     *  cte<cte_1>()(select(&Object::id));
      */
     template<class Moniker,
              class... ExplicitCols,
@@ -534,15 +537,21 @@ namespace sqlite_orm {
     }
 #endif
 
-    // tuple of CTEs
+    /** 
+     *  With-clause for a tuple of CTEs.
+     */
     template<class E, class... Monikers, class... Selects, class... ExplicitCols>
     internal::with_t<E, internal::common_table_expression<Monikers, Selects, ExplicitCols>...>
     with(std::tuple<internal::common_table_expression<Monikers, Selects, ExplicitCols>...> cte, E expression) {
         return {std::move(cte), std::move(expression)};
     }
 
-    /** A single CTE.
-     *  Example : with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
+    /** 
+     *  With-clause for a single CTE.
+     *  
+     *  Example:
+     *  using cte_1 = decltype(1_ctealias);
+     *  with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
      */
     template<class E, class Moniker, class Select, class ExplicitCols>
     internal::with_t<E, internal::common_table_expression<Moniker, Select, ExplicitCols>>
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 422879807..a4faf322a 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -27,7 +27,7 @@ using namespace sqlite_orm;
 
 void all_integers_between(int from, int end) {
     auto storage = make_storage("");
-    // variant 1, where-clause
+    // variant 1, where-clause, implicitly numbered column
     {
         //WITH RECURSIVE
         //    cnt(x) AS(VALUES(1) UNION ALL SELECT x + 1 FROM cnt WHERE x < 1000000)
@@ -38,18 +38,12 @@ void all_integers_between(int from, int end) {
             with(cte<cnt>()(union_all(select(from), select(cnt->*1_colalias + 1, where(cnt->*1_colalias < end)))),
                  select(cnt->*1_colalias));
 #else
+        using cnt = decltype(1_ctealias);
         auto ast =
-            with(cte<cte_1>()(union_all(select(from),
-                                        select(1_ctealias->*1_colalias + 1, where(1_ctealias->*1_colalias < end)))),
+            with(cte<cnt>()(union_all(select(from),
+                                      select(1_ctealias->*1_colalias + 1, where(1_ctealias->*1_colalias < end)))),
                  select(1_ctealias->*1_colalias));
 #endif
-// alternative
-#if 0
-        auto ast = with(
-            cte<cte_1>()(union_all(select(from >>= colalias_i{}),
-                                   select(1_ctealias->*colalias_i{} + 1, where(1_ctealias->*colalias_i{} < end)))),
-            select(1_ctealias->*colalias_i{}));
-#endif
 
         string sql = storage.dump(ast);
 
@@ -63,7 +57,7 @@ void all_integers_between(int from, int end) {
         cout << endl;
     }
 
-    // variant 2, limit-clause
+    // variant 2, limit-clause, implicit column
     {
         //WITH RECURSIVE
         //    cnt(x) AS(
@@ -75,12 +69,13 @@ void all_integers_between(int from, int end) {
         //    SELECT x FROM cnt;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto cnt = "cnt"_cte;
-        auto ast = with(cte<cnt>("y"_col)(union_all(select(from >>= "x"_col), select(cnt->*"y"_col + 1, limit(end)))),
-                        select(cnt->*"y"_col));
+        constexpr auto x = "x"_col;
+        auto ast = with(cte<cnt>()(union_all(select(from >>= x), select(cnt->*x + 1, limit(end)))), select(cnt->*x));
 #else
-        auto ast = with(
-            cte<cte_1>()(union_all(select(as<colalias_i>(from)), select(column<cte_1>(colalias_i{}) + 1, limit(end)))),
-            select(column<cte_1>(colalias_i{})));
+        using cnt = decltype(1_ctealias);
+        constexpr auto x = colalias_i{};
+        auto ast = with(cte<cnt>()(union_all(select(from >>= x), select(column<cnt>(x) + 1, limit(end)))),
+                        select(column<cnt>(x)));
 #endif
 
         string sql = storage.dump(ast);
@@ -95,17 +90,17 @@ void all_integers_between(int from, int end) {
         cout << endl;
     }
 
-    // variant 3, limit-clause, explicit as() call
+    // variant 3, limit-clause, explicit column spec
     {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto cnt = "cnt"_cte;
-        auto ast =
-            with(cte<cnt>().as(union_all(select(as<"i"_col>(from)), select(column<cnt>("i"_col) + 1, limit(end)))),
-                 select(column<cnt>("i"_col)));
+        constexpr auto x = "x"_col;
+        auto ast = with(cte<cnt>(x)(union_all(select(from), select(cnt->*x + 1, limit(end)))), select(cnt->*x));
 #else
-        auto ast = with(cte<cte_1>().as(union_all(select(as<colalias_i>(from)),
-                                                  select(column<cte_1>(colalias_i{}) + 1, limit(end)))),
-                        select(column<cte_1>(colalias_i{})));
+        using cnt = decltype(1_ctealias);
+        constexpr auto x = colalias_i{};
+        auto ast = with(cte<cnt>(x).as(union_all(select(from), select(column<cnt>(x) + 1, limit(end)))),
+                        select(column<cnt>(x)));
 #endif
 
         string sql = storage.dump(ast);
@@ -174,11 +169,12 @@ void supervisor_chain() {
                                                where(alias_column<alias_a<Org>>(&Org::name) == chain->*&Org::boss)))),
                  select(chain->*&Org::name));
 #else
+        using chain = decltype(1_ctealias);
         auto ast = with(
-            cte<cte_1>()(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
+            cte<chain>()(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
                                    select(asterisk<alias_a<Org>>(),
-                                          where(alias_column<alias_a<Org>>(&Org::name) == column<cte_1>(&Org::boss))))),
-            select(column<cte_1>(&Org::name)));
+                                          where(alias_column<alias_a<Org>>(&Org::name) == column<chain>(&Org::boss))))),
+            select(column<chain>(&Org::name)));
 #endif
         string sql = storage.dump(ast);
 
@@ -240,9 +236,11 @@ void works_for_alice() {
                      union_(select("Alice"), select(&Org::name, where(&Org::boss == works_for_alice->*"n"_col)))),
                  select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(works_for_alice->*"n"_col)))));
 #else
+        using works_for_alice = decltype(1_ctealias);
         auto ast = with(
-            cte<cte_1>()(union_(select("Alice"), select(&Org::name, where(&Org::boss == column<cte_1>(1_colalias))))),
-            select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<cte_1>(1_colalias))))));
+            cte<works_for_alice>()(
+                union_(select("Alice"), select(&Org::name, where(&Org::boss == column<works_for_alice>(1_colalias))))),
+            select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<works_for_alice>(1_colalias))))));
 #endif
 
         //WITH cte_1("n")
@@ -329,17 +327,22 @@ void family_tree() {
                             select(parent_of->*parent, where(parent_of->*&Family::name == "Alice")),
                             select(parent_of->*parent, join<ancestor_of_alice>(using_(parent_of->*&Family::name)))))),
              select(&Family::name,
-                    where(is_equal(ancestor_of_alice->*name, &Family::name) && is_null(&Family::died)),
+                    where(ancestor_of_alice->*name == &Family::name && is_null(&Family::died)),
                     order_by(&Family::born)));
 #else
+    using parent_of = decltype(1_ctealias);
+    using ancestor_of_alice = decltype(2_ctealias);
+    constexpr auto parent = colalias_h{};
+    constexpr auto name = colalias_f{};
     auto ast = with(
-        make_tuple(cte<cte_1>("name", "parent")(union_(select(columns(&Family::name, &Family::mom >>= colalias_h{})),
-                                                       select(columns(&Family::name, &Family::dad)))),
-                   cte<cte_2>("name")(union_all(
-                       select(column<cte_1>(colalias_h{}), where(column<cte_1>(&Family::name) == "Alice")),
-                       select(column<cte_1>(colalias_h{}), join<cte_2>(using_(column<cte_1>(&Family::name))))))),
+        make_tuple(
+            cte<parent_of>("name", "parent")(union_(select(columns(&Family::name, &Family::mom >>= parent)),
+                                                    select(columns(&Family::name, &Family::dad)))),
+            cte<ancestor_of_alice>("name")(union_all(
+                select(column<parent_of>(parent) >>= name, where(column<parent_of>(&Family::name) == "Alice")),
+                select(column<parent_of>(parent), join<ancestor_of_alice>(using_(column<parent_of>(&Family::name))))))),
         select(&Family::name,
-               where(is_equal(column<cte_2>(colalias_h{}), &Family::name) && is_null(&Family::died)),
+               where(column<ancestor_of_alice>(name) == &Family::name && is_null(&Family::died)),
                order_by(&Family::born)));
 #endif
 
@@ -445,12 +448,14 @@ void depth_or_breadth_first() {
                                              order_by(2)))),
                         select(substr("..........", 1, under_alice->*level * 3) || under_alice->*&Org::name));
 #else
-        auto ast =
-            with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
-                                                       select(columns(&Org::name, column<cte_1>(2_colalias) + 1),
-                                                              join<cte_1>(on(column<cte_1>(1_colalias) == &Org::boss)),
-                                                              order_by(2)))),
-                 select(substr("..........", 1, column<cte_1>(2_colalias) * 3) || column<cte_1>(1_colalias)));
+        using under_alice = decltype(1_ctealias);
+        auto ast = with(
+            cte<under_alice>("name", "level")(
+                union_all(select(columns("Alice", 0)),
+                          select(columns(&Org::name, column<under_alice>(2_colalias) + 1),
+                                 join<under_alice>(on(column<under_alice>(1_colalias) == &Org::boss)),
+                                 order_by(2)))),
+            select(substr("..........", 1, column<under_alice>(2_colalias) * 3) || column<under_alice>(1_colalias)));
 #endif
 
         string sql = storage.dump(ast);
@@ -486,12 +491,14 @@ void depth_or_breadth_first() {
                                              order_by(2).desc()))),
                         select(substr("..........", 1, under_alice->*level * 3) || under_alice->*&Org::name));
 #else
-        auto ast =
-            with(cte<cte_1>("name", "level")(union_all(select(columns("Alice", 0)),
-                                                       select(columns(&Org::name, column<cte_1>(2_colalias) + 1),
-                                                              join<cte_1>(on(column<cte_1>(1_colalias) == &Org::boss)),
-                                                              order_by(2).desc()))),
-                 select(substr("..........", 1, column<cte_1>(2_colalias) * 3) || column<cte_1>(1_colalias)));
+        using under_alice = decltype(1_ctealias);
+        auto ast = with(
+            cte<under_alice>("name", "level")(
+                union_all(select(columns("Alice", 0)),
+                          select(columns(&Org::name, column<under_alice>(2_colalias) + 1),
+                                 join<under_alice>(on(column<under_alice>(1_colalias) == &Org::boss)),
+                                 order_by(2).desc()))),
+            select(substr("..........", 1, column<under_alice>(2_colalias) * 3) || column<under_alice>(1_colalias)));
 #endif
 
         string sql = storage.dump(ast);
@@ -535,8 +542,9 @@ void select_from_subselect() {
     auto expression = with(cte<sub>()(select(columns(&Employee::m_salary, &Employee::m_commission))),
                            select(asterisk<sub>(), where(sub->*&Employee::m_salary < 5000)));
 #else
-    auto expression = with(cte<cte_1>()(select(columns(&Employee::m_salary, &Employee::m_commission))),
-                           select(asterisk<cte_1>(), where(1_ctealias->*&Employee::m_salary < 5000)));
+    using sub = decltype(1_ctealias);
+    auto expression = with(cte<sub>()(select(columns(&Employee::m_salary, &Employee::m_commission))),
+                           select(asterisk<sub>(), where(column<sub>(&Employee::m_salary) < 5000)));
 #endif
 
     string sql = storage.dump(expression);
@@ -609,12 +617,12 @@ void apfelmaennchen() {
     constexpr cte_m m{};
     constexpr cte_m2 m2{};
     constexpr cte_a a{};
-    constexpr internal::column_alias<'x'> x;
-    constexpr internal::column_alias<'y'> y;
-    constexpr internal::column_alias<'i', 't', 'e', 'r'> iter;
-    constexpr internal::column_alias<'c', 'x'> cx;
-    constexpr internal::column_alias<'c', 'y'> cy;
-    constexpr internal::column_alias<'t'> t;
+    constexpr auto x = colalias_a{};
+    constexpr auto y = colalias_b{};
+    constexpr auto iter = colalias_c{};
+    constexpr auto cx = colalias_d{};
+    constexpr auto cy = colalias_e{};
+    constexpr auto t = colalias_f{};
     auto ast = with(
         make_tuple(cte<cte_xaxis>("x")(union_all(select(-2.0 >>= x), select(xaxis->*x + 0.05, where(xaxis->*x < 1.2)))),
                    cte<cte_yaxis>("y")(union_all(select(-1.0 >>= y), select(yaxis->*y + 0.10, where(yaxis->*y < 1.0)))),
@@ -734,6 +742,7 @@ void show_mapping_and_backreferencing() {
             return "counter";
         }
     };
+    using cte_1 = decltype(1_ctealias);
 
     auto storage = make_storage("", make_table("object", make_column("id", &Object::id)));
     storage.sync_schema();
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index eaa50d0c0..ec400332d 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3226,6 +3226,7 @@ namespace sqlite_orm {
      *
      *  Example:
      *  struct Object { ... };
+     *  using cte_1 = decltype(1_ctealias);
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
      *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
@@ -3255,8 +3256,8 @@ namespace sqlite_orm {
      *
      *  Example:
      *  struct Object { ... };
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select("z"_cte->*&Object::id));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select("z"_cte->*"a"_col));
+     *  storage.with(cte<"z"_cte>()(select(&Object::id)), select(column<"z"_cte>(&Object::id)));
+     *  storage.with(cte<"z"_cte>()(select(&Object::id)), select(column<"z"_cte>(1_colalias)));
      */
     template<orm_cte_moniker auto moniker, class F>
     constexpr auto column([[maybe_unused]] F field) {
@@ -3279,6 +3280,7 @@ namespace sqlite_orm {
      *
      *  Example:
      *  struct Object { ... };
+     *  using cte_1 = decltype(1_ctealias);
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
      */
@@ -7776,13 +7778,16 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
     /**
-     *  Example : cte<cte_1>()(select(&Object::id));
      *  The list of explicit columns is optional;
      *  if provided the number of columns must match the number of columns of the subselect.
      *  The column names will be merged with the subselect:
      *  1. column names of subselect
      *  2. explicit columns
      *  3. fill in empty column names with column index
+     *  
+     *  Example:
+     *  using cte_1 = decltype(1_ctealias);
+     *  cte<cte_1>()(select(&Object::id));
      */
     template<class Moniker,
              class... ExplicitCols,
@@ -7822,15 +7827,21 @@ namespace sqlite_orm {
     }
 #endif
 
-    // tuple of CTEs
+    /** 
+     *  With-clause for a tuple of CTEs.
+     */
     template<class E, class... Monikers, class... Selects, class... ExplicitCols>
     internal::with_t<E, internal::common_table_expression<Monikers, Selects, ExplicitCols>...>
     with(std::tuple<internal::common_table_expression<Monikers, Selects, ExplicitCols>...> cte, E expression) {
         return {std::move(cte), std::move(expression)};
     }
 
-    /** A single CTE.
-     *  Example : with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
+    /** 
+     *  With-clause for a single CTE.
+     *  
+     *  Example:
+     *  using cte_1 = decltype(1_ctealias);
+     *  with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
      */
     template<class E, class Moniker, class Select, class ExplicitCols>
     internal::with_t<E, internal::common_table_expression<Moniker, Select, ExplicitCols>>
@@ -20645,28 +20656,6 @@ namespace sqlite_orm {
         return internal::to_alias<internal::cte_moniker, t>(std::make_index_sequence<t.size()>{});
     }
 #endif
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    using cte_1 = decltype("1"_cte);
-    using cte_2 = decltype("2"_cte);
-    using cte_3 = decltype("3"_cte);
-    using cte_4 = decltype("4"_cte);
-    using cte_5 = decltype("5"_cte);
-    using cte_6 = decltype("6"_cte);
-    using cte_7 = decltype("7"_cte);
-    using cte_8 = decltype("8"_cte);
-    using cte_9 = decltype("9"_cte);
-#else
-    using cte_1 = decltype(1_ctealias);
-    using cte_2 = decltype(2_ctealias);
-    using cte_3 = decltype(3_ctealias);
-    using cte_4 = decltype(4_ctealias);
-    using cte_5 = decltype(5_ctealias);
-    using cte_6 = decltype(6_ctealias);
-    using cte_7 = decltype(7_ctealias);
-    using cte_8 = decltype(8_ctealias);
-    using cte_9 = decltype(9_ctealias);
-#endif
 }
 #endif
 #pragma once
diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index 51d22d3f2..d88563c06 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -8,6 +8,7 @@ using internal::alias_column_t;
 using internal::alias_holder;
 using internal::column_alias;
 using internal::column_pointer;
+using internal::cte_moniker;
 using internal::iterate_ast;
 
 TEST_CASE("ast_iterator") {
@@ -331,9 +332,10 @@ TEST_CASE("ast_iterator") {
 #endif
 #ifdef SQLITE_ORM_WITH_CTE
     SECTION("with") {
+        using cte_1 = decltype(1_ctealias);
         auto expression =
             with(cte<cte_1>()(
-                     union_all(select(1), select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < 10)))),
+                     union_all(select(1), select(1_ctealias->*1_colalias + 1, where(1_ctealias->*1_colalias < 10)))),
                  select(1_ctealias->*1_colalias));
         expected.insert(expected.cend(),
                         {typeid(int),
@@ -349,15 +351,16 @@ TEST_CASE("ast_iterator") {
         constexpr auto c = "1"_cte;
         constexpr auto z_alias = "z"_alias.for_<c>();
         auto expression = z_alias->*&User::id;
-        expected.push_back(typeid(alias_column_t<alias_z<cte_1>, column_pointer<cte_1, decltype(&User::id)>>));
+        expected.push_back(
+            typeid(alias_column_t<alias_z<cte_moniker<'1'>>, column_pointer<cte_moniker<'1'>, decltype(&User::id)>>));
         iterate_ast(expression, lambda);
     }
     SECTION("aliased CTE column alias") {
         constexpr auto c = "1"_cte;
         constexpr auto z_alias = "z"_alias.for_<c>();
         auto expression = z_alias->*1_colalias;
-        expected.push_back(
-            typeid(alias_column_t<alias_z<cte_1>, column_pointer<cte_1, alias_holder<column_alias<'1'>>>>));
+        expected.push_back(typeid(alias_column_t<alias_z<cte_moniker<'1'>>,
+                                                 column_pointer<cte_moniker<'1'>, alias_holder<column_alias<'1'>>>>));
         iterate_ast(expression, lambda);
     }
 #endif
diff --git a/tests/statement_serializer_tests/alias_extractor.cpp b/tests/statement_serializer_tests/alias_extractor.cpp
index 9b862beb4..ea31f422f 100644
--- a/tests/statement_serializer_tests/alias_extractor.cpp
+++ b/tests/statement_serializer_tests/alias_extractor.cpp
@@ -21,6 +21,7 @@ TEST_CASE("alias extractor") {
     }
 #ifdef SQLITE_ORM_WITH_CTE
     SECTION("cte table") {
+        using cte_1 = decltype(1_ctealias);
         REQUIRE(alias_extractor<cte_1>::extract() == "1");
         REQUIRE(alias_extractor<cte_1>::as_alias() == "");
     }
diff --git a/tests/statement_serializer_tests/select_constraints.cpp b/tests/statement_serializer_tests/select_constraints.cpp
index 92ba376db..54f7d6f8d 100644
--- a/tests/statement_serializer_tests/select_constraints.cpp
+++ b/tests/statement_serializer_tests/select_constraints.cpp
@@ -88,6 +88,7 @@ TEST_CASE("statement_serializer select constraints") {
     }
 #ifdef SQLITE_ORM_WITH_CTE
     SECTION("from CTE") {
+        using cte_1 = decltype(1_ctealias);
         auto dbObjects2 =
             internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
         using context_t = internal::serializer_context<decltype(dbObjects2)>;
diff --git a/tests/static_tests/alias.cpp b/tests/static_tests/alias.cpp
index 412a1e33a..3df4a8c91 100644
--- a/tests/static_tests/alias.cpp
+++ b/tests/static_tests/alias.cpp
@@ -48,6 +48,7 @@ TEST_CASE("aliases") {
 #ifdef SQLITE_ORM_WITH_CTE
         runTest<column_alias<'1'>>(1_colalias);
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        using cte_1 = decltype(1_ctealias);
         constexpr auto c_alias = "c"_alias.for_<"1"_cte>();
         runTest<alias_column_t<alias_c<cte_1>, column_pointer<cte_1, alias_holder<column_alias<'a'>>>>>(
             alias_column<c_alias>("a"_col));
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index 4937c94c4..77cb783ec 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -50,6 +50,7 @@ TEST_CASE("column_expression_of_t") {
 
     runTest<db_objects_t, column_pointer<Derived, int64 Org::*>>(column<Derived>(&Org::id));
 #ifdef SQLITE_ORM_WITH_CTE
+    using cte_1 = decltype(1_ctealias);
     auto dbObjects2 =
         internal::db_objects_cat(dbObjects,
                                  internal::make_cte_table(dbObjects, cte<cte_1>()(select(columns(&Org::id, 1)))));
diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
index 47d1fbb0b..d62f42894 100644
--- a/tests/static_tests/column_result_t.cpp
+++ b/tests/static_tests/column_result_t.cpp
@@ -116,6 +116,7 @@ TEST_CASE("column_result_of_t") {
     runTest<db_objects_t, int>(alias_column<alias_a<User>>(&User::id));
     runTest<db_objects_t, User>(object<User>());
 #ifdef SQLITE_ORM_WITH_CTE
+    using cte_1 = decltype(1_ctealias);
     // note: even though used with the CTE, &User::id doesn't need to be mapped into the CTE to make column results work;
     //       this is because the result type is taken from the member pointer just because we can't look it up in the storage definition
     auto dbObjects2 = internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
diff --git a/tests/static_tests/cte.cpp b/tests/static_tests/cte.cpp
index ee9a78583..5f7ba8939 100644
--- a/tests/static_tests/cte.cpp
+++ b/tests/static_tests/cte.cpp
@@ -53,6 +53,7 @@ TEST_CASE("CTE storage") {
         auto idx1 = make_unique_index("idx1_org", &Org::id);
         auto idx2 = make_index("idx2_org", &Org::id);
         auto dbObjects = tuple{idx1, idx2, table};
+        using cte_1 = decltype(1_ctealias);
         auto cteTable = internal::make_cte_table(dbObjects, cte<cte_1>()(select(1)));
         auto dbObjects2 = internal::db_objects_cat(dbObjects, cteTable);
 
diff --git a/tests/static_tests/node_tuple.cpp b/tests/static_tests/node_tuple.cpp
index 3a6759258..e70e8bda3 100644
--- a/tests/static_tests/node_tuple.cpp
+++ b/tests/static_tests/node_tuple.cpp
@@ -949,6 +949,7 @@ TEST_CASE("Node tuple") {
     }
 #ifdef SQLITE_ORM_WITH_CTE
     SECTION("with") {
+        using cte_1 = decltype(1_ctealias);
         auto expression =
             with(cte<cte_1>()(
                      union_all(select(1), select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < 10)))),
diff --git a/tests/table_name_collector.cpp b/tests/table_name_collector.cpp
index 16d90a242..bf6492d6b 100644
--- a/tests/table_name_collector.cpp
+++ b/tests/table_name_collector.cpp
@@ -47,6 +47,7 @@ TEST_CASE("table name collector") {
 
 #ifdef SQLITE_ORM_WITH_CTE
     SECTION("from CTE") {
+        using cte_1 = decltype(1_ctealias);
         auto dbObjects2 =
             internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
         using context_t = internal::serializer_context<decltype(dbObjects2)>;

From 2d3c8fceb350fee12f0cc2fb9aa5f39e25cec2b9 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Mon, 9 Oct 2023 23:27:19 +0200
Subject: [PATCH 127/161] Convenience function for constructing a CTE by
 directly using a moniker

---
 dev/cte.h                                     |  43 ++++-
 dev/select_constraints.h                      |  33 ++++
 examples/common_table_expressions.cpp         |  99 ++++++-----
 include/sqlite_orm/sqlite_orm.h               | 162 +++++++++++++++++-
 .../column_names.cpp                          |   2 +-
 tests/static_tests/cte.cpp                    |  15 +-
 tests/static_tests/node_tuple.cpp             |   2 +-
 tests/table_name_collector.cpp                |   3 +-
 8 files changed, 300 insertions(+), 59 deletions(-)

diff --git a/dev/cte.h b/dev/cte.h
index a91042c27..244e05d34 100644
--- a/dev/cte.h
+++ b/dev/cte.h
@@ -1,8 +1,14 @@
 #pragma once
 
 #ifdef SQLITE_ORM_WITH_CTE
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+#include <concepts>
 #include <utility>  //  std::make_index_sequence
 #endif
+#include <type_traits>  //  std::enable_if, std::is_member_pointer, std::is_same, std::is_convertible
+#include <tuple>  //  std::ignore
+#include <string>
+#endif
 
 #include "functional/cxx_universal.h"
 #include "alias.h"
@@ -19,7 +25,42 @@ namespace sqlite_orm {
             : recordset_alias<
                   cte_moniker<A, X...> /* refer to self, since a moniker is both, an alias and a mapped type */,
                   A,
-                  X...> {};
+                  X...> {
+            /** 
+             *  Introduce the construction of a common table expression.
+             *  
+             *  The list of explicit columns is optional;
+             *  if provided the number of columns must match the number of columns of the subselect.
+             *  The column names will be merged with the subselect:
+             *  1. column names of subselect
+             *  2. explicit columns
+             *  3. fill in empty column names with column index
+             *  
+             *  Example:
+             *  1_ctealias()(select(&Object::id));
+             *  1_ctealias(&Object::name)(select("object"));
+             *  
+             *  @return A `cte_builder` instance.
+             *  @note (internal): Defined in select_constraints.h in order to keep this member function in the same place as the named factory function `cte()`.
+             */
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+            template<class... ExplicitCols>
+                requires((is_column_alias_v<ExplicitCols> || std::is_member_pointer_v<ExplicitCols> ||
+                          std::same_as<ExplicitCols, std::remove_cvref_t<decltype(std::ignore)>> ||
+                          std::convertible_to<ExplicitCols, std::string>) &&
+                         ...)
+            auto operator()(ExplicitCols... explicitColumns) const;
+#else
+            template<class... ExplicitCols,
+                     std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
+                                          is_column_alias<ExplicitCols>,
+                                          std::is_member_pointer<ExplicitCols>,
+                                          std::is_same<ExplicitCols, polyfill::remove_cvref_t<decltype(std::ignore)>>,
+                                          std::is_convertible<ExplicitCols, std::string>>...>,
+                                      bool> = true>
+            auto operator()(ExplicitCols... explicitColumns) const;
+#endif
+        };
     }
 
     /**
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index e95fdfa25..aa134177b 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -1,5 +1,8 @@
 #pragma once
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+#include <concepts>
+#endif
 #include <type_traits>  //  std::remove_const
 #include <string>  //  std::string
 #include <utility>  //  std::move
@@ -16,6 +19,7 @@
 #include "ast/group_by.h"
 #include "core_functions.h"
 #include "alias_traits.h"
+#include "cte.h"
 
 namespace sqlite_orm {
 
@@ -488,6 +492,8 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
     /**
+     *  Introduce the construction of a common table expression.
+     *  
      *  The list of explicit columns is optional;
      *  if provided the number of columns must match the number of columns of the subselect.
      *  The column names will be merged with the subselect:
@@ -498,6 +504,7 @@ namespace sqlite_orm {
      *  Example:
      *  using cte_1 = decltype(1_ctealias);
      *  cte<cte_1>()(select(&Object::id));
+     *  cte<cte_1>(&Object::name)(select("object"));
      */
     template<class Moniker,
              class... ExplicitCols,
@@ -537,6 +544,32 @@ namespace sqlite_orm {
     }
 #endif
 
+    namespace internal {
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        template<char A, char... X>
+        template<class... ExplicitCols>
+            requires((is_column_alias_v<ExplicitCols> || std::is_member_pointer_v<ExplicitCols> ||
+                      std::same_as<ExplicitCols, std::remove_cvref_t<decltype(std::ignore)>> ||
+                      std::convertible_to<ExplicitCols, std::string>) &&
+                     ...)
+        auto cte_moniker<A, X...>::operator()(ExplicitCols... explicitColumns) const {
+            return cte<cte_moniker<A, X...>>(std::forward<ExplicitCols>(explicitColumns)...);
+        }
+#else
+        template<char A, char... X>
+        template<class... ExplicitCols,
+                 std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
+                                      is_column_alias<ExplicitCols>,
+                                      std::is_member_pointer<ExplicitCols>,
+                                      std::is_same<ExplicitCols, polyfill::remove_cvref_t<decltype(std::ignore)>>,
+                                      std::is_convertible<ExplicitCols, std::string>>...>,
+                                  bool>>
+        auto cte_moniker<A, X...>::operator()(ExplicitCols... explicitColumns) const {
+            return cte<cte_moniker<A, X...>>(std::forward<ExplicitCols>(explicitColumns)...);
+        }
+#endif
+    }
+
     /** 
      *  With-clause for a tuple of CTEs.
      */
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index a4faf322a..f5c2fb8e3 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -34,9 +34,8 @@ void all_integers_between(int from, int end) {
         //    SELECT x FROM cnt;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto cnt = "cnt"_cte;
-        auto ast =
-            with(cte<cnt>()(union_all(select(from), select(cnt->*1_colalias + 1, where(cnt->*1_colalias < end)))),
-                 select(cnt->*1_colalias));
+        auto ast = with(cnt()(union_all(select(from), select(cnt->*1_colalias + 1, where(cnt->*1_colalias < end)))),
+                        select(cnt->*1_colalias));
 #else
         using cnt = decltype(1_ctealias);
         auto ast =
@@ -70,7 +69,7 @@ void all_integers_between(int from, int end) {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto cnt = "cnt"_cte;
         constexpr auto x = "x"_col;
-        auto ast = with(cte<cnt>()(union_all(select(from >>= x), select(cnt->*x + 1, limit(end)))), select(cnt->*x));
+        auto ast = with(cnt()(union_all(select(from >>= x), select(cnt->*x + 1, limit(end)))), select(cnt->*x));
 #else
         using cnt = decltype(1_ctealias);
         constexpr auto x = colalias_i{};
@@ -95,7 +94,7 @@ void all_integers_between(int from, int end) {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto cnt = "cnt"_cte;
         constexpr auto x = "x"_col;
-        auto ast = with(cte<cnt>(x)(union_all(select(from), select(cnt->*x + 1, limit(end)))), select(cnt->*x));
+        auto ast = with(cnt(x)(union_all(select(from), select(cnt->*x + 1, limit(end)))), select(cnt->*x));
 #else
         using cnt = decltype(1_ctealias);
         constexpr auto x = colalias_i{};
@@ -163,11 +162,10 @@ void supervisor_chain() {
         //    SELECT name FROM chain;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto chain = "chain"_cte;
-        auto ast =
-            with(cte<chain>()(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
-                                        select(asterisk<alias_a<Org>>(),
-                                               where(alias_column<alias_a<Org>>(&Org::name) == chain->*&Org::boss)))),
-                 select(chain->*&Org::name));
+        auto ast = with(chain()(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
+                                          select(asterisk<alias_a<Org>>(),
+                                                 where(alias_column<alias_a<Org>>(&Org::name) == chain->*&Org::boss)))),
+                        select(chain->*&Org::name));
 #else
         using chain = decltype(1_ctealias);
         auto ast = with(
@@ -232,15 +230,15 @@ void works_for_alice() {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto works_for_alice = "works_for_alice"_cte;
         auto ast =
-            with(cte<works_for_alice>("n"_col)(
-                     union_(select("Alice"), select(&Org::name, where(&Org::boss == works_for_alice->*"n"_col)))),
-                 select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(works_for_alice->*"n"_col)))));
+            with(works_for_alice(&Org::name)(
+                     union_(select("Alice"), select(&Org::name, where(&Org::boss == works_for_alice->*&Org::name)))),
+                 select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(works_for_alice->*&Org::name)))));
 #else
         using works_for_alice = decltype(1_ctealias);
         auto ast = with(
-            cte<works_for_alice>()(
-                union_(select("Alice"), select(&Org::name, where(&Org::boss == column<works_for_alice>(1_colalias))))),
-            select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<works_for_alice>(1_colalias))))));
+            cte<works_for_alice>(&Org::name)(
+                union_(select("Alice"), select(&Org::name, where(&Org::boss == column<works_for_alice>(&Org::name))))),
+            select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<works_for_alice>(&Org::name))))));
 #endif
 
         //WITH cte_1("n")
@@ -321,9 +319,9 @@ void family_tree() {
     constexpr auto parent = "parent"_col;
     constexpr auto name = "name"_col;
     auto ast =
-        with(make_tuple(cte<parent_of>(&Family::name, parent)(union_(select(columns(&Family::name, &Family::mom)),
-                                                                     select(columns(&Family::name, &Family::dad)))),
-                        cte<ancestor_of_alice>(name)(union_all(
+        with(make_tuple(parent_of(&Family::name, parent)(union_(select(columns(&Family::name, &Family::mom)),
+                                                                select(columns(&Family::name, &Family::dad)))),
+                        ancestor_of_alice(name)(union_all(
                             select(parent_of->*parent, where(parent_of->*&Family::name == "Alice")),
                             select(parent_of->*parent, join<ancestor_of_alice>(using_(parent_of->*&Family::name)))))),
              select(&Family::name,
@@ -441,7 +439,7 @@ void depth_or_breadth_first() {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto under_alice = "under_alice"_cte;
         constexpr auto level = "level"_col;
-        auto ast = with(cte<under_alice>(&Org::name, level)(
+        auto ast = with(under_alice(&Org::name, level)(
                             union_all(select(columns("Alice", 0)),
                                       select(columns(&Org::name, under_alice->*level + 1),
                                              join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
@@ -484,7 +482,7 @@ void depth_or_breadth_first() {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto under_alice = "under_alice"_cte;
         constexpr auto level = "level"_col;
-        auto ast = with(cte<under_alice>(&Org::name, level)(
+        auto ast = with(under_alice(&Org::name, level)(
                             union_all(select(columns("Alice", 0)),
                                       select(columns(&Org::name, under_alice->*level + 1),
                                              join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
@@ -539,7 +537,7 @@ void select_from_subselect() {
     // SELECT * FROM (SELECT salary, comm AS commmission FROM emp) WHERE salary < 5000
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     constexpr auto sub = "sub"_cte;
-    auto expression = with(cte<sub>()(select(columns(&Employee::m_salary, &Employee::m_commission))),
+    auto expression = with(sub()(select(columns(&Employee::m_salary, &Employee::m_commission))),
                            select(asterisk<sub>(), where(sub->*&Employee::m_salary < 5000)));
 #else
     using sub = decltype(1_ctealias);
@@ -592,19 +590,18 @@ void apfelmaennchen() {
     constexpr auto cy = "cy"_col;
     constexpr auto t = "t"_col;
     auto ast = with(
-        make_tuple(cte<xaxis>(x)(union_all(select(-2.0), select(xaxis->*x + 0.05, where(xaxis->*x < 1.2)))),
-                   cte<yaxis>(y)(union_all(select(-1.0), select(yaxis->*y + 0.10, where(yaxis->*y < 1.0)))),
-                   cte<m>(iter, cx, cy, x, y)(
-                       union_all(select(columns(0, xaxis->*x, yaxis->*y, 0.0, 0.0)),
-                                 select(columns(m->*iter + 1,
-                                                m->*cx,
-                                                m->*cy,
-                                                m->*x * m->*x - m->*y * m->*y + m->*cx,
-                                                2.0 * m->*x * m->*y + m->*cy),
-                                        where((m->*x * m->*x + m->*y * m->*y) < 4.0 && m->*iter < 28)))),
-                   cte<m2>(iter, cx, cy)(select(columns(max<>(m->*iter), m->*cx, m->*cy), group_by(m->*cx, m->*cy))),
-                   cte<a>(t)(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / 7.0, 4.0), 1), ""),
-                                    group_by(m2->*cy)))),
+        make_tuple(
+            xaxis(x)(union_all(select(-2.0), select(xaxis->*x + 0.05, where(xaxis->*x < 1.2)))),
+            yaxis(y)(union_all(select(-1.0), select(yaxis->*y + 0.10, where(yaxis->*y < 1.0)))),
+            m(iter, cx, cy, x, y)(union_all(select(columns(0, xaxis->*x, yaxis->*y, 0.0, 0.0)),
+                                            select(columns(m->*iter + 1,
+                                                           m->*cx,
+                                                           m->*cy,
+                                                           m->*x * m->*x - m->*y * m->*y + m->*cx,
+                                                           2.0 * m->*x * m->*y + m->*cy),
+                                                   where((m->*x * m->*x + m->*y * m->*y) < 4.0 && m->*iter < 28)))),
+            m2(iter, cx, cy)(select(columns(max<>(m->*iter), m->*cx, m->*cy), group_by(m->*cx, m->*cy))),
+            a(t)(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / 7.0, 4.0), 1), ""), group_by(m2->*cy)))),
         select(group_concat(rtrim(a->*t), "\n")));
 #else
     using cte_xaxis = decltype(1_ctealias);
@@ -883,23 +880,23 @@ void neevek_issue_222() {
     constexpr auto register_date = "register_date"_col;
     constexpr auto user_count = "user_count"_col;
     constexpr auto ndays = "ndays"_col;
-    auto expression = with(
-        make_tuple(
-            cte<register_user>()(select(
-                columns(&user_activity::uid, min(date(&user_activity::timestamp, "unixepoch")) >>= register_date),
-                group_by(&user_activity::uid).having(greater_or_equal(register_date, date("now", "-7 days"))))),
-            cte<registered_cnt>()(select(columns(register_user->*register_date,
+    auto expression =
+        with(make_tuple(
+                 register_user()(select(
+                     columns(&user_activity::uid, min(date(&user_activity::timestamp, "unixepoch")) >>= register_date),
+                     group_by(&user_activity::uid).having(greater_or_equal(register_date, date("now", "-7 days"))))),
+                 registered_cnt()(select(columns(register_user->*register_date,
                                                  count(distinct(register_user->*&user_activity::uid)) >>= user_count),
                                          group_by(register_user->*register_date)))),
-        select(columns(register_user->*register_date,
-                       c(cast<int>(julianday(date(&user_activity::timestamp, "unixepoch")))) -
-                           cast<int>(julianday(register_user->*register_date)) >>= ndays,
-                       count(distinct(&user_activity::uid)) >>= "retention"_col,
-                       registered_cnt->*user_count),
-               left_join<register_user>(using_(&user_activity::uid)),
-               left_join<registered_cnt>(using_(registered_cnt->*register_date)),
-               group_by(register_user->*register_date, ndays)
-                   .having(date(&user_activity::timestamp, "unixepoch") >= date("now", "-7 days"))));
+             select(columns(register_user->*register_date,
+                            c(cast<int>(julianday(date(&user_activity::timestamp, "unixepoch")))) -
+                                cast<int>(julianday(register_user->*register_date)) >>= ndays,
+                            count(distinct(&user_activity::uid)) >>= "retention"_col,
+                            registered_cnt->*user_count),
+                    left_join<register_user>(using_(&user_activity::uid)),
+                    left_join<registered_cnt>(using_(registered_cnt->*register_date)),
+                    group_by(register_user->*register_date, ndays)
+                        .having(date(&user_activity::timestamp, "unixepoch") >= date("now", "-7 days"))));
 
     string sql = storage.dump(expression);
 
@@ -975,7 +972,7 @@ void greatest_n_per_group() {
     constexpr auto wnd = "wnd"_cte;
     constexpr auto max_date = "max_date"_col;
     auto expression =
-        with(cte<wnd>(&some_result::item_id, max_date)(
+        with(wnd(&some_result::item_id, max_date)(
                  select(columns(&some_result::item_id, max(&some_result::timestamp)), group_by(&some_result::item_id))),
              select(object<some_result>(),
                     inner_join<wnd>(on(&some_result::item_id == wnd->*&some_result::item_id and
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index ec400332d..abd8b6b91 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -7154,6 +7154,9 @@ namespace sqlite_orm {
 }
 #pragma once
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+#include <concepts>
+#endif
 #include <type_traits>  //  std::remove_const
 #include <string>  //  std::string
 #include <utility>  //  std::move
@@ -7307,6 +7310,93 @@ namespace sqlite_orm {
 
 // #include "alias_traits.h"
 
+// #include "cte.h"
+
+#ifdef SQLITE_ORM_WITH_CTE
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+#include <concepts>
+#include <utility>  //  std::make_index_sequence
+#endif
+#include <type_traits>  //  std::enable_if, std::is_member_pointer, std::is_same, std::is_convertible
+#include <tuple>  //  std::ignore
+#include <string>
+#endif
+
+// #include "functional/cxx_universal.h"
+
+// #include "alias.h"
+
+#ifdef SQLITE_ORM_WITH_CTE
+namespace sqlite_orm {
+
+    namespace internal {
+        /** 
+         *  A special record set alias that is both, a storage lookup type (mapping type) and an alias.
+         */
+        template<char A, char... X>
+        struct cte_moniker
+            : recordset_alias<
+                  cte_moniker<A, X...> /* refer to self, since a moniker is both, an alias and a mapped type */,
+                  A,
+                  X...> {
+            /** 
+             *  Introduce the construction of a common table expression.
+             *  
+             *  The list of explicit columns is optional;
+             *  if provided the number of columns must match the number of columns of the subselect.
+             *  The column names will be merged with the subselect:
+             *  1. column names of subselect
+             *  2. explicit columns
+             *  3. fill in empty column names with column index
+             *  
+             *  Example:
+             *  1_ctealias()(select(&Object::id));
+             *  1_ctealias(&Object::name)(select("object"));
+             *  
+             *  @return A `cte_builder` instance.
+             *  @note (internal): Defined in select_constraints.h in order to keep this member function in the same place as the named factory function `cte()`.
+             */
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+            template<class... ExplicitCols>
+                requires((is_column_alias_v<ExplicitCols> || std::is_member_pointer_v<ExplicitCols> ||
+                          std::same_as<ExplicitCols, std::remove_cvref_t<decltype(std::ignore)>> ||
+                          std::convertible_to<ExplicitCols, std::string>) &&
+                         ...)
+            auto operator()(ExplicitCols... explicitColumns) const;
+#else
+            template<class... ExplicitCols,
+                     std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
+                                          is_column_alias<ExplicitCols>,
+                                          std::is_member_pointer<ExplicitCols>,
+                                          std::is_same<ExplicitCols, polyfill::remove_cvref_t<decltype(std::ignore)>>,
+                                          std::is_convertible<ExplicitCols, std::string>>...>,
+                                      bool> = true>
+            auto operator()(ExplicitCols... explicitColumns) const;
+#endif
+        };
+    }
+
+    /**
+     *  cte_moniker<'n'> from a numeric literal.
+     *  E.g. 1_ctealias, 2_ctealias
+     */
+    template<char... Chars>
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
+        return internal::cte_moniker<Chars...>{};
+    }
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  cte_moniker<'1'[, ...]> from a string literal.
+     *  E.g. "1"_cte, "2"_cte
+     */
+    template<internal::string_identifier_template t>
+    [[nodiscard]] consteval auto operator"" _cte() {
+        return internal::to_alias<internal::cte_moniker, t>(std::make_index_sequence<t.size()>{});
+    }
+#endif
+}
+#endif
+
 namespace sqlite_orm {
 
     namespace internal {
@@ -7778,6 +7868,8 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
     /**
+     *  Introduce the construction of a common table expression.
+     *  
      *  The list of explicit columns is optional;
      *  if provided the number of columns must match the number of columns of the subselect.
      *  The column names will be merged with the subselect:
@@ -7788,6 +7880,7 @@ namespace sqlite_orm {
      *  Example:
      *  using cte_1 = decltype(1_ctealias);
      *  cte<cte_1>()(select(&Object::id));
+     *  cte<cte_1>(&Object::name)(select("object"));
      */
     template<class Moniker,
              class... ExplicitCols,
@@ -7827,6 +7920,32 @@ namespace sqlite_orm {
     }
 #endif
 
+    namespace internal {
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        template<char A, char... X>
+        template<class... ExplicitCols>
+            requires((is_column_alias_v<ExplicitCols> || std::is_member_pointer_v<ExplicitCols> ||
+                      std::same_as<ExplicitCols, std::remove_cvref_t<decltype(std::ignore)>> ||
+                      std::convertible_to<ExplicitCols, std::string>) &&
+                     ...)
+        auto cte_moniker<A, X...>::operator()(ExplicitCols... explicitColumns) const {
+            return cte<cte_moniker<A, X...>>(std::forward<ExplicitCols>(explicitColumns)...);
+        }
+#else
+        template<char A, char... X>
+        template<class... ExplicitCols,
+                 std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
+                                      is_column_alias<ExplicitCols>,
+                                      std::is_member_pointer<ExplicitCols>,
+                                      std::is_same<ExplicitCols, polyfill::remove_cvref_t<decltype(std::ignore)>>,
+                                      std::is_convertible<ExplicitCols, std::string>>...>,
+                                  bool>>
+        auto cte_moniker<A, X...>::operator()(ExplicitCols... explicitColumns) const {
+            return cte<cte_moniker<A, X...>>(std::forward<ExplicitCols>(explicitColumns)...);
+        }
+#endif
+    }
+
     /** 
      *  With-clause for a tuple of CTEs.
      */
@@ -20616,8 +20735,14 @@ namespace sqlite_orm {
 #pragma once
 
 #ifdef SQLITE_ORM_WITH_CTE
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+#include <concepts>
 #include <utility>  //  std::make_index_sequence
 #endif
+#include <type_traits>  //  std::enable_if, std::is_member_pointer, std::is_same, std::is_convertible
+#include <tuple>  //  std::ignore
+#include <string>
+#endif
 
 // #include "functional/cxx_universal.h"
 
@@ -20635,7 +20760,42 @@ namespace sqlite_orm {
             : recordset_alias<
                   cte_moniker<A, X...> /* refer to self, since a moniker is both, an alias and a mapped type */,
                   A,
-                  X...> {};
+                  X...> {
+            /** 
+             *  Introduce the construction of a common table expression.
+             *  
+             *  The list of explicit columns is optional;
+             *  if provided the number of columns must match the number of columns of the subselect.
+             *  The column names will be merged with the subselect:
+             *  1. column names of subselect
+             *  2. explicit columns
+             *  3. fill in empty column names with column index
+             *  
+             *  Example:
+             *  1_ctealias()(select(&Object::id));
+             *  1_ctealias(&Object::name)(select("object"));
+             *  
+             *  @return A `cte_builder` instance.
+             *  @note (internal): Defined in select_constraints.h in order to keep this member function in the same place as the named factory function `cte()`.
+             */
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+            template<class... ExplicitCols>
+                requires((is_column_alias_v<ExplicitCols> || std::is_member_pointer_v<ExplicitCols> ||
+                          std::same_as<ExplicitCols, std::remove_cvref_t<decltype(std::ignore)>> ||
+                          std::convertible_to<ExplicitCols, std::string>) &&
+                         ...)
+            auto operator()(ExplicitCols... explicitColumns) const;
+#else
+            template<class... ExplicitCols,
+                     std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
+                                          is_column_alias<ExplicitCols>,
+                                          std::is_member_pointer<ExplicitCols>,
+                                          std::is_same<ExplicitCols, polyfill::remove_cvref_t<decltype(std::ignore)>>,
+                                          std::is_convertible<ExplicitCols, std::string>>...>,
+                                      bool> = true>
+            auto operator()(ExplicitCols... explicitColumns) const;
+#endif
+        };
     }
 
     /**
diff --git a/tests/statement_serializer_tests/column_names.cpp b/tests/statement_serializer_tests/column_names.cpp
index ab24d00f5..aceca1368 100644
--- a/tests/statement_serializer_tests/column_names.cpp
+++ b/tests/statement_serializer_tests/column_names.cpp
@@ -160,7 +160,7 @@ TEST_CASE("statement_serializer column names") {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         SECTION("cte") {
             auto dbObjects2 =
-                internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<1_ctealias>()(select(1))));
+                internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, 1_ctealias()(select(1))));
             using context_t = internal::serializer_context<decltype(dbObjects2)>;
             context_t context{dbObjects2};
             context.skip_table_name = false;
diff --git a/tests/static_tests/cte.cpp b/tests/static_tests/cte.cpp
index 5f7ba8939..b84339c88 100644
--- a/tests/static_tests/cte.cpp
+++ b/tests/static_tests/cte.cpp
@@ -43,6 +43,18 @@ TEST_CASE("CTE type traits") {
     }
 }
 
+TEST_CASE("CTE building") {
+    SECTION("builder") {
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        auto builder1 = cte<1_ctealias>();
+#else
+        auto builder1 = cte<decltype(1_ctealias)>();
+#endif
+        auto builder2 = 1_ctealias();
+        static_assert(std::is_same<decltype(builder2), decltype(builder1)>::value);
+    }
+}
+
 TEST_CASE("CTE storage") {
     SECTION("db_objects_cat") {
         struct Org {
@@ -53,8 +65,7 @@ TEST_CASE("CTE storage") {
         auto idx1 = make_unique_index("idx1_org", &Org::id);
         auto idx2 = make_index("idx2_org", &Org::id);
         auto dbObjects = tuple{idx1, idx2, table};
-        using cte_1 = decltype(1_ctealias);
-        auto cteTable = internal::make_cte_table(dbObjects, cte<cte_1>()(select(1)));
+        auto cteTable = internal::make_cte_table(dbObjects, 1_ctealias()(select(1)));
         auto dbObjects2 = internal::db_objects_cat(dbObjects, cteTable);
 
         // note: deliberately make indexes resulting in the same index_t<> type, such that we know `db_objects_cat()` is working properly
diff --git a/tests/static_tests/node_tuple.cpp b/tests/static_tests/node_tuple.cpp
index e70e8bda3..36169d6e4 100644
--- a/tests/static_tests/node_tuple.cpp
+++ b/tests/static_tests/node_tuple.cpp
@@ -951,7 +951,7 @@ TEST_CASE("Node tuple") {
     SECTION("with") {
         using cte_1 = decltype(1_ctealias);
         auto expression =
-            with(cte<cte_1>()(
+            with(1_ctealias()(
                      union_all(select(1), select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < 10)))),
                  select(1_ctealias->*1_colalias));
         using Tuple = node_tuple_t<decltype(expression)>;
diff --git a/tests/table_name_collector.cpp b/tests/table_name_collector.cpp
index bf6492d6b..b09af0cfb 100644
--- a/tests/table_name_collector.cpp
+++ b/tests/table_name_collector.cpp
@@ -47,9 +47,8 @@ TEST_CASE("table name collector") {
 
 #ifdef SQLITE_ORM_WITH_CTE
     SECTION("from CTE") {
-        using cte_1 = decltype(1_ctealias);
         auto dbObjects2 =
-            internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
+            internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, 1_ctealias()(select(1))));
         using context_t = internal::serializer_context<decltype(dbObjects2)>;
         context_t context{dbObjects2};
         auto collector = internal::make_table_name_collector(context.db_objects);

From 8bfbca05d9b7e14cb2989dcf6f9e7749ad6d6383 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 10 Oct 2023 00:15:51 +0200
Subject: [PATCH 128/161] Corrected test file ast_iterator_tests.cpp

---
 tests/ast_iterator_tests.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index d88563c06..4be85f659 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -8,7 +8,6 @@ using internal::alias_column_t;
 using internal::alias_holder;
 using internal::column_alias;
 using internal::column_pointer;
-using internal::cte_moniker;
 using internal::iterate_ast;
 
 TEST_CASE("ast_iterator") {
@@ -349,18 +348,18 @@ TEST_CASE("ast_iterator") {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     SECTION("aliased CTE column pointer") {
         constexpr auto c = "1"_cte;
+        using cte_1 = decltype(c);
         constexpr auto z_alias = "z"_alias.for_<c>();
         auto expression = z_alias->*&User::id;
-        expected.push_back(
-            typeid(alias_column_t<alias_z<cte_moniker<'1'>>, column_pointer<cte_moniker<'1'>, decltype(&User::id)>>));
+        expected.push_back(typeid(alias_column_t<alias_z<cte_1>, column_pointer<cte_1, decltype(&User::id)>>));
         iterate_ast(expression, lambda);
     }
     SECTION("aliased CTE column alias") {
         constexpr auto c = "1"_cte;
         constexpr auto z_alias = "z"_alias.for_<c>();
         auto expression = z_alias->*1_colalias;
-        expected.push_back(typeid(alias_column_t<alias_z<cte_moniker<'1'>>,
-                                                 column_pointer<cte_moniker<'1'>, alias_holder<column_alias<'1'>>>>));
+        expected.push_back(
+            typeid(alias_column_t<alias_z<cte_1>, column_pointer<cte_1, alias_holder<column_alias<'1'>>>>));
         iterate_ast(expression, lambda);
     }
 #endif

From ff0f66a020201b7153b9716e44486914c2e61428 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 10 Oct 2023 11:51:29 +0200
Subject: [PATCH 129/161] Renamed cte.h -> cte_moniker.h

---
 dev/{cte.h => cte_moniker.h}                  |  5 +-
 dev/select_constraints.h                      |  4 +-
 include/sqlite_orm/sqlite_orm.h               | 95 +------------------
 .../sqlite_orm/sqlite_orm.h                   |  1 -
 third_party/amalgamate/config.json            |  1 -
 5 files changed, 10 insertions(+), 96 deletions(-)
 rename dev/{cte.h => cte_moniker.h} (96%)

diff --git a/dev/cte.h b/dev/cte_moniker.h
similarity index 96%
rename from dev/cte.h
rename to dev/cte_moniker.h
index 244e05d34..79d486064 100644
--- a/dev/cte.h
+++ b/dev/cte_moniker.h
@@ -27,7 +27,7 @@ namespace sqlite_orm {
                   A,
                   X...> {
             /** 
-             *  Introduce the construction of a common table expression.
+             *  Introduce the construction of a common table expression using this moniker.
              *  
              *  The list of explicit columns is optional;
              *  if provided the number of columns must match the number of columns of the subselect.
@@ -41,7 +41,8 @@ namespace sqlite_orm {
              *  1_ctealias(&Object::name)(select("object"));
              *  
              *  @return A `cte_builder` instance.
-             *  @note (internal): Defined in select_constraints.h in order to keep this member function in the same place as the named factory function `cte()`.
+             *  @note (internal): Defined in select_constraints.h in order to keep this member function in the same place as the named factory function `cte()`,
+             *  and to keep the actual creation of the builder in one place.
              */
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
             template<class... ExplicitCols>
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index aa134177b..7cfe9d12d 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -19,7 +19,7 @@
 #include "ast/group_by.h"
 #include "core_functions.h"
 #include "alias_traits.h"
-#include "cte.h"
+#include "cte_moniker.h"
 
 namespace sqlite_orm {
 
@@ -492,7 +492,7 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
     /**
-     *  Introduce the construction of a common table expression.
+     *  Introduce the construction of a common table expression using the specified moniker.
      *  
      *  The list of explicit columns is optional;
      *  if provided the number of columns must match the number of columns of the subselect.
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index abd8b6b91..5a92771d4 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -7310,7 +7310,7 @@ namespace sqlite_orm {
 
 // #include "alias_traits.h"
 
-// #include "cte.h"
+// #include "cte_moniker.h"
 
 #ifdef SQLITE_ORM_WITH_CTE
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
@@ -7340,7 +7340,7 @@ namespace sqlite_orm {
                   A,
                   X...> {
             /** 
-             *  Introduce the construction of a common table expression.
+             *  Introduce the construction of a common table expression using this moniker.
              *  
              *  The list of explicit columns is optional;
              *  if provided the number of columns must match the number of columns of the subselect.
@@ -7354,7 +7354,8 @@ namespace sqlite_orm {
              *  1_ctealias(&Object::name)(select("object"));
              *  
              *  @return A `cte_builder` instance.
-             *  @note (internal): Defined in select_constraints.h in order to keep this member function in the same place as the named factory function `cte()`.
+             *  @note (internal): Defined in select_constraints.h in order to keep this member function in the same place as the named factory function `cte()`,
+             *  and to keep the actual creation of the builder in one place.
              */
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
             template<class... ExplicitCols>
@@ -7868,7 +7869,7 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
     /**
-     *  Introduce the construction of a common table expression.
+     *  Introduce the construction of a common table expression using the specified moniker.
      *  
      *  The list of explicit columns is optional;
      *  if provided the number of columns must match the number of columns of the subselect.
@@ -20734,92 +20735,6 @@ namespace sqlite_orm {
 }
 #pragma once
 
-#ifdef SQLITE_ORM_WITH_CTE
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-#include <concepts>
-#include <utility>  //  std::make_index_sequence
-#endif
-#include <type_traits>  //  std::enable_if, std::is_member_pointer, std::is_same, std::is_convertible
-#include <tuple>  //  std::ignore
-#include <string>
-#endif
-
-// #include "functional/cxx_universal.h"
-
-// #include "alias.h"
-
-#ifdef SQLITE_ORM_WITH_CTE
-namespace sqlite_orm {
-
-    namespace internal {
-        /** 
-         *  A special record set alias that is both, a storage lookup type (mapping type) and an alias.
-         */
-        template<char A, char... X>
-        struct cte_moniker
-            : recordset_alias<
-                  cte_moniker<A, X...> /* refer to self, since a moniker is both, an alias and a mapped type */,
-                  A,
-                  X...> {
-            /** 
-             *  Introduce the construction of a common table expression.
-             *  
-             *  The list of explicit columns is optional;
-             *  if provided the number of columns must match the number of columns of the subselect.
-             *  The column names will be merged with the subselect:
-             *  1. column names of subselect
-             *  2. explicit columns
-             *  3. fill in empty column names with column index
-             *  
-             *  Example:
-             *  1_ctealias()(select(&Object::id));
-             *  1_ctealias(&Object::name)(select("object"));
-             *  
-             *  @return A `cte_builder` instance.
-             *  @note (internal): Defined in select_constraints.h in order to keep this member function in the same place as the named factory function `cte()`.
-             */
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-            template<class... ExplicitCols>
-                requires((is_column_alias_v<ExplicitCols> || std::is_member_pointer_v<ExplicitCols> ||
-                          std::same_as<ExplicitCols, std::remove_cvref_t<decltype(std::ignore)>> ||
-                          std::convertible_to<ExplicitCols, std::string>) &&
-                         ...)
-            auto operator()(ExplicitCols... explicitColumns) const;
-#else
-            template<class... ExplicitCols,
-                     std::enable_if_t<polyfill::conjunction_v<polyfill::disjunction<
-                                          is_column_alias<ExplicitCols>,
-                                          std::is_member_pointer<ExplicitCols>,
-                                          std::is_same<ExplicitCols, polyfill::remove_cvref_t<decltype(std::ignore)>>,
-                                          std::is_convertible<ExplicitCols, std::string>>...>,
-                                      bool> = true>
-            auto operator()(ExplicitCols... explicitColumns) const;
-#endif
-        };
-    }
-
-    /**
-     *  cte_moniker<'n'> from a numeric literal.
-     *  E.g. 1_ctealias, 2_ctealias
-     */
-    template<char... Chars>
-    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
-        return internal::cte_moniker<Chars...>{};
-    }
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    /**
-     *  cte_moniker<'1'[, ...]> from a string literal.
-     *  E.g. "1"_cte, "2"_cte
-     */
-    template<internal::string_identifier_template t>
-    [[nodiscard]] consteval auto operator"" _cte() {
-        return internal::to_alias<internal::cte_moniker, t>(std::make_index_sequence<t.size()>{});
-    }
-#endif
-}
-#endif
-#pragma once
-
 #include <type_traits>  //  std::is_same, std::decay, std::remove_reference
 #include <tuple>  //  std::get
 
diff --git a/not_single_header_include/sqlite_orm/sqlite_orm.h b/not_single_header_include/sqlite_orm/sqlite_orm.h
index 62aa27967..3064474d0 100644
--- a/not_single_header_include/sqlite_orm/sqlite_orm.h
+++ b/not_single_header_include/sqlite_orm/sqlite_orm.h
@@ -31,7 +31,6 @@
 #include "../../dev/storage_impl.h"
 #include "../../dev/default_value_extractor.h"
 #include "../../dev/storage.h"
-#include "../../dev/cte.h"
 #include "../../dev/get_prepared_statement.h"
 #include "../../dev/carray.h"
 #include "../../dev/sqlite_schema_table.h"
diff --git a/third_party/amalgamate/config.json b/third_party/amalgamate/config.json
index ca2292de8..a3e62a7a4 100755
--- a/third_party/amalgamate/config.json
+++ b/third_party/amalgamate/config.json
@@ -33,7 +33,6 @@
     "dev/storage_impl.h",
     "dev/default_value_extractor.h",
     "dev/storage.h",
-    "dev/cte.h",
     "dev/get_prepared_statement.h",
     "dev/carray.h",
     "dev/sqlite_schema_table.h",

From 5ffcc6a07cb3d8a1ebc13bd18bf774b9a21858e4 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 10 Oct 2023 14:31:52 +0200
Subject: [PATCH 130/161] Fixed unit test for "aliased CTE column alias"

---
 tests/ast_iterator_tests.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index 4be85f659..3a915a71f 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -356,6 +356,7 @@ TEST_CASE("ast_iterator") {
     }
     SECTION("aliased CTE column alias") {
         constexpr auto c = "1"_cte;
+        using cte_1 = decltype(c);
         constexpr auto z_alias = "z"_alias.for_<c>();
         auto expression = z_alias->*1_colalias;
         expected.push_back(

From 91900882982ff35f555b8727be80a403033a32ca Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 10 Oct 2023 18:49:24 +0200
Subject: [PATCH 131/161] Fixed unit test for aliased CTE column

---
 tests/ast_iterator_tests.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index 3a915a71f..7dd0773ef 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -348,7 +348,7 @@ TEST_CASE("ast_iterator") {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     SECTION("aliased CTE column pointer") {
         constexpr auto c = "1"_cte;
-        using cte_1 = decltype(c);
+        using cte_1 = decltype("1"_cte);
         constexpr auto z_alias = "z"_alias.for_<c>();
         auto expression = z_alias->*&User::id;
         expected.push_back(typeid(alias_column_t<alias_z<cte_1>, column_pointer<cte_1, decltype(&User::id)>>));
@@ -356,7 +356,7 @@ TEST_CASE("ast_iterator") {
     }
     SECTION("aliased CTE column alias") {
         constexpr auto c = "1"_cte;
-        using cte_1 = decltype(c);
+        using cte_1 = decltype("1"_cte);
         constexpr auto z_alias = "z"_alias.for_<c>();
         auto expression = z_alias->*1_colalias;
         expected.push_back(

From c477ac9f66682f5de3a7eb5cd4aba2b4164e4147 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 14 Oct 2023 09:53:49 +0200
Subject: [PATCH 132/161] Create a CTE using `as()`

---
 dev/select_constraints.h                      |  11 -
 examples/common_table_expressions.cpp         | 244 +++++++++---------
 include/sqlite_orm/sqlite_orm.h               |  11 -
 tests/ast_iterator_tests.cpp                  |   2 +-
 .../column_names.cpp                          |   2 +-
 .../select_constraints.cpp                    |   8 +-
 tests/static_tests/column_expression_type.cpp |   2 +-
 tests/static_tests/column_result_t.cpp        |   3 +-
 tests/static_tests/cte.cpp                    |   2 +-
 tests/static_tests/node_tuple.cpp             |   2 +-
 tests/table_name_collector.cpp                |   2 +-
 11 files changed, 137 insertions(+), 152 deletions(-)

diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 7cfe9d12d..2d3335ef2 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -249,17 +249,6 @@ namespace sqlite_orm {
         struct cte_builder {
             ExplicitCols explicitColumns;
 
-            template<class T, class... Args>
-            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols>
-            operator()(select_t<T, Args...> sel) && {
-                return {std::move(this->explicitColumns), std::move(sel)};
-            }
-
-            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
-            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> operator()(Compound sel) && {
-                return {std::move(this->explicitColumns), {std::move(sel)}};
-            }
-
             template<class T, class... Args>
             common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols> as(select_t<T, Args...> sel) && {
                 return {std::move(this->explicitColumns), std::move(sel)};
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index f5c2fb8e3..937530232 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -34,13 +34,13 @@ void all_integers_between(int from, int end) {
         //    SELECT x FROM cnt;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto cnt = "cnt"_cte;
-        auto ast = with(cnt()(union_all(select(from), select(cnt->*1_colalias + 1, where(cnt->*1_colalias < end)))),
+        auto ast = with(cnt().as(union_all(select(from), select(cnt->*1_colalias + 1, where(cnt->*1_colalias < end)))),
                         select(cnt->*1_colalias));
 #else
         using cnt = decltype(1_ctealias);
         auto ast =
-            with(cte<cnt>()(union_all(select(from),
-                                      select(1_ctealias->*1_colalias + 1, where(1_ctealias->*1_colalias < end)))),
+            with(cte<cnt>().as(union_all(select(from),
+                                         select(1_ctealias->*1_colalias + 1, where(1_ctealias->*1_colalias < end)))),
                  select(1_ctealias->*1_colalias));
 #endif
 
@@ -69,11 +69,11 @@ void all_integers_between(int from, int end) {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto cnt = "cnt"_cte;
         constexpr auto x = "x"_col;
-        auto ast = with(cnt()(union_all(select(from >>= x), select(cnt->*x + 1, limit(end)))), select(cnt->*x));
+        auto ast = with(cnt().as(union_all(select(from >>= x), select(cnt->*x + 1, limit(end)))), select(cnt->*x));
 #else
         using cnt = decltype(1_ctealias);
         constexpr auto x = colalias_i{};
-        auto ast = with(cte<cnt>()(union_all(select(from >>= x), select(column<cnt>(x) + 1, limit(end)))),
+        auto ast = with(cte<cnt>().as(union_all(select(from >>= x), select(column<cnt>(x) + 1, limit(end)))),
                         select(column<cnt>(x)));
 #endif
 
@@ -94,7 +94,7 @@ void all_integers_between(int from, int end) {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto cnt = "cnt"_cte;
         constexpr auto x = "x"_col;
-        auto ast = with(cnt(x)(union_all(select(from), select(cnt->*x + 1, limit(end)))), select(cnt->*x));
+        auto ast = with(cnt(x).as(union_all(select(from), select(cnt->*x + 1, limit(end)))), select(cnt->*x));
 #else
         using cnt = decltype(1_ctealias);
         constexpr auto x = colalias_i{};
@@ -162,17 +162,18 @@ void supervisor_chain() {
         //    SELECT name FROM chain;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto chain = "chain"_cte;
-        auto ast = with(chain()(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
-                                          select(asterisk<alias_a<Org>>(),
-                                                 where(alias_column<alias_a<Org>>(&Org::name) == chain->*&Org::boss)))),
-                        select(chain->*&Org::name));
+        auto ast =
+            with(chain().as(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
+                                      select(asterisk<alias_a<Org>>(),
+                                             where(alias_column<alias_a<Org>>(&Org::name) == chain->*&Org::boss)))),
+                 select(chain->*&Org::name));
 #else
         using chain = decltype(1_ctealias);
-        auto ast = with(
-            cte<chain>()(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
-                                   select(asterisk<alias_a<Org>>(),
-                                          where(alias_column<alias_a<Org>>(&Org::name) == column<chain>(&Org::boss))))),
-            select(column<chain>(&Org::name)));
+        auto ast = with(cte<chain>().as(union_all(
+                            select(asterisk<Org>(), where(&Org::name == c("Fred"))),
+                            select(asterisk<alias_a<Org>>(),
+                                   where(alias_column<alias_a<Org>>(&Org::name) == column<chain>(&Org::boss))))),
+                        select(column<chain>(&Org::name)));
 #endif
         string sql = storage.dump(ast);
 
@@ -229,15 +230,16 @@ void works_for_alice() {
         //    WHERE org.name IN works_for_alice;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto works_for_alice = "works_for_alice"_cte;
-        auto ast =
-            with(works_for_alice(&Org::name)(
-                     union_(select("Alice"), select(&Org::name, where(&Org::boss == works_for_alice->*&Org::name)))),
-                 select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(works_for_alice->*&Org::name)))));
+        auto ast = with(
+            works_for_alice(&Org::name)
+                .as(union_(select("Alice"), select(&Org::name, where(&Org::boss == works_for_alice->*&Org::name)))),
+            select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(works_for_alice->*&Org::name)))));
 #else
         using works_for_alice = decltype(1_ctealias);
         auto ast = with(
-            cte<works_for_alice>(&Org::name)(
-                union_(select("Alice"), select(&Org::name, where(&Org::boss == column<works_for_alice>(&Org::name))))),
+            cte<works_for_alice>(&Org::name)
+                .as(union_(select("Alice"),
+                           select(&Org::name, where(&Org::boss == column<works_for_alice>(&Org::name))))),
             select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(column<works_for_alice>(&Org::name))))));
 #endif
 
@@ -318,15 +320,16 @@ void family_tree() {
     constexpr auto ancestor_of_alice = "ancestor_of_alice"_cte;
     constexpr auto parent = "parent"_col;
     constexpr auto name = "name"_col;
-    auto ast =
-        with(make_tuple(parent_of(&Family::name, parent)(union_(select(columns(&Family::name, &Family::mom)),
-                                                                select(columns(&Family::name, &Family::dad)))),
-                        ancestor_of_alice(name)(union_all(
-                            select(parent_of->*parent, where(parent_of->*&Family::name == "Alice")),
-                            select(parent_of->*parent, join<ancestor_of_alice>(using_(parent_of->*&Family::name)))))),
-             select(&Family::name,
-                    where(ancestor_of_alice->*name == &Family::name && is_null(&Family::died)),
-                    order_by(&Family::born)));
+    auto ast = with(
+        make_tuple(
+            parent_of(&Family::name, parent)
+                .as(union_(select(columns(&Family::name, &Family::mom)), select(columns(&Family::name, &Family::dad)))),
+            ancestor_of_alice(name).as(
+                union_all(select(parent_of->*parent, where(parent_of->*&Family::name == "Alice")),
+                          select(parent_of->*parent, join<ancestor_of_alice>(using_(parent_of->*&Family::name)))))),
+        select(&Family::name,
+               where(ancestor_of_alice->*name == &Family::name && is_null(&Family::died)),
+               order_by(&Family::born)));
 #else
     using parent_of = decltype(1_ctealias);
     using ancestor_of_alice = decltype(2_ctealias);
@@ -334,9 +337,10 @@ void family_tree() {
     constexpr auto name = colalias_f{};
     auto ast = with(
         make_tuple(
-            cte<parent_of>("name", "parent")(union_(select(columns(&Family::name, &Family::mom >>= parent)),
-                                                    select(columns(&Family::name, &Family::dad)))),
-            cte<ancestor_of_alice>("name")(union_all(
+            cte<parent_of>("name", "parent")
+                .as(union_(select(columns(&Family::name, &Family::mom >>= parent)),
+                           select(columns(&Family::name, &Family::dad)))),
+            cte<ancestor_of_alice>("name").as(union_all(
                 select(column<parent_of>(parent) >>= name, where(column<parent_of>(&Family::name) == "Alice")),
                 select(column<parent_of>(parent), join<ancestor_of_alice>(using_(column<parent_of>(&Family::name))))))),
         select(&Family::name,
@@ -439,20 +443,20 @@ void depth_or_breadth_first() {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto under_alice = "under_alice"_cte;
         constexpr auto level = "level"_col;
-        auto ast = with(under_alice(&Org::name, level)(
-                            union_all(select(columns("Alice", 0)),
-                                      select(columns(&Org::name, under_alice->*level + 1),
-                                             join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
-                                             order_by(2)))),
+        auto ast = with(under_alice(&Org::name, level)
+                            .as(union_all(select(columns("Alice", 0)),
+                                          select(columns(&Org::name, under_alice->*level + 1),
+                                                 join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
+                                                 order_by(2)))),
                         select(substr("..........", 1, under_alice->*level * 3) || under_alice->*&Org::name));
 #else
         using under_alice = decltype(1_ctealias);
         auto ast = with(
-            cte<under_alice>("name", "level")(
-                union_all(select(columns("Alice", 0)),
-                          select(columns(&Org::name, column<under_alice>(2_colalias) + 1),
-                                 join<under_alice>(on(column<under_alice>(1_colalias) == &Org::boss)),
-                                 order_by(2)))),
+            cte<under_alice>("name", "level")
+                .as(union_all(select(columns("Alice", 0)),
+                              select(columns(&Org::name, column<under_alice>(2_colalias) + 1),
+                                     join<under_alice>(on(column<under_alice>(1_colalias) == &Org::boss)),
+                                     order_by(2)))),
             select(substr("..........", 1, column<under_alice>(2_colalias) * 3) || column<under_alice>(1_colalias)));
 #endif
 
@@ -482,20 +486,20 @@ void depth_or_breadth_first() {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto under_alice = "under_alice"_cte;
         constexpr auto level = "level"_col;
-        auto ast = with(under_alice(&Org::name, level)(
-                            union_all(select(columns("Alice", 0)),
-                                      select(columns(&Org::name, under_alice->*level + 1),
-                                             join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
-                                             order_by(2).desc()))),
+        auto ast = with(under_alice(&Org::name, level)
+                            .as(union_all(select(columns("Alice", 0)),
+                                          select(columns(&Org::name, under_alice->*level + 1),
+                                                 join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
+                                                 order_by(2).desc()))),
                         select(substr("..........", 1, under_alice->*level * 3) || under_alice->*&Org::name));
 #else
         using under_alice = decltype(1_ctealias);
         auto ast = with(
-            cte<under_alice>("name", "level")(
-                union_all(select(columns("Alice", 0)),
-                          select(columns(&Org::name, column<under_alice>(2_colalias) + 1),
-                                 join<under_alice>(on(column<under_alice>(1_colalias) == &Org::boss)),
-                                 order_by(2).desc()))),
+            cte<under_alice>("name", "level")
+                .as(union_all(select(columns("Alice", 0)),
+                              select(columns(&Org::name, column<under_alice>(2_colalias) + 1),
+                                     join<under_alice>(on(column<under_alice>(1_colalias) == &Org::boss)),
+                                     order_by(2).desc()))),
             select(substr("..........", 1, column<under_alice>(2_colalias) * 3) || column<under_alice>(1_colalias)));
 #endif
 
@@ -537,11 +541,11 @@ void select_from_subselect() {
     // SELECT * FROM (SELECT salary, comm AS commmission FROM emp) WHERE salary < 5000
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     constexpr auto sub = "sub"_cte;
-    auto expression = with(sub()(select(columns(&Employee::m_salary, &Employee::m_commission))),
+    auto expression = with(sub().as(select(columns(&Employee::m_salary, &Employee::m_commission))),
                            select(asterisk<sub>(), where(sub->*&Employee::m_salary < 5000)));
 #else
     using sub = decltype(1_ctealias);
-    auto expression = with(cte<sub>()(select(columns(&Employee::m_salary, &Employee::m_commission))),
+    auto expression = with(cte<sub>().as(select(columns(&Employee::m_salary, &Employee::m_commission))),
                            select(asterisk<sub>(), where(column<sub>(&Employee::m_salary) < 5000)));
 #endif
 
@@ -589,20 +593,21 @@ void apfelmaennchen() {
     constexpr auto cx = "cx"_col;
     constexpr auto cy = "cy"_col;
     constexpr auto t = "t"_col;
-    auto ast = with(
-        make_tuple(
-            xaxis(x)(union_all(select(-2.0), select(xaxis->*x + 0.05, where(xaxis->*x < 1.2)))),
-            yaxis(y)(union_all(select(-1.0), select(yaxis->*y + 0.10, where(yaxis->*y < 1.0)))),
-            m(iter, cx, cy, x, y)(union_all(select(columns(0, xaxis->*x, yaxis->*y, 0.0, 0.0)),
-                                            select(columns(m->*iter + 1,
-                                                           m->*cx,
-                                                           m->*cy,
-                                                           m->*x * m->*x - m->*y * m->*y + m->*cx,
-                                                           2.0 * m->*x * m->*y + m->*cy),
-                                                   where((m->*x * m->*x + m->*y * m->*y) < 4.0 && m->*iter < 28)))),
-            m2(iter, cx, cy)(select(columns(max<>(m->*iter), m->*cx, m->*cy), group_by(m->*cx, m->*cy))),
-            a(t)(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / 7.0, 4.0), 1), ""), group_by(m2->*cy)))),
-        select(group_concat(rtrim(a->*t), "\n")));
+    auto ast =
+        with(make_tuple(xaxis(x).as(union_all(select(-2.0), select(xaxis->*x + 0.05, where(xaxis->*x < 1.2)))),
+                        yaxis(y).as(union_all(select(-1.0), select(yaxis->*y + 0.10, where(yaxis->*y < 1.0)))),
+                        m(iter, cx, cy, x, y)
+                            .as(union_all(select(columns(0, xaxis->*x, yaxis->*y, 0.0, 0.0)),
+                                          select(columns(m->*iter + 1,
+                                                         m->*cx,
+                                                         m->*cy,
+                                                         m->*x * m->*x - m->*y * m->*y + m->*cx,
+                                                         2.0 * m->*x * m->*y + m->*cy),
+                                                 where((m->*x * m->*x + m->*y * m->*y) < 4.0 && m->*iter < 28)))),
+                        m2(iter, cx, cy).as(select(columns(max<>(m->*iter), m->*cx, m->*cy), group_by(m->*cx, m->*cy))),
+                        a(t).as(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / 7.0, 4.0), 1), ""),
+                                       group_by(m2->*cy)))),
+             select(group_concat(rtrim(a->*t), "\n")));
 #else
     using cte_xaxis = decltype(1_ctealias);
     using cte_yaxis = decltype(2_ctealias);
@@ -621,20 +626,21 @@ void apfelmaennchen() {
     constexpr auto cy = colalias_e{};
     constexpr auto t = colalias_f{};
     auto ast = with(
-        make_tuple(cte<cte_xaxis>("x")(union_all(select(-2.0 >>= x), select(xaxis->*x + 0.05, where(xaxis->*x < 1.2)))),
-                   cte<cte_yaxis>("y")(union_all(select(-1.0 >>= y), select(yaxis->*y + 0.10, where(yaxis->*y < 1.0)))),
-                   cte<cte_m>("iter", "cx", "cy", "x", "y")(
-                       union_all(select(columns(0 >>= iter, xaxis->*x >>= cx, yaxis->*y >>= cy, 0.0 >>= x, 0.0 >>= y)),
-                                 select(columns(m->*iter + 1,
-                                                m->*cx,
-                                                m->*cy,
-                                                m->*x * m->*x - m->*y * m->*y + m->*cx,
-                                                2.0 * m->*x * m->*y + m->*cy),
-                                        where((m->*x * m->*x + m->*y * m->*y) < 4.0 && m->*iter < 28)))),
-                   cte<cte_m2>("iter", "cx", "cy")(
-                       select(columns(max<>(m->*iter) >>= iter, m->*cx, m->*cy), group_by(m->*cx, m->*cy))),
-                   cte<cte_a>("t")(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / 7.0, 4.0), 1), "") >>= t,
-                                          group_by(m2->*cy)))),
+        make_tuple(
+            cte<cte_xaxis>("x").as(union_all(select(-2.0 >>= x), select(xaxis->*x + 0.05, where(xaxis->*x < 1.2)))),
+            cte<cte_yaxis>("y").as(union_all(select(-1.0 >>= y), select(yaxis->*y + 0.10, where(yaxis->*y < 1.0)))),
+            cte<cte_m>("iter", "cx", "cy", "x", "y")
+                .as(union_all(select(columns(0 >>= iter, xaxis->*x >>= cx, yaxis->*y >>= cy, 0.0 >>= x, 0.0 >>= y)),
+                              select(columns(m->*iter + 1,
+                                             m->*cx,
+                                             m->*cy,
+                                             m->*x * m->*x - m->*y * m->*y + m->*cx,
+                                             2.0 * m->*x * m->*y + m->*cy),
+                                     where((m->*x * m->*x + m->*y * m->*y) < 4.0 && m->*iter < 28)))),
+            cte<cte_m2>("iter", "cx", "cy")
+                .as(select(columns(max<>(m->*iter) >>= iter, m->*cx, m->*cy), group_by(m->*cx, m->*cy))),
+            cte<cte_a>("t").as(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / 7.0, 4.0), 1), "") >>= t,
+                                      group_by(m2->*cy)))),
         select(group_concat(rtrim(a->*t), "\n")));
 #endif
 
@@ -694,12 +700,12 @@ void sudoku() {
     constexpr auto ind = "ind"_col;
     auto ast = with(
         make_tuple(
-            cte<input>(sud)(
+            cte<input>(sud).as(
                 select("53..7....6..195....98....6.8...6...34..8.3..17...2...6.6....28....419..5....8..79")),
-            cte<digits>(z, lp)(
+            cte<digits>(z, lp).as(
                 union_all(select(columns("1", 1)),
                           select(columns(cast<string>(digits->*lp + 1), digits->*lp + 1), where(digits->*lp < 9)))),
-            cte<x>(s, ind)(union_all(
+            cte<x>(s, ind).as(union_all(
                 select(columns(input->*sud, instr(input->*sud, "."))),
                 select(columns(substr(x->*s, 1, x->*ind - 1) || z || substr(x->*s, x->*ind + 1),
                                instr(substr(x->*s, 1, x->*ind - 1) || z || substr(x->*s, x->*ind + 1), ".")),
@@ -746,7 +752,7 @@ void show_mapping_and_backreferencing() {
 
     // back-reference via `column_pointer<cte_1, F O::*>`
     {
-        auto ast = with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
+        auto ast = with(cte<cte_1>().as(select(&Object::id)), select(column<cte_1>(&Object::id)));
 
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);
@@ -756,7 +762,7 @@ void show_mapping_and_backreferencing() {
     // back-reference via `column_pointer<cte_1, alias_holder>`
     {
         auto ast =
-            with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(column<cte_1>(get<cnt>()) + 1, limit(10)))),
+            with(cte<cte_1>("x").as(union_all(select(as<cnt>(1)), select(column<cte_1>(get<cnt>()) + 1, limit(10)))),
                  select(column<cte_1>(get<cnt>())));
 
         string sql = storage.dump(ast);
@@ -765,7 +771,7 @@ void show_mapping_and_backreferencing() {
     // map column via alias_holder into cte,
     // back-reference via `column_pointer<cte_1, alias_holder>`
     {
-        auto ast = with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(column<cte_1>(cnt{}) + 1, limit(10)))),
+        auto ast = with(cte<cte_1>("x").as(union_all(select(as<cnt>(1)), select(column<cte_1>(cnt{}) + 1, limit(10)))),
                         select(column<cte_1>(cnt{})));
 
         string sql = storage.dump(ast);
@@ -774,7 +780,7 @@ void show_mapping_and_backreferencing() {
     // map column via alias_holder into cte,
     // back-reference via `column_pointer<cte_1, alias_holder>`
     {
-        auto ast = with(cte<cte_1>("x")(union_all(select(as<cnt>(1)), select(cte_1{}->*cnt{} + 1, limit(10)))),
+        auto ast = with(cte<cte_1>("x").as(union_all(select(as<cnt>(1)), select(cte_1{}->*cnt{} + 1, limit(10)))),
                         select(cte_1{}->*cnt{}));
 
         string sql = storage.dump(ast);
@@ -783,7 +789,7 @@ void show_mapping_and_backreferencing() {
 
     // implicitly remap column into cte
     {
-        auto ast = with(cte<cte_1>(std::ignore)(select(&Object::id)), select(column<cte_1>(&Object::id)));
+        auto ast = with(cte<cte_1>(std::ignore).as(select(&Object::id)), select(column<cte_1>(&Object::id)));
 
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);
@@ -791,7 +797,7 @@ void show_mapping_and_backreferencing() {
 
     // explicitly remap column into cte (independent of subselect)
     {
-        auto ast = with(cte<cte_1>(&Object::id)(select(&Object::id)), select(column<cte_1>(&Object::id)));
+        auto ast = with(cte<cte_1>(&Object::id).as(select(&Object::id)), select(column<cte_1>(&Object::id)));
 
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);
@@ -799,7 +805,7 @@ void show_mapping_and_backreferencing() {
 
     // explicitly remap column as an alias into cte (independent of subselect)
     {
-        auto ast = with(cte<cte_1>(cnt{})(select(&Object::id)), select(column<cte_1>(get<cnt>())));
+        auto ast = with(cte<cte_1>(cnt{}).as(select(&Object::id)), select(column<cte_1>(get<cnt>())));
 
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);
@@ -818,7 +824,7 @@ void show_mapping_and_backreferencing() {
             int64 xyz;
         };
         auto ast =
-            with(cte<CTEObject>(make_column("xyz", &CTEObject::xyz))(select(&Object::id)), select(&CTEObject::xyz));
+            with(cte<CTEObject>(make_column("xyz", &CTEObject::xyz)).as(select(&Object::id)), select(&CTEObject::xyz));
 
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);
@@ -880,23 +886,23 @@ void neevek_issue_222() {
     constexpr auto register_date = "register_date"_col;
     constexpr auto user_count = "user_count"_col;
     constexpr auto ndays = "ndays"_col;
-    auto expression =
-        with(make_tuple(
-                 register_user()(select(
-                     columns(&user_activity::uid, min(date(&user_activity::timestamp, "unixepoch")) >>= register_date),
-                     group_by(&user_activity::uid).having(greater_or_equal(register_date, date("now", "-7 days"))))),
-                 registered_cnt()(select(columns(register_user->*register_date,
-                                                 count(distinct(register_user->*&user_activity::uid)) >>= user_count),
-                                         group_by(register_user->*register_date)))),
-             select(columns(register_user->*register_date,
-                            c(cast<int>(julianday(date(&user_activity::timestamp, "unixepoch")))) -
-                                cast<int>(julianday(register_user->*register_date)) >>= ndays,
-                            count(distinct(&user_activity::uid)) >>= "retention"_col,
-                            registered_cnt->*user_count),
-                    left_join<register_user>(using_(&user_activity::uid)),
-                    left_join<registered_cnt>(using_(registered_cnt->*register_date)),
-                    group_by(register_user->*register_date, ndays)
-                        .having(date(&user_activity::timestamp, "unixepoch") >= date("now", "-7 days"))));
+    auto expression = with(
+        make_tuple(
+            register_user().as(select(
+                columns(&user_activity::uid, min(date(&user_activity::timestamp, "unixepoch")) >>= register_date),
+                group_by(&user_activity::uid).having(greater_or_equal(register_date, date("now", "-7 days"))))),
+            registered_cnt().as(select(columns(register_user->*register_date,
+                                               count(distinct(register_user->*&user_activity::uid)) >>= user_count),
+                                       group_by(register_user->*register_date)))),
+        select(columns(register_user->*register_date,
+                       c(cast<int>(julianday(date(&user_activity::timestamp, "unixepoch")))) -
+                           cast<int>(julianday(register_user->*register_date)) >>= ndays,
+                       count(distinct(&user_activity::uid)) >>= "retention"_col,
+                       registered_cnt->*user_count),
+               left_join<register_user>(using_(&user_activity::uid)),
+               left_join<registered_cnt>(using_(registered_cnt->*register_date)),
+               group_by(register_user->*register_date, ndays)
+                   .having(date(&user_activity::timestamp, "unixepoch") >= date("now", "-7 days"))));
 
     string sql = storage.dump(expression);
 
@@ -971,14 +977,14 @@ void greatest_n_per_group() {
     //where r.flag = 1
     constexpr auto wnd = "wnd"_cte;
     constexpr auto max_date = "max_date"_col;
-    auto expression =
-        with(wnd(&some_result::item_id, max_date)(
-                 select(columns(&some_result::item_id, max(&some_result::timestamp)), group_by(&some_result::item_id))),
-             select(object<some_result>(),
-                    inner_join<wnd>(on(&some_result::item_id == wnd->*&some_result::item_id and
-                                       &some_result::timestamp == wnd->*max_date)),
-                    // additional conditions
-                    where(c(&some_result::flag) == true)));
+    auto expression = with(
+        wnd(&some_result::item_id, max_date)
+            .as(select(columns(&some_result::item_id, max(&some_result::timestamp)), group_by(&some_result::item_id))),
+        select(object<some_result>(),
+               inner_join<wnd>(on(&some_result::item_id == wnd->*&some_result::item_id and
+                                  &some_result::timestamp == wnd->*max_date)),
+               // additional conditions
+               where(c(&some_result::flag) == true)));
     string sql = storage.dump(expression);
 
     auto stmt = storage.prepare(expression);
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index d5207e679..eec0f45ce 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -7639,17 +7639,6 @@ namespace sqlite_orm {
         struct cte_builder {
             ExplicitCols explicitColumns;
 
-            template<class T, class... Args>
-            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols>
-            operator()(select_t<T, Args...> sel) && {
-                return {std::move(this->explicitColumns), std::move(sel)};
-            }
-
-            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
-            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> operator()(Compound sel) && {
-                return {std::move(this->explicitColumns), {std::move(sel)}};
-            }
-
             template<class T, class... Args>
             common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols> as(select_t<T, Args...> sel) && {
                 return {std::move(this->explicitColumns), std::move(sel)};
diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index 7dd0773ef..2a24f2e4f 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -333,7 +333,7 @@ TEST_CASE("ast_iterator") {
     SECTION("with") {
         using cte_1 = decltype(1_ctealias);
         auto expression =
-            with(cte<cte_1>()(
+            with(cte<cte_1>().as(
                      union_all(select(1), select(1_ctealias->*1_colalias + 1, where(1_ctealias->*1_colalias < 10)))),
                  select(1_ctealias->*1_colalias));
         expected.insert(expected.cend(),
diff --git a/tests/statement_serializer_tests/column_names.cpp b/tests/statement_serializer_tests/column_names.cpp
index aceca1368..1cca895df 100644
--- a/tests/statement_serializer_tests/column_names.cpp
+++ b/tests/statement_serializer_tests/column_names.cpp
@@ -160,7 +160,7 @@ TEST_CASE("statement_serializer column names") {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         SECTION("cte") {
             auto dbObjects2 =
-                internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, 1_ctealias()(select(1))));
+                internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, 1_ctealias().as(select(1))));
             using context_t = internal::serializer_context<decltype(dbObjects2)>;
             context_t context{dbObjects2};
             context.skip_table_name = false;
diff --git a/tests/statement_serializer_tests/select_constraints.cpp b/tests/statement_serializer_tests/select_constraints.cpp
index 54f7d6f8d..1c7f64a85 100644
--- a/tests/statement_serializer_tests/select_constraints.cpp
+++ b/tests/statement_serializer_tests/select_constraints.cpp
@@ -90,7 +90,7 @@ TEST_CASE("statement_serializer select constraints") {
     SECTION("from CTE") {
         using cte_1 = decltype(1_ctealias);
         auto dbObjects2 =
-            internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
+            internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>().as(select(1))));
         using context_t = internal::serializer_context<decltype(dbObjects2)>;
         context_t context{dbObjects2};
         SECTION("without alias 1") {
@@ -105,12 +105,12 @@ TEST_CASE("statement_serializer select constraints") {
         }
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         SECTION("without alias 2") {
-            auto expression = from<"1"_cte>();
+            auto expression = from<1_ctealias>();
             value = serialize(expression, context);
             expected = R"(FROM "1")";
         }
         SECTION("with alias 2") {
-            constexpr auto z_alias = "z"_alias.for_<"1"_cte>();
+            constexpr auto z_alias = "z"_alias.for_<1_ctealias>();
             auto expression = from<z_alias>();
             value = serialize(expression, context);
             expected = R"(FROM "1" "z")";
@@ -118,7 +118,7 @@ TEST_CASE("statement_serializer select constraints") {
 #endif
         SECTION("complete select") {
             auto expression = with(
-                cte<cte_1>()(
+                cte<cte_1>().as(
                     union_all(select(1), select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < 10)))),
                 select(1_ctealias->*1_colalias));
             value = serialize(expression, context);
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index 77cb783ec..5c26cb964 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -53,7 +53,7 @@ TEST_CASE("column_expression_of_t") {
     using cte_1 = decltype(1_ctealias);
     auto dbObjects2 =
         internal::db_objects_cat(dbObjects,
-                                 internal::make_cte_table(dbObjects, cte<cte_1>()(select(columns(&Org::id, 1)))));
+                                 internal::make_cte_table(dbObjects, cte<cte_1>().as(select(columns(&Org::id, 1)))));
     using db_objects2_t = decltype(dbObjects2);
     runTest<db_objects_t, column_pointer<cte_1, int64 Org::*>>(column<cte_1>(&Org::id));
     runTest<db_objects_t, column_pointer<cte_1, int64 Org::*>>(cte_1{}->*&Org::id);
diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
index d62f42894..681d7a9f4 100644
--- a/tests/static_tests/column_result_t.cpp
+++ b/tests/static_tests/column_result_t.cpp
@@ -119,7 +119,8 @@ TEST_CASE("column_result_of_t") {
     using cte_1 = decltype(1_ctealias);
     // note: even though used with the CTE, &User::id doesn't need to be mapped into the CTE to make column results work;
     //       this is because the result type is taken from the member pointer just because we can't look it up in the storage definition
-    auto dbObjects2 = internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>()(select(1))));
+    auto dbObjects2 =
+        internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, cte<cte_1>().as(select(1))));
     using db_objects2_t = decltype(dbObjects2);
     runTest<db_objects_t, int>(column<cte_1>(&User::id));
     runTest<db_objects2_t, int>(column<cte_1>(1_colalias));
diff --git a/tests/static_tests/cte.cpp b/tests/static_tests/cte.cpp
index b84339c88..685fb7414 100644
--- a/tests/static_tests/cte.cpp
+++ b/tests/static_tests/cte.cpp
@@ -65,7 +65,7 @@ TEST_CASE("CTE storage") {
         auto idx1 = make_unique_index("idx1_org", &Org::id);
         auto idx2 = make_index("idx2_org", &Org::id);
         auto dbObjects = tuple{idx1, idx2, table};
-        auto cteTable = internal::make_cte_table(dbObjects, 1_ctealias()(select(1)));
+        auto cteTable = internal::make_cte_table(dbObjects, 1_ctealias().as(select(1)));
         auto dbObjects2 = internal::db_objects_cat(dbObjects, cteTable);
 
         // note: deliberately make indexes resulting in the same index_t<> type, such that we know `db_objects_cat()` is working properly
diff --git a/tests/static_tests/node_tuple.cpp b/tests/static_tests/node_tuple.cpp
index 36169d6e4..200727d2d 100644
--- a/tests/static_tests/node_tuple.cpp
+++ b/tests/static_tests/node_tuple.cpp
@@ -951,7 +951,7 @@ TEST_CASE("Node tuple") {
     SECTION("with") {
         using cte_1 = decltype(1_ctealias);
         auto expression =
-            with(1_ctealias()(
+            with(1_ctealias().as(
                      union_all(select(1), select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < 10)))),
                  select(1_ctealias->*1_colalias));
         using Tuple = node_tuple_t<decltype(expression)>;
diff --git a/tests/table_name_collector.cpp b/tests/table_name_collector.cpp
index b09af0cfb..649e74214 100644
--- a/tests/table_name_collector.cpp
+++ b/tests/table_name_collector.cpp
@@ -48,7 +48,7 @@ TEST_CASE("table name collector") {
 #ifdef SQLITE_ORM_WITH_CTE
     SECTION("from CTE") {
         auto dbObjects2 =
-            internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, 1_ctealias()(select(1))));
+            internal::db_objects_cat(dbObjects, internal::make_cte_table(dbObjects, 1_ctealias().as(select(1))));
         using context_t = internal::serializer_context<decltype(dbObjects2)>;
         context_t context{dbObjects2};
         auto collector = internal::make_table_name_collector(context.db_objects);

From 96043a1e7ada17a9208ad696a1a69e354f891f54 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 14 Oct 2023 09:59:24 +0200
Subject: [PATCH 133/161] Serialized `WITH` keyword differently

---
 dev/select_constraints.h        |  8 +-------
 dev/statement_serializer.h      |  3 ++-
 include/sqlite_orm/sqlite_orm.h | 11 +++--------
 3 files changed, 6 insertions(+), 16 deletions(-)

diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 2d3335ef2..91fb33a2a 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -200,12 +200,6 @@ namespace sqlite_orm {
         };
 
 #ifdef SQLITE_ORM_WITH_CTE
-        struct with_string {
-            explicit operator std::string() const {
-                return "WITH";
-            }
-        };
-
         /*
          *  Turn explicit columns for a CTE into types that the CTE backend understands
          */
@@ -290,7 +284,7 @@ namespace sqlite_orm {
          *  WITH object type - expression with prepended CTEs.
          */
         template<class E, class... CTEs>
-        struct with_t : with_string {
+        struct with_t {
             using cte_type = common_table_expressions<CTEs...>;
             using expression_type = E;
 
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index 001afd952..86626ac4a 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -612,7 +612,8 @@ namespace sqlite_orm {
                 tupleContext.use_parentheses = false;
 
                 std::stringstream ss;
-                ss << static_cast<std::string>(c) << " ";
+                ss << "WITH";
+                ss << " ";
                 ss << serialize(c.cte, tupleContext) << " ";
                 ss << serialize(c.expression, context);
                 return ss.str();
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index eec0f45ce..a2c3a51d6 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -7590,12 +7590,6 @@ namespace sqlite_orm {
         };
 
 #ifdef SQLITE_ORM_WITH_CTE
-        struct with_string {
-            explicit operator std::string() const {
-                return "WITH";
-            }
-        };
-
         /*
          *  Turn explicit columns for a CTE into types that the CTE backend understands
          */
@@ -7680,7 +7674,7 @@ namespace sqlite_orm {
          *  WITH object type - expression with prepended CTEs.
          */
         template<class E, class... CTEs>
-        struct with_t : with_string {
+        struct with_t {
             using cte_type = common_table_expressions<CTEs...>;
             using expression_type = E;
 
@@ -17232,7 +17226,8 @@ namespace sqlite_orm {
                 tupleContext.use_parentheses = false;
 
                 std::stringstream ss;
-                ss << static_cast<std::string>(c) << " ";
+                ss << "WITH";
+                ss << " ";
                 ss << serialize(c.cte, tupleContext) << " ";
                 ss << serialize(c.expression, context);
                 return ss.str();

From ee5aba14f6fa9f8f793dd58d93e031a41e5991d6 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 14 Oct 2023 21:28:08 +0200
Subject: [PATCH 134/161] Provided optional `WITH RECURSIVE`

---
 dev/select_constraints.h                      |  47 ++++++--
 dev/statement_serializer.h                    |   8 +-
 dev/storage.h                                 |  46 ++++++-
 examples/common_table_expressions.cpp         | 112 +++++++++---------
 include/sqlite_orm/sqlite_orm.h               | 101 +++++++++++++---
 tests/ast_iterator_tests.cpp                  |  37 +++++-
 .../select_constraints.cpp                    |  25 +++-
 tests/static_tests/node_tuple.cpp             |  39 +++++-
 8 files changed, 316 insertions(+), 99 deletions(-)

diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 91fb33a2a..61b9de362 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -288,10 +288,12 @@ namespace sqlite_orm {
             using cte_type = common_table_expressions<CTEs...>;
             using expression_type = E;
 
+            bool recursiveIndicated;
             cte_type cte;
             expression_type expression;
 
-            with_t(cte_type cte, expression_type expression) : cte{std::move(cte)}, expression{std::move(expression)} {
+            with_t(bool recursiveIndicated, cte_type cte, expression_type expression) :
+                recursiveIndicated{recursiveIndicated}, cte{std::move(cte)}, expression{std::move(expression)} {
                 this->expression.highest_level = true;
             }
         };
@@ -554,25 +556,56 @@ namespace sqlite_orm {
     }
 
     /** 
-     *  With-clause for a tuple of CTEs.
+     *  With-clause for a tuple of ordinary CTEs.
+     *  
+     *  Despite the missing RECURSIVE keyword, the CTEs can be recursive.
      */
     template<class E, class... Monikers, class... Selects, class... ExplicitCols>
     internal::with_t<E, internal::common_table_expression<Monikers, Selects, ExplicitCols>...>
     with(std::tuple<internal::common_table_expression<Monikers, Selects, ExplicitCols>...> cte, E expression) {
-        return {std::move(cte), std::move(expression)};
+        return {false, std::move(cte), std::move(expression)};
     }
 
     /** 
-     *  With-clause for a single CTE.
+     *  With-clause for a single ordinary CTE.
+     *  
+     *  Despite the missing `RECURSIVE` keyword, the CTE can be recursive.
      *  
      *  Example:
-     *  using cte_1 = decltype(1_ctealias);
-     *  with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
+     *  constexpr auto cte_1 = 1_ctealias;
+     *  with(cte_1().as(select(&Object::id)), select(cte_1->*1_colalias));
      */
     template<class E, class Moniker, class Select, class ExplicitCols>
     internal::with_t<E, internal::common_table_expression<Moniker, Select, ExplicitCols>>
     with(internal::common_table_expression<Moniker, Select, ExplicitCols> cte, E expression) {
-        return {std::make_tuple(std::move(cte)), std::move(expression)};
+        return {false, std::make_tuple(std::move(cte)), std::move(expression)};
+    }
+
+    /** 
+     *  With-clause for a tuple of potentially recursive CTEs.
+     *  
+     *  @note The use of RECURSIVE does not force common table expressions to be recursive.
+     */
+    template<class E, class... Monikers, class... Selects, class... ExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Monikers, Selects, ExplicitCols>...>
+    with_recursive(std::tuple<internal::common_table_expression<Monikers, Selects, ExplicitCols>...> cte,
+                   E expression) {
+        return {true, std::move(cte), std::move(expression)};
+    }
+
+    /** 
+     *  With-clause for a single potentially recursive CTE.
+     *  
+     *  @note The use of RECURSIVE does not force common table expressions to be recursive.
+     *  
+     *  Example:
+     *  constexpr auto cte_1 = 1_ctealias;
+     *  with_recursive(cte_1().as(select(&Object::id)), select(cte_1->*1_colalias));
+     */
+    template<class E, class Moniker, class Select, class ExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Moniker, Select, ExplicitCols>>
+    with_recursive(internal::common_table_expression<Moniker, Select, ExplicitCols> cte, E expression) {
+        return {true, std::make_tuple(std::move(cte)), std::move(expression)};
     }
 #endif
 
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index 86626ac4a..7af2e4094 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -613,9 +613,11 @@ namespace sqlite_orm {
 
                 std::stringstream ss;
                 ss << "WITH";
-                ss << " ";
-                ss << serialize(c.cte, tupleContext) << " ";
-                ss << serialize(c.expression, context);
+                if(c.recursiveIndicated) {
+                    ss << " RECURSIVE";
+                }
+                ss << " " << serialize(c.cte, tupleContext);
+                ss << " " << serialize(c.expression, context);
                 return ss.str();
             }
         };
diff --git a/dev/storage.h b/dev/storage.h
index 13c16bd45..de7c0aac8 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -599,9 +599,7 @@ namespace sqlite_orm {
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class CTE,
-                     class Compound,
-                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            template<class CTE, class Compound, satisfies<is_compound_operator, Compound> = true>
             auto with(CTE cte, Compound sel) {
                 auto statement = this->prepare(sqlite_orm::with(std::move(cte), sqlite_orm::select(std::move(sel))));
                 return this->execute(statement);
@@ -610,13 +608,49 @@ namespace sqlite_orm {
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class... CTEs,
-                     class Compound,
-                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            template<class... CTEs, class Compound, satisfies<is_compound_operator, Compound> = true>
             auto with(common_table_expressions<CTEs...> cte, Compound sel) {
                 auto statement = this->prepare(sqlite_orm::with(std::move(cte), sqlite_orm::select(std::move(sel))));
                 return this->execute(statement);
             }
+
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class CTE, class T, class... Args>
+            auto with_recursive(CTE cte, select_t<T, Args...> sel) {
+                auto statement = this->prepare(sqlite_orm::with_recursive(std::move(cte), std::move(sel)));
+                return this->execute(statement);
+            }
+
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class... CTEs, class T, class... Args>
+            auto with_recursive(common_table_expressions<CTEs...> cte, select_t<T, Args...> sel) {
+                auto statement = this->prepare(sqlite_orm::with_recursive(std::move(cte), std::move(sel)));
+                return this->execute(statement);
+            }
+
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class CTE, class Compound, satisfies<is_compound_operator, Compound> = true>
+            auto with_recursive(CTE cte, Compound sel) {
+                auto statement =
+                    this->prepare(sqlite_orm::with_recursive(std::move(cte), sqlite_orm::select(std::move(sel))));
+                return this->execute(statement);
+            }
+
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class... CTEs, class Compound, satisfies<is_compound_operator, Compound> = true>
+            auto with_recursive(common_table_expressions<CTEs...> cte, Compound sel) {
+                auto statement =
+                    this->prepare(sqlite_orm::with_recursive(std::move(cte), sqlite_orm::select(std::move(sel))));
+                return this->execute(statement);
+            }
 #endif
 
             template<class T, satisfies<is_prepared_statement, T> = true>
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 937530232..8981f9fcc 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -34,14 +34,15 @@ void all_integers_between(int from, int end) {
         //    SELECT x FROM cnt;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto cnt = "cnt"_cte;
-        auto ast = with(cnt().as(union_all(select(from), select(cnt->*1_colalias + 1, where(cnt->*1_colalias < end)))),
-                        select(cnt->*1_colalias));
+        auto ast = with_recursive(
+            cnt().as(union_all(select(from), select(cnt->*1_colalias + 1, where(cnt->*1_colalias < end)))),
+            select(cnt->*1_colalias));
 #else
         using cnt = decltype(1_ctealias);
-        auto ast =
-            with(cte<cnt>().as(union_all(select(from),
-                                         select(1_ctealias->*1_colalias + 1, where(1_ctealias->*1_colalias < end)))),
-                 select(1_ctealias->*1_colalias));
+        auto ast = with_recursive(
+            cte<cnt>().as(
+                union_all(select(from), select(1_ctealias->*1_colalias + 1, where(1_ctealias->*1_colalias < end)))),
+            select(1_ctealias->*1_colalias));
 #endif
 
         string sql = storage.dump(ast);
@@ -69,12 +70,13 @@ void all_integers_between(int from, int end) {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto cnt = "cnt"_cte;
         constexpr auto x = "x"_col;
-        auto ast = with(cnt().as(union_all(select(from >>= x), select(cnt->*x + 1, limit(end)))), select(cnt->*x));
+        auto ast =
+            with_recursive(cnt().as(union_all(select(from >>= x), select(cnt->*x + 1, limit(end)))), select(cnt->*x));
 #else
         using cnt = decltype(1_ctealias);
         constexpr auto x = colalias_i{};
-        auto ast = with(cte<cnt>().as(union_all(select(from >>= x), select(column<cnt>(x) + 1, limit(end)))),
-                        select(column<cnt>(x)));
+        auto ast = with_recursive(cte<cnt>().as(union_all(select(from >>= x), select(column<cnt>(x) + 1, limit(end)))),
+                                  select(column<cnt>(x)));
 #endif
 
         string sql = storage.dump(ast);
@@ -162,18 +164,18 @@ void supervisor_chain() {
         //    SELECT name FROM chain;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto chain = "chain"_cte;
-        auto ast =
-            with(chain().as(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
-                                      select(asterisk<alias_a<Org>>(),
-                                             where(alias_column<alias_a<Org>>(&Org::name) == chain->*&Org::boss)))),
-                 select(chain->*&Org::name));
+        auto ast = with_recursive(
+            chain().as(union_all(
+                select(asterisk<Org>(), where(&Org::name == c("Fred"))),
+                select(asterisk<alias_a<Org>>(), where(alias_column<alias_a<Org>>(&Org::name) == chain->*&Org::boss)))),
+            select(chain->*&Org::name));
 #else
         using chain = decltype(1_ctealias);
-        auto ast = with(cte<chain>().as(union_all(
-                            select(asterisk<Org>(), where(&Org::name == c("Fred"))),
-                            select(asterisk<alias_a<Org>>(),
-                                   where(alias_column<alias_a<Org>>(&Org::name) == column<chain>(&Org::boss))))),
-                        select(column<chain>(&Org::name)));
+        auto ast = with_recursive(cte<chain>().as(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
+                                                            select(asterisk<alias_a<Org>>(),
+                                                                   where(alias_column<alias_a<Org>>(&Org::name) ==
+                                                                         column<chain>(&Org::boss))))),
+                                  select(column<chain>(&Org::name)));
 #endif
         string sql = storage.dump(ast);
 
@@ -230,13 +232,13 @@ void works_for_alice() {
         //    WHERE org.name IN works_for_alice;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto works_for_alice = "works_for_alice"_cte;
-        auto ast = with(
+        auto ast = with_recursive(
             works_for_alice(&Org::name)
                 .as(union_(select("Alice"), select(&Org::name, where(&Org::boss == works_for_alice->*&Org::name)))),
             select(avg(&Org::height), from<Org>(), where(in(&Org::name, select(works_for_alice->*&Org::name)))));
 #else
         using works_for_alice = decltype(1_ctealias);
-        auto ast = with(
+        auto ast = with_recursive(
             cte<works_for_alice>(&Org::name)
                 .as(union_(select("Alice"),
                            select(&Org::name, where(&Org::boss == column<works_for_alice>(&Org::name))))),
@@ -320,7 +322,7 @@ void family_tree() {
     constexpr auto ancestor_of_alice = "ancestor_of_alice"_cte;
     constexpr auto parent = "parent"_col;
     constexpr auto name = "name"_col;
-    auto ast = with(
+    auto ast = with_recursive(
         make_tuple(
             parent_of(&Family::name, parent)
                 .as(union_(select(columns(&Family::name, &Family::mom)), select(columns(&Family::name, &Family::dad)))),
@@ -335,7 +337,7 @@ void family_tree() {
     using ancestor_of_alice = decltype(2_ctealias);
     constexpr auto parent = colalias_h{};
     constexpr auto name = colalias_f{};
-    auto ast = with(
+    auto ast = with_recursive(
         make_tuple(
             cte<parent_of>("name", "parent")
                 .as(union_(select(columns(&Family::name, &Family::mom >>= parent)),
@@ -443,15 +445,16 @@ void depth_or_breadth_first() {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto under_alice = "under_alice"_cte;
         constexpr auto level = "level"_col;
-        auto ast = with(under_alice(&Org::name, level)
-                            .as(union_all(select(columns("Alice", 0)),
-                                          select(columns(&Org::name, under_alice->*level + 1),
-                                                 join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
-                                                 order_by(2)))),
-                        select(substr("..........", 1, under_alice->*level * 3) || under_alice->*&Org::name));
+        auto ast =
+            with_recursive(under_alice(&Org::name, level)
+                               .as(union_all(select(columns("Alice", 0)),
+                                             select(columns(&Org::name, under_alice->*level + 1),
+                                                    join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
+                                                    order_by(2)))),
+                           select(substr("..........", 1, under_alice->*level * 3) || under_alice->*&Org::name));
 #else
         using under_alice = decltype(1_ctealias);
-        auto ast = with(
+        auto ast = with_recursive(
             cte<under_alice>("name", "level")
                 .as(union_all(select(columns("Alice", 0)),
                               select(columns(&Org::name, column<under_alice>(2_colalias) + 1),
@@ -486,15 +489,16 @@ void depth_or_breadth_first() {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto under_alice = "under_alice"_cte;
         constexpr auto level = "level"_col;
-        auto ast = with(under_alice(&Org::name, level)
-                            .as(union_all(select(columns("Alice", 0)),
-                                          select(columns(&Org::name, under_alice->*level + 1),
-                                                 join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
-                                                 order_by(2).desc()))),
-                        select(substr("..........", 1, under_alice->*level * 3) || under_alice->*&Org::name));
+        auto ast =
+            with_recursive(under_alice(&Org::name, level)
+                               .as(union_all(select(columns("Alice", 0)),
+                                             select(columns(&Org::name, under_alice->*level + 1),
+                                                    join<under_alice>(on(under_alice->*&Org::name == &Org::boss)),
+                                                    order_by(2).desc()))),
+                           select(substr("..........", 1, under_alice->*level * 3) || under_alice->*&Org::name));
 #else
         using under_alice = decltype(1_ctealias);
-        auto ast = with(
+        auto ast = with_recursive(
             cte<under_alice>("name", "level")
                 .as(union_all(select(columns("Alice", 0)),
                               select(columns(&Org::name, column<under_alice>(2_colalias) + 1),
@@ -593,21 +597,21 @@ void apfelmaennchen() {
     constexpr auto cx = "cx"_col;
     constexpr auto cy = "cy"_col;
     constexpr auto t = "t"_col;
-    auto ast =
-        with(make_tuple(xaxis(x).as(union_all(select(-2.0), select(xaxis->*x + 0.05, where(xaxis->*x < 1.2)))),
-                        yaxis(y).as(union_all(select(-1.0), select(yaxis->*y + 0.10, where(yaxis->*y < 1.0)))),
-                        m(iter, cx, cy, x, y)
-                            .as(union_all(select(columns(0, xaxis->*x, yaxis->*y, 0.0, 0.0)),
-                                          select(columns(m->*iter + 1,
-                                                         m->*cx,
-                                                         m->*cy,
-                                                         m->*x * m->*x - m->*y * m->*y + m->*cx,
-                                                         2.0 * m->*x * m->*y + m->*cy),
-                                                 where((m->*x * m->*x + m->*y * m->*y) < 4.0 && m->*iter < 28)))),
-                        m2(iter, cx, cy).as(select(columns(max<>(m->*iter), m->*cx, m->*cy), group_by(m->*cx, m->*cy))),
-                        a(t).as(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / 7.0, 4.0), 1), ""),
-                                       group_by(m2->*cy)))),
-             select(group_concat(rtrim(a->*t), "\n")));
+    auto ast = with_recursive(
+        make_tuple(
+            xaxis(x).as(union_all(select(-2.0), select(xaxis->*x + 0.05, where(xaxis->*x < 1.2)))),
+            yaxis(y).as(union_all(select(-1.0), select(yaxis->*y + 0.10, where(yaxis->*y < 1.0)))),
+            m(iter, cx, cy, x, y)
+                .as(union_all(select(columns(0, xaxis->*x, yaxis->*y, 0.0, 0.0)),
+                              select(columns(m->*iter + 1,
+                                             m->*cx,
+                                             m->*cy,
+                                             m->*x * m->*x - m->*y * m->*y + m->*cx,
+                                             2.0 * m->*x * m->*y + m->*cy),
+                                     where((m->*x * m->*x + m->*y * m->*y) < 4.0 && m->*iter < 28)))),
+            m2(iter, cx, cy).as(select(columns(max<>(m->*iter), m->*cx, m->*cy), group_by(m->*cx, m->*cy))),
+            a(t).as(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / 7.0, 4.0), 1), ""), group_by(m2->*cy)))),
+        select(group_concat(rtrim(a->*t), "\n")));
 #else
     using cte_xaxis = decltype(1_ctealias);
     using cte_yaxis = decltype(2_ctealias);
@@ -625,7 +629,7 @@ void apfelmaennchen() {
     constexpr auto cx = colalias_d{};
     constexpr auto cy = colalias_e{};
     constexpr auto t = colalias_f{};
-    auto ast = with(
+    auto ast = with_recursive(
         make_tuple(
             cte<cte_xaxis>("x").as(union_all(select(-2.0 >>= x), select(xaxis->*x + 0.05, where(xaxis->*x < 1.2)))),
             cte<cte_yaxis>("y").as(union_all(select(-1.0 >>= y), select(yaxis->*y + 0.10, where(yaxis->*y < 1.0)))),
@@ -698,7 +702,7 @@ void sudoku() {
     constexpr auto lp = "lp"_col;
     constexpr auto s = "s"_col;
     constexpr auto ind = "ind"_col;
-    auto ast = with(
+    auto ast = with_recursive(
         make_tuple(
             cte<input>(sud).as(
                 select("53..7....6..195....98....6.8...6...34..8.3..17...2...6.6....28....419..5....8..79")),
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index a2c3a51d6..736184f1f 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -7678,10 +7678,12 @@ namespace sqlite_orm {
             using cte_type = common_table_expressions<CTEs...>;
             using expression_type = E;
 
+            bool recursiveIndicated;
             cte_type cte;
             expression_type expression;
 
-            with_t(cte_type cte, expression_type expression) : cte{std::move(cte)}, expression{std::move(expression)} {
+            with_t(bool recursiveIndicated, cte_type cte, expression_type expression) :
+                recursiveIndicated{recursiveIndicated}, cte{std::move(cte)}, expression{std::move(expression)} {
                 this->expression.highest_level = true;
             }
         };
@@ -7944,25 +7946,56 @@ namespace sqlite_orm {
     }
 
     /** 
-     *  With-clause for a tuple of CTEs.
+     *  With-clause for a tuple of ordinary CTEs.
+     *  
+     *  Despite the missing RECURSIVE keyword, the CTEs can be recursive.
      */
     template<class E, class... Monikers, class... Selects, class... ExplicitCols>
     internal::with_t<E, internal::common_table_expression<Monikers, Selects, ExplicitCols>...>
     with(std::tuple<internal::common_table_expression<Monikers, Selects, ExplicitCols>...> cte, E expression) {
-        return {std::move(cte), std::move(expression)};
+        return {false, std::move(cte), std::move(expression)};
     }
 
     /** 
-     *  With-clause for a single CTE.
+     *  With-clause for a single ordinary CTE.
+     *  
+     *  Despite the missing `RECURSIVE` keyword, the CTE can be recursive.
      *  
      *  Example:
-     *  using cte_1 = decltype(1_ctealias);
-     *  with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(0_col)));
+     *  constexpr auto cte_1 = 1_ctealias;
+     *  with(cte_1().as(select(&Object::id)), select(cte_1->*1_colalias));
      */
     template<class E, class Moniker, class Select, class ExplicitCols>
     internal::with_t<E, internal::common_table_expression<Moniker, Select, ExplicitCols>>
     with(internal::common_table_expression<Moniker, Select, ExplicitCols> cte, E expression) {
-        return {std::make_tuple(std::move(cte)), std::move(expression)};
+        return {false, std::make_tuple(std::move(cte)), std::move(expression)};
+    }
+
+    /** 
+     *  With-clause for a tuple of potentially recursive CTEs.
+     *  
+     *  @note The use of RECURSIVE does not force common table expressions to be recursive.
+     */
+    template<class E, class... Monikers, class... Selects, class... ExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Monikers, Selects, ExplicitCols>...>
+    with_recursive(std::tuple<internal::common_table_expression<Monikers, Selects, ExplicitCols>...> cte,
+                   E expression) {
+        return {true, std::move(cte), std::move(expression)};
+    }
+
+    /** 
+     *  With-clause for a single potentially recursive CTE.
+     *  
+     *  @note The use of RECURSIVE does not force common table expressions to be recursive.
+     *  
+     *  Example:
+     *  constexpr auto cte_1 = 1_ctealias;
+     *  with_recursive(cte_1().as(select(&Object::id)), select(cte_1->*1_colalias));
+     */
+    template<class E, class Moniker, class Select, class ExplicitCols>
+    internal::with_t<E, internal::common_table_expression<Moniker, Select, ExplicitCols>>
+    with_recursive(internal::common_table_expression<Moniker, Select, ExplicitCols> cte, E expression) {
+        return {true, std::make_tuple(std::move(cte)), std::move(expression)};
     }
 #endif
 
@@ -17227,9 +17260,11 @@ namespace sqlite_orm {
 
                 std::stringstream ss;
                 ss << "WITH";
-                ss << " ";
-                ss << serialize(c.cte, tupleContext) << " ";
-                ss << serialize(c.expression, context);
+                if(c.recursiveIndicated) {
+                    ss << " RECURSIVE";
+                }
+                ss << " " << serialize(c.cte, tupleContext);
+                ss << " " << serialize(c.expression, context);
                 return ss.str();
             }
         };
@@ -19807,9 +19842,7 @@ namespace sqlite_orm {
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class CTE,
-                     class Compound,
-                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            template<class CTE, class Compound, satisfies<is_compound_operator, Compound> = true>
             auto with(CTE cte, Compound sel) {
                 auto statement = this->prepare(sqlite_orm::with(std::move(cte), sqlite_orm::select(std::move(sel))));
                 return this->execute(statement);
@@ -19818,13 +19851,49 @@ namespace sqlite_orm {
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class... CTEs,
-                     class Compound,
-                     std::enable_if_t<is_base_of_template<Compound, compound_operator>::value, bool> = true>
+            template<class... CTEs, class Compound, satisfies<is_compound_operator, Compound> = true>
             auto with(common_table_expressions<CTEs...> cte, Compound sel) {
                 auto statement = this->prepare(sqlite_orm::with(std::move(cte), sqlite_orm::select(std::move(sel))));
                 return this->execute(statement);
             }
+
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class CTE, class T, class... Args>
+            auto with_recursive(CTE cte, select_t<T, Args...> sel) {
+                auto statement = this->prepare(sqlite_orm::with_recursive(std::move(cte), std::move(sel)));
+                return this->execute(statement);
+            }
+
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class... CTEs, class T, class... Args>
+            auto with_recursive(common_table_expressions<CTEs...> cte, select_t<T, Args...> sel) {
+                auto statement = this->prepare(sqlite_orm::with_recursive(std::move(cte), std::move(sel)));
+                return this->execute(statement);
+            }
+
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class CTE, class Compound, satisfies<is_compound_operator, Compound> = true>
+            auto with_recursive(CTE cte, Compound sel) {
+                auto statement =
+                    this->prepare(sqlite_orm::with_recursive(std::move(cte), sqlite_orm::select(std::move(sel))));
+                return this->execute(statement);
+            }
+
+            /**
+             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
+             */
+            template<class... CTEs, class Compound, satisfies<is_compound_operator, Compound> = true>
+            auto with_recursive(common_table_expressions<CTEs...> cte, Compound sel) {
+                auto statement =
+                    this->prepare(sqlite_orm::with_recursive(std::move(cte), sqlite_orm::select(std::move(sel))));
+                return this->execute(statement);
+            }
 #endif
 
             template<class T, satisfies<is_prepared_statement, T> = true>
diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index 2a24f2e4f..877fa168a 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -330,12 +330,39 @@ TEST_CASE("ast_iterator") {
     }
 #endif
 #ifdef SQLITE_ORM_WITH_CTE
-    SECTION("with") {
+    SECTION("with ordinary") {
         using cte_1 = decltype(1_ctealias);
-        auto expression =
-            with(cte<cte_1>().as(
-                     union_all(select(1), select(1_ctealias->*1_colalias + 1, where(1_ctealias->*1_colalias < 10)))),
-                 select(1_ctealias->*1_colalias));
+        auto expression = with(cte<cte_1>().as(select(1)), select(column<cte_1>(1_colalias)));
+        expected.insert(expected.cend(), {typeid(int), typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>)});
+        iterate_ast(expression, lambda);
+    }
+    SECTION("with not enforced recursive") {
+        using cte_1 = decltype(1_ctealias);
+        auto expression = with_recursive(cte<cte_1>().as(select(1)), select(column<cte_1>(1_colalias)));
+        expected.insert(expected.cend(), {typeid(int), typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>)});
+        iterate_ast(expression, lambda);
+    }
+    SECTION("with optional recursive") {
+        using cte_1 = decltype(1_ctealias);
+        auto expression = with(
+            cte<cte_1>().as(
+                union_all(select(1), select(column<cte_1>(1_colalias) + 1, where(column<cte_1>(1_colalias) < 10)))),
+            select(column<cte_1>(1_colalias)));
+        expected.insert(expected.cend(),
+                        {typeid(int),
+                         typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>),
+                         typeid(int),
+                         typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>),
+                         typeid(int),
+                         typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>)});
+        iterate_ast(expression, lambda);
+    }
+    SECTION("with recursive") {
+        using cte_1 = decltype(1_ctealias);
+        auto expression = with_recursive(
+            cte<cte_1>().as(
+                union_all(select(1), select(column<cte_1>(1_colalias) + 1, where(column<cte_1>(1_colalias) < 10)))),
+            select(column<cte_1>(1_colalias)));
         expected.insert(expected.cend(),
                         {typeid(int),
                          typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>),
diff --git a/tests/statement_serializer_tests/select_constraints.cpp b/tests/statement_serializer_tests/select_constraints.cpp
index 1c7f64a85..d92ca3fb6 100644
--- a/tests/statement_serializer_tests/select_constraints.cpp
+++ b/tests/statement_serializer_tests/select_constraints.cpp
@@ -116,15 +116,34 @@ TEST_CASE("statement_serializer select constraints") {
             expected = R"(FROM "1" "z")";
         }
 #endif
-        SECTION("complete select") {
+        SECTION("with ordinary") {
+            auto expression = with(cte<cte_1>().as(select(1)), select(column<cte_1>(1_colalias)));
+            value = serialize(expression, context);
+            expected = R"(WITH "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1")";
+        }
+        SECTION("with not enforced recursive") {
+            auto expression = with_recursive(cte<cte_1>().as(select(1)), select(column<cte_1>(1_colalias)));
+            value = serialize(expression, context);
+            expected = R"(WITH RECURSIVE "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1")";
+        }
+        SECTION("with optional recursive") {
             auto expression = with(
                 cte<cte_1>().as(
-                    union_all(select(1), select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < 10)))),
-                select(1_ctealias->*1_colalias));
+                    union_all(select(1), select(column<cte_1>(1_colalias) + 1, where(column<cte_1>(1_colalias) < 10)))),
+                select(column<cte_1>(1_colalias)));
             value = serialize(expression, context);
             expected =
                 R"(WITH "1"("1") AS (SELECT 1 UNION ALL SELECT "1"."1" + 1 FROM "1" WHERE ("1"."1" < 10)) SELECT "1"."1" FROM "1")";
         }
+        SECTION("with recursive") {
+            auto expression = with_recursive(
+                cte<cte_1>().as(
+                    union_all(select(1), select(column<cte_1>(1_colalias) + 1, where(column<cte_1>(1_colalias) < 10)))),
+                select(column<cte_1>(1_colalias)));
+            value = serialize(expression, context);
+            expected =
+                R"(WITH RECURSIVE "1"("1") AS (SELECT 1 UNION ALL SELECT "1"."1" + 1 FROM "1" WHERE ("1"."1" < 10)) SELECT "1"."1" FROM "1")";
+        }
     }
 #endif
     // tests whether the statement serializer for a select with joins
diff --git a/tests/static_tests/node_tuple.cpp b/tests/static_tests/node_tuple.cpp
index 200727d2d..22dda6f71 100644
--- a/tests/static_tests/node_tuple.cpp
+++ b/tests/static_tests/node_tuple.cpp
@@ -948,12 +948,41 @@ TEST_CASE("Node tuple") {
         STATIC_REQUIRE(std::is_same<Tuple, ExpectedTuple>::value);
     }
 #ifdef SQLITE_ORM_WITH_CTE
-    SECTION("with") {
+    SECTION("with ordinary") {
         using cte_1 = decltype(1_ctealias);
-        auto expression =
-            with(1_ctealias().as(
-                     union_all(select(1), select(1_ctealias->*1_colalias + c(1), where(1_ctealias->*1_colalias < 10)))),
-                 select(1_ctealias->*1_colalias));
+        auto expression = with(1_ctealias().as(select(1)), select(column<cte_1>(1_colalias)));
+        using Tuple = node_tuple_t<decltype(expression)>;
+        using ExpectedTuple = tuple<int, column_pointer<cte_1, alias_holder<column_alias<'1'>>>>;
+        STATIC_REQUIRE(std::is_same_v<Tuple, ExpectedTuple>);
+    }
+    SECTION("with not enforced recursive") {
+        using cte_1 = decltype(1_ctealias);
+        auto expression = with(1_ctealias().as(select(1)), select(column<cte_1>(1_colalias)));
+        using Tuple = node_tuple_t<decltype(expression)>;
+        using ExpectedTuple = tuple<int, column_pointer<cte_1, alias_holder<column_alias<'1'>>>>;
+        STATIC_REQUIRE(std::is_same_v<Tuple, ExpectedTuple>);
+    }
+    SECTION("with optional recursive") {
+        using cte_1 = decltype(1_ctealias);
+        auto expression = with_recursive(
+            1_ctealias().as(
+                union_all(select(1), select(column<cte_1>(1_colalias) + 1, where(column<cte_1>(1_colalias) < 10)))),
+            select(column<cte_1>(1_colalias)));
+        using Tuple = node_tuple_t<decltype(expression)>;
+        using ExpectedTuple = tuple<int,
+                                    column_pointer<cte_1, alias_holder<column_alias<'1'>>>,
+                                    int,
+                                    column_pointer<cte_1, alias_holder<column_alias<'1'>>>,
+                                    int,
+                                    column_pointer<cte_1, alias_holder<column_alias<'1'>>>>;
+        STATIC_REQUIRE(std::is_same_v<Tuple, ExpectedTuple>);
+    }
+    SECTION("with recursive") {
+        using cte_1 = decltype(1_ctealias);
+        auto expression = with_recursive(
+            1_ctealias().as(
+                union_all(select(1), select(column<cte_1>(1_colalias) + 1, where(column<cte_1>(1_colalias) < 10)))),
+            select(column<cte_1>(1_colalias)));
         using Tuple = node_tuple_t<decltype(expression)>;
         using ExpectedTuple = tuple<int,
                                     column_pointer<cte_1, alias_holder<column_alias<'1'>>>,

From 5d2a8d82b67dd1ce72a6d2a091590afd2685ece1 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 14 Oct 2023 21:57:55 +0200
Subject: [PATCH 135/161] Simplified a few node expressions involving
 comparisons with aliases

---
 tests/ast_iterator_tests.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index 877fa168a..a9048c5ca 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -192,7 +192,7 @@ TEST_CASE("ast_iterator") {
             iterate_ast(node, lambda);
         }
         SECTION("column alias in expression") {
-            auto node = order_by(get<colalias_a>() > c(1));
+            auto node = order_by(get<colalias_a>() > 1);
             expected.push_back(typeid(int));
             iterate_ast(node, lambda);
         }
@@ -284,14 +284,14 @@ TEST_CASE("ast_iterator") {
     }
     SECTION("aliases") {
         SECTION("holder") {
-            auto expression = get<colalias_a>() > c(0);
+            auto expression = get<colalias_a>() > 0;
             expected.push_back(typeid(int));
             iterate_ast(expression, lambda);
         }
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         {
             SECTION("direct") {
-                auto expression = "a"_col > c(0);
+                auto expression = "a"_col > 0;
                 expected.push_back(typeid(int));
                 iterate_ast(expression, lambda);
             }

From e8bfdb4d9aa6b8a5fcda437b8cff706bd28e55fd Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 14 Oct 2023 22:33:26 +0200
Subject: [PATCH 136/161] Unit tests for with select from CTE directly from
 storage object

---
 dev/statement_serializer.h                    |  6 +--
 examples/common_table_expressions.cpp         |  4 +-
 include/sqlite_orm/sqlite_orm.h               |  6 +--
 .../select_constraints.cpp                    | 12 ++++++
 tests/tests3.cpp                              | 37 +++++++++++++++++++
 5 files changed, 57 insertions(+), 8 deletions(-)

diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index 2c3dc1eb9..0b56d356c 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -164,7 +164,7 @@ namespace sqlite_orm {
             using statement_type = current_time_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx& context) {
+            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) {
                 return "CURRENT_TIME";
             }
         };
@@ -174,7 +174,7 @@ namespace sqlite_orm {
             using statement_type = current_date_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx& context) {
+            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) {
                 return "CURRENT_DATE";
             }
         };
@@ -184,7 +184,7 @@ namespace sqlite_orm {
             using statement_type = current_timestamp_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx& context) {
+            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) {
                 return "CURRENT_TIMESTAMP";
             }
         };
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 8981f9fcc..f91bb7e38 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -41,8 +41,8 @@ void all_integers_between(int from, int end) {
         using cnt = decltype(1_ctealias);
         auto ast = with_recursive(
             cte<cnt>().as(
-                union_all(select(from), select(1_ctealias->*1_colalias + 1, where(1_ctealias->*1_colalias < end)))),
-            select(1_ctealias->*1_colalias));
+                union_all(select(from), select(column<cnt>(1_colalias) + 1, where(column<cnt>(1_colalias) < end)))),
+            select(column<cnt>(1_colalias)));
 #endif
 
         string sql = storage.dump(ast);
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 19398c713..50216ee07 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -16871,7 +16871,7 @@ namespace sqlite_orm {
             using statement_type = current_time_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx& context) {
+            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) {
                 return "CURRENT_TIME";
             }
         };
@@ -16881,7 +16881,7 @@ namespace sqlite_orm {
             using statement_type = current_date_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx& context) {
+            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) {
                 return "CURRENT_DATE";
             }
         };
@@ -16891,7 +16891,7 @@ namespace sqlite_orm {
             using statement_type = current_timestamp_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx& context) {
+            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) {
                 return "CURRENT_TIMESTAMP";
             }
         };
diff --git a/tests/statement_serializer_tests/select_constraints.cpp b/tests/statement_serializer_tests/select_constraints.cpp
index d92ca3fb6..5711e7e7a 100644
--- a/tests/statement_serializer_tests/select_constraints.cpp
+++ b/tests/statement_serializer_tests/select_constraints.cpp
@@ -126,6 +126,18 @@ TEST_CASE("statement_serializer select constraints") {
             value = serialize(expression, context);
             expected = R"(WITH RECURSIVE "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1")";
         }
+        SECTION("with ordinary, multiple") {
+            auto expression = with(std::make_tuple(cte<cte_1>().as(select(1)), cte<cte_1>().as(select(1))),
+                                   select(column<cte_1>(1_colalias)));
+            value = serialize(expression, context);
+            expected = R"(WITH "1"("1") AS (SELECT 1), "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1")";
+        }
+        SECTION("with not enforced recursive, multiple") {
+            auto expression = with_recursive(std::make_tuple(cte<cte_1>().as(select(1)), cte<cte_1>().as(select(1))),
+                                             select(column<cte_1>(1_colalias)));
+            value = serialize(expression, context);
+            expected = R"(WITH RECURSIVE "1"("1") AS (SELECT 1), "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1")";
+        }
         SECTION("with optional recursive") {
             auto expression = with(
                 cte<cte_1>().as(
diff --git a/tests/tests3.cpp b/tests/tests3.cpp
index 234a0eff9..248551879 100644
--- a/tests/tests3.cpp
+++ b/tests/tests3.cpp
@@ -385,3 +385,40 @@ TEST_CASE("Escape chars") {
     storage.update(selena);
     storage.remove<Employee>(10);
 }
+
+TEST_CASE("With select") {
+    using Catch::Matchers::Equals;
+
+    using cnt = decltype(1_ctealias);
+    auto storage = make_storage("");
+    SECTION("with ordinary") {
+        auto rows = storage.with(cte<cnt>().as(select(1)), select(column<cnt>(1_colalias)));
+        REQUIRE_THAT(rows, Equals(std::vector<int>{1}));
+    }
+    SECTION("with not enforced recursive") {
+        auto rows = storage.with_recursive(cte<cnt>().as(select(1)), select(column<cnt>(1_colalias)));
+        REQUIRE_THAT(rows, Equals(std::vector<int>{1}));
+    }
+    SECTION("with ordinary 2") {
+        auto rows = storage.with(std::make_tuple(cte<cnt>().as(select(1))), select(column<cnt>(1_colalias)));
+        REQUIRE_THAT(rows, Equals(std::vector<int>{1}));
+    }
+    SECTION("with not enforced recursive 2") {
+        auto rows = storage.with_recursive(std::make_tuple(cte<cnt>().as(select(1))), select(column<cnt>(1_colalias)));
+        REQUIRE_THAT(rows, Equals(std::vector<int>{1}));
+    }
+    SECTION("with optional recursive") {
+        auto rows = storage.with(
+            cte<cnt>().as(
+                union_all(select(1), select(column<cnt>(1_colalias) + 1, where(column<cnt>(1_colalias) < 2)))),
+            select(column<cnt>(1_colalias)));
+        REQUIRE_THAT(rows, Equals(std::vector<int>{1, 2}));
+    }
+    SECTION("with recursive") {
+        auto rows = storage.with_recursive(
+            cte<cnt>().as(
+                union_all(select(1), select(column<cnt>(1_colalias) + 1, where(column<cnt>(1_colalias) < 2)))),
+            select(column<cnt>(1_colalias)));
+        REQUIRE_THAT(rows, Equals(std::vector<int>{1, 2}));
+    }
+}

From 135733b26f414dd0d421f54cc9b35198c2fb53a6 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 14 Oct 2023 22:44:14 +0200
Subject: [PATCH 137/161] Guarded storage tests for CTEs

---
 tests/tests3.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/tests3.cpp b/tests/tests3.cpp
index 248551879..b6c759289 100644
--- a/tests/tests3.cpp
+++ b/tests/tests3.cpp
@@ -386,6 +386,7 @@ TEST_CASE("Escape chars") {
     storage.remove<Employee>(10);
 }
 
+#ifdef SQLITE_ORM_WITH_CTE
 TEST_CASE("With select") {
     using Catch::Matchers::Equals;
 
@@ -422,3 +423,4 @@ TEST_CASE("With select") {
         REQUIRE_THAT(rows, Equals(std::vector<int>{1, 2}));
     }
 }
+#endif

From c928cf439086c447972652be1f55f30ad4683ab9 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 15 Oct 2023 17:53:23 +0200
Subject: [PATCH 138/161] First implementation of CTEs with materialization
 hints

* Also simplified streaming of column constraints
---
 dev/select_constraints.h                      | 108 ++++++-----
 dev/serializing_util.h                        |  30 ++-
 dev/statement_serializer.h                    |  33 +++-
 examples/common_table_expressions.cpp         |  31 ++++
 include/sqlite_orm/sqlite_orm.h               | 171 ++++++++++++------
 .../select_constraints.cpp                    |  15 ++
 6 files changed, 274 insertions(+), 114 deletions(-)

diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 61b9de362..ffea7f121 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -218,16 +218,30 @@ namespace sqlite_orm {
         template<class T>
         using decay_explicit_column_t = typename decay_explicit_column<T>::type;
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        /*
+         *  Materialization hint to instruct SQLite to materialize the select statement of a CTE into an ephemeral table as an "optimization fence".
+         */
+        struct materialized_t {};
+
+        /*
+         *  Materialization hint to instruct SQLite to substitute a CTE's select statement as a subquery subject to optimization.
+         */
+        struct not_materialized_t {};
+#endif
+
         /**
          *  Monikered (aliased) CTE expression.
          */
-        template<class Moniker, class Select, class ExplicitCols>
+        template<class Moniker, class ExplicitCols, class Hints, class Select>
         struct common_table_expression {
             using cte_moniker_type = Moniker;
             using expression_type = Select;
             using explicit_colrefs_tuple = ExplicitCols;
+            using hints_tuple = Hints;
             static constexpr size_t explicit_colref_count = std::tuple_size_v<ExplicitCols>;
 
+            SQLITE_ORM_NOUNIQUEADDRESS hints_tuple hints;
             explicit_colrefs_tuple explicitColumns;
             expression_type subselect;
 
@@ -243,41 +257,28 @@ namespace sqlite_orm {
         struct cte_builder {
             ExplicitCols explicitColumns;
 
-            template<class T, class... Args>
-            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols> as(select_t<T, Args...> sel) && {
+#if SQLITE_VERSION_NUMBER >= 3035000 && defined(SQLITE_ORM_WITH_CPP20_ALIASES)
+            template<auto... hints, class Select, satisfies<is_select, Select> = true>
+            common_table_expression<Moniker, ExplicitCols, std::tuple<decltype(hints)...>, Select> as(Select sel) && {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
-            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
-            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> as(Compound sel) && {
+            template<auto... hints, class Compound, satisfies<is_compound_operator, Compound> = true>
+            common_table_expression<Moniker, ExplicitCols, std::tuple<decltype(hints)...>, select_t<Compound>>
+            as(Compound sel) && {
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
-
-            template<class T, class... Args>
-            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols>
-            materialized(select_t<T, Args...> sel) && {
-                static_assert(polyfill::always_false_v<T>, "`WITH ... AS MATERIALIZED` is unimplemented");
-                return {std::move(this->explicitColumns), std::move(sel)};
-            }
-
-            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
-            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> materialized(Compound sel) && {
-                static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS MATERIALIZED` is unimplemented");
-                return {std::move(this->explicitColumns), {std::move(sel)}};
-            }
-
-            template<class T, class... Args>
-            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols>
-            not_materialized(select_t<T, Args...> sel) && {
-                static_assert(polyfill::always_false_v<T>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
+#else
+            template<class Select, satisfies<is_select, Select> = true>
+            common_table_expression<Moniker, ExplicitCols, std::tuple<>, Select> as(Select sel) && {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
-            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
-            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> not_materialized(Compound sel) && {
-                static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
+            template<class Compound, satisfies<is_compound_operator, Compound> = true>
+            common_table_expression<Moniker, ExplicitCols, std::tuple<>, select_t<Compound>> as(Compound sel) && {
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
+#endif
         };
 
         /**
@@ -476,6 +477,28 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_WITH_CTE
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /*
+     *  Materialization hint to instruct SQLite to materialize the select statement of a CTE into an ephemeral table as an "optimization fence".
+     *  
+     *  Example:
+     *  1_ctealias().as<materialized()>(select(1));
+     */
+    inline consteval internal::materialized_t materialized() {
+        return {};
+    }
+
+    /*
+     *  Materialization hint to instruct SQLite to substitute a CTE's select statement as a subquery subject to optimization.
+     *  
+     *  Example:
+     *  1_ctealias().as<not_materialized()>(select(1));
+     */
+    inline consteval internal::not_materialized_t not_materialized() {
+        return {};
+    }
+#endif
+
     /**
      *  Introduce the construction of a common table expression using the specified moniker.
      *  
@@ -560,10 +583,9 @@ namespace sqlite_orm {
      *  
      *  Despite the missing RECURSIVE keyword, the CTEs can be recursive.
      */
-    template<class E, class... Monikers, class... Selects, class... ExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Monikers, Selects, ExplicitCols>...>
-    with(std::tuple<internal::common_table_expression<Monikers, Selects, ExplicitCols>...> cte, E expression) {
-        return {false, std::move(cte), std::move(expression)};
+    template<class E, class... CTEs>
+    internal::with_t<E, CTEs...> with(internal::common_table_expressions<CTEs...> ctes, E expression) {
+        return {false, std::move(ctes), std::move(expression)};
     }
 
     /** 
@@ -575,10 +597,11 @@ namespace sqlite_orm {
      *  constexpr auto cte_1 = 1_ctealias;
      *  with(cte_1().as(select(&Object::id)), select(cte_1->*1_colalias));
      */
-    template<class E, class Moniker, class Select, class ExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Moniker, Select, ExplicitCols>>
-    with(internal::common_table_expression<Moniker, Select, ExplicitCols> cte, E expression) {
-        return {false, std::make_tuple(std::move(cte)), std::move(expression)};
+    template<class E,
+             class CTE,
+             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true>
+    internal::with_t<E, CTE> with(CTE cte, E expression) {
+        return {false, {std::move(cte)}, std::move(expression)};
     }
 
     /** 
@@ -586,11 +609,9 @@ namespace sqlite_orm {
      *  
      *  @note The use of RECURSIVE does not force common table expressions to be recursive.
      */
-    template<class E, class... Monikers, class... Selects, class... ExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Monikers, Selects, ExplicitCols>...>
-    with_recursive(std::tuple<internal::common_table_expression<Monikers, Selects, ExplicitCols>...> cte,
-                   E expression) {
-        return {true, std::move(cte), std::move(expression)};
+    template<class E, class... CTEs>
+    internal::with_t<E, CTEs...> with_recursive(internal::common_table_expressions<CTEs...> ctes, E expression) {
+        return {true, std::move(ctes), std::move(expression)};
     }
 
     /** 
@@ -602,10 +623,11 @@ namespace sqlite_orm {
      *  constexpr auto cte_1 = 1_ctealias;
      *  with_recursive(cte_1().as(select(&Object::id)), select(cte_1->*1_colalias));
      */
-    template<class E, class Moniker, class Select, class ExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Moniker, Select, ExplicitCols>>
-    with_recursive(internal::common_table_expression<Moniker, Select, ExplicitCols> cte, E expression) {
-        return {true, std::make_tuple(std::move(cte)), std::move(expression)};
+    template<class E,
+             class CTE,
+             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true>
+    internal::with_t<E, CTE> with_recursive(CTE cte, E expression) {
+        return {true, {std::move(cte)}, std::move(expression)};
     }
 #endif
 
diff --git a/dev/serializing_util.h b/dev/serializing_util.h
index 1ffb836ed..1f2e28418 100644
--- a/dev/serializing_util.h
+++ b/dev/serializing_util.h
@@ -101,6 +101,7 @@ namespace sqlite_orm {
             field_values_excluding,
             mapped_columns_expressions,
             column_constraints,
+            constraints_tuple,
         };
 
         template<stream_as mode>
@@ -127,6 +128,7 @@ namespace sqlite_orm {
         constexpr streaming<stream_as::non_generated_columns> streaming_non_generated_column_names{};
         constexpr streaming<stream_as::field_values_excluding> streaming_field_values_excluding{};
         constexpr streaming<stream_as::mapped_columns_expressions> streaming_mapped_columns_expressions{};
+        constexpr streaming<stream_as::constraints_tuple> streaming_constraints_tuple{};
         constexpr streaming<stream_as::column_constraints> streaming_column_constraints{};
 
         // serialize and stream a tuple of condition expressions;
@@ -356,6 +358,22 @@ namespace sqlite_orm {
             return ss;
         }
 
+        // serialize and stream a tuple of conditions or hints;
+        // space + space-separated
+        template<class T, class Ctx>
+        std::ostream& operator<<(std::ostream& ss,
+                                 std::tuple<const streaming<stream_as::constraints_tuple>&, T, Ctx> tpl) {
+            const auto& constraints = get<1>(tpl);
+            auto& context = get<2>(tpl);
+
+            iterate_tuple(constraints, [&ss, &context](auto& constraint) mutable {
+                ss << ' ' << serialize(constraint, context);
+            });
+            return ss;
+        }
+
+        // serialize and stream a tuple of column constraints;
+        // space + space-separated
         template<class... Op, class Ctx>
         std::ostream& operator<<(std::ostream& ss,
                                  std::tuple<const streaming<stream_as::column_constraints>&,
@@ -366,22 +384,18 @@ namespace sqlite_orm {
             const bool& isNotNull = get<2>(tpl);
             auto& context = get<3>(tpl);
 
-            auto first = true;
-            constexpr std::array<const char*, 2> sep = {" ", ""};
-            iterate_tuple(column.constraints, [&ss, &context, &first, &sep](auto& constraint) {
-                ss << sep[std::exchange(first, false)];
-                ss << serialize(constraint, context);
+            iterate_tuple(column.constraints, [&ss, &context](auto& constraint) {
+                ss << ' ' << serialize(constraint, context);
             });
             using constraints_tuple = decltype(column.constraints);
             constexpr bool hasExplicitNullableConstraint =
                 mpl::invoke_t<mpl::disjunction<check_if_tuple_has_type<null_t>, check_if_tuple_has_type<not_null_t>>,
                               constraints_tuple>::value;
             if(!hasExplicitNullableConstraint) {
-                ss << sep[std::exchange(first, false)];
                 if(isNotNull) {
-                    ss << "NOT NULL";
+                    ss << " NOT NULL";
                 } else {
-                    ss << "NULL";
+                    ss << " NULL";
                 }
             }
 
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index 0b56d356c..07bfd85ca 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -609,6 +609,27 @@ namespace sqlite_orm {
         };
 
 #ifdef SQLITE_ORM_WITH_CTE
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        template<>
+        struct statement_serializer<materialized_t, void> {
+            using statement_type = materialized_t;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) {
+                return "MATERIALIZED";
+            }
+        };
+        template<>
+        struct statement_serializer<not_materialized_t, void> {
+            using statement_type = not_materialized_t;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) {
+                return "NOT MATERIALIZED";
+            }
+        };
+#endif
+
         template<class CTE>
         struct statement_serializer<CTE, match_specialization_of<CTE, common_table_expression>> {
             using statement_type = CTE;
@@ -628,7 +649,8 @@ namespace sqlite_orm {
                                                  context);
                     ss << '(' << streaming_identifiers(columnNames) << ')';
                 }
-                ss << " AS " << '(' << serialize(cte.subselect, cteContext) << ')';
+                ss << " AS" << streaming_constraints_tuple(cte.hints, context) << " ("
+                   << serialize(cte.subselect, cteContext) << ')';
                 return ss.str();
             }
         };
@@ -1128,11 +1150,10 @@ namespace sqlite_orm {
                 ss << streaming_identifier(column.name);
                 if(!context.skip_types_and_constraints) {
                     ss << " " << type_printer<field_type_t<column_type>>().print();
-                    ss << " "
-                       << streaming_column_constraints(
-                              call_as_template_base<column_constraints>(polyfill::identity{})(column),
-                              column.is_not_null(),
-                              context);
+                    ss << streaming_column_constraints(
+                        call_as_template_base<column_constraints>(polyfill::identity{})(column),
+                        column.is_not_null(),
+                        context);
                 }
                 return ss.str();
             }
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index f91bb7e38..61b5ea1c5 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -738,6 +738,36 @@ void sudoku() {
 #endif
 }
 
+void show_optimization_fence() {
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    auto storage = make_storage("");
+
+    {
+        //WITH
+        //    cnt(x) AS MATERIALIZED(VALUES(1))
+        //    SELECT x FROM cnt;
+        constexpr auto cnt = "cnt"_cte;
+        auto ast = with(cnt().as<materialized()>(select(1)), select(cnt->*1_colalias));
+
+        [[maybe_unused]] string sql = storage.dump(ast);
+
+        [[maybe_unused]] auto stmt = storage.prepare(ast);
+    }
+
+    {
+        //WITH
+        //    cnt(x) AS NOT MATERIALIZED(VALUES(1))
+        //    SELECT x FROM cnt;
+        constexpr auto cnt = "cnt"_cte;
+        auto ast = with(cnt().as<not_materialized()>(select(1)), select(cnt->*1_colalias));
+
+        [[maybe_unused]] string sql = storage.dump(ast);
+
+        [[maybe_unused]] auto stmt = storage.prepare(ast);
+    }
+#endif
+}
+
 void show_mapping_and_backreferencing() {
     struct Object {
         int64 id;
@@ -1021,6 +1051,7 @@ int main() {
         neevek_issue_222();
         select_from_subselect();
         greatest_n_per_group();
+        show_optimization_fence();
         show_mapping_and_backreferencing();
     } catch(const system_error& e) {
         cout << "[" << e.code() << "] " << e.what();
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 50216ee07..d85270711 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -7608,16 +7608,30 @@ namespace sqlite_orm {
         template<class T>
         using decay_explicit_column_t = typename decay_explicit_column<T>::type;
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        /*
+         *  Materialization hint to instruct SQLite to materialize the select statement of a CTE into an ephemeral table as an "optimization fence".
+         */
+        struct materialized_t {};
+
+        /*
+         *  Materialization hint to instruct SQLite to substitute a CTE's select statement as a subquery subject to optimization.
+         */
+        struct not_materialized_t {};
+#endif
+
         /**
          *  Monikered (aliased) CTE expression.
          */
-        template<class Moniker, class Select, class ExplicitCols>
+        template<class Moniker, class ExplicitCols, class Hints, class Select>
         struct common_table_expression {
             using cte_moniker_type = Moniker;
             using expression_type = Select;
             using explicit_colrefs_tuple = ExplicitCols;
+            using hints_tuple = Hints;
             static constexpr size_t explicit_colref_count = std::tuple_size_v<ExplicitCols>;
 
+            SQLITE_ORM_NOUNIQUEADDRESS hints_tuple hints;
             explicit_colrefs_tuple explicitColumns;
             expression_type subselect;
 
@@ -7633,41 +7647,28 @@ namespace sqlite_orm {
         struct cte_builder {
             ExplicitCols explicitColumns;
 
-            template<class T, class... Args>
-            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols> as(select_t<T, Args...> sel) && {
-                return {std::move(this->explicitColumns), std::move(sel)};
-            }
-
-            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
-            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> as(Compound sel) && {
-                return {std::move(this->explicitColumns), {std::move(sel)}};
-            }
-
-            template<class T, class... Args>
-            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols>
-            materialized(select_t<T, Args...> sel) && {
-                static_assert(polyfill::always_false_v<T>, "`WITH ... AS MATERIALIZED` is unimplemented");
+#if SQLITE_VERSION_NUMBER >= 3035000 && defined(SQLITE_ORM_WITH_CPP20_ALIASES)
+            template<auto... hints, class Select, satisfies<is_select, Select> = true>
+            common_table_expression<Moniker, ExplicitCols, std::tuple<decltype(hints)...>, Select> as(Select sel) && {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
-            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
-            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> materialized(Compound sel) && {
-                static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS MATERIALIZED` is unimplemented");
+            template<auto... hints, class Compound, satisfies<is_compound_operator, Compound> = true>
+            common_table_expression<Moniker, ExplicitCols, std::tuple<decltype(hints)...>, select_t<Compound>>
+            as(Compound sel) && {
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
-
-            template<class T, class... Args>
-            common_table_expression<Moniker, select_t<T, Args...>, ExplicitCols>
-            not_materialized(select_t<T, Args...> sel) && {
-                static_assert(polyfill::always_false_v<T>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
+#else
+            template<class Select, satisfies<is_select, Select> = true>
+            common_table_expression<Moniker, ExplicitCols, std::tuple<>, Select> as(Select sel) && {
                 return {std::move(this->explicitColumns), std::move(sel)};
             }
 
-            template<class Compound, std::enable_if_t<is_compound_operator_v<Compound>, bool> = true>
-            common_table_expression<Moniker, select_t<Compound>, ExplicitCols> not_materialized(Compound sel) && {
-                static_assert(polyfill::always_false_v<Compound>, "`WITH ... AS NOT MATERIALIZED` is unimplemented");
+            template<class Compound, satisfies<is_compound_operator, Compound> = true>
+            common_table_expression<Moniker, ExplicitCols, std::tuple<>, select_t<Compound>> as(Compound sel) && {
                 return {std::move(this->explicitColumns), {std::move(sel)}};
             }
+#endif
         };
 
         /**
@@ -7866,6 +7867,28 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_WITH_CTE
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /*
+     *  Materialization hint to instruct SQLite to materialize the select statement of a CTE into an ephemeral table as an "optimization fence".
+     *  
+     *  Example:
+     *  1_ctealias().as<materialized()>(select(1));
+     */
+    inline consteval internal::materialized_t materialized() {
+        return {};
+    }
+
+    /*
+     *  Materialization hint to instruct SQLite to substitute a CTE's select statement as a subquery subject to optimization.
+     *  
+     *  Example:
+     *  1_ctealias().as<not_materialized()>(select(1));
+     */
+    inline consteval internal::not_materialized_t not_materialized() {
+        return {};
+    }
+#endif
+
     /**
      *  Introduce the construction of a common table expression using the specified moniker.
      *  
@@ -7950,10 +7973,9 @@ namespace sqlite_orm {
      *  
      *  Despite the missing RECURSIVE keyword, the CTEs can be recursive.
      */
-    template<class E, class... Monikers, class... Selects, class... ExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Monikers, Selects, ExplicitCols>...>
-    with(std::tuple<internal::common_table_expression<Monikers, Selects, ExplicitCols>...> cte, E expression) {
-        return {false, std::move(cte), std::move(expression)};
+    template<class E, class... CTEs>
+    internal::with_t<E, CTEs...> with(internal::common_table_expressions<CTEs...> ctes, E expression) {
+        return {false, std::move(ctes), std::move(expression)};
     }
 
     /** 
@@ -7965,10 +7987,11 @@ namespace sqlite_orm {
      *  constexpr auto cte_1 = 1_ctealias;
      *  with(cte_1().as(select(&Object::id)), select(cte_1->*1_colalias));
      */
-    template<class E, class Moniker, class Select, class ExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Moniker, Select, ExplicitCols>>
-    with(internal::common_table_expression<Moniker, Select, ExplicitCols> cte, E expression) {
-        return {false, std::make_tuple(std::move(cte)), std::move(expression)};
+    template<class E,
+             class CTE,
+             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true>
+    internal::with_t<E, CTE> with(CTE cte, E expression) {
+        return {false, {std::move(cte)}, std::move(expression)};
     }
 
     /** 
@@ -7976,11 +7999,9 @@ namespace sqlite_orm {
      *  
      *  @note The use of RECURSIVE does not force common table expressions to be recursive.
      */
-    template<class E, class... Monikers, class... Selects, class... ExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Monikers, Selects, ExplicitCols>...>
-    with_recursive(std::tuple<internal::common_table_expression<Monikers, Selects, ExplicitCols>...> cte,
-                   E expression) {
-        return {true, std::move(cte), std::move(expression)};
+    template<class E, class... CTEs>
+    internal::with_t<E, CTEs...> with_recursive(internal::common_table_expressions<CTEs...> ctes, E expression) {
+        return {true, std::move(ctes), std::move(expression)};
     }
 
     /** 
@@ -7992,10 +8013,11 @@ namespace sqlite_orm {
      *  constexpr auto cte_1 = 1_ctealias;
      *  with_recursive(cte_1().as(select(&Object::id)), select(cte_1->*1_colalias));
      */
-    template<class E, class Moniker, class Select, class ExplicitCols>
-    internal::with_t<E, internal::common_table_expression<Moniker, Select, ExplicitCols>>
-    with_recursive(internal::common_table_expression<Moniker, Select, ExplicitCols> cte, E expression) {
-        return {true, std::make_tuple(std::move(cte)), std::move(expression)};
+    template<class E,
+             class CTE,
+             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true>
+    internal::with_t<E, CTE> with_recursive(CTE cte, E expression) {
+        return {true, {std::move(cte)}, std::move(expression)};
     }
 #endif
 
@@ -14312,6 +14334,7 @@ namespace sqlite_orm {
             field_values_excluding,
             mapped_columns_expressions,
             column_constraints,
+            constraints_tuple,
         };
 
         template<stream_as mode>
@@ -14338,6 +14361,7 @@ namespace sqlite_orm {
         constexpr streaming<stream_as::non_generated_columns> streaming_non_generated_column_names{};
         constexpr streaming<stream_as::field_values_excluding> streaming_field_values_excluding{};
         constexpr streaming<stream_as::mapped_columns_expressions> streaming_mapped_columns_expressions{};
+        constexpr streaming<stream_as::constraints_tuple> streaming_constraints_tuple{};
         constexpr streaming<stream_as::column_constraints> streaming_column_constraints{};
 
         // serialize and stream a tuple of condition expressions;
@@ -14567,6 +14591,22 @@ namespace sqlite_orm {
             return ss;
         }
 
+        // serialize and stream a tuple of conditions or hints;
+        // space + space-separated
+        template<class T, class Ctx>
+        std::ostream& operator<<(std::ostream& ss,
+                                 std::tuple<const streaming<stream_as::constraints_tuple>&, T, Ctx> tpl) {
+            const auto& constraints = get<1>(tpl);
+            auto& context = get<2>(tpl);
+
+            iterate_tuple(constraints, [&ss, &context](auto& constraint) mutable {
+                ss << ' ' << serialize(constraint, context);
+            });
+            return ss;
+        }
+
+        // serialize and stream a tuple of column constraints;
+        // space + space-separated
         template<class... Op, class Ctx>
         std::ostream& operator<<(std::ostream& ss,
                                  std::tuple<const streaming<stream_as::column_constraints>&,
@@ -14577,22 +14617,18 @@ namespace sqlite_orm {
             const bool& isNotNull = get<2>(tpl);
             auto& context = get<3>(tpl);
 
-            auto first = true;
-            constexpr std::array<const char*, 2> sep = {" ", ""};
-            iterate_tuple(column.constraints, [&ss, &context, &first, &sep](auto& constraint) {
-                ss << sep[std::exchange(first, false)];
-                ss << serialize(constraint, context);
+            iterate_tuple(column.constraints, [&ss, &context](auto& constraint) {
+                ss << ' ' << serialize(constraint, context);
             });
             using constraints_tuple = decltype(column.constraints);
             constexpr bool hasExplicitNullableConstraint =
                 mpl::invoke_t<mpl::disjunction<check_if_tuple_has_type<null_t>, check_if_tuple_has_type<not_null_t>>,
                               constraints_tuple>::value;
             if(!hasExplicitNullableConstraint) {
-                ss << sep[std::exchange(first, false)];
                 if(isNotNull) {
-                    ss << "NOT NULL";
+                    ss << " NOT NULL";
                 } else {
-                    ss << "NULL";
+                    ss << " NULL";
                 }
             }
 
@@ -17316,6 +17352,27 @@ namespace sqlite_orm {
         };
 
 #ifdef SQLITE_ORM_WITH_CTE
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        template<>
+        struct statement_serializer<materialized_t, void> {
+            using statement_type = materialized_t;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) {
+                return "MATERIALIZED";
+            }
+        };
+        template<>
+        struct statement_serializer<not_materialized_t, void> {
+            using statement_type = not_materialized_t;
+
+            template<class Ctx>
+            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) {
+                return "NOT MATERIALIZED";
+            }
+        };
+#endif
+
         template<class CTE>
         struct statement_serializer<CTE, match_specialization_of<CTE, common_table_expression>> {
             using statement_type = CTE;
@@ -17335,7 +17392,8 @@ namespace sqlite_orm {
                                                  context);
                     ss << '(' << streaming_identifiers(columnNames) << ')';
                 }
-                ss << " AS " << '(' << serialize(cte.subselect, cteContext) << ')';
+                ss << " AS" << streaming_constraints_tuple(cte.hints, context) << " ("
+                   << serialize(cte.subselect, cteContext) << ')';
                 return ss.str();
             }
         };
@@ -17835,11 +17893,10 @@ namespace sqlite_orm {
                 ss << streaming_identifier(column.name);
                 if(!context.skip_types_and_constraints) {
                     ss << " " << type_printer<field_type_t<column_type>>().print();
-                    ss << " "
-                       << streaming_column_constraints(
-                              call_as_template_base<column_constraints>(polyfill::identity{})(column),
-                              column.is_not_null(),
-                              context);
+                    ss << streaming_column_constraints(
+                        call_as_template_base<column_constraints>(polyfill::identity{})(column),
+                        column.is_not_null(),
+                        context);
                 }
                 return ss.str();
             }
diff --git a/tests/statement_serializer_tests/select_constraints.cpp b/tests/statement_serializer_tests/select_constraints.cpp
index 5711e7e7a..8d2a77be6 100644
--- a/tests/statement_serializer_tests/select_constraints.cpp
+++ b/tests/statement_serializer_tests/select_constraints.cpp
@@ -115,6 +115,21 @@ TEST_CASE("statement_serializer select constraints") {
             value = serialize(expression, context);
             expected = R"(FROM "1" "z")";
         }
+        SECTION("as") {
+            auto expression = cte<cte_1>().as(select(1));
+            value = serialize(expression, context);
+            expected = R"("1"("1") AS (SELECT 1))";
+        }
+        SECTION("as materialized") {
+            auto expression = cte<cte_1>().as<materialized()>(select(1));
+            value = serialize(expression, context);
+            expected = R"("1"("1") AS MATERIALIZED (SELECT 1))";
+        }
+        SECTION("as not materialized") {
+            auto expression = cte<cte_1>().as<not_materialized()>(select(1));
+            value = serialize(expression, context);
+            expected = R"("1"("1") AS NOT MATERIALIZED (SELECT 1))";
+        }
 #endif
         SECTION("with ordinary") {
             auto expression = with(cte<cte_1>().as(select(1)), select(column<cte_1>(1_colalias)));

From 4fedb37512c8e1832fc0290876fdaf6e8c6ebda8 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 19 Oct 2023 20:24:39 +0200
Subject: [PATCH 139/161] Improved CTE example fetching a hierarchy

---
 examples/common_table_expressions.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 61b5ea1c5..1f2c67b65 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -164,10 +164,10 @@ void supervisor_chain() {
         //    SELECT name FROM chain;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         constexpr auto chain = "chain"_cte;
+        constexpr auto parent = "parent"_alias.for_<Org>();
         auto ast = with_recursive(
-            chain().as(union_all(
-                select(asterisk<Org>(), where(&Org::name == c("Fred"))),
-                select(asterisk<alias_a<Org>>(), where(alias_column<alias_a<Org>>(&Org::name) == chain->*&Org::boss)))),
+            chain().as(union_all(select(asterisk<Org>(), where(&Org::name == c("Fred"))),
+                                 select(asterisk<parent>(), where(parent->*&Org::name == chain->*&Org::boss)))),
             select(chain->*&Org::name));
 #else
         using chain = decltype(1_ctealias);

From f1b2e362860e1bc99e8b8b04d08d02c9fc37fd86 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 19 Oct 2023 22:16:47 +0200
Subject: [PATCH 140/161] Allow "compound" statements in with-clause

---
 dev/select_constraints.h                      |  66 ++++++++-
 dev/storage.h                                 |  62 ++-------
 include/sqlite_orm/sqlite_orm.h               | 128 ++++++++++--------
 tests/ast_iterator_tests.cpp                  |   6 +
 .../select_constraints.cpp                    |  46 +++++++
 tests/tests3.cpp                              |  24 +++-
 6 files changed, 222 insertions(+), 110 deletions(-)

diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index ffea7f121..f3b84f89f 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -583,11 +583,22 @@ namespace sqlite_orm {
      *  
      *  Despite the missing RECURSIVE keyword, the CTEs can be recursive.
      */
-    template<class E, class... CTEs>
+    template<class E, class... CTEs, internal::satisfies_not<internal::is_compound_operator, E> = true>
     internal::with_t<E, CTEs...> with(internal::common_table_expressions<CTEs...> ctes, E expression) {
         return {false, std::move(ctes), std::move(expression)};
     }
 
+    /** 
+     *  With-clause for a tuple of ordinary CTEs.
+     *  
+     *  Despite the missing RECURSIVE keyword, the CTEs can be recursive.
+     */
+    template<class Compound, class... CTEs, internal::satisfies<internal::is_compound_operator, Compound> = true>
+    internal::with_t<internal::select_t<Compound>, CTEs...> with(internal::common_table_expressions<CTEs...> ctes,
+                                                                 Compound sel) {
+        return {false, std::move(ctes), sqlite_orm::select(std::move(sel))};
+    }
+
     /** 
      *  With-clause for a single ordinary CTE.
      *  
@@ -599,21 +610,50 @@ namespace sqlite_orm {
      */
     template<class E,
              class CTE,
-             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true>
+             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true,
+             internal::satisfies_not<internal::is_compound_operator, E> = true>
     internal::with_t<E, CTE> with(CTE cte, E expression) {
         return {false, {std::move(cte)}, std::move(expression)};
     }
 
+    /** 
+     *  With-clause for a single ordinary CTE.
+     *  
+     *  Despite the missing `RECURSIVE` keyword, the CTE can be recursive.
+     *  
+     *  Example:
+     *  constexpr auto cte_1 = 1_ctealias;
+     *  with(cte_1().as(select(&Object::id)), select(cte_1->*1_colalias));
+     */
+    template<class Compound,
+             class CTE,
+             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true,
+             internal::satisfies<internal::is_compound_operator, Compound> = true>
+    internal::with_t<internal::select_t<Compound>, CTE> with(CTE cte, Compound sel) {
+        return {false, {std::move(cte)}, sqlite_orm::select(std::move(sel))};
+    }
+
     /** 
      *  With-clause for a tuple of potentially recursive CTEs.
      *  
      *  @note The use of RECURSIVE does not force common table expressions to be recursive.
      */
-    template<class E, class... CTEs>
+    template<class E, class... CTEs, internal::satisfies_not<internal::is_compound_operator, E> = true>
     internal::with_t<E, CTEs...> with_recursive(internal::common_table_expressions<CTEs...> ctes, E expression) {
         return {true, std::move(ctes), std::move(expression)};
     }
 
+    /** 
+     *  With-clause for a tuple of potentially recursive CTEs.
+     *  
+     *  @note The use of RECURSIVE does not force common table expressions to be recursive.
+     */
+    template<class Compound, class... CTEs, internal::satisfies<internal::is_compound_operator, Compound> = true>
+    internal::with_t<internal::select_t<Compound>, CTEs...>
+    with_recursive(internal::common_table_expressions<CTEs...> ctes, Compound sel) {
+        return {true, std::move(ctes), sqlite_orm::select(std::move(sel))};
+    }
+
     /** 
      *  With-clause for a single potentially recursive CTE.
      *  
@@ -625,10 +665,28 @@ namespace sqlite_orm {
      */
     template<class E,
              class CTE,
-             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true>
+             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true,
+             internal::satisfies_not<internal::is_compound_operator, E> = true>
     internal::with_t<E, CTE> with_recursive(CTE cte, E expression) {
         return {true, {std::move(cte)}, std::move(expression)};
     }
+
+    /** 
+     *  With-clause for a single potentially recursive CTE.
+     *  
+     *  @note The use of RECURSIVE does not force common table expressions to be recursive.
+     *  
+     *  Example:
+     *  constexpr auto cte_1 = 1_ctealias;
+     *  with_recursive(cte_1().as(select(&Object::id)), select(cte_1->*1_colalias));
+     */
+    template<class Compound,
+             class CTE,
+             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true,
+             internal::satisfies<internal::is_compound_operator, Compound> = true>
+    internal::with_t<internal::select_t<Compound>, CTE> with_recursive(CTE cte, Compound sel) {
+        return {true, {std::move(cte)}, sqlite_orm::select(std::move(sel))};
+    }
 #endif
 
     /**
diff --git a/dev/storage.h b/dev/storage.h
index de7c0aac8..f261524b3 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -581,74 +581,36 @@ namespace sqlite_orm {
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class CTE, class T, class... Args>
-            auto with(CTE cte, select_t<T, Args...> sel) {
-                auto statement = this->prepare(sqlite_orm::with(std::move(cte), std::move(sel)));
+            template<class CTE, class E>
+            auto with(CTE cte, E expression) {
+                auto statement = this->prepare(sqlite_orm::with(std::move(cte), std::move(expression)));
                 return this->execute(statement);
             }
 
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class... CTEs, class T, class... Args>
-            auto with(common_table_expressions<CTEs...> cte, select_t<T, Args...> sel) {
-                auto statement = this->prepare(sqlite_orm::with(std::move(cte), std::move(sel)));
-                return this->execute(statement);
-            }
-
-            /**
-             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
-             */
-            template<class CTE, class Compound, satisfies<is_compound_operator, Compound> = true>
-            auto with(CTE cte, Compound sel) {
-                auto statement = this->prepare(sqlite_orm::with(std::move(cte), sqlite_orm::select(std::move(sel))));
-                return this->execute(statement);
-            }
-
-            /**
-             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
-             */
-            template<class... CTEs, class Compound, satisfies<is_compound_operator, Compound> = true>
-            auto with(common_table_expressions<CTEs...> cte, Compound sel) {
-                auto statement = this->prepare(sqlite_orm::with(std::move(cte), sqlite_orm::select(std::move(sel))));
-                return this->execute(statement);
-            }
-
-            /**
-             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
-             */
-            template<class CTE, class T, class... Args>
-            auto with_recursive(CTE cte, select_t<T, Args...> sel) {
-                auto statement = this->prepare(sqlite_orm::with_recursive(std::move(cte), std::move(sel)));
-                return this->execute(statement);
-            }
-
-            /**
-             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
-             */
-            template<class... CTEs, class T, class... Args>
-            auto with_recursive(common_table_expressions<CTEs...> cte, select_t<T, Args...> sel) {
-                auto statement = this->prepare(sqlite_orm::with_recursive(std::move(cte), std::move(sel)));
+            template<class... CTEs, class E>
+            auto with(common_table_expressions<CTEs...> cte, E expression) {
+                auto statement = this->prepare(sqlite_orm::with(std::move(cte), std::move(expression)));
                 return this->execute(statement);
             }
 
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class CTE, class Compound, satisfies<is_compound_operator, Compound> = true>
-            auto with_recursive(CTE cte, Compound sel) {
-                auto statement =
-                    this->prepare(sqlite_orm::with_recursive(std::move(cte), sqlite_orm::select(std::move(sel))));
+            template<class CTE, class E>
+            auto with_recursive(CTE cte, E expression) {
+                auto statement = this->prepare(sqlite_orm::with_recursive(std::move(cte), std::move(expression)));
                 return this->execute(statement);
             }
 
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class... CTEs, class Compound, satisfies<is_compound_operator, Compound> = true>
-            auto with_recursive(common_table_expressions<CTEs...> cte, Compound sel) {
-                auto statement =
-                    this->prepare(sqlite_orm::with_recursive(std::move(cte), sqlite_orm::select(std::move(sel))));
+            template<class... CTEs, class E>
+            auto with_recursive(common_table_expressions<CTEs...> cte, E expression) {
+                auto statement = this->prepare(sqlite_orm::with_recursive(std::move(cte), std::move(expression)));
                 return this->execute(statement);
             }
 #endif
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index d85270711..5c5724169 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -7973,11 +7973,22 @@ namespace sqlite_orm {
      *  
      *  Despite the missing RECURSIVE keyword, the CTEs can be recursive.
      */
-    template<class E, class... CTEs>
+    template<class E, class... CTEs, internal::satisfies_not<internal::is_compound_operator, E> = true>
     internal::with_t<E, CTEs...> with(internal::common_table_expressions<CTEs...> ctes, E expression) {
         return {false, std::move(ctes), std::move(expression)};
     }
 
+    /** 
+     *  With-clause for a tuple of ordinary CTEs.
+     *  
+     *  Despite the missing RECURSIVE keyword, the CTEs can be recursive.
+     */
+    template<class Compound, class... CTEs, internal::satisfies<internal::is_compound_operator, Compound> = true>
+    internal::with_t<internal::select_t<Compound>, CTEs...> with(internal::common_table_expressions<CTEs...> ctes,
+                                                                 Compound sel) {
+        return {false, std::move(ctes), sqlite_orm::select(std::move(sel))};
+    }
+
     /** 
      *  With-clause for a single ordinary CTE.
      *  
@@ -7989,21 +8000,50 @@ namespace sqlite_orm {
      */
     template<class E,
              class CTE,
-             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true>
+             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true,
+             internal::satisfies_not<internal::is_compound_operator, E> = true>
     internal::with_t<E, CTE> with(CTE cte, E expression) {
         return {false, {std::move(cte)}, std::move(expression)};
     }
 
+    /** 
+     *  With-clause for a single ordinary CTE.
+     *  
+     *  Despite the missing `RECURSIVE` keyword, the CTE can be recursive.
+     *  
+     *  Example:
+     *  constexpr auto cte_1 = 1_ctealias;
+     *  with(cte_1().as(select(&Object::id)), select(cte_1->*1_colalias));
+     */
+    template<class Compound,
+             class CTE,
+             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true,
+             internal::satisfies<internal::is_compound_operator, Compound> = true>
+    internal::with_t<internal::select_t<Compound>, CTE> with(CTE cte, Compound sel) {
+        return {false, {std::move(cte)}, sqlite_orm::select(std::move(sel))};
+    }
+
     /** 
      *  With-clause for a tuple of potentially recursive CTEs.
      *  
      *  @note The use of RECURSIVE does not force common table expressions to be recursive.
      */
-    template<class E, class... CTEs>
+    template<class E, class... CTEs, internal::satisfies_not<internal::is_compound_operator, E> = true>
     internal::with_t<E, CTEs...> with_recursive(internal::common_table_expressions<CTEs...> ctes, E expression) {
         return {true, std::move(ctes), std::move(expression)};
     }
 
+    /** 
+     *  With-clause for a tuple of potentially recursive CTEs.
+     *  
+     *  @note The use of RECURSIVE does not force common table expressions to be recursive.
+     */
+    template<class Compound, class... CTEs, internal::satisfies<internal::is_compound_operator, Compound> = true>
+    internal::with_t<internal::select_t<Compound>, CTEs...>
+    with_recursive(internal::common_table_expressions<CTEs...> ctes, Compound sel) {
+        return {true, std::move(ctes), sqlite_orm::select(std::move(sel))};
+    }
+
     /** 
      *  With-clause for a single potentially recursive CTE.
      *  
@@ -8015,10 +8055,28 @@ namespace sqlite_orm {
      */
     template<class E,
              class CTE,
-             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true>
+             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true,
+             internal::satisfies_not<internal::is_compound_operator, E> = true>
     internal::with_t<E, CTE> with_recursive(CTE cte, E expression) {
         return {true, {std::move(cte)}, std::move(expression)};
     }
+
+    /** 
+     *  With-clause for a single potentially recursive CTE.
+     *  
+     *  @note The use of RECURSIVE does not force common table expressions to be recursive.
+     *  
+     *  Example:
+     *  constexpr auto cte_1 = 1_ctealias;
+     *  with_recursive(cte_1().as(select(&Object::id)), select(cte_1->*1_colalias));
+     */
+    template<class Compound,
+             class CTE,
+             internal::satisfies_is_specialization_of<CTE, internal::common_table_expression> = true,
+             internal::satisfies<internal::is_compound_operator, Compound> = true>
+    internal::with_t<internal::select_t<Compound>, CTE> with_recursive(CTE cte, Compound sel) {
+        return {true, {std::move(cte)}, sqlite_orm::select(std::move(sel))};
+    }
 #endif
 
     /**
@@ -19972,74 +20030,36 @@ namespace sqlite_orm {
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class CTE, class T, class... Args>
-            auto with(CTE cte, select_t<T, Args...> sel) {
-                auto statement = this->prepare(sqlite_orm::with(std::move(cte), std::move(sel)));
+            template<class CTE, class E>
+            auto with(CTE cte, E expression) {
+                auto statement = this->prepare(sqlite_orm::with(std::move(cte), std::move(expression)));
                 return this->execute(statement);
             }
 
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class... CTEs, class T, class... Args>
-            auto with(common_table_expressions<CTEs...> cte, select_t<T, Args...> sel) {
-                auto statement = this->prepare(sqlite_orm::with(std::move(cte), std::move(sel)));
+            template<class... CTEs, class E>
+            auto with(common_table_expressions<CTEs...> cte, E expression) {
+                auto statement = this->prepare(sqlite_orm::with(std::move(cte), std::move(expression)));
                 return this->execute(statement);
             }
 
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class CTE, class Compound, satisfies<is_compound_operator, Compound> = true>
-            auto with(CTE cte, Compound sel) {
-                auto statement = this->prepare(sqlite_orm::with(std::move(cte), sqlite_orm::select(std::move(sel))));
+            template<class CTE, class E>
+            auto with_recursive(CTE cte, E expression) {
+                auto statement = this->prepare(sqlite_orm::with_recursive(std::move(cte), std::move(expression)));
                 return this->execute(statement);
             }
 
             /**
              *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
              */
-            template<class... CTEs, class Compound, satisfies<is_compound_operator, Compound> = true>
-            auto with(common_table_expressions<CTEs...> cte, Compound sel) {
-                auto statement = this->prepare(sqlite_orm::with(std::move(cte), sqlite_orm::select(std::move(sel))));
-                return this->execute(statement);
-            }
-
-            /**
-             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
-             */
-            template<class CTE, class T, class... Args>
-            auto with_recursive(CTE cte, select_t<T, Args...> sel) {
-                auto statement = this->prepare(sqlite_orm::with_recursive(std::move(cte), std::move(sel)));
-                return this->execute(statement);
-            }
-
-            /**
-             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
-             */
-            template<class... CTEs, class T, class... Args>
-            auto with_recursive(common_table_expressions<CTEs...> cte, select_t<T, Args...> sel) {
-                auto statement = this->prepare(sqlite_orm::with_recursive(std::move(cte), std::move(sel)));
-                return this->execute(statement);
-            }
-
-            /**
-             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
-             */
-            template<class CTE, class Compound, satisfies<is_compound_operator, Compound> = true>
-            auto with_recursive(CTE cte, Compound sel) {
-                auto statement =
-                    this->prepare(sqlite_orm::with_recursive(std::move(cte), sqlite_orm::select(std::move(sel))));
-                return this->execute(statement);
-            }
-
-            /**
-             *  Using a CTE, select a single column into std::vector<T> or multiple columns into std::vector<std::tuple<...>>.
-             */
-            template<class... CTEs, class Compound, satisfies<is_compound_operator, Compound> = true>
-            auto with_recursive(common_table_expressions<CTEs...> cte, Compound sel) {
-                auto statement =
-                    this->prepare(sqlite_orm::with_recursive(std::move(cte), sqlite_orm::select(std::move(sel))));
+            template<class... CTEs, class E>
+            auto with_recursive(common_table_expressions<CTEs...> cte, E expression) {
+                auto statement = this->prepare(sqlite_orm::with_recursive(std::move(cte), std::move(expression)));
                 return this->execute(statement);
             }
 #endif
diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index a9048c5ca..99d081175 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -335,12 +335,14 @@ TEST_CASE("ast_iterator") {
         auto expression = with(cte<cte_1>().as(select(1)), select(column<cte_1>(1_colalias)));
         expected.insert(expected.cend(), {typeid(int), typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>)});
         iterate_ast(expression, lambda);
+        REQUIRE(typeIndexes == expected);
     }
     SECTION("with not enforced recursive") {
         using cte_1 = decltype(1_ctealias);
         auto expression = with_recursive(cte<cte_1>().as(select(1)), select(column<cte_1>(1_colalias)));
         expected.insert(expected.cend(), {typeid(int), typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>)});
         iterate_ast(expression, lambda);
+        REQUIRE(typeIndexes == expected);
     }
     SECTION("with optional recursive") {
         using cte_1 = decltype(1_ctealias);
@@ -356,6 +358,7 @@ TEST_CASE("ast_iterator") {
                          typeid(int),
                          typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>)});
         iterate_ast(expression, lambda);
+        REQUIRE(typeIndexes == expected);
     }
     SECTION("with recursive") {
         using cte_1 = decltype(1_ctealias);
@@ -371,6 +374,7 @@ TEST_CASE("ast_iterator") {
                          typeid(int),
                          typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>)});
         iterate_ast(expression, lambda);
+        REQUIRE(typeIndexes == expected);
     }
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     SECTION("aliased CTE column pointer") {
@@ -380,6 +384,7 @@ TEST_CASE("ast_iterator") {
         auto expression = z_alias->*&User::id;
         expected.push_back(typeid(alias_column_t<alias_z<cte_1>, column_pointer<cte_1, decltype(&User::id)>>));
         iterate_ast(expression, lambda);
+        REQUIRE(typeIndexes == expected);
     }
     SECTION("aliased CTE column alias") {
         constexpr auto c = "1"_cte;
@@ -389,6 +394,7 @@ TEST_CASE("ast_iterator") {
         expected.push_back(
             typeid(alias_column_t<alias_z<cte_1>, column_pointer<cte_1, alias_holder<column_alias<'1'>>>>));
         iterate_ast(expression, lambda);
+        REQUIRE(typeIndexes == expected);
     }
 #endif
 #endif
diff --git a/tests/statement_serializer_tests/select_constraints.cpp b/tests/statement_serializer_tests/select_constraints.cpp
index 8d2a77be6..20c944c3e 100644
--- a/tests/statement_serializer_tests/select_constraints.cpp
+++ b/tests/statement_serializer_tests/select_constraints.cpp
@@ -97,61 +97,105 @@ TEST_CASE("statement_serializer select constraints") {
             auto expression = from<cte_1>();
             value = serialize(expression, context);
             expected = R"(FROM "1")";
+            REQUIRE(value == expected);
         }
         SECTION("with alias 1") {
             auto expression = from<alias_z<cte_1>>();
             value = serialize(expression, context);
             expected = R"(FROM "1" "z")";
+            REQUIRE(value == expected);
         }
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         SECTION("without alias 2") {
             auto expression = from<1_ctealias>();
             value = serialize(expression, context);
             expected = R"(FROM "1")";
+            REQUIRE(value == expected);
         }
         SECTION("with alias 2") {
             constexpr auto z_alias = "z"_alias.for_<1_ctealias>();
             auto expression = from<z_alias>();
             value = serialize(expression, context);
             expected = R"(FROM "1" "z")";
+            REQUIRE(value == expected);
         }
         SECTION("as") {
             auto expression = cte<cte_1>().as(select(1));
             value = serialize(expression, context);
             expected = R"("1"("1") AS (SELECT 1))";
+            REQUIRE(value == expected);
         }
         SECTION("as materialized") {
             auto expression = cte<cte_1>().as<materialized()>(select(1));
             value = serialize(expression, context);
             expected = R"("1"("1") AS MATERIALIZED (SELECT 1))";
+            REQUIRE(value == expected);
         }
         SECTION("as not materialized") {
             auto expression = cte<cte_1>().as<not_materialized()>(select(1));
             value = serialize(expression, context);
             expected = R"("1"("1") AS NOT MATERIALIZED (SELECT 1))";
+            REQUIRE(value == expected);
         }
 #endif
         SECTION("with ordinary") {
             auto expression = with(cte<cte_1>().as(select(1)), select(column<cte_1>(1_colalias)));
             value = serialize(expression, context);
             expected = R"(WITH "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1")";
+            REQUIRE(value == expected);
+        }
+        SECTION("with ordinary, compound") {
+            auto expression = with(cte<cte_1>().as(select(1)),
+                                   union_all(select(column<cte_1>(1_colalias)), select(column<cte_1>(1_colalias))));
+            value = serialize(expression, context);
+            expected = R"(WITH "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1" UNION ALL SELECT "1"."1" FROM "1")";
+            REQUIRE(value == expected);
         }
         SECTION("with not enforced recursive") {
             auto expression = with_recursive(cte<cte_1>().as(select(1)), select(column<cte_1>(1_colalias)));
             value = serialize(expression, context);
             expected = R"(WITH RECURSIVE "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1")";
+            REQUIRE(value == expected);
+        }
+        SECTION("with not enforced recursive, compound") {
+            auto expression =
+                with_recursive(cte<cte_1>().as(select(1)),
+                               union_all(select(column<cte_1>(1_colalias)), select(column<cte_1>(1_colalias))));
+            value = serialize(expression, context);
+            expected =
+                R"(WITH RECURSIVE "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1" UNION ALL SELECT "1"."1" FROM "1")";
+            REQUIRE(value == expected);
         }
         SECTION("with ordinary, multiple") {
             auto expression = with(std::make_tuple(cte<cte_1>().as(select(1)), cte<cte_1>().as(select(1))),
                                    select(column<cte_1>(1_colalias)));
             value = serialize(expression, context);
             expected = R"(WITH "1"("1") AS (SELECT 1), "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1")";
+            REQUIRE(value == expected);
+        }
+        SECTION("with ordinary, multiple, compound") {
+            auto expression = with(std::make_tuple(cte<cte_1>().as(select(1)), cte<cte_1>().as(select(1))),
+                                   union_all(select(column<cte_1>(1_colalias)), select(column<cte_1>(1_colalias))));
+            value = serialize(expression, context);
+            expected =
+                R"(WITH "1"("1") AS (SELECT 1), "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1" UNION ALL SELECT "1"."1" FROM "1")";
+            REQUIRE(value == expected);
         }
         SECTION("with not enforced recursive, multiple") {
             auto expression = with_recursive(std::make_tuple(cte<cte_1>().as(select(1)), cte<cte_1>().as(select(1))),
                                              select(column<cte_1>(1_colalias)));
             value = serialize(expression, context);
             expected = R"(WITH RECURSIVE "1"("1") AS (SELECT 1), "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1")";
+            REQUIRE(value == expected);
+        }
+        SECTION("with not enforced recursive, multiple, compound") {
+            auto expression =
+                with_recursive(std::make_tuple(cte<cte_1>().as(select(1)), cte<cte_1>().as(select(1))),
+                               union_all(select(column<cte_1>(1_colalias)), select(column<cte_1>(1_colalias))));
+            value = serialize(expression, context);
+            expected =
+                R"(WITH RECURSIVE "1"("1") AS (SELECT 1), "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1" UNION ALL SELECT "1"."1" FROM "1")";
+            REQUIRE(value == expected);
         }
         SECTION("with optional recursive") {
             auto expression = with(
@@ -161,6 +205,7 @@ TEST_CASE("statement_serializer select constraints") {
             value = serialize(expression, context);
             expected =
                 R"(WITH "1"("1") AS (SELECT 1 UNION ALL SELECT "1"."1" + 1 FROM "1" WHERE ("1"."1" < 10)) SELECT "1"."1" FROM "1")";
+            REQUIRE(value == expected);
         }
         SECTION("with recursive") {
             auto expression = with_recursive(
@@ -170,6 +215,7 @@ TEST_CASE("statement_serializer select constraints") {
             value = serialize(expression, context);
             expected =
                 R"(WITH RECURSIVE "1"("1") AS (SELECT 1 UNION ALL SELECT "1"."1" + 1 FROM "1" WHERE ("1"."1" < 10)) SELECT "1"."1" FROM "1")";
+            REQUIRE(value == expected);
         }
     }
 #endif
diff --git a/tests/tests3.cpp b/tests/tests3.cpp
index b6c759289..c9d710759 100644
--- a/tests/tests3.cpp
+++ b/tests/tests3.cpp
@@ -396,18 +396,38 @@ TEST_CASE("With select") {
         auto rows = storage.with(cte<cnt>().as(select(1)), select(column<cnt>(1_colalias)));
         REQUIRE_THAT(rows, Equals(std::vector<int>{1}));
     }
+    SECTION("with ordinary, compound") {
+        auto rows = storage.with(cte<cnt>().as(select(1)),
+                                 union_all(select(column<cnt>(1_colalias)), select(column<cnt>(1_colalias))));
+        REQUIRE_THAT(rows, Equals(std::vector<int>{1, 1}));
+    }
     SECTION("with not enforced recursive") {
         auto rows = storage.with_recursive(cte<cnt>().as(select(1)), select(column<cnt>(1_colalias)));
         REQUIRE_THAT(rows, Equals(std::vector<int>{1}));
     }
-    SECTION("with ordinary 2") {
+    SECTION("with not enforced recursive, compound") {
+        auto rows = storage.with_recursive(cte<cnt>().as(select(1)),
+                                           union_all(select(column<cnt>(1_colalias)), select(column<cnt>(1_colalias))));
+        REQUIRE_THAT(rows, Equals(std::vector<int>{1, 1}));
+    }
+    SECTION("with ordinary, multiple") {
         auto rows = storage.with(std::make_tuple(cte<cnt>().as(select(1))), select(column<cnt>(1_colalias)));
         REQUIRE_THAT(rows, Equals(std::vector<int>{1}));
     }
-    SECTION("with not enforced recursive 2") {
+    SECTION("with ordinary, multiple, compound") {
+        auto rows = storage.with(std::make_tuple(cte<cnt>().as(select(1))),
+                                 union_all(select(column<cnt>(1_colalias)), select(column<cnt>(1_colalias))));
+        REQUIRE_THAT(rows, Equals(std::vector<int>{1, 1}));
+    }
+    SECTION("with not enforced recursive, multiple") {
         auto rows = storage.with_recursive(std::make_tuple(cte<cnt>().as(select(1))), select(column<cnt>(1_colalias)));
         REQUIRE_THAT(rows, Equals(std::vector<int>{1}));
     }
+    SECTION("with not enforced recursive, multiple, compound") {
+        auto rows = storage.with_recursive(std::make_tuple(cte<cnt>().as(select(1))),
+                                           union_all(select(column<cnt>(1_colalias)), select(column<cnt>(1_colalias))));
+        REQUIRE_THAT(rows, Equals(std::vector<int>{1, 1}));
+    }
     SECTION("with optional recursive") {
         auto rows = storage.with(
             cte<cnt>().as(

From f484fcac91928c9ebfcbf529231a3e44a5811b6f Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 20 Oct 2023 00:16:03 +0200
Subject: [PATCH 141/161] Count asterisk from CTE using C++20 aliases

---
 dev/core_functions.h                          | 15 ++++++++++++++-
 include/sqlite_orm/sqlite_orm.h               | 15 ++++++++++++++-
 .../aggregate_functions.cpp                   | 13 +++++++++++--
 tests/static_tests/column_result_t.cpp        | 11 +++++++----
 tests/static_tests/node_tuple.cpp             | 18 ++++++++++++++++++
 tests/table_name_collector.cpp                | 19 ++++++++++++++++++-
 6 files changed, 82 insertions(+), 9 deletions(-)

diff --git a/dev/core_functions.h b/dev/core_functions.h
index d6b467877..8f1991488 100644
--- a/dev/core_functions.h
+++ b/dev/core_functions.h
@@ -1837,7 +1837,7 @@ namespace sqlite_orm {
     }
 
     /**
-     *  COUNT(*) with FROM function. Specified type T will be serializeed as
+     *  COUNT(*) with FROM function. Specified type T will be serialized as
      *  a from argument.
      */
     template<class T>
@@ -1845,6 +1845,19 @@ namespace sqlite_orm {
         return {};
     }
 
+#ifdef SQLITE_ORM_WITH_CTE
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  COUNT(*) with FROM function. Specified cte moniker will be serialized as
+     *  a from argument.
+     */
+    template<orm_cte_moniker auto moniker>
+    internal::count_asterisk_t<std::remove_const_t<decltype(moniker)>> count() {
+        return {};
+    }
+#endif
+#endif
+
     /**
      *  AVG(X) aggregate function.
      */
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 5c5724169..3e7301826 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -6895,7 +6895,7 @@ namespace sqlite_orm {
     }
 
     /**
-     *  COUNT(*) with FROM function. Specified type T will be serializeed as
+     *  COUNT(*) with FROM function. Specified type T will be serialized as
      *  a from argument.
      */
     template<class T>
@@ -6903,6 +6903,19 @@ namespace sqlite_orm {
         return {};
     }
 
+#ifdef SQLITE_ORM_WITH_CTE
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  COUNT(*) with FROM function. Specified cte moniker will be serialized as
+     *  a from argument.
+     */
+    template<orm_cte_moniker auto moniker>
+    internal::count_asterisk_t<std::remove_const_t<decltype(moniker)>> count() {
+        return {};
+    }
+#endif
+#endif
+
     /**
      *  AVG(X) aggregate function.
      */
diff --git a/tests/statement_serializer_tests/aggregate_functions.cpp b/tests/statement_serializer_tests/aggregate_functions.cpp
index 76f06c63a..95e969355 100644
--- a/tests/statement_serializer_tests/aggregate_functions.cpp
+++ b/tests/statement_serializer_tests/aggregate_functions.cpp
@@ -76,16 +76,25 @@ TEST_CASE("statement_serializer aggregate functions") {
     }
     SECTION("count(*)") {
         SECTION("simple") {
-            SECTION("with filter") {
+            SECTION("without filter") {
                 auto expression = count<User>();
                 value = serialize(expression, context);
                 expected = R"(COUNT(*))";
             }
-            SECTION("without filter") {
+            SECTION("with filter") {
                 auto expression = count<User>().filter(where(less_than(&User::id, 10)));
                 value = serialize(expression, context);
                 expected = R"(COUNT(*) FILTER (WHERE ("id" < 10)))";
             }
+#ifdef SQLITE_ORM_WITH_CTE
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+            SECTION("with CTE") {
+                auto expression = count<1_ctealias>();
+                value = serialize(expression, context);
+                expected = R"(COUNT(*))";
+#endif
+#endif
+            }
         }
     }
     SECTION("group_concat(X)") {
diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
index 681d7a9f4..e733802cb 100644
--- a/tests/static_tests/column_result_t.cpp
+++ b/tests/static_tests/column_result_t.cpp
@@ -130,11 +130,14 @@ TEST_CASE("column_result_of_t") {
     runTest<db_objects2_t, int>(alias_column<alias_a<cte_1>>(1_colalias));
     runTest<db_objects2_t, std::tuple<int>>(asterisk<cte_1>());
     runTest<db_objects2_t, std::tuple<int>>(asterisk<alias_a<cte_1>>());
+    runTest<db_objects_t, int>(count<cte_1>());
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    runTest<db_objects_t, int>(column<"1"_cte>(&User::id));
-    runTest<db_objects2_t, int>(column<"1"_cte>(1_colalias));
-    runTest<db_objects2_t, int>(column<"1"_cte>(get<1_colalias>()));
-    runTest<db_objects_t, int>("1"_cte->*&User::id);
+    constexpr auto cte1 = 1_ctealias;
+    runTest<db_objects_t, int>(column<cte1>(&User::id));
+    runTest<db_objects2_t, int>(column<cte1>(1_colalias));
+    runTest<db_objects2_t, int>(column<cte1>(get<1_colalias>()));
+    runTest<db_objects_t, int>(cte1->*&User::id);
+    runTest<db_objects_t, int>(count<cte1>());
 #endif
 #endif
 }
diff --git a/tests/static_tests/node_tuple.cpp b/tests/static_tests/node_tuple.cpp
index 22dda6f71..98631d8c4 100644
--- a/tests/static_tests/node_tuple.cpp
+++ b/tests/static_tests/node_tuple.cpp
@@ -236,6 +236,24 @@ TEST_CASE("Node tuple") {
             using Expected = tuple<decltype(node)>;
             static_assert(is_same<Tuple, Expected>::value, "count(*)");
         }
+#ifdef SQLITE_ORM_WITH_CTE
+        SECTION("count(*) cte") {
+            auto node = count<decltype(1_ctealias)>();
+            using Node = decltype(node);
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<Node>;
+            static_assert(is_same<Tuple, Expected>::value, "count(*) cte");
+        }
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        SECTION("count(*) cte 2") {
+            auto node = count<1_ctealias>();
+            using Node = decltype(node);
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<Node>;
+            static_assert(is_same<Tuple, Expected>::value, "count(*) cte 2");
+        }
+#endif
+#endif
         SECTION("count(*) filter") {
             auto node = count<User>().filter(where(length(&User::name) > 5));
             using Node = decltype(node);
diff --git a/tests/table_name_collector.cpp b/tests/table_name_collector.cpp
index 649e74214..5f075f453 100644
--- a/tests/table_name_collector.cpp
+++ b/tests/table_name_collector.cpp
@@ -20,7 +20,6 @@ TEST_CASE("table name collector") {
 
     SECTION("from table") {
         SECTION("regular column") {
-            using als = alias_z<User>;
             auto expression = &User::id;
             expected.emplace(table.name, "");
             iterate_ast(expression, collector);
@@ -42,6 +41,11 @@ TEST_CASE("table name collector") {
             expected.emplace(table.name, "z");
             iterate_ast(expression, collector);
         }
+        SECTION("count asterisk") {
+            auto expression = count<User>();
+            expected.emplace(table.name, "");
+            iterate_ast(expression, collector);
+        }
         REQUIRE(collector.table_names == expected);
     }
 
@@ -65,6 +69,13 @@ TEST_CASE("table name collector") {
             expected.emplace(alias_extractor<decltype(c)>::extract(), "");
             iterate_ast(expression, collector);
         }
+        SECTION("CTE count asterisk") {
+            constexpr auto c = 1_ctealias;
+            using cte_1 = decltype(1_ctealias);
+            auto expression = count<cte_1>();
+            expected.emplace(alias_extractor<decltype(c)>::extract(), "");
+            iterate_ast(expression, collector);
+        }
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         SECTION("aliased CTE column") {
             constexpr auto c = "1"_cte;
@@ -80,6 +91,12 @@ TEST_CASE("table name collector") {
             expected.emplace(alias_extractor<decltype(c)>::extract(), "z");
             iterate_ast(expression, collector);
         }
+        SECTION("CTE count asterisk 2") {
+            constexpr auto c = 1_ctealias;
+            auto expression = count<c>();
+            expected.emplace(alias_extractor<decltype(c)>::extract(), "");
+            iterate_ast(expression, collector);
+        }
 #endif
         REQUIRE(collector.table_names == expected);
     }

From 28d99bf7a54d51630de68d66c599a9997b600f30 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 20 Oct 2023 09:57:50 +0200
Subject: [PATCH 142/161] Corrected unit tests for aggregate functions

---
 tests/statement_serializer_tests/aggregate_functions.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/statement_serializer_tests/aggregate_functions.cpp b/tests/statement_serializer_tests/aggregate_functions.cpp
index 95e969355..2fd88a0b7 100644
--- a/tests/statement_serializer_tests/aggregate_functions.cpp
+++ b/tests/statement_serializer_tests/aggregate_functions.cpp
@@ -92,9 +92,9 @@ TEST_CASE("statement_serializer aggregate functions") {
                 auto expression = count<1_ctealias>();
                 value = serialize(expression, context);
                 expected = R"(COUNT(*))";
+            }
 #endif
 #endif
-            }
         }
     }
     SECTION("group_concat(X)") {

From f9eb74e284dfdc1faf8faf349dbaee0649a4f0dc Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 20 Oct 2023 10:33:57 +0200
Subject: [PATCH 143/161] Clarified comment on `alias_extractor` a bit

---
 dev/alias.h                     | 6 +++---
 include/sqlite_orm/sqlite_orm.h | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 1b95af186..d8ecd2128 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -100,8 +100,8 @@ namespace sqlite_orm {
         /*
          * Encapsulates extracting the alias identifier of an alias.
          * 
-         * `extract()` always returns the alias identifier.
-         * `as_alias()` is used in contexts where a table is aliased, and the alias identifier is returned.
+         * `extract()` always returns the alias identifier or CTE moniker.
+         * `as_alias()` is used in contexts where a recordset is aliased, and the alias identifier is returned.
          * `as_qualifier()` is used in contexts where a table is aliased, and the alias identifier is returned.
          */
         template<class A>
@@ -119,7 +119,7 @@ namespace sqlite_orm {
             }
 
 #ifdef SQLITE_ORM_WITH_CTE
-            // for cte monikers -> empty
+            // for CTE monikers -> empty
             template<class T = A, satisfies<std::is_same, polyfill::detected_t<type_t, T>, A> = true>
             static std::string as_alias() {
                 return {};
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 3e7301826..1f411b085 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4697,8 +4697,8 @@ namespace sqlite_orm {
         /*
          * Encapsulates extracting the alias identifier of an alias.
          * 
-         * `extract()` always returns the alias identifier.
-         * `as_alias()` is used in contexts where a table is aliased, and the alias identifier is returned.
+         * `extract()` always returns the alias identifier or CTE moniker.
+         * `as_alias()` is used in contexts where a recordset is aliased, and the alias identifier is returned.
          * `as_qualifier()` is used in contexts where a table is aliased, and the alias identifier is returned.
          */
         template<class A>
@@ -4716,7 +4716,7 @@ namespace sqlite_orm {
             }
 
 #ifdef SQLITE_ORM_WITH_CTE
-            // for cte monikers -> empty
+            // for CTE monikers -> empty
             template<class T = A, satisfies<std::is_same, polyfill::detected_t<type_t, T>, A> = true>
             static std::string as_alias() {
                 return {};

From ab013e621ac8e418864dad70e2be5a83cba49c37 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 22 Oct 2023 11:48:40 +0200
Subject: [PATCH 144/161] Relaxed forming a column reference to an aliased
 table column pointer

---
 dev/alias.h                        | 109 ++++++++++++++++++----
 dev/column_pointer.h               |   3 +-
 dev/functional/cxx_core_features.h |   4 -
 dev/table_type_of.h                |  27 +++++-
 include/sqlite_orm/sqlite_orm.h    | 145 +++++++++++++++++++++++------
 tests/static_tests/alias.cpp       |  13 +++
 tests/static_tests/column.cpp      |   8 ++
 7 files changed, 251 insertions(+), 58 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index d8ecd2128..d321f2a36 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -14,6 +14,7 @@
 #include "functional/cxx_type_traits_polyfill.h"
 #include "type_traits.h"
 #include "alias_traits.h"
+#include "table_type_of.h"
 #include "tags.h"
 #include "column_pointer.h"
 
@@ -204,8 +205,11 @@ namespace sqlite_orm {
     }
 
     /**
-     *  @return column with table alias attached. Place it instead of a column statement in case you need to specify a
-     *  column with table alias prefix like 'a.column'.
+     *  Using a column pointer, create a column reference to an aliased table column.
+     *  
+     *  Example:
+     *  using als = alias_u<User>;
+     *  select(alias_column<als>(column<User>(&User::id)))
      */
     template<
         class A,
@@ -213,49 +217,111 @@ namespace sqlite_orm {
         std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<A>,
                                                  polyfill::negation<internal::is_cte_moniker<internal::type_t<A>>>>,
                          bool> = true>
-    internal::alias_column_t<A, C> alias_column(C c) {
-        using aliased_type = internal::type_t<A>;
-        static_assert(std::is_same<polyfill::detected_t<internal::table_type_of_t, C>, aliased_type>::value,
-                      "Column must be from aliased table");
-        return {c};
+    constexpr auto alias_column(C field) {
+        using namespace ::sqlite_orm::internal;
+        using aliased_type = type_t<A>;
+        static_assert(is_field_of_v<C, aliased_type>, "Column must be from aliased table");
+
+        return alias_column_t<A, C>{std::move(field)};
+    }
+
+    /**
+     *  Using an object member field, create a column reference to an aliased table column.
+     *  
+     *  @note The object member pointer can be from a derived class without explicitly forming a column pointer.
+     *  
+     *  Example:
+     *  using als = alias_u<User>;
+     *  select(alias_column<als>(&User::id))
+     */
+    template<
+        class A,
+        class F,
+        class O,
+        std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<A>,
+                                                 polyfill::negation<internal::is_cte_moniker<internal::type_t<A>>>>,
+                         bool> = true>
+    constexpr auto alias_column(F O::*field) {
+        using namespace ::sqlite_orm::internal;
+        using aliased_type = type_t<A>;
+        static_assert(is_field_of_v<F O::*, aliased_type>, "Column must be from aliased table");
+
+        using C1 =
+            std::conditional_t<std::is_same<O, aliased_type>::value, F O::*, column_pointer<aliased_type, F O::*>>;
+        return alias_column_t<A, C1>{{field}};
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Create a column reference to an aliased table column.
+     *  
+     *  @note An object member pointer can be from a derived class without explicitly forming a column pointer.
+     *  
+     *  Example:
+     *  constexpr auto als = "u"_alias.for_<User>();
+     *  select(alias_column<als>(&User::id))
+     */
     template<orm_table_alias auto als, class C>
         requires(!orm_cte_moniker<internal::auto_type_t<als>>)
-    auto alias_column(C c) {
+    constexpr auto alias_column(C field) {
+        using namespace ::sqlite_orm::internal;
         using A = std::remove_const_t<decltype(als)>;
-        using aliased_type = internal::type_t<A>;
-        static_assert(std::is_same_v<polyfill::detected_t<internal::table_type_of_t, C>, aliased_type>,
-                      "Column must be from aliased table");
-        return internal::alias_column_t<A, decltype(c)>{c};
+        using aliased_type = type_t<A>;
+        static_assert(is_field_of_v<C, aliased_type>, "Column must be from aliased table");
+
+        if constexpr(is_column_pointer_v<C>) {
+            return alias_column_t<A, C>{std::move(field)};
+        } else if constexpr(std::is_same_v<member_object_type_t<C>, aliased_type>) {
+            return alias_column_t<A, C>{field};
+        } else {
+            // wrap in column_pointer
+            using C1 = column_pointer<aliased_type, C>;
+            return alias_column_t<A, C1>{{field}};
+        }
     }
 
+    /**
+     *  Create a column reference to an aliased table column.
+     *  
+     *  @note An object member pointer can be from a derived class without explicitly forming a column pointer.
+     *  
+     *  Example:
+     *  constexpr auto als = "u"_alias.for_<User>();
+     *  select(als->*&User::id)
+     */
     template<orm_table_alias A, class F>
         requires(!orm_cte_moniker<internal::type_t<A>>)
     constexpr auto operator->*(const A& /*tableAlias*/, F field) {
-        return internal::alias_column_t<A, F>{field};
+        return alias_column<A>(std::move(field));
     }
 #endif
 
 #ifdef SQLITE_ORM_WITH_CTE
+    /**
+     *  Create a column reference to an aliased CTE column.
+     */
     template<class A,
              class C,
              std::enable_if_t<
                  polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_moniker<internal::type_t<A>>>,
                  bool> = true>
-    auto alias_column(C c) {
-        using cte_moniker_t = internal::type_t<A>;
-        if constexpr(internal::is_column_pointer_v<C>) {
-            static_assert(std::is_same<internal::table_type_of_t<C>, cte_moniker_t>::value,
+    constexpr auto alias_column(C c) {
+        using namespace internal;
+        using cte_moniker_t = type_t<A>;
+
+        if constexpr(is_column_pointer_v<C>) {
+            static_assert(std::is_same<table_type_of_t<C>, cte_moniker_t>::value,
                           "Column pointer must match aliased CTE");
-            return internal::alias_column_t<A, C>{c};
+            return alias_column_t<A, C>{c};
         } else {
             auto cp = column<cte_moniker_t>(c);
-            return internal::alias_column_t<A, decltype(cp)>{cp};
+            return alias_column_t<A, decltype(cp)>{std::move(cp)};
         }
     }
 
+    /**
+     *  Create a column reference to an aliased CTE column.
+     */
     template<class A,
              class F,
              std::enable_if_t<
@@ -266,9 +332,12 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Create a column reference to an aliased CTE column.
+     */
     template<orm_table_alias auto als, class C>
         requires(orm_cte_moniker<internal::auto_type_t<als>>)
-    auto alias_column(C c) {
+    constexpr auto alias_column(C c) {
         using A = std::remove_const_t<decltype(als)>;
         return alias_column<A>(std::move(c));
     }
diff --git a/dev/column_pointer.h b/dev/column_pointer.h
index de80ce400..174315b3b 100644
--- a/dev/column_pointer.h
+++ b/dev/column_pointer.h
@@ -17,7 +17,6 @@ namespace sqlite_orm {
          */
         template<class T, class F>
         struct column_pointer {
-            using self = column_pointer<T, F>;
             using type = T;
             using field_type = F;
 
@@ -49,7 +48,7 @@ namespace sqlite_orm {
      *  storage.select(column<MyType>(&BaseType::id));
      */
     template<class Object, class F, internal::satisfies_not<internal::is_recordset_alias, Object> = true>
-    internal::column_pointer<Object, F> column(F field) {
+    constexpr internal::column_pointer<Object, F> column(F field) {
         return {std::move(field)};
     }
 
diff --git a/dev/functional/cxx_core_features.h b/dev/functional/cxx_core_features.h
index ccb31adf9..d71644fd3 100644
--- a/dev/functional/cxx_core_features.h
+++ b/dev/functional/cxx_core_features.h
@@ -37,10 +37,6 @@
 #define SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
 #endif
 
-#if __cpp_inline_variables >= 201606L
-#define SQLITE_ORM_INLINE_VARIABLES_SUPPORTED
-#endif
-
 #if __cpp_if_constexpr >= 201606L
 #define SQLITE_ORM_IF_CONSTEXPR_SUPPORTED
 #endif
diff --git a/dev/table_type_of.h b/dev/table_type_of.h
index 47c9d9d88..32fab610f 100644
--- a/dev/table_type_of.h
+++ b/dev/table_type_of.h
@@ -1,4 +1,6 @@
 #pragma once
+#include <type_traits>  //  std::declval
+#include "functional/cxx_type_traits_polyfill.h"
 
 namespace sqlite_orm {
 
@@ -33,11 +35,30 @@ namespace sqlite_orm {
         };
 
         template<class C>
-        struct table_type_of<indexed_column_t<C>> {
-            using type = typename table_type_of<C>::type;
-        };
+        struct table_type_of<indexed_column_t<C>> : table_type_of<C> {};
 
         template<class T>
         using table_type_of_t = typename table_type_of<T>::type;
+
+        /*
+         *  This trait can be used to check whether the object type of a member pointer or column pointer matches the target type.
+         *  
+         *  One use case is the ability to create column reference to an aliased table column of a derived object field without explicitly using a column pointer.
+         *  E.g.
+         *  regular: `alias_column<alias_d<Derived>>(column<Derived>(&Base::field))`
+         *  short:   `alias_column<alias_d<Derived>>(&Base::field)`
+         */
+        template<class F, class T, class SFINAE = void>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_field_of_v = false;
+
+        /*
+         *  `true` if a pointer-to-member operator is a valid expression for an object of type `T` and a member pointer of type `F O::*`.
+         */
+        template<class F, class O, class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool
+            is_field_of_v<F O::*, T, polyfill::void_t<decltype(std::declval<T>().*std::declval<F O::*>())>> = true;
+
+        template<class F, class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_field_of_v<column_pointer<T, F>, T, void> = true;
     }
 }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 1f411b085..13d2da272 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -65,10 +65,6 @@ using std::nullptr_t;
 #define SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
 #endif
 
-#if __cpp_inline_variables >= 201606L
-#define SQLITE_ORM_INLINE_VARIABLES_SUPPORTED
-#endif
-
 #if __cpp_if_constexpr >= 201606L
 #define SQLITE_ORM_IF_CONSTEXPR_SUPPORTED
 #endif
@@ -1339,6 +1335,9 @@ namespace sqlite_orm {
 
 // #include "table_type_of.h"
 
+#include <type_traits>  //  std::declval
+// #include "functional/cxx_type_traits_polyfill.h"
+
 namespace sqlite_orm {
 
     namespace internal {
@@ -1372,12 +1371,31 @@ namespace sqlite_orm {
         };
 
         template<class C>
-        struct table_type_of<indexed_column_t<C>> {
-            using type = typename table_type_of<C>::type;
-        };
+        struct table_type_of<indexed_column_t<C>> : table_type_of<C> {};
 
         template<class T>
         using table_type_of_t = typename table_type_of<T>::type;
+
+        /*
+         *  This trait can be used to check whether the object type of a member pointer or column pointer matches the target type.
+         *  
+         *  One use case is the ability to create column reference to an aliased table column of a derived object field without explicitly using a column pointer.
+         *  E.g.
+         *  regular: `alias_column<alias_d<Derived>>(column<Derived>(&Base::field))`
+         *  short:   `alias_column<alias_d<Derived>>(&Base::field)`
+         */
+        template<class F, class T, class SFINAE = void>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_field_of_v = false;
+
+        /*
+         *  `true` if a pointer-to-member operator is a valid expression for an object of type `T` and a member pointer of type `F O::*`.
+         */
+        template<class F, class O, class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool
+            is_field_of_v<F O::*, T, polyfill::void_t<decltype(std::declval<T>().*std::declval<F O::*>())>> = true;
+
+        template<class F, class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_field_of_v<column_pointer<T, F>, T, void> = true;
     }
 }
 
@@ -3197,7 +3215,6 @@ namespace sqlite_orm {
          */
         template<class T, class F>
         struct column_pointer {
-            using self = column_pointer<T, F>;
             using type = T;
             using field_type = F;
 
@@ -3229,7 +3246,7 @@ namespace sqlite_orm {
      *  storage.select(column<MyType>(&BaseType::id));
      */
     template<class Object, class F, internal::satisfies_not<internal::is_recordset_alias, Object> = true>
-    internal::column_pointer<Object, F> column(F field) {
+    constexpr internal::column_pointer<Object, F> column(F field) {
         return {std::move(field)};
     }
 
@@ -4610,6 +4627,8 @@ namespace sqlite_orm {
 
 // #include "alias_traits.h"
 
+// #include "table_type_of.h"
+
 // #include "tags.h"
 
 // #include "column_pointer.h"
@@ -4801,8 +4820,11 @@ namespace sqlite_orm {
     }
 
     /**
-     *  @return column with table alias attached. Place it instead of a column statement in case you need to specify a
-     *  column with table alias prefix like 'a.column'.
+     *  Using a column pointer, create a column reference to an aliased table column.
+     *  
+     *  Example:
+     *  using als = alias_u<User>;
+     *  select(alias_column<als>(column<User>(&User::id)))
      */
     template<
         class A,
@@ -4810,49 +4832,111 @@ namespace sqlite_orm {
         std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<A>,
                                                  polyfill::negation<internal::is_cte_moniker<internal::type_t<A>>>>,
                          bool> = true>
-    internal::alias_column_t<A, C> alias_column(C c) {
-        using aliased_type = internal::type_t<A>;
-        static_assert(std::is_same<polyfill::detected_t<internal::table_type_of_t, C>, aliased_type>::value,
-                      "Column must be from aliased table");
-        return {c};
+    constexpr auto alias_column(C field) {
+        using namespace ::sqlite_orm::internal;
+        using aliased_type = type_t<A>;
+        static_assert(is_field_of_v<C, aliased_type>, "Column must be from aliased table");
+
+        return alias_column_t<A, C>{std::move(field)};
+    }
+
+    /**
+     *  Using an object member field, create a column reference to an aliased table column.
+     *  
+     *  @note The object member pointer can be from a derived class without explicitly forming a column pointer.
+     *  
+     *  Example:
+     *  using als = alias_u<User>;
+     *  select(alias_column<als>(&User::id))
+     */
+    template<
+        class A,
+        class F,
+        class O,
+        std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<A>,
+                                                 polyfill::negation<internal::is_cte_moniker<internal::type_t<A>>>>,
+                         bool> = true>
+    constexpr auto alias_column(F O::*field) {
+        using namespace ::sqlite_orm::internal;
+        using aliased_type = type_t<A>;
+        static_assert(is_field_of_v<F O::*, aliased_type>, "Column must be from aliased table");
+
+        using C1 =
+            std::conditional_t<std::is_same<O, aliased_type>::value, F O::*, column_pointer<aliased_type, F O::*>>;
+        return alias_column_t<A, C1>{{field}};
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Create a column reference to an aliased table column.
+     *  
+     *  @note An object member pointer can be from a derived class without explicitly forming a column pointer.
+     *  
+     *  Example:
+     *  constexpr auto als = "u"_alias.for_<User>();
+     *  select(alias_column<als>(&User::id))
+     */
     template<orm_table_alias auto als, class C>
         requires(!orm_cte_moniker<internal::auto_type_t<als>>)
-    auto alias_column(C c) {
+    constexpr auto alias_column(C field) {
+        using namespace ::sqlite_orm::internal;
         using A = std::remove_const_t<decltype(als)>;
-        using aliased_type = internal::type_t<A>;
-        static_assert(std::is_same_v<polyfill::detected_t<internal::table_type_of_t, C>, aliased_type>,
-                      "Column must be from aliased table");
-        return internal::alias_column_t<A, decltype(c)>{c};
+        using aliased_type = type_t<A>;
+        static_assert(is_field_of_v<C, aliased_type>, "Column must be from aliased table");
+
+        if constexpr(is_column_pointer_v<C>) {
+            return alias_column_t<A, C>{std::move(field)};
+        } else if constexpr(std::is_same_v<member_object_type_t<C>, aliased_type>) {
+            return alias_column_t<A, C>{field};
+        } else {
+            // wrap in column_pointer
+            using C1 = column_pointer<aliased_type, C>;
+            return alias_column_t<A, C1>{{field}};
+        }
     }
 
+    /**
+     *  Create a column reference to an aliased table column.
+     *  
+     *  @note An object member pointer can be from a derived class without explicitly forming a column pointer.
+     *  
+     *  Example:
+     *  constexpr auto als = "u"_alias.for_<User>();
+     *  select(als->*&User::id)
+     */
     template<orm_table_alias A, class F>
         requires(!orm_cte_moniker<internal::type_t<A>>)
     constexpr auto operator->*(const A& /*tableAlias*/, F field) {
-        return internal::alias_column_t<A, F>{field};
+        return alias_column<A>(std::move(field));
     }
 #endif
 
 #ifdef SQLITE_ORM_WITH_CTE
+    /**
+     *  Create a column reference to an aliased CTE column.
+     */
     template<class A,
              class C,
              std::enable_if_t<
                  polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_moniker<internal::type_t<A>>>,
                  bool> = true>
-    auto alias_column(C c) {
-        using cte_moniker_t = internal::type_t<A>;
-        if constexpr(internal::is_column_pointer_v<C>) {
-            static_assert(std::is_same<internal::table_type_of_t<C>, cte_moniker_t>::value,
+    constexpr auto alias_column(C c) {
+        using namespace internal;
+        using cte_moniker_t = type_t<A>;
+
+        if constexpr(is_column_pointer_v<C>) {
+            static_assert(std::is_same<table_type_of_t<C>, cte_moniker_t>::value,
                           "Column pointer must match aliased CTE");
-            return internal::alias_column_t<A, C>{c};
+            return alias_column_t<A, C>{c};
         } else {
             auto cp = column<cte_moniker_t>(c);
-            return internal::alias_column_t<A, decltype(cp)>{cp};
+            return alias_column_t<A, decltype(cp)>{std::move(cp)};
         }
     }
 
+    /**
+     *  Create a column reference to an aliased CTE column.
+     */
     template<class A,
              class F,
              std::enable_if_t<
@@ -4863,9 +4947,12 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Create a column reference to an aliased CTE column.
+     */
     template<orm_table_alias auto als, class C>
         requires(orm_cte_moniker<internal::auto_type_t<als>>)
-    auto alias_column(C c) {
+    constexpr auto alias_column(C c) {
         using A = std::remove_const_t<decltype(als)>;
         return alias_column<A>(std::move(c));
     }
diff --git a/tests/static_tests/alias.cpp b/tests/static_tests/alias.cpp
index 3df4a8c91..57e878ce5 100644
--- a/tests/static_tests/alias.cpp
+++ b/tests/static_tests/alias.cpp
@@ -24,6 +24,7 @@ TEST_CASE("aliases") {
     struct User {
         int id;
     };
+    struct DerivedUser : User {};
 
     SECTION("column alias expressions") {
         runTest<alias_holder<column_alias<'a'>>>(get<colalias_a>());
@@ -31,6 +32,11 @@ TEST_CASE("aliases") {
         runTest<alias_column_t<alias_z<User>, int User::*>>(alias_column<alias_z<User>>(&User::id));
         runTest<alias_column_t<alias_z<User>, column_pointer<User, int User::*>>>(
             alias_column<alias_z<User>>(column<User>(&User::id)));
+        runTest<alias_column_t<alias_d<DerivedUser>, column_pointer<DerivedUser, int User::*>>>(
+            alias_column<alias_d<DerivedUser>>(column<DerivedUser>(&User::id)));
+        // must implicitly create column pointer
+        runTest<alias_column_t<alias_d<DerivedUser>, column_pointer<DerivedUser, int User::*>>>(
+            alias_column<alias_d<DerivedUser>>(&User::id));
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         runTest<alias_holder<column_alias<'a'>>>(get<"a"_col>());
         runTest<column_alias<'a'>>("a"_col);
@@ -44,6 +50,13 @@ TEST_CASE("aliases") {
         runTest<alias_column_t<alias_z<User>, column_pointer<User, int User::*>>>(z_alias->*column<User>(&User::id));
         runTest<alias_column_t<alias_z<User>, column_pointer<User, int User::*>>>(
             alias_column<z_alias>(column<User>(&User::id)));
+        constexpr auto d_alias = "d"_alias.for_<DerivedUser>();
+        runTest<alias_column_t<alias_d<DerivedUser>, column_pointer<DerivedUser, int User::*>>>(
+            alias_column<d_alias>(column<DerivedUser>(&User::id)));
+        // must implicitly create column pointer
+        runTest<alias_column_t<alias_d<DerivedUser>, column_pointer<DerivedUser, int User::*>>>(
+            alias_column<d_alias>(&User::id));
+        runTest<alias_column_t<alias_d<DerivedUser>, column_pointer<DerivedUser, int User::*>>>(d_alias->*&User::id);
 #endif
 #ifdef SQLITE_ORM_WITH_CTE
         runTest<column_alias<'1'>>(1_colalias);
diff --git a/tests/static_tests/column.cpp b/tests/static_tests/column.cpp
index 8348f70d0..af92de34d 100644
--- a/tests/static_tests/column.cpp
+++ b/tests/static_tests/column.cpp
@@ -32,6 +32,7 @@ TEST_CASE("Column") {
         STATIC_REQUIRE(std::is_same<column_type::field_type, int>::value);
         STATIC_REQUIRE(std::is_same<column_type::member_pointer_t, const int& (User::*)() const>::value);
         STATIC_REQUIRE(std::is_same<column_type::setter_type, void (User::*)(int)>::value);
+        STATIC_REQUIRE(!internal::is_field_of_v<column_type::member_pointer_t, User>);
     }
     {
         using column_type = decltype(make_column("id", &User::setIdByVal, &User::getIdByRefConst));
@@ -80,6 +81,13 @@ TEST_CASE("Column") {
         STATIC_REQUIRE(std::is_same<field_type, decltype(&Object::id)>::value);
         STATIC_REQUIRE(std::is_same<internal::table_type_of<column_type>::type, Token>::value);
         STATIC_REQUIRE(std::is_same<internal::table_type_of<field_type>::type, Object>::value);
+        STATIC_REQUIRE(internal::is_field_of_v<column_type, Token>);
+        STATIC_REQUIRE(internal::is_field_of_v<field_type, Token>);
+        STATIC_REQUIRE(internal::is_field_of_v<field_type, Object>);
+        STATIC_REQUIRE(!internal::is_field_of_v<column_type, Object>);
+        STATIC_REQUIRE(!internal::is_field_of_v<column_type, User>);
+        STATIC_REQUIRE(!internal::is_field_of_v<field_type, User>);
+        STATIC_REQUIRE(std::is_same<internal::table_type_of<field_type>::type, Object>::value);
         STATIC_REQUIRE(std::is_same<internal::column_result_t<internal::storage_t<>, field_type>::type, int>::value);
         STATIC_REQUIRE(std::is_member_pointer<field_type>::value);
         STATIC_REQUIRE_FALSE(std::is_member_function_pointer<field_type>::value);

From d77fa596c60af825c3226decd8aef6550504fcfc Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 22 Oct 2023 11:53:41 +0200
Subject: [PATCH 145/161] Operators for column references to aliased table
 columns

---
 dev/alias.h                          | 4 ++++
 include/sqlite_orm/sqlite_orm.h      | 4 ++++
 tests/static_tests/operators_adl.cpp | 3 +++
 tests/tests.cpp                      | 8 ++++++++
 4 files changed, 19 insertions(+)

diff --git a/dev/alias.h b/dev/alias.h
index d321f2a36..9762a3840 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -73,6 +73,10 @@ namespace sqlite_orm {
             column_type column;
         };
 
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool
+            is_operator_argument_v<T, std::enable_if_t<polyfill::is_specialization_of_v<T, alias_column_t>>> = true;
+
         struct basic_table;
 
         /*
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 13d2da272..8350d4247 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4688,6 +4688,10 @@ namespace sqlite_orm {
             column_type column;
         };
 
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool
+            is_operator_argument_v<T, std::enable_if_t<polyfill::is_specialization_of_v<T, alias_column_t>>> = true;
+
         struct basic_table;
 
         /*
diff --git a/tests/static_tests/operators_adl.cpp b/tests/static_tests/operators_adl.cpp
index 757ae8813..2c8a3c200 100644
--- a/tests/static_tests/operators_adl.cpp
+++ b/tests/static_tests/operators_adl.cpp
@@ -4,6 +4,8 @@
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
 using sqlite_orm::operator"" _col;
 #endif
+using sqlite_orm::alias_a;
+using sqlite_orm::alias_column;
 using sqlite_orm::and_;
 using sqlite_orm::c;
 using sqlite_orm::colalias_a;
@@ -109,6 +111,7 @@ TEST_CASE("ADL and expression operators") {
     runTests(c(&User::id));
     runTests(column<User>(&User::id));
     runTests(get<colalias_a>());
+    runTests(alias_column<alias_a<User>>(&User::id));
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     runTests("a"_col);
 #endif
diff --git a/tests/tests.cpp b/tests/tests.cpp
index d0e13dc57..71687322d 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -1,6 +1,14 @@
 #include <sqlite_orm/sqlite_orm.h>
 #include <catch2/catch_all.hpp>
 
+#ifdef _DEBUG
+#pragma comment(lib, "Catch2d.Lib")
+#pragma comment(lib, "manual-link/Catch2Maind.Lib")
+#else
+#pragma comment(lib, "Catch2.Lib")
+#pragma comment(lib, "manual-link/Catch2Main.Lib")
+#endif
+
 #include <vector>  //  std::vector
 #include <string>  //  std::string
 #include <memory>  //  std::unique_ptr

From b1c9dfca3bf36b14185206debc45c781d78b4f11 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 10 Nov 2023 21:40:45 +0200
Subject: [PATCH 146/161] A few more CTE unit tests

---
 dev/node_tuple.h                              | 14 ++-----
 include/sqlite_orm/sqlite_orm.h               | 14 ++-----
 .../alias_extractor.cpp                       |  2 +-
 tests/static_tests/cte.cpp                    | 39 ++++++++++++-------
 4 files changed, 34 insertions(+), 35 deletions(-)

diff --git a/dev/node_tuple.h b/dev/node_tuple.h
index b70db5ea1..428a0f92f 100644
--- a/dev/node_tuple.h
+++ b/dev/node_tuple.h
@@ -124,18 +124,12 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
         template<class CTE>
-        struct node_tuple<CTE, std::enable_if_t<polyfill::is_specialization_of_v<CTE, common_table_expression>>> {
-            using node_type = CTE;
-            using type = node_tuple_t<typename node_type::expression_type>;
-        };
+        struct node_tuple<CTE, match_specialization_of<CTE, common_table_expression>>
+            : node_tuple<typename CTE::expression_type> {};
 
         template<class With>
-        struct node_tuple<With, std::enable_if_t<polyfill::is_specialization_of_v<With, with_t>>> {
-            using node_type = With;
-            using cte_tuple = node_tuple_t<typename node_type::cte_type>;
-            using expression_tuple = node_tuple_t<typename node_type::expression_type>;
-            using type = typename conc_tuple<cte_tuple, expression_tuple>::type;
-        };
+        struct node_tuple<With, match_specialization_of<With, with_t>>
+            : node_tuple_for<typename With::cte_type, typename With::expression_type> {};
 #endif
 
         template<class T, class... Args>
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index c3b580fe5..4b10882a2 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -21417,18 +21417,12 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CTE
         template<class CTE>
-        struct node_tuple<CTE, std::enable_if_t<polyfill::is_specialization_of_v<CTE, common_table_expression>>> {
-            using node_type = CTE;
-            using type = node_tuple_t<typename node_type::expression_type>;
-        };
+        struct node_tuple<CTE, match_specialization_of<CTE, common_table_expression>>
+            : node_tuple<typename CTE::expression_type> {};
 
         template<class With>
-        struct node_tuple<With, std::enable_if_t<polyfill::is_specialization_of_v<With, with_t>>> {
-            using node_type = With;
-            using cte_tuple = node_tuple_t<typename node_type::cte_type>;
-            using expression_tuple = node_tuple_t<typename node_type::expression_type>;
-            using type = typename conc_tuple<cte_tuple, expression_tuple>::type;
-        };
+        struct node_tuple<With, match_specialization_of<With, with_t>>
+            : node_tuple_for<typename With::cte_type, typename With::expression_type> {};
 #endif
 
         template<class T, class... Args>
diff --git a/tests/statement_serializer_tests/alias_extractor.cpp b/tests/statement_serializer_tests/alias_extractor.cpp
index ea31f422f..aca275ad3 100644
--- a/tests/statement_serializer_tests/alias_extractor.cpp
+++ b/tests/statement_serializer_tests/alias_extractor.cpp
@@ -20,7 +20,7 @@ TEST_CASE("alias extractor") {
         REQUIRE(alias_extractor<alias_a<User>>::as_alias() == "a");
     }
 #ifdef SQLITE_ORM_WITH_CTE
-    SECTION("cte table") {
+    SECTION("cte moniker") {
         using cte_1 = decltype(1_ctealias);
         REQUIRE(alias_extractor<cte_1>::extract() == "1");
         REQUIRE(alias_extractor<cte_1>::as_alias() == "");
diff --git a/tests/static_tests/cte.cpp b/tests/static_tests/cte.cpp
index 685fb7414..385e2354a 100644
--- a/tests/static_tests/cte.cpp
+++ b/tests/static_tests/cte.cpp
@@ -11,16 +11,21 @@ using internal::column_t;
 using std::is_same, std::is_constructible;
 using std::tuple;
 
-template<class ColRefs, class E>
+template<class T, class E>
 void do_assert() {
-    STATIC_REQUIRE(is_same<ColRefs, E>::value);
+    STATIC_REQUIRE(is_same<T, E>::value);
 }
 
 template<class E, class ColRef>
-void runTest(ColRef /*colRef*/) {
+void runDecay(ColRef /*colRef*/) {
     do_assert<internal::transform_tuple_t<tuple<ColRef>, internal::decay_explicit_column_t>, E>();
 }
 
+template<class E, class T>
+void runTest(T /*test*/) {
+    do_assert<T, E>();
+}
+
 TEST_CASE("CTE type traits") {
     SECTION("decay_explicit_column") {
         struct Org {
@@ -31,19 +36,25 @@ TEST_CASE("CTE type traits") {
         };
 
         STATIC_REQUIRE(is_constructible<alias_holder<column_alias<'c'>>, column_alias<'c'>>::value);
-        runTest<tuple<decltype(&Org::id)>>(&Org::id);
-        runTest<tuple<decltype(&Org::getId)>>(&Org::getId);
-        runTest<tuple<alias_holder<column_alias<'1'>>>>(1_colalias);
+        runDecay<tuple<decltype(&Org::id)>>(&Org::id);
+        runDecay<tuple<decltype(&Org::getId)>>(&Org::getId);
+        runDecay<tuple<alias_holder<column_alias<'1'>>>>(1_colalias);
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-        runTest<tuple<alias_holder<column_alias<'a'>>>>("a"_col);
+        runDecay<tuple<alias_holder<column_alias<'a'>>>>("a"_col);
 #endif
-        runTest<tuple<column_t<int64 Org::*, internal::empty_setter>>>(make_column("id", &Org::id));
-        runTest<tuple<polyfill::remove_cvref_t<decltype(std::ignore)>>>(std::ignore);
-        runTest<tuple<std::string>>("");
+        runDecay<tuple<column_t<int64 Org::*, internal::empty_setter>>>(make_column("id", &Org::id));
+        runDecay<tuple<polyfill::remove_cvref_t<decltype(std::ignore)>>>(std::ignore);
+        runDecay<tuple<std::string>>("");
     }
 }
 
 TEST_CASE("CTE building") {
+    SECTION("moniker") {
+        runTest<internal::cte_moniker<'1'>>(1_ctealias);
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        runTest<internal::cte_moniker<'z'>>("z"_cte);
+#endif
+    }
     SECTION("builder") {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         auto builder1 = cte<1_ctealias>();
@@ -51,7 +62,7 @@ TEST_CASE("CTE building") {
         auto builder1 = cte<decltype(1_ctealias)>();
 #endif
         auto builder2 = 1_ctealias();
-        static_assert(std::is_same<decltype(builder2), decltype(builder1)>::value);
+        STATIC_REQUIRE(std::is_same<decltype(builder2), decltype(builder1)>::value);
     }
 }
 
@@ -69,9 +80,9 @@ TEST_CASE("CTE storage") {
         auto dbObjects2 = internal::db_objects_cat(dbObjects, cteTable);
 
         // note: deliberately make indexes resulting in the same index_t<> type, such that we know `db_objects_cat()` is working properly
-        static_assert(is_same<decltype(idx1), decltype(idx2)>::value);
-        static_assert(is_same<decltype(dbObjects2),
-                              tuple<decltype(cteTable), decltype(idx1), decltype(idx2), decltype(table)>>::value);
+        STATIC_REQUIRE(is_same<decltype(idx1), decltype(idx2)>::value);
+        STATIC_REQUIRE(is_same<decltype(dbObjects2),
+                               tuple<decltype(cteTable), decltype(idx1), decltype(idx2), decltype(table)>>::value);
     }
 }
 #endif

From baf801e7bbf7cb86c7dcd25f844adfd1c224f8bf Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 10 Nov 2023 22:29:26 +0200
Subject: [PATCH 147/161] Properly guarded CTE alias column operator under
 C++20 aliases

---
 dev/alias.h                     | 11 ++++-------
 include/sqlite_orm/sqlite_orm.h | 11 ++++-------
 2 files changed, 8 insertions(+), 14 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 9762a3840..f307f30a6 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -323,19 +323,16 @@ namespace sqlite_orm {
         }
     }
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
      *  Create a column reference to an aliased CTE column.
      */
-    template<class A,
-             class F,
-             std::enable_if_t<
-                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_moniker<internal::type_t<A>>>,
-                 bool> = true>
-    constexpr auto operator->*(const A& /*tableAlias*/, F field) {
+    template<orm_table_alias A, class C>
+        requires(orm_cte_moniker<internal::type_t<A>>)
+    constexpr auto operator->*(const A& /*tableAlias*/, C field) {
         return alias_column<A>(std::move(field));
     }
 
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
      *  Create a column reference to an aliased CTE column.
      */
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 4b10882a2..f3e9a76f4 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4974,19 +4974,16 @@ namespace sqlite_orm {
         }
     }
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
      *  Create a column reference to an aliased CTE column.
      */
-    template<class A,
-             class F,
-             std::enable_if_t<
-                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_moniker<internal::type_t<A>>>,
-                 bool> = true>
-    constexpr auto operator->*(const A& /*tableAlias*/, F field) {
+    template<orm_table_alias A, class C>
+        requires(orm_cte_moniker<internal::type_t<A>>)
+    constexpr auto operator->*(const A& /*tableAlias*/, C field) {
         return alias_column<A>(std::move(field));
     }
 
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
      *  Create a column reference to an aliased CTE column.
      */

From f4745e6bddde387b3506ad30e629020c712f7781 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Fri, 10 Nov 2023 23:01:42 +0200
Subject: [PATCH 148/161] Guarded CTE column operator under C++20 aliases

This change has been made to align usage with C++20 aliases and avoid surprises when using them.
---
 dev/column_pointer.h                          | 29 ++---------
 examples/common_table_expressions.cpp         | 51 +++++++++----------
 include/sqlite_orm/sqlite_orm.h               | 29 ++---------
 tests/static_tests/column_expression_type.cpp |  3 +-
 tests/static_tests/column_result_t.cpp        |  1 -
 5 files changed, 35 insertions(+), 78 deletions(-)

diff --git a/dev/column_pointer.h b/dev/column_pointer.h
index 174315b3b..5e0fff740 100644
--- a/dev/column_pointer.h
+++ b/dev/column_pointer.h
@@ -92,20 +92,10 @@ namespace sqlite_orm {
      *  storage.with(cte<"z"_cte>()(select(&Object::id)), select(column<"z"_cte>(1_colalias)));
      */
     template<orm_cte_moniker auto moniker, class F>
-    constexpr auto column([[maybe_unused]] F field) {
-        using namespace ::sqlite_orm::internal;
+    constexpr auto column(F field) {
         using Moniker = std::remove_const_t<decltype(moniker)>;
-
-        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
-            static_assert(is_column_alias_v<type_t<F>>);
-            return column_pointer<Moniker, F>{{}};
-        } else if constexpr(is_column_alias_v<F>) {
-            return column_pointer<Moniker, alias_holder<F>>{{}};
-        } else {
-            return column_pointer<Moniker, F>{std::move(field)};
-        }
+        return column<Moniker>(std::forward<F>(field));
     }
-#endif
 
     /**
      *  Explicitly refer to a column mapped into a CTE or subquery.
@@ -116,19 +106,10 @@ namespace sqlite_orm {
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
      */
-    template<class Moniker, class F, internal::satisfies<internal::is_cte_moniker, Moniker> = true>
+    template<orm_cte_moniker Moniker, class F>
     constexpr auto operator->*(const Moniker& /*moniker*/, F field) {
-        using namespace ::sqlite_orm::internal;
-
-        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
-            static_assert(is_column_alias_v<type_t<F>>);
-            return column_pointer<Moniker, F>{{}};
-        } else if constexpr(is_column_alias_v<F>) {
-            return column_pointer<Moniker, alias_holder<F>>{{}};
-        } else {
-            return column_pointer<Moniker, F>{std::move(field)};
-        }
-        (void)field;
+        return column<Moniker>(std::forward<F>(field));
     }
 #endif
+#endif
 }
\ No newline at end of file
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 1f2c67b65..70d96e47f 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -618,11 +618,6 @@ void apfelmaennchen() {
     using cte_m = decltype(3_ctealias);
     using cte_m2 = decltype(4_ctealias);
     using cte_a = decltype(5_ctealias);
-    constexpr cte_xaxis xaxis{};
-    constexpr cte_yaxis yaxis{};
-    constexpr cte_m m{};
-    constexpr cte_m2 m2{};
-    constexpr cte_a a{};
     constexpr auto x = colalias_a{};
     constexpr auto y = colalias_b{};
     constexpr auto iter = colalias_c{};
@@ -631,21 +626,32 @@ void apfelmaennchen() {
     constexpr auto t = colalias_f{};
     auto ast = with_recursive(
         make_tuple(
-            cte<cte_xaxis>("x").as(union_all(select(-2.0 >>= x), select(xaxis->*x + 0.05, where(xaxis->*x < 1.2)))),
-            cte<cte_yaxis>("y").as(union_all(select(-1.0 >>= y), select(yaxis->*y + 0.10, where(yaxis->*y < 1.0)))),
+            cte<cte_xaxis>("x").as(
+                union_all(select(-2.0 >>= x), select(column<cte_xaxis>(x) + 0.05, where(column<cte_xaxis>(x) < 1.2)))),
+            cte<cte_yaxis>("y").as(
+                union_all(select(-1.0 >>= y), select(column<cte_yaxis>(y) + 0.10, where(column<cte_yaxis>(y) < 1.0)))),
             cte<cte_m>("iter", "cx", "cy", "x", "y")
-                .as(union_all(select(columns(0 >>= iter, xaxis->*x >>= cx, yaxis->*y >>= cy, 0.0 >>= x, 0.0 >>= y)),
-                              select(columns(m->*iter + 1,
-                                             m->*cx,
-                                             m->*cy,
-                                             m->*x * m->*x - m->*y * m->*y + m->*cx,
-                                             2.0 * m->*x * m->*y + m->*cy),
-                                     where((m->*x * m->*x + m->*y * m->*y) < 4.0 && m->*iter < 28)))),
+                .as(union_all(
+                    select(columns(0 >>= iter,
+                                   column<cte_xaxis>(x) >>= cx,
+                                   column<cte_yaxis>(y) >>= cy,
+                                   0.0 >>= x,
+                                   0.0 >>= y)),
+                    select(columns(column<cte_m>(iter) + 1,
+                                   column<cte_m>(cx),
+                                   column<cte_m>(cy),
+                                   column<cte_m>(x) * column<cte_m>(x) - column<cte_m>(y) * column<cte_m>(y) +
+                                       column<cte_m>(cx),
+                                   2.0 * column<cte_m>(x) * column<cte_m>(y) + column<cte_m>(cy)),
+                           where((column<cte_m>(x) * column<cte_m>(x) + column<cte_m>(y) * column<cte_m>(y)) < 4.0 &&
+                                 column<cte_m>(iter) < 28)))),
             cte<cte_m2>("iter", "cx", "cy")
-                .as(select(columns(max<>(m->*iter) >>= iter, m->*cx, m->*cy), group_by(m->*cx, m->*cy))),
-            cte<cte_a>("t").as(select(group_concat(substr(" .+*#", 1 + min<>(m2->*iter / 7.0, 4.0), 1), "") >>= t,
-                                      group_by(m2->*cy)))),
-        select(group_concat(rtrim(a->*t), "\n")));
+                .as(select(columns(max<>(column<cte_m>(iter)) >>= iter, column<cte_m>(cx), column<cte_m>(cy)),
+                           group_by(column<cte_m>(cx), column<cte_m>(cy)))),
+            cte<cte_a>("t").as(
+                select(group_concat(substr(" .+*#", 1 + min<>(column<cte_m2>(iter) / 7.0, 4.0), 1), "") >>= t,
+                       group_by(column<cte_m2>(cy))))),
+        select(group_concat(rtrim(column<cte_a>(t)), "\n")));
 #endif
 
     string sql = storage.dump(ast);
@@ -811,15 +817,6 @@ void show_mapping_and_backreferencing() {
         string sql = storage.dump(ast);
         auto stmt = storage.prepare(ast);
     }
-    // map column via alias_holder into cte,
-    // back-reference via `column_pointer<cte_1, alias_holder>`
-    {
-        auto ast = with(cte<cte_1>("x").as(union_all(select(as<cnt>(1)), select(cte_1{}->*cnt{} + 1, limit(10)))),
-                        select(cte_1{}->*cnt{}));
-
-        string sql = storage.dump(ast);
-        auto stmt = storage.prepare(ast);
-    }
 
     // implicitly remap column into cte
     {
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index f3e9a76f4..5665cdab8 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3326,20 +3326,10 @@ namespace sqlite_orm {
      *  storage.with(cte<"z"_cte>()(select(&Object::id)), select(column<"z"_cte>(1_colalias)));
      */
     template<orm_cte_moniker auto moniker, class F>
-    constexpr auto column([[maybe_unused]] F field) {
-        using namespace ::sqlite_orm::internal;
+    constexpr auto column(F field) {
         using Moniker = std::remove_const_t<decltype(moniker)>;
-
-        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
-            static_assert(is_column_alias_v<type_t<F>>);
-            return column_pointer<Moniker, F>{{}};
-        } else if constexpr(is_column_alias_v<F>) {
-            return column_pointer<Moniker, alias_holder<F>>{{}};
-        } else {
-            return column_pointer<Moniker, F>{std::move(field)};
-        }
+        return column<Moniker>(std::forward<F>(field));
     }
-#endif
 
     /**
      *  Explicitly refer to a column mapped into a CTE or subquery.
@@ -3350,21 +3340,12 @@ namespace sqlite_orm {
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
      *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
      */
-    template<class Moniker, class F, internal::satisfies<internal::is_cte_moniker, Moniker> = true>
+    template<orm_cte_moniker Moniker, class F>
     constexpr auto operator->*(const Moniker& /*moniker*/, F field) {
-        using namespace ::sqlite_orm::internal;
-
-        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
-            static_assert(is_column_alias_v<type_t<F>>);
-            return column_pointer<Moniker, F>{{}};
-        } else if constexpr(is_column_alias_v<F>) {
-            return column_pointer<Moniker, alias_holder<F>>{{}};
-        } else {
-            return column_pointer<Moniker, F>{std::move(field)};
-        }
-        (void)field;
+        return column<Moniker>(std::forward<F>(field));
     }
 #endif
+#endif
 }
 // #include "tags.h"
 
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index 5c26cb964..c955e78da 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -56,9 +56,8 @@ TEST_CASE("column_expression_of_t") {
                                  internal::make_cte_table(dbObjects, cte<cte_1>().as(select(columns(&Org::id, 1)))));
     using db_objects2_t = decltype(dbObjects2);
     runTest<db_objects_t, column_pointer<cte_1, int64 Org::*>>(column<cte_1>(&Org::id));
-    runTest<db_objects_t, column_pointer<cte_1, int64 Org::*>>(cte_1{}->*&Org::id);
     runTest<db_objects_t, column_pointer<cte_1, alias_holder<column_alias<'1'>>>>(column<cte_1>(1_colalias));
-    runTest<db_objects_t, column_pointer<cte_1, alias_holder<colalias_c>>>(1_ctealias->*colalias_c{});
+    runTest<db_objects_t, column_pointer<cte_1, alias_holder<colalias_c>>>(column<cte_1>(colalias_c{}));
     runTest<db_objects_t, alias_column_t<alias_a<cte_1>, column_pointer<cte_1, int64 Org::*>>>(
         alias_column<alias_a<cte_1>>(&Org::id));
     runTest<db_objects_t, alias_column_t<alias_a<cte_1>, column_pointer<cte_1, alias_holder<column_alias<'1'>>>>>(
diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
index b0561ef9f..901ba72d1 100644
--- a/tests/static_tests/column_result_t.cpp
+++ b/tests/static_tests/column_result_t.cpp
@@ -131,7 +131,6 @@ TEST_CASE("column_result_of_t") {
     runTest<db_objects_t, int>(column<cte_1>(&User::id));
     runTest<db_objects2_t, int>(column<cte_1>(1_colalias));
     runTest<db_objects2_t, int>(column<cte_1>(get<internal::column_alias<'1'>>()));
-    runTest<db_objects_t, int>(1_ctealias->*&User::id);
     runTest<db_objects_t, int>(alias_column<alias_a<cte_1>>(&User::id));
     runTest<db_objects2_t, int>(alias_column<alias_a<cte_1>>(1_colalias));
     runTest<db_objects2_t, std::tuple<int>>(asterisk<cte_1>());

From f6e1c97a8047df0b3ce292f6699b55a9a575d2b4 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sat, 11 Nov 2023 09:12:53 +0200
Subject: [PATCH 149/161] Corrected unit tests for table name collector

---
 tests/table_name_collector.cpp | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/tests/table_name_collector.cpp b/tests/table_name_collector.cpp
index 5f075f453..3a870392a 100644
--- a/tests/table_name_collector.cpp
+++ b/tests/table_name_collector.cpp
@@ -58,22 +58,21 @@ TEST_CASE("table name collector") {
         auto collector = internal::make_table_name_collector(context.db_objects);
 
         SECTION("CTE column") {
-            constexpr auto c = 1_ctealias;
-            auto expression = c->*&User::id;
-            expected.emplace(alias_extractor<decltype(c)>::extract(), "");
+            using cte_1 = decltype(1_ctealias);
+            auto expression = column<cte_1>(&User::id);
+            expected.emplace(alias_extractor<cte_1>::extract(), "");
             iterate_ast(expression, collector);
         }
         SECTION("CTE column alias") {
-            constexpr auto c = 1_ctealias;
-            auto expression = c->*1_colalias;
-            expected.emplace(alias_extractor<decltype(c)>::extract(), "");
+            using cte_1 = decltype(1_ctealias);
+            auto expression = column<cte_1>(1_colalias);
+            expected.emplace(alias_extractor<cte_1>::extract(), "");
             iterate_ast(expression, collector);
         }
         SECTION("CTE count asterisk") {
-            constexpr auto c = 1_ctealias;
             using cte_1 = decltype(1_ctealias);
             auto expression = count<cte_1>();
-            expected.emplace(alias_extractor<decltype(c)>::extract(), "");
+            expected.emplace(alias_extractor<cte_1>::extract(), "");
             iterate_ast(expression, collector);
         }
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES

From 6b0613da4ca5968fc2d214da48ab00f21b211b6c Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 12 Nov 2023 09:21:47 +0200
Subject: [PATCH 150/161] Uniform syntax for column pointer expressions through
 table references

---
 dev/alias.h                                   |   4 +-
 dev/alias_traits.h                            | 253 ++++++++------
 dev/column_pointer.h                          |  44 ++-
 dev/conditions.h                              |  29 +-
 dev/core_functions.h                          |  10 +-
 dev/mapped_type_proxy.h                       |   9 +-
 dev/prepared_statement.h                      |  31 +-
 dev/select_constraints.h                      |  11 +-
 dev/storage.h                                 | 137 +++++---
 dev/table_type_of.h                           |   2 +
 examples/column_aliases.cpp                   |  27 +-
 include/sqlite_orm/sqlite_orm.h               | 316 +++++++++++++-----
 tests/CMakeLists.txt                          |   1 +
 tests/builtin_tables.cpp                      |   6 +
 tests/prepared_statement_tests/get_all.cpp    |   8 +-
 .../aggregate_functions.cpp                   |   8 +
 .../select_constraints.cpp                    |   6 +
 tests/static_tests/alias.cpp                  |  35 ++
 tests/static_tests/column_expression_type.cpp |   5 +
 tests/static_tests/column_pointer.cpp         | 119 +++++++
 tests/tests.cpp                               |   3 -
 21 files changed, 772 insertions(+), 292 deletions(-)
 create mode 100644 tests/static_tests/column_pointer.cpp

diff --git a/dev/alias.h b/dev/alias.h
index f307f30a6..1a5b08de6 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -329,8 +329,8 @@ namespace sqlite_orm {
      */
     template<orm_table_alias A, class C>
         requires(orm_cte_moniker<internal::type_t<A>>)
-    constexpr auto operator->*(const A& /*tableAlias*/, C field) {
-        return alias_column<A>(std::move(field));
+    constexpr auto operator->*(const A& /*tableAlias*/, C c) {
+        return alias_column<A>(std::move(c));
     }
 
     /**
diff --git a/dev/alias_traits.h b/dev/alias_traits.h
index 2d4874a83..3d6513abd 100644
--- a/dev/alias_traits.h
+++ b/dev/alias_traits.h
@@ -1,109 +1,144 @@
-#pragma once
-
-#include <type_traits>  //  std::remove_const, std::is_base_of, std::is_same
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-#include <concepts>
-#endif
-
-#include "functional/cxx_universal.h"
-#include "functional/cxx_type_traits_polyfill.h"
-#include "type_traits.h"
-
-namespace sqlite_orm {
-
-    /** @short Base class for a custom table alias, column alias or expression alias.
-     */
-    struct alias_tag {};
-
-    namespace internal {
-
-        template<class A>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_alias_v = std::is_base_of<alias_tag, A>::value;
-
-        template<class A>
-        using is_alias = polyfill::bool_constant<is_alias_v<A>>;
-
-        /** @short Alias of a column in a record set, see `orm_column_alias`.
-         */
-        template<class A>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_column_alias_v =
-            polyfill::conjunction_v<is_alias<A>, polyfill::negation<polyfill::is_detected<type_t, A>>>;
-
-        template<class A>
-        using is_column_alias = is_alias<A>;
-
-        /** @short Alias of any type of record set, see `orm_recordset_alias`.
-         */
-        template<class A>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_recordset_alias_v =
-            polyfill::conjunction_v<is_alias<A>, polyfill::is_detected<type_t, A>>;
-
-        template<class A>
-        using is_recordset_alias = polyfill::bool_constant<is_recordset_alias_v<A>>;
-
-        /** @short Alias of a concrete table, see `orm_table_alias`.
-         */
-        template<class A>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_table_alias_v = polyfill::conjunction_v<
-            is_recordset_alias<A>,
-            polyfill::negation<std::is_same<polyfill::detected_t<type_t, A>, std::remove_const_t<A>>>>;
-
-        template<class A>
-        using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
-
-        /** @short Alias of a CTE, see `orm_cte_moniker`.
-         */
-        template<class A>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_cte_moniker_v =
-#ifdef SQLITE_ORM_WITH_CTE
-            polyfill::conjunction_v<is_recordset_alias<A>,
-                                    std::is_same<polyfill::detected_t<type_t, A>, std::remove_const_t<A>>>;
-#else
-            false;
-#endif
-
-        template<class A>
-        using is_cte_moniker = polyfill::bool_constant<is_cte_moniker_v<A>>;
-    }
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    template<class A>
-    concept orm_alias = std::derived_from<A, alias_tag>;
-
-    /** @short Alias of a column in a record set.
-     *
-     *  A column alias has the following traits:
-     *  - is derived from `alias_tag`
-     *  - must not have a nested `type` typename
-     */
-    template<class A>
-    concept orm_column_alias = (orm_alias<A> && !orm_names_type<A>);
-
-    /** @short Alias of any type of record set.
-     *
-     *  A record set alias has the following traits:
-     *  - is derived from `alias_tag`.
-     *  - has a nested `type` typename, which refers to a mapped object.
-     */
-    template<class A>
-    concept orm_recordset_alias = (orm_alias<A> && orm_names_type<A>);
-
-    /** @short Alias of a concrete table.
-     *
-     *  A concrete table alias has the following traits:
-     *  - is derived from `alias_tag`.
-     *  - has a `type` typename, which refers to another mapped object (i.e. doesn't refer to itself).
-     */
-    template<class A>
-    concept orm_table_alias = (orm_recordset_alias<A> && !std::same_as<typename A::type, std::remove_const_t<A>>);
-
-    /** @short Moniker of a CTE.
-     *
-     *  A CTE moniker has the following traits:
-     *  - is derived from `alias_tag`.
-     *  - has a `type` typename, which refers to itself.
-     */
-    template<class A>
-    concept orm_cte_moniker = (orm_recordset_alias<A> && std::same_as<typename A::type, std::remove_const_t<A>>);
-#endif
-}
+#pragma once
+
+#include <type_traits>  //  std::remove_const, std::is_base_of, std::is_same, std::type_identity
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+#include <concepts>
+#endif
+
+#include "functional/cxx_universal.h"
+#include "functional/cxx_type_traits_polyfill.h"
+#include "type_traits.h"
+
+namespace sqlite_orm {
+
+    /** @short Base class for a custom table alias, column alias or expression alias.
+     */
+    struct alias_tag {};
+
+    namespace internal {
+
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_alias_v = std::is_base_of<alias_tag, A>::value;
+
+        template<class A>
+        using is_alias = polyfill::bool_constant<is_alias_v<A>>;
+
+        /** @short Alias of a column in a record set, see `orm_column_alias`.
+         */
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_column_alias_v =
+            polyfill::conjunction_v<is_alias<A>, polyfill::negation<polyfill::is_detected<type_t, A>>>;
+
+        template<class A>
+        using is_column_alias = is_alias<A>;
+
+        /** @short Alias of any type of record set, see `orm_recordset_alias`.
+         */
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_recordset_alias_v =
+            polyfill::conjunction_v<is_alias<A>, polyfill::is_detected<type_t, A>>;
+
+        template<class A>
+        using is_recordset_alias = polyfill::bool_constant<is_recordset_alias_v<A>>;
+
+        /** @short Alias of a concrete table, see `orm_table_alias`.
+         */
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_table_alias_v = polyfill::conjunction_v<
+            is_recordset_alias<A>,
+            polyfill::negation<std::is_same<polyfill::detected_t<type_t, A>, std::remove_const_t<A>>>>;
+
+        template<class A>
+        using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        /*
+         *  Identity wrapper around a mapped object, facilitating uniform column pointer expressions.
+         */
+        template<class O>
+        struct table_reference : std::type_identity<O> {};
+
+        template<class RecordSet>
+        struct decay_table_reference : std::remove_const<RecordSet> {};
+        template<class O>
+        struct decay_table_reference<table_reference<O>> : std::type_identity<O> {};
+        template<class O>
+        struct decay_table_reference<const table_reference<O>> : std::type_identity<O> {};
+
+        template<auto recordset>
+        using decay_table_reference_t = typename decay_table_reference<decltype(recordset)>::type;
+#endif
+
+        /** @short Moniker of a CTE, see `orm_cte_moniker`.
+         */
+        template<class A>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_cte_moniker_v =
+#ifdef SQLITE_ORM_WITH_CTE
+            polyfill::conjunction_v<is_recordset_alias<A>,
+                                    std::is_same<polyfill::detected_t<type_t, A>, std::remove_const_t<A>>>;
+#else
+            false;
+#endif
+
+        template<class A>
+        using is_cte_moniker = polyfill::bool_constant<is_cte_moniker_v<A>>;
+    }
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    template<class A>
+    concept orm_alias = std::derived_from<A, alias_tag>;
+
+    /** @short Alias of a column in a record set.
+     *
+     *  A column alias has the following traits:
+     *  - is derived from `alias_tag`
+     *  - must not have a nested `type` typename
+     */
+    template<class A>
+    concept orm_column_alias = (orm_alias<A> && !orm_names_type<A>);
+
+    /** @short Alias of any type of record set.
+     *
+     *  A record set alias has the following traits:
+     *  - is derived from `alias_tag`.
+     *  - has a nested `type` typename, which refers to a mapped object.
+     */
+    template<class A>
+    concept orm_recordset_alias = (orm_alias<A> && orm_names_type<A>);
+
+    /** @short Alias of a concrete table.
+     *
+     *  A concrete table alias has the following traits:
+     *  - is derived from `alias_tag`.
+     *  - has a `type` typename, which refers to another mapped object (i.e. doesn't refer to itself).
+     */
+    template<class A>
+    concept orm_table_alias = (orm_recordset_alias<A> && !std::same_as<typename A::type, std::remove_const_t<A>>);
+
+    /** @short Reference of a concrete table, especially of a derived class.
+     *
+     *  A concrete table reference has the following traits:
+     *  - specialization of `table_reference`, whose `type` typename references a mapped object.
+     */
+    template<class R>
+    concept orm_table_reference = polyfill::is_specialization_of_v<std::remove_const_t<R>, internal::table_reference>;
+
+    /** @short Moniker of a CTE.
+     *
+     *  A CTE moniker has the following traits:
+     *  - is derived from `alias_tag`.
+     *  - has a `type` typename, which refers to itself.
+     */
+    template<class A>
+    concept orm_cte_moniker = (orm_recordset_alias<A> && std::same_as<typename A::type, std::remove_const_t<A>>);
+
+    template<class T>
+    concept orm_refers_to_table = (orm_table_reference<T> || orm_table_alias<T>);
+
+    template<class T>
+    concept orm_refers_to_recordset = (orm_table_reference<T> || orm_recordset_alias<T>);
+
+    template<class T>
+    concept orm_mapped_recordset = (orm_table_reference<T> || orm_cte_moniker<T>);
+#endif
+}
diff --git a/dev/column_pointer.h b/dev/column_pointer.h
index 5e0fff740..56bd59839 100644
--- a/dev/column_pointer.h
+++ b/dev/column_pointer.h
@@ -47,11 +47,49 @@ namespace sqlite_orm {
      *  struct MyType : BaseType { ... };
      *  storage.select(column<MyType>(&BaseType::id));
      */
-    template<class Object, class F, internal::satisfies_not<internal::is_recordset_alias, Object> = true>
-    constexpr internal::column_pointer<Object, F> column(F field) {
-        return {std::move(field)};
+    template<class Object, class F, class O, internal::satisfies_not<internal::is_recordset_alias, Object> = true>
+    constexpr internal::column_pointer<Object, F O::*> column(F O::*field) {
+        static_assert(internal::is_field_of_v<F O::*, Object>, "Column must be from derived class");
+        return {field};
     }
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Explicitly refer to a column.
+     */
+    template<orm_table_reference auto table, class O, class F>
+    constexpr auto column(F O::*field) {
+        using R = std::remove_const_t<decltype(table)>;
+        return column<typename R::type>(field);
+    }
+
+    /**
+     *  Explicitly refer to a column.
+     */
+    template<orm_table_reference R, class O, class F>
+    constexpr auto operator->*(const R& /*table*/, F O::*field) {
+        return column<typename R::type>(field);
+    }
+
+    /**
+     *  Make table reference.
+     */
+    template<class O>
+        requires(!orm_recordset_alias<O>)
+    constexpr internal::table_reference<O> column() {
+        return {};
+    }
+
+    /**
+     *  Make table reference.
+     */
+    template<class O>
+        requires(!orm_recordset_alias<O>)
+    constexpr internal::table_reference<O> c() {
+        return {};
+    }
+#endif
+
 #ifdef SQLITE_ORM_WITH_CTE
     /**
      *  Explicitly refer to a column alias mapped into a CTE or subquery.
diff --git a/dev/conditions.h b/dev/conditions.h
index 6cd5c300a..043d6dd25 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -834,10 +834,9 @@ namespace sqlite_orm {
      *  Explicit FROM function. Usage:
      *  `storage.select(&User::id, from<"a"_alias.for_<User>>());`
      */
-    template<orm_recordset_alias auto... tables>
+    template<orm_refers_to_recordset auto... recordsets>
     auto from() {
-        static_assert(sizeof...(tables) > 0);
-        return internal::from_t<std::remove_const_t<decltype(tables)>...>{};
+        return from<internal::decay_table_reference_t<recordsets>...>();
     }
 #endif
 
@@ -954,12 +953,12 @@ namespace sqlite_orm {
     }
 
     template<class F, class O>
-    internal::using_t<O, F O::*> using_(F O::*p) {
-        return {p};
+    internal::using_t<O, F O::*> using_(F O::*field) {
+        return {field};
     }
     template<class T, class M>
-    internal::using_t<T, M> using_(internal::column_pointer<T, M> cp) {
-        return {std::move(cp)};
+    internal::using_t<T, M> using_(internal::column_pointer<T, M> field) {
+        return {std::move(field)};
     }
 
     template<class T>
@@ -983,9 +982,9 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    template<orm_recordset_alias auto alias, class On>
+    template<orm_refers_to_recordset auto alias, class On>
     auto left_join(On on) {
-        return internal::left_join_t<std::remove_const_t<decltype(alias)>, On>{std::move(on)};
+        return left_join<internal::decay_table_reference_t<alias>, On>(std::move(on));
     }
 #endif
 
@@ -995,9 +994,9 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    template<orm_recordset_alias auto alias, class On>
+    template<orm_refers_to_recordset auto alias, class On>
     auto join(On on) {
-        return internal::join_t<std::remove_const_t<decltype(alias)>, On>{std::move(on)};
+        return join<internal::decay_table_reference_t<alias>, On>(std::move(on));
     }
 #endif
 
@@ -1007,9 +1006,9 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    template<orm_recordset_alias auto alias, class On>
+    template<orm_refers_to_recordset auto alias, class On>
     auto left_outer_join(On on) {
-        return internal::left_outer_join_t<std::remove_const_t<decltype(alias)>, On>{std::move(on)};
+        return left_outer_join<internal::decay_table_reference_t<alias>, On>(std::move(on));
     }
 #endif
 
@@ -1019,9 +1018,9 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    template<orm_recordset_alias auto alias, class On>
+    template<orm_refers_to_recordset auto alias, class On>
     auto inner_join(On on) {
-        return internal::inner_join_t<std::remove_const_t<decltype(alias)>, On>{std::move(on)};
+        return inner_join<internal::decay_table_reference_t<alias>, On>(std::move(on));
     }
 #endif
 
diff --git a/dev/core_functions.h b/dev/core_functions.h
index 8f1991488..f5f2905fd 100644
--- a/dev/core_functions.h
+++ b/dev/core_functions.h
@@ -1845,17 +1845,15 @@ namespace sqlite_orm {
         return {};
     }
 
-#ifdef SQLITE_ORM_WITH_CTE
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
-     *  COUNT(*) with FROM function. Specified cte moniker will be serialized as
+     *  COUNT(*) with FROM function. Specified recordset will be serialized as
      *  a from argument.
      */
-    template<orm_cte_moniker auto moniker>
-    internal::count_asterisk_t<std::remove_const_t<decltype(moniker)>> count() {
-        return {};
+    template<orm_refers_to_recordset auto mapped>
+    auto count() {
+        return count<internal::decay_table_reference_t<mapped>>();
     }
-#endif
 #endif
 
     /**
diff --git a/dev/mapped_type_proxy.h b/dev/mapped_type_proxy.h
index fd914d0b7..dca68216d 100644
--- a/dev/mapped_type_proxy.h
+++ b/dev/mapped_type_proxy.h
@@ -16,8 +16,13 @@ namespace sqlite_orm {
         template<class T, class SFINAE = void>
         struct mapped_type_proxy : std::remove_const<T> {};
 
-        template<class T>
-        struct mapped_type_proxy<T, match_if<is_recordset_alias, T>> : std::remove_const<type_t<T>> {};
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        template<orm_table_reference R>
+        struct mapped_type_proxy<R, void> : R {};
+#endif
+
+        template<class A>
+        struct mapped_type_proxy<A, match_if<is_recordset_alias, A>> : std::remove_const<type_t<A>> {};
 
         template<class T>
         using mapped_type_proxy_t = typename mapped_type_proxy<T>::type;
diff --git a/dev/prepared_statement.h b/dev/prepared_statement.h
index 0fd9f1b45..50e309996 100644
--- a/dev/prepared_statement.h
+++ b/dev/prepared_statement.h
@@ -616,10 +616,21 @@ namespace sqlite_orm {
      */
     template<class T, class... Ids>
     internal::get_t<T, Ids...> get(Ids... ids) {
-        std::tuple<Ids...> idsTuple{std::forward<Ids>(ids)...};
-        return {std::move(idsTuple)};
+        return {{std::forward<Ids>(ids)...}};
     }
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Create a get statement.
+     *  T is an object type mapped to a storage.
+     *  Usage: get<User>(5);
+     */
+    template<orm_table_reference auto als, class... Ids>
+    auto get(Ids... ids) {
+        return get<internal::mapped_type_proxy_t<decltype(als)>>(std::forward<Ids>(ids)...);
+    }
+#endif
+
     /**
      *  Create a get pointer statement.
      *  T is an object type mapped to a storage.
@@ -627,8 +638,7 @@ namespace sqlite_orm {
      */
     template<class T, class... Ids>
     internal::get_pointer_t<T, Ids...> get_pointer(Ids... ids) {
-        std::tuple<Ids...> idsTuple{std::forward<Ids>(ids)...};
-        return {std::move(idsTuple)};
+        return {{std::forward<Ids>(ids)...}};
     }
 
 #ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
@@ -639,8 +649,7 @@ namespace sqlite_orm {
      */
     template<class T, class... Ids>
     internal::get_optional_t<T, Ids...> get_optional(Ids... ids) {
-        std::tuple<Ids...> idsTuple{std::forward<Ids>(ids)...};
-        return {std::move(idsTuple)};
+        return {{std::forward<Ids>(ids)...}};
     }
 #endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
 
@@ -673,17 +682,15 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
      *  Create a get all statement.
-     *  `alias` is an explicitly specified table alias of an object to be extracted.
+     *  `als` is an explicitly specified table proxy of an object to be extracted.
      *  `R` is the container return type, which must have a `R::push_back(T&&)` method, and defaults to `std::vector<T>`
      *  Usage: storage.get_all<sqlite_schema>(...);
      */
-    template<orm_table_alias auto alias,
-             class R = std::vector<internal::mapped_type_proxy_t<decltype(alias)>>,
+    template<orm_refers_to_table auto als,
+             class R = std::vector<internal::mapped_type_proxy_t<decltype(als)>>,
              class... Args>
     auto get_all(Args&&... conditions) {
-        using expression_type = internal::get_all_t<std::remove_const_t<decltype(alias)>, R, std::decay_t<Args>...>;
-        internal::validate_conditions<typename expression_type::conditions_type>();
-        return expression_type{{std::forward<Args>(conditions)...}};
+        return get_all<internal::decay_table_reference_t<als>, R>(std::forward<Args>(conditions)...);
     }
 #endif
 
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 7d11614b9..983b7d406 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -727,9 +727,9 @@ namespace sqlite_orm {
      *  auto reportingTo = 
      *      storage.select(asterisk<m>(), inner_join<m>(on(m->*&Employee::reportsTo == &Employee::employeeId)));
      */
-    template<orm_recordset_alias auto alias>
+    template<orm_refers_to_recordset auto recordset>
     auto asterisk(bool definedOrder = false) {
-        return internal::asterisk_t<std::remove_const_t<decltype(alias)>>{definedOrder};
+        return asterisk<internal::decay_table_reference_t<recordset>>(definedOrder);
     }
 #endif
 
@@ -748,4 +748,11 @@ namespace sqlite_orm {
     internal::object_t<T> object(bool definedOrder = false) {
         return {definedOrder};
     }
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    template<orm_refers_to_table auto als>
+    auto object(bool definedOrder = false) {
+        return object<internal::decay_table_reference_t<als>>(definedOrder);
+    }
+#endif
 }
diff --git a/dev/storage.h b/dev/storage.h
index 84dfa9a77..037c93c84 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -322,18 +322,18 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
             /**
              *  SELECT * routine.
-             *  `alias` is an explicitly specified table alias of an object to be extracted.
+             *  `als` is an explicitly specified table proxy of an object to be extracted.
              *  `R` is the container return type, which must have a `R::push_back(O&&)` method, and defaults to `std::vector<O>`
              *  @return All objects stored in database.
              *  @example: storage.get_all<sqlite_schema, std::list<sqlite_master>>(); - SELECT sqlite_schema.* FROM sqlite_master AS sqlite_schema
             */
-            template<orm_table_alias auto alias,
-                     class R = std::vector<mapped_type_proxy_t<decltype(alias)>>,
+            template<orm_refers_to_table auto als,
+                     class R = std::vector<mapped_type_proxy_t<decltype(als)>>,
                      class... Args>
             R get_all(Args&&... args) {
-                using A = decltype(alias);
+                using A = decltype(als);
                 this->assert_mapped_type<mapped_type_proxy_t<A>>();
-                auto statement = this->prepare(sqlite_orm::get_all<alias, R>(std::forward<Args>(args)...));
+                auto statement = this->prepare(sqlite_orm::get_all<als, R>(std::forward<Args>(args)...));
                 return this->execute(statement);
             }
 #endif
@@ -385,6 +385,13 @@ namespace sqlite_orm {
                 return this->execute(statement);
             }
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+            template<orm_table_reference auto mapped, class... Ids>
+            auto get(Ids... ids) {
+                return this->get<decay_table_reference_t<mapped>>(std::forward<Ids>(ids)...);
+            }
+#endif
+
             /**
              *  The same as `get` function but doesn't throw an exception if noting found but returns std::unique_ptr
              * with null value. throws std::system_error in case of db error.
@@ -431,8 +438,9 @@ namespace sqlite_orm {
              *  SELECT COUNT(*) https://www.sqlite.org/lang_aggfunc.html#count
              *  @return Number of O object in table.
              */
-            template<class O, class... Args, class R = mapped_type_proxy_t<O>>
+            template<class O, class... Args>
             int count(Args&&... args) {
+                using R = mapped_type_proxy_t<O>;
                 this->assert_mapped_type<R>();
                 auto rows = this->select(sqlite_orm::count<R>(), std::forward<Args>(args)...);
                 if(!rows.empty()) {
@@ -442,15 +450,25 @@ namespace sqlite_orm {
                 }
             }
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+            template<orm_refers_to_recordset auto mapped, class... Args>
+            int count(Args&&... args) {
+                return this->count<decay_table_reference_t<mapped>>(std::forward<Args>(args)...);
+            }
+#endif
+
             /**
              *  SELECT COUNT(X) https://www.sqlite.org/lang_aggfunc.html#count
              *  @param m member pointer to class mapped to the storage.
              *  @return count of `m` values from database.
              */
-            template<class F, class O, class... Args>
-            int count(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::count(m), std::forward<Args>(args)...);
+            template<
+                class F,
+                class... Args,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            int count(F field, Args&&... args) {
+                this->assert_mapped_type<table_type_of_t<F>>();
+                auto rows = this->select(sqlite_orm::count(std::move(field)), std::forward<Args>(args)...);
                 if(!rows.empty()) {
                     return rows.front();
                 } else {
@@ -463,10 +481,13 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return average value from database.
              */
-            template<class F, class O, class... Args>
-            double avg(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::avg(m), std::forward<Args>(args)...);
+            template<
+                class F,
+                class... Args,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            double avg(F field, Args&&... args) {
+                this->assert_mapped_type<table_type_of_t<F>>();
+                auto rows = this->select(sqlite_orm::avg(std::move(field)), std::forward<Args>(args)...);
                 if(!rows.empty()) {
                     return rows.front();
                 } else {
@@ -474,9 +495,11 @@ namespace sqlite_orm {
                 }
             }
 
-            template<class F, class O>
-            std::string group_concat(F O::*m) {
-                return this->group_concat_internal(m, {});
+            template<
+                class F,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            std::string group_concat(F field) {
+                return this->group_concat_internal(std::move(field), {});
             }
 
             /**
@@ -484,13 +507,14 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return group_concat query result.
              */
-            template<class F,
-                     class O,
-                     class... Args,
-                     class Tuple = std::tuple<Args...>,
-                     std::enable_if_t<std::tuple_size<Tuple>::value >= 1, bool> = true>
-            std::string group_concat(F O::*m, Args&&... args) {
-                return this->group_concat_internal(m, {}, std::forward<Args>(args)...);
+            template<
+                class F,
+                class... Args,
+                class Tuple = std::tuple<Args...>,
+                std::enable_if_t<std::tuple_size<Tuple>::value >= 1, bool> = true,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            std::string group_concat(F field, Args&&... args) {
+                return this->group_concat_internal(std::move(field), {}, std::forward<Args>(args)...);
             }
 
             /**
@@ -498,22 +522,28 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return group_concat query result.
              */
-            template<class F, class O, class... Args>
-            std::string group_concat(F O::*m, std::string y, Args&&... args) {
-                return this->group_concat_internal(m,
+            template<
+                class F,
+                class... Args,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            std::string group_concat(F field, std::string y, Args&&... args) {
+                return this->group_concat_internal(std::move(field),
                                                    std::make_unique<std::string>(std::move(y)),
                                                    std::forward<Args>(args)...);
             }
 
-            template<class F, class O, class... Args>
-            std::string group_concat(F O::*m, const char* y, Args&&... args) {
+            template<
+                class F,
+                class... Args,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            std::string group_concat(F field, const char* y, Args&&... args) {
                 std::unique_ptr<std::string> str;
                 if(y) {
                     str = std::make_unique<std::string>(y);
                 } else {
                     str = std::make_unique<std::string>();
                 }
-                return this->group_concat_internal(m, std::move(str), std::forward<Args>(args)...);
+                return this->group_concat_internal(std::move(field), std::move(str), std::forward<Args>(args)...);
             }
 
             /**
@@ -521,10 +551,14 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return std::unique_ptr with max value or null if sqlite engine returned null.
              */
-            template<class F, class O, class... Args, class Ret = column_result_of_t<db_objects_type, F O::*>>
-            std::unique_ptr<Ret> max(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::max(m), std::forward<Args>(args)...);
+            template<
+                class F,
+                class... Args,
+                class Ret = column_result_of_t<db_objects_type, F>,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            std::unique_ptr<Ret> max(F field, Args&&... args) {
+                this->assert_mapped_type<table_type_of_t<F>>();
+                auto rows = this->select(sqlite_orm::max(std::move(field)), std::forward<Args>(args)...);
                 if(!rows.empty()) {
                     return std::move(rows.front());
                 } else {
@@ -537,10 +571,14 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return std::unique_ptr with min value or null if sqlite engine returned null.
              */
-            template<class F, class O, class... Args, class Ret = column_result_of_t<db_objects_type, F O::*>>
-            std::unique_ptr<Ret> min(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::min(m), std::forward<Args>(args)...);
+            template<
+                class F,
+                class... Args,
+                class Ret = column_result_of_t<db_objects_type, F>,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            std::unique_ptr<Ret> min(F field, Args&&... args) {
+                this->assert_mapped_type<table_type_of_t<F>>();
+                auto rows = this->select(sqlite_orm::min(std::move(field)), std::forward<Args>(args)...);
                 if(!rows.empty()) {
                     return std::move(rows.front());
                 } else {
@@ -553,11 +591,15 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return std::unique_ptr with sum value or null if sqlite engine returned null.
              */
-            template<class F, class O, class... Args, class Ret = column_result_of_t<db_objects_type, F O::*>>
-            std::unique_ptr<Ret> sum(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
+            template<
+                class F,
+                class... Args,
+                class Ret = column_result_of_t<db_objects_type, F>,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            std::unique_ptr<Ret> sum(F field, Args&&... args) {
+                this->assert_mapped_type<table_type_of_t<F>>();
                 std::vector<std::unique_ptr<double>> rows =
-                    this->select(sqlite_orm::sum(m), std::forward<Args>(args)...);
+                    this->select(sqlite_orm::sum(std::move(field)), std::forward<Args>(args)...);
                 if(!rows.empty()) {
                     if(rows.front()) {
                         return std::make_unique<Ret>(std::move(*rows.front()));
@@ -575,10 +617,13 @@ namespace sqlite_orm {
              *  @return total value (the same as SUM but not nullable. More details here
              * https://www.sqlite.org/lang_aggfunc.html)
              */
-            template<class F, class O, class... Args>
-            double total(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::total(m), std::forward<Args>(args)...);
+            template<
+                class F,
+                class... Args,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            double total(F field, Args&&... args) {
+                this->assert_mapped_type<table_type_of_t<F>>();
+                auto rows = this->select(sqlite_orm::total(std::move(field)), std::forward<Args>(args)...);
                 if(!rows.empty()) {
                     return std::move(rows.front());
                 } else {
diff --git a/dev/table_type_of.h b/dev/table_type_of.h
index 32fab610f..5061b4815 100644
--- a/dev/table_type_of.h
+++ b/dev/table_type_of.h
@@ -20,6 +20,8 @@ namespace sqlite_orm {
          *  -   `table_type_of<decltype(&User::id)>::type` is `User`
          *  -   `table_type_of<decltype(&User::getName)>::type` is `User`
          *  -   `table_type_of<decltype(&User::setName)>::type` is `User`
+         *  -   `table_type_of<decltype(column<User>(&User::id))>::type` is `User`
+         *  -   `table_type_of<decltype(derived->*&User::id)>::type` is `User`
          */
         template<class T>
         struct table_type_of;
diff --git a/examples/column_aliases.cpp b/examples/column_aliases.cpp
index 1cba0a2b1..fc52e26f6 100644
--- a/examples/column_aliases.cpp
+++ b/examples/column_aliases.cpp
@@ -66,7 +66,7 @@ void marvel_hero_ordered_by_o_pos() {
         //  WHERE i > 0
         //  ORDER BY i
         auto rows = storage.select(columns(&MarvelHero::name, as<i>(instr(&MarvelHero::abilities, "o"))),
-                                   where(i > c(0)),
+                                   where(i > 0),
                                    order_by(i));
         for(auto& row: rows) {
             cout << get<0>(row) << '\t' << get<1>(row) << '\n';
@@ -86,9 +86,34 @@ void marvel_hero_ordered_by_o_pos() {
     cout << endl;
 }
 
+void cpp20_column_pointer() {
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    struct Result {
+        int64 id;
+        time_t stamp;
+    };
+
+    struct LastResult : Result {};
+    constexpr auto last_result = c<LastResult>();
+
+    auto storage = make_storage(
+        "",
+        make_table("result", make_column("id", &Result::id, primary_key()), make_column("stamp", &Result::stamp)),
+        make_table<LastResult>("last_result",
+                               make_column("id", &LastResult::id, primary_key()),
+                               make_column("stamp", &LastResult::stamp)));
+    storage.sync_schema();
+
+    //  SELECT "last_result"."id", "last_result"."stamp" FROM "last_result"
+    std::string sql = storage.dump(select(columns(last_result->*&LastResult::id, last_result->*&LastResult::stamp)));
+    cout << sql << endl;
+#endif
+}
+
 int main() {
     try {
         marvel_hero_ordered_by_o_pos();
+        cpp20_column_pointer();
     } catch(const system_error& e) {
         cout << "[" << e.code() << "] " << e.what();
     }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index eaf6ceed4..70e2acb6c 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -1387,6 +1387,8 @@ namespace sqlite_orm {
          *  -   `table_type_of<decltype(&User::id)>::type` is `User`
          *  -   `table_type_of<decltype(&User::getName)>::type` is `User`
          *  -   `table_type_of<decltype(&User::setName)>::type` is `User`
+         *  -   `table_type_of<decltype(column<User>(&User::id))>::type` is `User`
+         *  -   `table_type_of<decltype(derived->*&User::id)>::type` is `User`
          */
         template<class T>
         struct table_type_of;
@@ -3023,7 +3025,7 @@ namespace sqlite_orm {
 
 // #include "alias_traits.h"
 
-#include <type_traits>  //  std::remove_const, std::is_base_of, std::is_same
+#include <type_traits>  //  std::remove_const, std::is_base_of, std::is_same, std::type_identity
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
 #include <concepts>
 #endif
@@ -3076,7 +3078,25 @@ namespace sqlite_orm {
         template<class A>
         using is_table_alias = polyfill::bool_constant<is_table_alias_v<A>>;
 
-        /** @short Alias of a CTE, see `orm_cte_moniker`.
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        /*
+         *  Identity wrapper around a mapped object, facilitating uniform column pointer expressions.
+         */
+        template<class O>
+        struct table_reference : std::type_identity<O> {};
+
+        template<class RecordSet>
+        struct decay_table_reference : std::remove_const<RecordSet> {};
+        template<class O>
+        struct decay_table_reference<table_reference<O>> : std::type_identity<O> {};
+        template<class O>
+        struct decay_table_reference<const table_reference<O>> : std::type_identity<O> {};
+
+        template<auto recordset>
+        using decay_table_reference_t = typename decay_table_reference<decltype(recordset)>::type;
+#endif
+
+        /** @short Moniker of a CTE, see `orm_cte_moniker`.
          */
         template<class A>
         SQLITE_ORM_INLINE_VAR constexpr bool is_cte_moniker_v =
@@ -3122,6 +3142,14 @@ namespace sqlite_orm {
     template<class A>
     concept orm_table_alias = (orm_recordset_alias<A> && !std::same_as<typename A::type, std::remove_const_t<A>>);
 
+    /** @short Reference of a concrete table, especially of a derived class.
+     *
+     *  A concrete table reference has the following traits:
+     *  - specialization of `table_reference`, whose `type` typename references a mapped object.
+     */
+    template<class R>
+    concept orm_table_reference = polyfill::is_specialization_of_v<std::remove_const_t<R>, internal::table_reference>;
+
     /** @short Moniker of a CTE.
      *
      *  A CTE moniker has the following traits:
@@ -3130,6 +3158,15 @@ namespace sqlite_orm {
      */
     template<class A>
     concept orm_cte_moniker = (orm_recordset_alias<A> && std::same_as<typename A::type, std::remove_const_t<A>>);
+
+    template<class T>
+    concept orm_refers_to_table = (orm_table_reference<T> || orm_table_alias<T>);
+
+    template<class T>
+    concept orm_refers_to_recordset = (orm_table_reference<T> || orm_recordset_alias<T>);
+
+    template<class T>
+    concept orm_mapped_recordset = (orm_table_reference<T> || orm_cte_moniker<T>);
 #endif
 }
 
@@ -3281,11 +3318,49 @@ namespace sqlite_orm {
      *  struct MyType : BaseType { ... };
      *  storage.select(column<MyType>(&BaseType::id));
      */
-    template<class Object, class F, internal::satisfies_not<internal::is_recordset_alias, Object> = true>
-    constexpr internal::column_pointer<Object, F> column(F field) {
-        return {std::move(field)};
+    template<class Object, class F, class O, internal::satisfies_not<internal::is_recordset_alias, Object> = true>
+    constexpr internal::column_pointer<Object, F O::*> column(F O::*field) {
+        static_assert(internal::is_field_of_v<F O::*, Object>, "Column must be from derived class");
+        return {field};
     }
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Explicitly refer to a column.
+     */
+    template<orm_table_reference auto table, class O, class F>
+    constexpr auto column(F O::*field) {
+        using R = std::remove_const_t<decltype(table)>;
+        return column<typename R::type>(field);
+    }
+
+    /**
+     *  Explicitly refer to a column.
+     */
+    template<orm_table_reference R, class O, class F>
+    constexpr auto operator->*(const R& /*table*/, F O::*field) {
+        return column<typename R::type>(field);
+    }
+
+    /**
+     *  Make table reference.
+     */
+    template<class O>
+        requires(!orm_recordset_alias<O>)
+    constexpr internal::table_reference<O> column() {
+        return {};
+    }
+
+    /**
+     *  Make table reference.
+     */
+    template<class O>
+        requires(!orm_recordset_alias<O>)
+    constexpr internal::table_reference<O> c() {
+        return {};
+    }
+#endif
+
 #ifdef SQLITE_ORM_WITH_CTE
     /**
      *  Explicitly refer to a column alias mapped into a CTE or subquery.
@@ -4180,10 +4255,9 @@ namespace sqlite_orm {
      *  Explicit FROM function. Usage:
      *  `storage.select(&User::id, from<"a"_alias.for_<User>>());`
      */
-    template<orm_recordset_alias auto... tables>
+    template<orm_refers_to_recordset auto... recordsets>
     auto from() {
-        static_assert(sizeof...(tables) > 0);
-        return internal::from_t<std::remove_const_t<decltype(tables)>...>{};
+        return from<internal::decay_table_reference_t<recordsets>...>();
     }
 #endif
 
@@ -4300,12 +4374,12 @@ namespace sqlite_orm {
     }
 
     template<class F, class O>
-    internal::using_t<O, F O::*> using_(F O::*p) {
-        return {p};
+    internal::using_t<O, F O::*> using_(F O::*field) {
+        return {field};
     }
     template<class T, class M>
-    internal::using_t<T, M> using_(internal::column_pointer<T, M> cp) {
-        return {std::move(cp)};
+    internal::using_t<T, M> using_(internal::column_pointer<T, M> field) {
+        return {std::move(field)};
     }
 
     template<class T>
@@ -4329,9 +4403,9 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    template<orm_recordset_alias auto alias, class On>
+    template<orm_refers_to_recordset auto alias, class On>
     auto left_join(On on) {
-        return internal::left_join_t<std::remove_const_t<decltype(alias)>, On>{std::move(on)};
+        return left_join<internal::decay_table_reference_t<alias>, On>(std::move(on));
     }
 #endif
 
@@ -4341,9 +4415,9 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    template<orm_recordset_alias auto alias, class On>
+    template<orm_refers_to_recordset auto alias, class On>
     auto join(On on) {
-        return internal::join_t<std::remove_const_t<decltype(alias)>, On>{std::move(on)};
+        return join<internal::decay_table_reference_t<alias>, On>(std::move(on));
     }
 #endif
 
@@ -4353,9 +4427,9 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    template<orm_recordset_alias auto alias, class On>
+    template<orm_refers_to_recordset auto alias, class On>
     auto left_outer_join(On on) {
-        return internal::left_outer_join_t<std::remove_const_t<decltype(alias)>, On>{std::move(on)};
+        return left_outer_join<internal::decay_table_reference_t<alias>, On>(std::move(on));
     }
 #endif
 
@@ -4365,9 +4439,9 @@ namespace sqlite_orm {
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    template<orm_recordset_alias auto alias, class On>
+    template<orm_refers_to_recordset auto alias, class On>
     auto inner_join(On on) {
-        return internal::inner_join_t<std::remove_const_t<decltype(alias)>, On>{std::move(on)};
+        return inner_join<internal::decay_table_reference_t<alias>, On>(std::move(on));
     }
 #endif
 
@@ -4961,8 +5035,8 @@ namespace sqlite_orm {
      */
     template<orm_table_alias A, class C>
         requires(orm_cte_moniker<internal::type_t<A>>)
-    constexpr auto operator->*(const A& /*tableAlias*/, C field) {
-        return alias_column<A>(std::move(field));
+    constexpr auto operator->*(const A& /*tableAlias*/, C c) {
+        return alias_column<A>(std::move(c));
     }
 
     /**
@@ -7008,17 +7082,15 @@ namespace sqlite_orm {
         return {};
     }
 
-#ifdef SQLITE_ORM_WITH_CTE
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
-     *  COUNT(*) with FROM function. Specified cte moniker will be serialized as
+     *  COUNT(*) with FROM function. Specified recordset will be serialized as
      *  a from argument.
      */
-    template<orm_cte_moniker auto moniker>
-    internal::count_asterisk_t<std::remove_const_t<decltype(moniker)>> count() {
-        return {};
+    template<orm_refers_to_recordset auto mapped>
+    auto count() {
+        return count<internal::decay_table_reference_t<mapped>>();
     }
-#endif
 #endif
 
     /**
@@ -8442,9 +8514,9 @@ namespace sqlite_orm {
      *  auto reportingTo = 
      *      storage.select(asterisk<m>(), inner_join<m>(on(m->*&Employee::reportsTo == &Employee::employeeId)));
      */
-    template<orm_recordset_alias auto alias>
+    template<orm_refers_to_recordset auto recordset>
     auto asterisk(bool definedOrder = false) {
-        return internal::asterisk_t<std::remove_const_t<decltype(alias)>>{definedOrder};
+        return asterisk<internal::decay_table_reference_t<recordset>>(definedOrder);
     }
 #endif
 
@@ -8463,6 +8535,13 @@ namespace sqlite_orm {
     internal::object_t<T> object(bool definedOrder = false) {
         return {definedOrder};
     }
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    template<orm_refers_to_table auto als>
+    auto object(bool definedOrder = false) {
+        return object<internal::decay_table_reference_t<als>>(definedOrder);
+    }
+#endif
 }
 #pragma once
 
@@ -11586,8 +11665,13 @@ namespace sqlite_orm {
         template<class T, class SFINAE = void>
         struct mapped_type_proxy : std::remove_const<T> {};
 
-        template<class T>
-        struct mapped_type_proxy<T, match_if<is_recordset_alias, T>> : std::remove_const<type_t<T>> {};
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        template<orm_table_reference R>
+        struct mapped_type_proxy<R, void> : R {};
+#endif
+
+        template<class A>
+        struct mapped_type_proxy<A, match_if<is_recordset_alias, A>> : std::remove_const<type_t<A>> {};
 
         template<class T>
         using mapped_type_proxy_t = typename mapped_type_proxy<T>::type;
@@ -13470,9 +13554,20 @@ namespace sqlite_orm {
      */
     template<class T, class... Ids>
     internal::get_t<T, Ids...> get(Ids... ids) {
-        std::tuple<Ids...> idsTuple{std::forward<Ids>(ids)...};
-        return {std::move(idsTuple)};
+        return {{std::forward<Ids>(ids)...}};
+    }
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Create a get statement.
+     *  T is an object type mapped to a storage.
+     *  Usage: get<User>(5);
+     */
+    template<orm_table_reference auto als, class... Ids>
+    auto get(Ids... ids) {
+        return get<internal::mapped_type_proxy_t<decltype(als)>>(std::forward<Ids>(ids)...);
     }
+#endif
 
     /**
      *  Create a get pointer statement.
@@ -13481,8 +13576,7 @@ namespace sqlite_orm {
      */
     template<class T, class... Ids>
     internal::get_pointer_t<T, Ids...> get_pointer(Ids... ids) {
-        std::tuple<Ids...> idsTuple{std::forward<Ids>(ids)...};
-        return {std::move(idsTuple)};
+        return {{std::forward<Ids>(ids)...}};
     }
 
 #ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
@@ -13493,8 +13587,7 @@ namespace sqlite_orm {
      */
     template<class T, class... Ids>
     internal::get_optional_t<T, Ids...> get_optional(Ids... ids) {
-        std::tuple<Ids...> idsTuple{std::forward<Ids>(ids)...};
-        return {std::move(idsTuple)};
+        return {{std::forward<Ids>(ids)...}};
     }
 #endif  // SQLITE_ORM_OPTIONAL_SUPPORTED
 
@@ -13527,17 +13620,15 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
      *  Create a get all statement.
-     *  `alias` is an explicitly specified table alias of an object to be extracted.
+     *  `als` is an explicitly specified table proxy of an object to be extracted.
      *  `R` is the container return type, which must have a `R::push_back(T&&)` method, and defaults to `std::vector<T>`
      *  Usage: storage.get_all<sqlite_schema>(...);
      */
-    template<orm_table_alias auto alias,
-             class R = std::vector<internal::mapped_type_proxy_t<decltype(alias)>>,
+    template<orm_refers_to_table auto als,
+             class R = std::vector<internal::mapped_type_proxy_t<decltype(als)>>,
              class... Args>
     auto get_all(Args&&... conditions) {
-        using expression_type = internal::get_all_t<std::remove_const_t<decltype(alias)>, R, std::decay_t<Args>...>;
-        internal::validate_conditions<typename expression_type::conditions_type>();
-        return expression_type{{std::forward<Args>(conditions)...}};
+        return get_all<internal::decay_table_reference_t<als>, R>(std::forward<Args>(conditions)...);
     }
 #endif
 
@@ -19991,18 +20082,18 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
             /**
              *  SELECT * routine.
-             *  `alias` is an explicitly specified table alias of an object to be extracted.
+             *  `als` is an explicitly specified table proxy of an object to be extracted.
              *  `R` is the container return type, which must have a `R::push_back(O&&)` method, and defaults to `std::vector<O>`
              *  @return All objects stored in database.
              *  @example: storage.get_all<sqlite_schema, std::list<sqlite_master>>(); - SELECT sqlite_schema.* FROM sqlite_master AS sqlite_schema
             */
-            template<orm_table_alias auto alias,
-                     class R = std::vector<mapped_type_proxy_t<decltype(alias)>>,
+            template<orm_refers_to_table auto als,
+                     class R = std::vector<mapped_type_proxy_t<decltype(als)>>,
                      class... Args>
             R get_all(Args&&... args) {
-                using A = decltype(alias);
+                using A = decltype(als);
                 this->assert_mapped_type<mapped_type_proxy_t<A>>();
-                auto statement = this->prepare(sqlite_orm::get_all<alias, R>(std::forward<Args>(args)...));
+                auto statement = this->prepare(sqlite_orm::get_all<als, R>(std::forward<Args>(args)...));
                 return this->execute(statement);
             }
 #endif
@@ -20054,6 +20145,13 @@ namespace sqlite_orm {
                 return this->execute(statement);
             }
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+            template<orm_table_reference auto mapped, class... Ids>
+            auto get(Ids... ids) {
+                return this->get<decay_table_reference_t<mapped>>(std::forward<Ids>(ids)...);
+            }
+#endif
+
             /**
              *  The same as `get` function but doesn't throw an exception if noting found but returns std::unique_ptr
              * with null value. throws std::system_error in case of db error.
@@ -20100,8 +20198,9 @@ namespace sqlite_orm {
              *  SELECT COUNT(*) https://www.sqlite.org/lang_aggfunc.html#count
              *  @return Number of O object in table.
              */
-            template<class O, class... Args, class R = mapped_type_proxy_t<O>>
+            template<class O, class... Args>
             int count(Args&&... args) {
+                using R = mapped_type_proxy_t<O>;
                 this->assert_mapped_type<R>();
                 auto rows = this->select(sqlite_orm::count<R>(), std::forward<Args>(args)...);
                 if(!rows.empty()) {
@@ -20111,15 +20210,25 @@ namespace sqlite_orm {
                 }
             }
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+            template<orm_refers_to_recordset auto mapped, class... Args>
+            int count(Args&&... args) {
+                return this->count<decay_table_reference_t<mapped>>(std::forward<Args>(args)...);
+            }
+#endif
+
             /**
              *  SELECT COUNT(X) https://www.sqlite.org/lang_aggfunc.html#count
              *  @param m member pointer to class mapped to the storage.
              *  @return count of `m` values from database.
              */
-            template<class F, class O, class... Args>
-            int count(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::count(m), std::forward<Args>(args)...);
+            template<
+                class F,
+                class... Args,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            int count(F field, Args&&... args) {
+                this->assert_mapped_type<table_type_of_t<F>>();
+                auto rows = this->select(sqlite_orm::count(std::move(field)), std::forward<Args>(args)...);
                 if(!rows.empty()) {
                     return rows.front();
                 } else {
@@ -20132,10 +20241,13 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return average value from database.
              */
-            template<class F, class O, class... Args>
-            double avg(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::avg(m), std::forward<Args>(args)...);
+            template<
+                class F,
+                class... Args,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            double avg(F field, Args&&... args) {
+                this->assert_mapped_type<table_type_of_t<F>>();
+                auto rows = this->select(sqlite_orm::avg(std::move(field)), std::forward<Args>(args)...);
                 if(!rows.empty()) {
                     return rows.front();
                 } else {
@@ -20143,9 +20255,11 @@ namespace sqlite_orm {
                 }
             }
 
-            template<class F, class O>
-            std::string group_concat(F O::*m) {
-                return this->group_concat_internal(m, {});
+            template<
+                class F,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            std::string group_concat(F field) {
+                return this->group_concat_internal(std::move(field), {});
             }
 
             /**
@@ -20153,13 +20267,14 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return group_concat query result.
              */
-            template<class F,
-                     class O,
-                     class... Args,
-                     class Tuple = std::tuple<Args...>,
-                     std::enable_if_t<std::tuple_size<Tuple>::value >= 1, bool> = true>
-            std::string group_concat(F O::*m, Args&&... args) {
-                return this->group_concat_internal(m, {}, std::forward<Args>(args)...);
+            template<
+                class F,
+                class... Args,
+                class Tuple = std::tuple<Args...>,
+                std::enable_if_t<std::tuple_size<Tuple>::value >= 1, bool> = true,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            std::string group_concat(F field, Args&&... args) {
+                return this->group_concat_internal(std::move(field), {}, std::forward<Args>(args)...);
             }
 
             /**
@@ -20167,22 +20282,28 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return group_concat query result.
              */
-            template<class F, class O, class... Args>
-            std::string group_concat(F O::*m, std::string y, Args&&... args) {
-                return this->group_concat_internal(m,
+            template<
+                class F,
+                class... Args,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            std::string group_concat(F field, std::string y, Args&&... args) {
+                return this->group_concat_internal(std::move(field),
                                                    std::make_unique<std::string>(std::move(y)),
                                                    std::forward<Args>(args)...);
             }
 
-            template<class F, class O, class... Args>
-            std::string group_concat(F O::*m, const char* y, Args&&... args) {
+            template<
+                class F,
+                class... Args,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            std::string group_concat(F field, const char* y, Args&&... args) {
                 std::unique_ptr<std::string> str;
                 if(y) {
                     str = std::make_unique<std::string>(y);
                 } else {
                     str = std::make_unique<std::string>();
                 }
-                return this->group_concat_internal(m, std::move(str), std::forward<Args>(args)...);
+                return this->group_concat_internal(std::move(field), std::move(str), std::forward<Args>(args)...);
             }
 
             /**
@@ -20190,10 +20311,14 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return std::unique_ptr with max value or null if sqlite engine returned null.
              */
-            template<class F, class O, class... Args, class Ret = column_result_of_t<db_objects_type, F O::*>>
-            std::unique_ptr<Ret> max(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::max(m), std::forward<Args>(args)...);
+            template<
+                class F,
+                class... Args,
+                class Ret = column_result_of_t<db_objects_type, F>,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            std::unique_ptr<Ret> max(F field, Args&&... args) {
+                this->assert_mapped_type<table_type_of_t<F>>();
+                auto rows = this->select(sqlite_orm::max(std::move(field)), std::forward<Args>(args)...);
                 if(!rows.empty()) {
                     return std::move(rows.front());
                 } else {
@@ -20206,10 +20331,14 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return std::unique_ptr with min value or null if sqlite engine returned null.
              */
-            template<class F, class O, class... Args, class Ret = column_result_of_t<db_objects_type, F O::*>>
-            std::unique_ptr<Ret> min(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::min(m), std::forward<Args>(args)...);
+            template<
+                class F,
+                class... Args,
+                class Ret = column_result_of_t<db_objects_type, F>,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            std::unique_ptr<Ret> min(F field, Args&&... args) {
+                this->assert_mapped_type<table_type_of_t<F>>();
+                auto rows = this->select(sqlite_orm::min(std::move(field)), std::forward<Args>(args)...);
                 if(!rows.empty()) {
                     return std::move(rows.front());
                 } else {
@@ -20222,11 +20351,15 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return std::unique_ptr with sum value or null if sqlite engine returned null.
              */
-            template<class F, class O, class... Args, class Ret = column_result_of_t<db_objects_type, F O::*>>
-            std::unique_ptr<Ret> sum(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
+            template<
+                class F,
+                class... Args,
+                class Ret = column_result_of_t<db_objects_type, F>,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            std::unique_ptr<Ret> sum(F field, Args&&... args) {
+                this->assert_mapped_type<table_type_of_t<F>>();
                 std::vector<std::unique_ptr<double>> rows =
-                    this->select(sqlite_orm::sum(m), std::forward<Args>(args)...);
+                    this->select(sqlite_orm::sum(std::move(field)), std::forward<Args>(args)...);
                 if(!rows.empty()) {
                     if(rows.front()) {
                         return std::make_unique<Ret>(std::move(*rows.front()));
@@ -20244,10 +20377,13 @@ namespace sqlite_orm {
              *  @return total value (the same as SUM but not nullable. More details here
              * https://www.sqlite.org/lang_aggfunc.html)
              */
-            template<class F, class O, class... Args>
-            double total(F O::*m, Args&&... args) {
-                this->assert_mapped_type<O>();
-                auto rows = this->select(sqlite_orm::total(m), std::forward<Args>(args)...);
+            template<
+                class F,
+                class... Args,
+                std::enable_if_t<polyfill::disjunction_v<std::is_member_pointer<F>, is_column_pointer<F>>, bool> = true>
+            double total(F field, Args&&... args) {
+                this->assert_mapped_type<table_type_of_t<F>>();
+                auto rows = this->select(sqlite_orm::total(std::move(field)), std::forward<Args>(args)...);
                 if(!rows.empty()) {
                     return std::move(rows.front());
                 } else {
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 7277502e4..f46031927 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -29,6 +29,7 @@ add_executable(unit_tests
     static_tests/core_function_return_types.cpp
     static_tests/column_expression_type.cpp
     static_tests/column_result_t.cpp
+    static_tests/column_pointer.cpp
     static_tests/alias.cpp
     static_tests/cte.cpp
     static_tests/is_primary_key_insertable.cpp
diff --git a/tests/builtin_tables.cpp b/tests/builtin_tables.cpp
index 8dce23c74..e4e38d0e9 100644
--- a/tests/builtin_tables.cpp
+++ b/tests/builtin_tables.cpp
@@ -16,6 +16,12 @@ TEST_CASE("builtin tables") {
 
         STATIC_REQUIRE(std::is_same_v<decltype(masterRows), decltype(schemaRows)>);
         REQUIRE_THAT(schemaRows, Equals(masterRows));
+
+        constexpr auto schema = c<sqlite_master>();
+        auto schemaRows2 = storage.get_all<schema>();
+
+        STATIC_REQUIRE(std::is_same_v<decltype(masterRows), decltype(schemaRows2)>);
+        REQUIRE_THAT(schemaRows2, Equals(masterRows));
 #endif
     }
 
diff --git a/tests/prepared_statement_tests/get_all.cpp b/tests/prepared_statement_tests/get_all.cpp
index 915ba108b..eec69cd70 100644
--- a/tests/prepared_statement_tests/get_all.cpp
+++ b/tests/prepared_statement_tests/get_all.cpp
@@ -215,7 +215,13 @@ TEST_CASE("Prepared get all") {
         }
     }
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    SECTION("from alias") {
+    SECTION("from table reference") {
+        constexpr auto schema = c<sqlite_master>();
+        auto statement = storage.prepare(get_all<schema>(where(schema->*&sqlite_master::type == "table")));
+        auto str = storage.dump(statement);
+        testSerializing(statement);
+    }
+    SECTION("from aliased table") {
         auto statement =
             storage.prepare(get_all<sqlite_schema>(where(sqlite_schema->*&sqlite_master::type == "table")));
         auto str = storage.dump(statement);
diff --git a/tests/statement_serializer_tests/aggregate_functions.cpp b/tests/statement_serializer_tests/aggregate_functions.cpp
index 2fd88a0b7..c255cb408 100644
--- a/tests/statement_serializer_tests/aggregate_functions.cpp
+++ b/tests/statement_serializer_tests/aggregate_functions.cpp
@@ -86,6 +86,14 @@ TEST_CASE("statement_serializer aggregate functions") {
                 value = serialize(expression, context);
                 expected = R"(COUNT(*) FILTER (WHERE ("id" < 10)))";
             }
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+            SECTION("with table reference") {
+                constexpr auto user = c<User>();
+                auto expression = count<user>();
+                value = serialize(expression, context);
+                expected = R"(COUNT(*))";
+            }
+#endif
 #ifdef SQLITE_ORM_WITH_CTE
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
             SECTION("with CTE") {
diff --git a/tests/statement_serializer_tests/select_constraints.cpp b/tests/statement_serializer_tests/select_constraints.cpp
index 20c944c3e..e610b7ae2 100644
--- a/tests/statement_serializer_tests/select_constraints.cpp
+++ b/tests/statement_serializer_tests/select_constraints.cpp
@@ -73,6 +73,12 @@ TEST_CASE("statement_serializer select constraints") {
         }
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         {
+            SECTION("with table reference") {
+                constexpr auto user = c<User>();
+                auto expression = from<user>();
+                value = serialize(expression, context);
+                expected = R"(FROM "users")";
+            }
             SECTION("with alias 2") {
                 auto expression = from<alias<'u'>.for_<User>()>();
                 value = serialize(expression, context);
diff --git a/tests/static_tests/alias.cpp b/tests/static_tests/alias.cpp
index 57e878ce5..ffd03bc9f 100644
--- a/tests/static_tests/alias.cpp
+++ b/tests/static_tests/alias.cpp
@@ -9,6 +9,7 @@ using internal::as_t;
 using internal::column_alias;
 using internal::column_pointer;
 using internal::recordset_alias;
+using internal::using_t;
 
 template<class ColAlias, class E>
 void do_assert() {
@@ -20,6 +21,14 @@ void runTest(ColAlias /*colRef*/) {
     do_assert<ColAlias, E>();
 }
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+template<class S, orm_table_alias auto als>
+concept storage_table_alias_callable = requires(S& storage) {
+    { storage.get_all<als>() };
+    { storage.count<als>() };
+};
+#endif
+
 TEST_CASE("aliases") {
     struct User {
         int id;
@@ -74,4 +83,30 @@ TEST_CASE("aliases") {
 #endif
 #endif
     }
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    SECTION("table alias expressions") {
+        constexpr auto derived_user = c<DerivedUser>();
+        constexpr auto d_alias = "d"_alias.for_<DerivedUser>();
+        using d_alias_type = decltype("d"_alias.for_<DerivedUser>());
+        runTest<internal::from_t<d_alias_type>>(from<d_alias>());
+        runTest<internal::asterisk_t<d_alias_type>>(asterisk<d_alias>());
+        runTest<internal::object_t<d_alias_type>>(object<d_alias>());
+        runTest<internal::count_asterisk_t<d_alias_type>>(count<d_alias>());
+        runTest<internal::get_all_t<d_alias_type, std::vector<DerivedUser>>>(get_all<d_alias>());
+        runTest<internal::left_join_t<d_alias_type, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
+            left_join<d_alias>(using_(derived_user->*&DerivedUser::id)));
+        runTest<internal::join_t<d_alias_type, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
+            join<d_alias>(using_(derived_user->*&DerivedUser::id)));
+        runTest<internal::left_outer_join_t<d_alias_type, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
+            left_outer_join<d_alias>(using_(derived_user->*&DerivedUser::id)));
+        runTest<internal::inner_join_t<d_alias_type, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
+            inner_join<d_alias>(using_(derived_user->*&DerivedUser::id)));
+
+        using storage_type = decltype(make_storage(
+            "",
+            make_table<DerivedUser>("derived_user", make_column("id", &DerivedUser::id, primary_key()))));
+
+        STATIC_REQUIRE(storage_table_alias_callable<storage_type, d_alias>);
+    }
+#endif
 }
diff --git a/tests/static_tests/column_expression_type.cpp b/tests/static_tests/column_expression_type.cpp
index c955e78da..bda360294 100644
--- a/tests/static_tests/column_expression_type.cpp
+++ b/tests/static_tests/column_expression_type.cpp
@@ -49,6 +49,11 @@ TEST_CASE("column_expression_of_t") {
     runTest<db_objects_t, alias_column_t<alias_a<Org>, int64 Org::*>>(alias_column<alias_a<Org>>(&Org::id));
 
     runTest<db_objects_t, column_pointer<Derived, int64 Org::*>>(column<Derived>(&Org::id));
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    constexpr auto moniker = c<Derived>();
+    runTest<db_objects_t, column_pointer<Derived, int64 Org::*>>(moniker->*&Org::id);
+    runTest<db_objects_t, std::tuple<int64 Org::*, int64 Org::*>>(asterisk<moniker>());
+#endif
 #ifdef SQLITE_ORM_WITH_CTE
     using cte_1 = decltype(1_ctealias);
     auto dbObjects2 =
diff --git a/tests/static_tests/column_pointer.cpp b/tests/static_tests/column_pointer.cpp
new file mode 100644
index 000000000..d0d4950a4
--- /dev/null
+++ b/tests/static_tests/column_pointer.cpp
@@ -0,0 +1,119 @@
+#include <sqlite_orm/sqlite_orm.h>
+#include <type_traits>  //  std::is_same
+#include <catch2/catch_all.hpp>
+
+using namespace sqlite_orm;
+using internal::column_pointer;
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+using internal::is_recordset_alias_v;
+using internal::is_table_alias_v;
+using internal::table_reference;
+using internal::using_t;
+#endif
+
+template<class T, class E>
+void do_assert() {
+    STATIC_REQUIRE(std::is_same<T, E>::value);
+}
+
+template<class E, class T>
+void runTest(const T& /*test*/) {
+    do_assert<T, E>();
+}
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+template<class C>
+concept field_callable = requires(C field) {
+    { count(field) };
+    { avg(field) };
+    { max(field) };
+    { min(field) };
+    { sum(field) };
+    { total(field) };
+    { group_concat(field) };
+};
+
+template<class S, class C>
+concept storage_field_callable = requires(S& storage, C field) {
+    { storage.count(field) };
+    { storage.avg(field) };
+    { storage.max(field) };
+    { storage.min(field) };
+    { storage.sum(field) };
+    { storage.total(field) };
+    { storage.group_concat(field) };
+    { storage.group_concat(field, "") };
+    { storage.group_concat(field, std::string{}) };
+    { storage.group_concat(field, 42) };
+};
+
+template<class S, orm_table_reference auto mapped>
+concept storage_table_reference_callable = requires(S& storage) {
+    { storage.get<mapped>(42) };
+    { storage.get_all<mapped>() };
+    { storage.count<mapped>() };
+};
+#endif
+
+TEST_CASE("column pointers") {
+    struct User {
+        int id;
+    };
+    struct DerivedUser : User {};
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    constexpr auto derived_user = c<DerivedUser>();
+#endif
+
+    SECTION("table reference") {
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        STATIC_REQUIRE(orm_table_reference<decltype(derived_user)>);
+        STATIC_REQUIRE_FALSE(is_table_alias_v<decltype(derived_user)>);
+        STATIC_REQUIRE_FALSE(is_recordset_alias_v<decltype(derived_user)>);
+        STATIC_REQUIRE_FALSE(orm_table_alias<decltype(derived_user)>);
+        STATIC_REQUIRE_FALSE(orm_recordset_alias<decltype(derived_user)>);
+        runTest<table_reference<DerivedUser>>(derived_user);
+        runTest<DerivedUser>(internal::decay_table_reference_t<derived_user>{});
+#endif
+    }
+    SECTION("column pointer expressions") {
+        runTest<column_pointer<User, decltype(&User::id)>>(column<User>(&User::id));
+        runTest<column_pointer<DerivedUser, decltype(&DerivedUser::id)>>(column<DerivedUser>(&DerivedUser::id));
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        runTest<column_pointer<DerivedUser, decltype(&DerivedUser::id)>>(derived_user->*&DerivedUser::id);
+        STATIC_REQUIRE(field_callable<decltype(&User::id)>);
+        STATIC_REQUIRE(field_callable<decltype(derived_user->*&DerivedUser::id)>);
+
+        using storage_type = decltype(make_storage(
+            "",
+            make_table<User>("user", make_column("id", &User::id, primary_key())),
+            make_table<DerivedUser>("derived_user", make_column("id", &DerivedUser::id, primary_key()))));
+
+        STATIC_REQUIRE(storage_field_callable<storage_type, decltype(&User::id)>);
+        STATIC_REQUIRE(storage_field_callable<storage_type, decltype(derived_user->*&DerivedUser::id)>);
+#endif
+    }
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    SECTION("table reference expressions") {
+        runTest<internal::from_t<DerivedUser>>(from<derived_user>());
+        runTest<internal::asterisk_t<DerivedUser>>(asterisk<derived_user>());
+        runTest<internal::object_t<DerivedUser>>(object<derived_user>());
+        runTest<internal::count_asterisk_t<DerivedUser>>(count<derived_user>());
+        runTest<internal::get_t<DerivedUser, int>>(get<derived_user>(42));
+        runTest<internal::get_all_t<DerivedUser, std::vector<DerivedUser>>>(get_all<derived_user>());
+        runTest<internal::left_join_t<DerivedUser, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
+            left_join<derived_user>(using_(derived_user->*&DerivedUser::id)));
+        runTest<internal::join_t<DerivedUser, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
+            join<derived_user>(using_(derived_user->*&DerivedUser::id)));
+        runTest<internal::left_outer_join_t<DerivedUser, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
+            left_outer_join<derived_user>(using_(derived_user->*&DerivedUser::id)));
+        runTest<internal::inner_join_t<DerivedUser, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
+            inner_join<derived_user>(using_(derived_user->*&DerivedUser::id)));
+
+        using storage_type = decltype(make_storage(
+            "",
+            make_table<DerivedUser>("derived_user", make_column("id", &DerivedUser::id, primary_key()))));
+
+        STATIC_REQUIRE(storage_table_reference_callable<storage_type, derived_user>);
+    }
+#endif
+}
diff --git a/tests/tests.cpp b/tests/tests.cpp
index d0e13dc57..dd5bdc63d 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -3,10 +3,7 @@
 
 #include <vector>  //  std::vector
 #include <string>  //  std::string
-#include <memory>  //  std::unique_ptr
 #include <cstdio>  //  remove
-#include <numeric>  //  std::iota
-#include <algorithm>  //  std::fill
 
 using namespace sqlite_orm;
 

From 348a8039fb3c492b98d6459f4e383b8a9df6faef Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 12 Nov 2023 14:22:16 +0200
Subject: [PATCH 151/161] Further unit tests for CTE expressions

---
 dev/storage.h                   |  2 +-
 include/sqlite_orm/sqlite_orm.h |  2 +-
 tests/static_tests/cte.cpp      | 34 ++++++++++++++++++++++++++++++++-
 3 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/dev/storage.h b/dev/storage.h
index 037c93c84..cc68dc9d2 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -451,7 +451,7 @@ namespace sqlite_orm {
             }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-            template<orm_refers_to_recordset auto mapped, class... Args>
+            template<orm_refers_to_table auto mapped, class... Args>
             int count(Args&&... args) {
                 return this->count<decay_table_reference_t<mapped>>(std::forward<Args>(args)...);
             }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 00bbbae9d..13d99bb74 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -20211,7 +20211,7 @@ namespace sqlite_orm {
             }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-            template<orm_refers_to_recordset auto mapped, class... Args>
+            template<orm_refers_to_table auto mapped, class... Args>
             int count(Args&&... args) {
                 return this->count<decay_table_reference_t<mapped>>(std::forward<Args>(args)...);
             }
diff --git a/tests/static_tests/cte.cpp b/tests/static_tests/cte.cpp
index 385e2354a..8bde4462e 100644
--- a/tests/static_tests/cte.cpp
+++ b/tests/static_tests/cte.cpp
@@ -10,6 +10,9 @@ using internal::alias_holder, internal::column_alias;
 using internal::column_t;
 using std::is_same, std::is_constructible;
 using std::tuple;
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+using internal::using_t;
+#endif
 
 template<class T, class E>
 void do_assert() {
@@ -50,16 +53,26 @@ TEST_CASE("CTE type traits") {
 
 TEST_CASE("CTE building") {
     SECTION("moniker") {
+        constexpr auto cte1 = 1_ctealias;
+        using cte_1 = decltype(1_ctealias);
         runTest<internal::cte_moniker<'1'>>(1_ctealias);
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         runTest<internal::cte_moniker<'z'>>("z"_cte);
+        STATIC_REQUIRE(internal::is_cte_moniker_v<cte_1>);
+        STATIC_REQUIRE(orm_cte_moniker<cte_1>);
+        STATIC_REQUIRE(internal::is_recordset_alias_v<cte_1>);
+        STATIC_REQUIRE(orm_recordset_alias<cte_1>);
+        STATIC_REQUIRE_FALSE(internal::is_table_alias_v<cte_1>);
+        STATIC_REQUIRE_FALSE(orm_table_alias<cte_1>);
 #endif
     }
     SECTION("builder") {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        constexpr auto cte1 = 1_ctealias;
         auto builder1 = cte<1_ctealias>();
 #else
-        auto builder1 = cte<decltype(1_ctealias)>();
+        using cte_1 = decltype(1_ctealias);
+        auto builder1 = cte<cte_1>();
 #endif
         auto builder2 = 1_ctealias();
         STATIC_REQUIRE(std::is_same<decltype(builder2), decltype(builder1)>::value);
@@ -85,4 +98,23 @@ TEST_CASE("CTE storage") {
                                tuple<decltype(cteTable), decltype(idx1), decltype(idx2), decltype(table)>>::value);
     }
 }
+
+TEST_CASE("CTE expressions") {
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    constexpr auto cte1 = 1_ctealias;
+    using cte_1 = decltype(1_ctealias);
+    constexpr auto x = 1_colalias;
+    using x_t = decltype(1_colalias);
+    SECTION("moniker expressions") {
+        runTest<internal::from_t<cte_1>>(from<cte1>());
+        runTest<internal::asterisk_t<cte_1>>(asterisk<cte1>());
+        runTest<internal::count_asterisk_t<cte_1>>(count<cte1>());
+        runTest<internal::left_join_t<cte_1, using_t<cte_1, alias_holder<x_t>>>>(left_join<cte1>(using_(cte1->*x)));
+        runTest<internal::join_t<cte_1, using_t<cte_1, alias_holder<x_t>>>>(join<cte1>(using_(cte1->*x)));
+        runTest<internal::left_outer_join_t<cte_1, using_t<cte_1, alias_holder<x_t>>>>(
+            left_outer_join<cte1>(using_(cte1->*x)));
+        runTest<internal::inner_join_t<cte_1, using_t<cte_1, alias_holder<x_t>>>>(inner_join<cte1>(using_(cte1->*x)));
+    }
+#endif
+}
 #endif

From 3a9665b39db6bf219f6f09dff0a4132aa8df87d6 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 12 Nov 2023 16:44:45 +0200
Subject: [PATCH 152/161] Table reference can be specified in call to
 `make_table()`

---
 dev/column_pointer.h                  |   4 +-
 dev/schema/table.h                    |  13 ++
 include/sqlite_orm/sqlite_orm.h       |  18 +-
 tests/static_tests/column_pointer.cpp | 239 +++++++++++++-------------
 4 files changed, 151 insertions(+), 123 deletions(-)

diff --git a/dev/column_pointer.h b/dev/column_pointer.h
index 4658f9bbb..432d0bed3 100644
--- a/dev/column_pointer.h
+++ b/dev/column_pointer.h
@@ -76,7 +76,7 @@ namespace sqlite_orm {
      */
     template<class O>
         requires(!orm_recordset_alias<O>)
-    constexpr internal::table_reference<O> column() {
+    consteval internal::table_reference<O> column() {
         return {};
     }
 
@@ -85,7 +85,7 @@ namespace sqlite_orm {
      */
     template<class O>
         requires(!orm_recordset_alias<O>)
-    constexpr internal::table_reference<O> c() {
+    consteval internal::table_reference<O> c() {
         return {};
     }
 #endif
diff --git a/dev/schema/table.h b/dev/schema/table.h
index 27bc4371a..80e9b7eb5 100644
--- a/dev/schema/table.h
+++ b/dev/schema/table.h
@@ -19,6 +19,7 @@
 #include "../member_traits/member_traits.h"
 #include "../typed_comparator.h"
 #include "../type_traits.h"
+#include "../alias_traits.h"
 #include "../constraints.h"
 #include "../table_info.h"
 #include "column.h"
@@ -431,6 +432,18 @@ namespace sqlite_orm {
             return {std::move(name), std::make_tuple<Cs...>(std::forward<Cs>(args)...)});
     }
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Factory function for a table definition.
+     *  
+     *  The mapped object type is explicitly specified.
+     */
+    template<orm_table_reference auto table, class... Cs>
+    auto make_table(std::string name, Cs... args) {
+        return make_table<internal::decay_table_reference_t<table>>(std::move(name), std::forward<Cs>(args)...);
+    }
+#endif
+
     template<class M>
     internal::virtual_table_t<M> make_virtual_table(std::string name, M module_details) {
         SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(return {std::move(name), std::move(module_details)});
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 13d99bb74..934e288a9 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3347,7 +3347,7 @@ namespace sqlite_orm {
      */
     template<class O>
         requires(!orm_recordset_alias<O>)
-    constexpr internal::table_reference<O> column() {
+    consteval internal::table_reference<O> column() {
         return {};
     }
 
@@ -3356,7 +3356,7 @@ namespace sqlite_orm {
      */
     template<class O>
         requires(!orm_recordset_alias<O>)
-    constexpr internal::table_reference<O> c() {
+    consteval internal::table_reference<O> c() {
         return {};
     }
 #endif
@@ -10755,6 +10755,8 @@ namespace sqlite_orm {
 
 // #include "../type_traits.h"
 
+// #include "../alias_traits.h"
+
 // #include "../constraints.h"
 
 // #include "../table_info.h"
@@ -11169,6 +11171,18 @@ namespace sqlite_orm {
             return {std::move(name), std::make_tuple<Cs...>(std::forward<Cs>(args)...)});
     }
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Factory function for a table definition.
+     *  
+     *  The mapped object type is explicitly specified.
+     */
+    template<orm_table_reference auto table, class... Cs>
+    auto make_table(std::string name, Cs... args) {
+        return make_table<internal::decay_table_reference_t<table>>(std::move(name), std::forward<Cs>(args)...);
+    }
+#endif
+
     template<class M>
     internal::virtual_table_t<M> make_virtual_table(std::string name, M module_details) {
         SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(return {std::move(name), std::move(module_details)});
diff --git a/tests/static_tests/column_pointer.cpp b/tests/static_tests/column_pointer.cpp
index d0d4950a4..ceac4a6c6 100644
--- a/tests/static_tests/column_pointer.cpp
+++ b/tests/static_tests/column_pointer.cpp
@@ -1,119 +1,120 @@
-#include <sqlite_orm/sqlite_orm.h>
-#include <type_traits>  //  std::is_same
-#include <catch2/catch_all.hpp>
-
-using namespace sqlite_orm;
-using internal::column_pointer;
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-using internal::is_recordset_alias_v;
-using internal::is_table_alias_v;
-using internal::table_reference;
-using internal::using_t;
-#endif
-
-template<class T, class E>
-void do_assert() {
-    STATIC_REQUIRE(std::is_same<T, E>::value);
-}
-
-template<class E, class T>
-void runTest(const T& /*test*/) {
-    do_assert<T, E>();
-}
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-template<class C>
-concept field_callable = requires(C field) {
-    { count(field) };
-    { avg(field) };
-    { max(field) };
-    { min(field) };
-    { sum(field) };
-    { total(field) };
-    { group_concat(field) };
-};
-
-template<class S, class C>
-concept storage_field_callable = requires(S& storage, C field) {
-    { storage.count(field) };
-    { storage.avg(field) };
-    { storage.max(field) };
-    { storage.min(field) };
-    { storage.sum(field) };
-    { storage.total(field) };
-    { storage.group_concat(field) };
-    { storage.group_concat(field, "") };
-    { storage.group_concat(field, std::string{}) };
-    { storage.group_concat(field, 42) };
-};
-
-template<class S, orm_table_reference auto mapped>
-concept storage_table_reference_callable = requires(S& storage) {
-    { storage.get<mapped>(42) };
-    { storage.get_all<mapped>() };
-    { storage.count<mapped>() };
-};
-#endif
-
-TEST_CASE("column pointers") {
-    struct User {
-        int id;
-    };
-    struct DerivedUser : User {};
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    constexpr auto derived_user = c<DerivedUser>();
-#endif
-
-    SECTION("table reference") {
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-        STATIC_REQUIRE(orm_table_reference<decltype(derived_user)>);
-        STATIC_REQUIRE_FALSE(is_table_alias_v<decltype(derived_user)>);
-        STATIC_REQUIRE_FALSE(is_recordset_alias_v<decltype(derived_user)>);
-        STATIC_REQUIRE_FALSE(orm_table_alias<decltype(derived_user)>);
-        STATIC_REQUIRE_FALSE(orm_recordset_alias<decltype(derived_user)>);
-        runTest<table_reference<DerivedUser>>(derived_user);
-        runTest<DerivedUser>(internal::decay_table_reference_t<derived_user>{});
-#endif
-    }
-    SECTION("column pointer expressions") {
-        runTest<column_pointer<User, decltype(&User::id)>>(column<User>(&User::id));
-        runTest<column_pointer<DerivedUser, decltype(&DerivedUser::id)>>(column<DerivedUser>(&DerivedUser::id));
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-        runTest<column_pointer<DerivedUser, decltype(&DerivedUser::id)>>(derived_user->*&DerivedUser::id);
-        STATIC_REQUIRE(field_callable<decltype(&User::id)>);
-        STATIC_REQUIRE(field_callable<decltype(derived_user->*&DerivedUser::id)>);
-
-        using storage_type = decltype(make_storage(
-            "",
-            make_table<User>("user", make_column("id", &User::id, primary_key())),
-            make_table<DerivedUser>("derived_user", make_column("id", &DerivedUser::id, primary_key()))));
-
-        STATIC_REQUIRE(storage_field_callable<storage_type, decltype(&User::id)>);
-        STATIC_REQUIRE(storage_field_callable<storage_type, decltype(derived_user->*&DerivedUser::id)>);
-#endif
-    }
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    SECTION("table reference expressions") {
-        runTest<internal::from_t<DerivedUser>>(from<derived_user>());
-        runTest<internal::asterisk_t<DerivedUser>>(asterisk<derived_user>());
-        runTest<internal::object_t<DerivedUser>>(object<derived_user>());
-        runTest<internal::count_asterisk_t<DerivedUser>>(count<derived_user>());
-        runTest<internal::get_t<DerivedUser, int>>(get<derived_user>(42));
-        runTest<internal::get_all_t<DerivedUser, std::vector<DerivedUser>>>(get_all<derived_user>());
-        runTest<internal::left_join_t<DerivedUser, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
-            left_join<derived_user>(using_(derived_user->*&DerivedUser::id)));
-        runTest<internal::join_t<DerivedUser, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
-            join<derived_user>(using_(derived_user->*&DerivedUser::id)));
-        runTest<internal::left_outer_join_t<DerivedUser, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
-            left_outer_join<derived_user>(using_(derived_user->*&DerivedUser::id)));
-        runTest<internal::inner_join_t<DerivedUser, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
-            inner_join<derived_user>(using_(derived_user->*&DerivedUser::id)));
-
-        using storage_type = decltype(make_storage(
-            "",
-            make_table<DerivedUser>("derived_user", make_column("id", &DerivedUser::id, primary_key()))));
-
-        STATIC_REQUIRE(storage_table_reference_callable<storage_type, derived_user>);
-    }
-#endif
-}
+#include <sqlite_orm/sqlite_orm.h>
+#include <type_traits>  //  std::is_same
+#include <catch2/catch_all.hpp>
+
+using namespace sqlite_orm;
+using internal::column_pointer;
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+using internal::is_recordset_alias_v;
+using internal::is_table_alias_v;
+using internal::table_reference;
+using internal::using_t;
+#endif
+
+template<class T, class E>
+void do_assert() {
+    STATIC_REQUIRE(std::is_same<T, E>::value);
+}
+
+template<class E, class T>
+void runTest(const T& /*test*/) {
+    do_assert<T, E>();
+}
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+template<class C>
+concept field_callable = requires(C field) {
+    { count(field) };
+    { avg(field) };
+    { max(field) };
+    { min(field) };
+    { sum(field) };
+    { total(field) };
+    { group_concat(field) };
+};
+
+template<class S, class C>
+concept storage_field_callable = requires(S& storage, C field) {
+    { storage.count(field) };
+    { storage.avg(field) };
+    { storage.max(field) };
+    { storage.min(field) };
+    { storage.sum(field) };
+    { storage.total(field) };
+    { storage.group_concat(field) };
+    { storage.group_concat(field, "") };
+    { storage.group_concat(field, std::string{}) };
+    { storage.group_concat(field, 42) };
+};
+
+template<class S, orm_table_reference auto mapped>
+concept storage_table_reference_callable = requires(S& storage) {
+    { storage.get<mapped>(42) };
+    { storage.get_all<mapped>() };
+    { storage.count<mapped>() };
+};
+#endif
+
+TEST_CASE("column pointers") {
+    struct User {
+        int id;
+    };
+    struct DerivedUser : User {};
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    constexpr auto derived_user = c<DerivedUser>();
+#endif
+
+    SECTION("table reference") {
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        STATIC_REQUIRE(orm_table_reference<decltype(derived_user)>);
+        STATIC_REQUIRE_FALSE(is_table_alias_v<decltype(derived_user)>);
+        STATIC_REQUIRE_FALSE(is_recordset_alias_v<decltype(derived_user)>);
+        STATIC_REQUIRE_FALSE(orm_table_alias<decltype(derived_user)>);
+        STATIC_REQUIRE_FALSE(orm_recordset_alias<decltype(derived_user)>);
+        runTest<table_reference<DerivedUser>>(derived_user);
+        runTest<DerivedUser>(internal::decay_table_reference_t<derived_user>{});
+#endif
+    }
+    SECTION("column pointer expressions") {
+        runTest<column_pointer<User, decltype(&User::id)>>(column<User>(&User::id));
+        runTest<column_pointer<DerivedUser, decltype(&DerivedUser::id)>>(column<DerivedUser>(&DerivedUser::id));
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        runTest<column_pointer<DerivedUser, decltype(&DerivedUser::id)>>(derived_user->*&DerivedUser::id);
+        STATIC_REQUIRE(field_callable<decltype(&User::id)>);
+        STATIC_REQUIRE(field_callable<decltype(derived_user->*&DerivedUser::id)>);
+
+        using storage_type = decltype(make_storage(
+            "",
+            make_table<User>("user", make_column("id", &User::id, primary_key())),
+            make_table<DerivedUser>("derived_user", make_column("id", &DerivedUser::id, primary_key()))));
+
+        STATIC_REQUIRE(storage_field_callable<storage_type, decltype(&User::id)>);
+        STATIC_REQUIRE(storage_field_callable<storage_type, decltype(derived_user->*&DerivedUser::id)>);
+#endif
+    }
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    SECTION("table reference expressions") {
+        runTest<internal::table_t<DerivedUser, false>>(make_table<derived_user>("derived_user"));
+        runTest<internal::from_t<DerivedUser>>(from<derived_user>());
+        runTest<internal::asterisk_t<DerivedUser>>(asterisk<derived_user>());
+        runTest<internal::object_t<DerivedUser>>(object<derived_user>());
+        runTest<internal::count_asterisk_t<DerivedUser>>(count<derived_user>());
+        runTest<internal::get_t<DerivedUser, int>>(get<derived_user>(42));
+        runTest<internal::get_all_t<DerivedUser, std::vector<DerivedUser>>>(get_all<derived_user>());
+        runTest<internal::left_join_t<DerivedUser, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
+            left_join<derived_user>(using_(derived_user->*&DerivedUser::id)));
+        runTest<internal::join_t<DerivedUser, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
+            join<derived_user>(using_(derived_user->*&DerivedUser::id)));
+        runTest<internal::left_outer_join_t<DerivedUser, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
+            left_outer_join<derived_user>(using_(derived_user->*&DerivedUser::id)));
+        runTest<internal::inner_join_t<DerivedUser, using_t<DerivedUser, decltype(&DerivedUser::id)>>>(
+            inner_join<derived_user>(using_(derived_user->*&DerivedUser::id)));
+
+        using storage_type = decltype(make_storage(
+            "",
+            make_table<DerivedUser>("derived_user", make_column("id", &DerivedUser::id, primary_key()))));
+
+        STATIC_REQUIRE(storage_table_reference_callable<storage_type, derived_user>);
+    }
+#endif
+}

From 3c914e5f334f2b191b29f684a88bd61adb6bc92b Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 26 Nov 2023 14:03:22 +0200
Subject: [PATCH 153/161] CTE with raw insert statements

---
 dev/select_constraints.h        |  4 +++-
 dev/storage.h                   | 22 ++++++++++++++++------
 include/sqlite_orm/sqlite_orm.h | 26 +++++++++++++++++++-------
 3 files changed, 38 insertions(+), 14 deletions(-)

diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 983b7d406..c5a60be30 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -288,7 +288,9 @@ namespace sqlite_orm {
 
             with_t(bool recursiveIndicated, cte_type cte, expression_type expression) :
                 recursiveIndicated{recursiveIndicated}, cte{std::move(cte)}, expression{std::move(expression)} {
-                this->expression.highest_level = true;
+                if constexpr(is_select_v<expression_type>) {
+                    this->expression.highest_level = true;
+                }
             }
         };
 #endif
diff --git a/dev/storage.h b/dev/storage.h
index 6a452bcc8..334bed279 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -1131,10 +1131,11 @@ namespace sqlite_orm {
             using storage_base::table_exists;  // now that it is in storage_base make it into overload set
 
 #ifdef SQLITE_ORM_WITH_CTE
-            template<class... CTEs, class T, class... Args>
-            prepared_statement_t<with_t<select_t<T, Args...>, CTEs...>>
-            prepare(with_t<select_t<T, Args...>, CTEs...> sel) {
-                return prepare_impl<with_t<select_t<T, Args...>, CTEs...>>(std::move(sel));
+            template<class... CTEs,
+                     class E,
+                     std::enable_if_t<polyfill::disjunction_v<is_select<E>, is_insert_raw<E>>, bool> = true>
+            prepared_statement_t<with_t<E, CTEs...>> prepare(with_t<E, CTEs...> sel) {
+                return prepare_impl<with_t<E, CTEs...>>(std::move(sel));
             }
 #endif
 
@@ -1253,14 +1254,23 @@ namespace sqlite_orm {
             template<class... Args>
             void execute(const prepared_statement_t<replace_raw_t<Args...>>& statement) {
                 sqlite3_stmt* stmt = reset_stmt(statement.stmt);
-                iterate_ast(statement.expression.args, conditional_binder{statement.stmt});
+                iterate_ast(statement.expression, conditional_binder{stmt});
+                perform_step(stmt);
+            }
+
+#ifdef SQLITE_ORM_WITH_CTE
+            template<class... CTEs, class E, satisfies<is_insert_raw, E> = true>
+            void execute(const prepared_statement_t<with_t<E, CTEs...>>& statement) {
+                sqlite3_stmt* stmt = reset_stmt(statement.stmt);
+                iterate_ast(statement.expression, conditional_binder{stmt});
                 perform_step(stmt);
             }
+#endif
 
             template<class... Args>
             void execute(const prepared_statement_t<insert_raw_t<Args...>>& statement) {
                 sqlite3_stmt* stmt = reset_stmt(statement.stmt);
-                iterate_ast(statement.expression.args, conditional_binder{stmt});
+                iterate_ast(statement.expression, conditional_binder{stmt});
                 perform_step(stmt);
             }
 
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index f8913de5a..fda8ea4c8 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -8102,7 +8102,9 @@ namespace sqlite_orm {
 
             with_t(bool recursiveIndicated, cte_type cte, expression_type expression) :
                 recursiveIndicated{recursiveIndicated}, cte{std::move(cte)}, expression{std::move(expression)} {
-                this->expression.highest_level = true;
+                if constexpr(is_select_v<expression_type>) {
+                    this->expression.highest_level = true;
+                }
             }
         };
 #endif
@@ -21615,10 +21617,11 @@ namespace sqlite_orm {
             using storage_base::table_exists;  // now that it is in storage_base make it into overload set
 
 #ifdef SQLITE_ORM_WITH_CTE
-            template<class... CTEs, class T, class... Args>
-            prepared_statement_t<with_t<select_t<T, Args...>, CTEs...>>
-            prepare(with_t<select_t<T, Args...>, CTEs...> sel) {
-                return prepare_impl<with_t<select_t<T, Args...>, CTEs...>>(std::move(sel));
+            template<class... CTEs,
+                     class E,
+                     std::enable_if_t<polyfill::disjunction_v<is_select<E>, is_insert_raw<E>>, bool> = true>
+            prepared_statement_t<with_t<E, CTEs...>> prepare(with_t<E, CTEs...> sel) {
+                return prepare_impl<with_t<E, CTEs...>>(std::move(sel));
             }
 #endif
 
@@ -21737,14 +21740,23 @@ namespace sqlite_orm {
             template<class... Args>
             void execute(const prepared_statement_t<replace_raw_t<Args...>>& statement) {
                 sqlite3_stmt* stmt = reset_stmt(statement.stmt);
-                iterate_ast(statement.expression.args, conditional_binder{statement.stmt});
+                iterate_ast(statement.expression, conditional_binder{stmt});
                 perform_step(stmt);
             }
 
+#ifdef SQLITE_ORM_WITH_CTE
+            template<class... CTEs, class E, satisfies<is_insert_raw, E> = true>
+            void execute(const prepared_statement_t<with_t<E, CTEs...>>& statement) {
+                sqlite3_stmt* stmt = reset_stmt(statement.stmt);
+                iterate_ast(statement.expression, conditional_binder{stmt});
+                perform_step(stmt);
+            }
+#endif
+
             template<class... Args>
             void execute(const prepared_statement_t<insert_raw_t<Args...>>& statement) {
                 sqlite3_stmt* stmt = reset_stmt(statement.stmt);
-                iterate_ast(statement.expression.args, conditional_binder{stmt});
+                iterate_ast(statement.expression, conditional_binder{stmt});
                 perform_step(stmt);
             }
 

From fe696b6ad1176ee0ea4af9468085c8e3d50b89f2 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Tue, 19 Dec 2023 21:38:20 +0200
Subject: [PATCH 154/161] Moved CTE string literal operators into inline
 namespace

---
 dev/alias.h                          | 975 ++++++++++++++-------------
 dev/column_pointer.h                 | 313 ++++-----
 dev/cte_moniker.h                    |  34 +-
 include/sqlite_orm/sqlite_orm.h      |  62 +-
 tests/static_tests/operators_adl.cpp | 290 ++++----
 5 files changed, 847 insertions(+), 827 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index bf24e7255..46f5842c8 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -1,486 +1,489 @@
-#pragma once
-
-#include <type_traits>  //  std::enable_if, std::is_same, std::conditional
-#include <utility>  //  std::make_index_sequence, std::move
-#include <string>  //  std::string
-#include <sstream>  //  std::stringstream
-#include <string>  //  std::string
-#ifdef SQLITE_ORM_WITH_CTE
-#include <array>
-#endif
-
-#include "functional/cxx_type_traits_polyfill.h"
-#include "functional/cstring_literal.h"
-#include "type_traits.h"
-#include "alias_traits.h"
-#include "table_type_of.h"
-#include "tags.h"
-#include "column_pointer.h"
-
-namespace sqlite_orm {
-
-    namespace internal {
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-        template<class T>
-        inline constexpr bool is_operator_argument_v<T, std::enable_if_t<orm_column_alias<T>>> = true;
-#endif
-
-        /**
-         *  This is a common built-in class used for character based table aliases.
-         *  For convenience there exist public type aliases `alias_a`, `alias_b`, ...
-         *  The easiest way to create a table alias is using `"z"_alias.for_<Object>()`.
-         */
-        template<class T, char A, char... X>
-        struct recordset_alias : alias_tag {
-            using type = T;
-
-            static std::string get() {
-                return {A, X...};
-            }
-        };
-
-        /**
-         *  Column expression with table alias attached like 'C.ID'. This is not a column alias
-         */
-        template<class T, class C>
-        struct alias_column_t {
-            using alias_type = T;
-            using column_type = C;
-
-            column_type column;
-        };
-
-        template<class T>
-        SQLITE_ORM_INLINE_VAR constexpr bool
-            is_operator_argument_v<T, std::enable_if_t<polyfill::is_specialization_of_v<T, alias_column_t>>> = true;
-
-        struct basic_table;
-
-        /*
-         * Encapsulates extracting the alias identifier of a non-alias.
-         * 
-         * `extract()` always returns the empty string.
-         * `as_alias()` is used in contexts where a table might be aliased, and the empty string is returned.
-         * `as_qualifier()` is used in contexts where a table might be aliased, and the given table's name is returned.
-         */
-        template<class T, class SFINAE = void>
-        struct alias_extractor {
-            static std::string extract() {
-                return {};
-            }
-
-            static std::string as_alias() {
-                return {};
-            }
-
-            template<class X = basic_table>
-            static const std::string& as_qualifier(const X& table) {
-                return table.name;
-            }
-        };
-
-        /*
-         * Encapsulates extracting the alias identifier of an alias.
-         * 
-         * `extract()` always returns the alias identifier or CTE moniker.
-         * `as_alias()` is used in contexts where a recordset is aliased, and the alias identifier is returned.
-         * `as_qualifier()` is used in contexts where a table is aliased, and the alias identifier is returned.
-         */
-        template<class A>
-        struct alias_extractor<A, match_if<is_alias, A>> {
-            static std::string extract() {
-                std::stringstream ss;
-                ss << A::get();
-                return ss.str();
-            }
-
-            // for column and regular table aliases -> alias identifier
-            template<class T = A, satisfies_not<std::is_same, polyfill::detected_t<type_t, T>, A> = true>
-            static std::string as_alias() {
-                return alias_extractor::extract();
-            }
-
-#ifdef SQLITE_ORM_WITH_CTE
-            // for CTE monikers -> empty
-            template<class T = A, satisfies<std::is_same, polyfill::detected_t<type_t, T>, A> = true>
-            static std::string as_alias() {
-                return {};
-            }
-#endif
-
-            // for regular table aliases -> alias identifier
-            template<class T = A, satisfies<is_table_alias, T> = true>
-            static std::string as_qualifier(const basic_table&) {
-                return alias_extractor::extract();
-            }
-        };
-
-        /**
-         * Used to store alias for expression
-         */
-        template<class T, class E>
-        struct as_t {
-            using alias_type = T;
-            using expression_type = E;
-
-            expression_type expression;
-        };
-
-        /**
-         *  Built-in column alias.
-         *  For convenience there exist type aliases `colalias_a`, `colalias_b`, ...
-         *  The easiest way to create a column alias is using `"xyz"_col`.
-         */
-        template<char A, char... X>
-        struct column_alias : alias_tag {
-            static std::string get() {
-                return {A, X...};
-            }
-        };
-
-        template<class T>
-        struct alias_holder {
-            using type = T;
-
-            alias_holder() = default;
-            // CTE feature needs it to implicitly convert a column alias to an alias_holder; see `cte()` factory function
-            alias_holder(const T&) noexcept {}
-        };
-
-        template<class T>
-        SQLITE_ORM_INLINE_VAR constexpr bool
-            is_operator_argument_v<T, std::enable_if_t<polyfill::is_specialization_of_v<T, alias_holder>>> = true;
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-        template<char A, char... X>
-        struct recordset_alias_builder {
-            template<class T>
-            [[nodiscard]] consteval recordset_alias<T, A, X...> for_() const {
-                return {};
-            }
-
-            template<auto t>
-            [[nodiscard]] consteval auto for_() const {
-                using T = std::remove_const_t<decltype(t)>;
-                return recordset_alias<T, A, X...>{};
-            }
-        };
-#endif
-
-#ifdef SQLITE_ORM_WITH_CTE
-        template<size_t n, char... C>
-        SQLITE_ORM_CONSTEVAL auto n_to_colalias() {
-            constexpr column_alias<'1' + n % 10, C...> colalias{};
-            if constexpr(n > 10) {
-                return n_to_colalias<n / 10, '1' + n % 10, C...>();
-            } else {
-                return colalias;
-            }
-        }
-
-        template<class T>
-        inline constexpr bool is_builtin_numeric_column_alias_v = false;
-        template<char... C>
-        inline constexpr bool is_builtin_numeric_column_alias_v<column_alias<C...>> = ((C >= '0' && C <= '9') && ...);
-#endif
-    }
-
-    /**
-     *  Using a column pointer, create a column reference to an aliased table column.
-     *  
-     *  Example:
-     *  using als = alias_u<User>;
-     *  select(alias_column<als>(column<User>(&User::id)))
-     */
-    template<
-        class A,
-        class C,
-        std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<A>,
-                                                 polyfill::negation<internal::is_cte_moniker<internal::type_t<A>>>>,
-                         bool> = true>
-    constexpr auto alias_column(C field) {
-        using namespace ::sqlite_orm::internal;
-        using aliased_type = type_t<A>;
-        static_assert(is_field_of_v<C, aliased_type>, "Column must be from aliased table");
-
-        return alias_column_t<A, C>{std::move(field)};
-    }
-
-    /**
-     *  Using an object member field, create a column reference to an aliased table column.
-     *  
-     *  @note The object member pointer can be from a derived class without explicitly forming a column pointer.
-     *  
-     *  Example:
-     *  using als = alias_u<User>;
-     *  select(alias_column<als>(&User::id))
-     */
-    template<
-        class A,
-        class F,
-        class O,
-        std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<A>,
-                                                 polyfill::negation<internal::is_cte_moniker<internal::type_t<A>>>>,
-                         bool> = true>
-    constexpr auto alias_column(F O::*field) {
-        using namespace ::sqlite_orm::internal;
-        using aliased_type = type_t<A>;
-        static_assert(is_field_of_v<F O::*, aliased_type>, "Column must be from aliased table");
-
-        using C1 =
-            std::conditional_t<std::is_same<O, aliased_type>::value, F O::*, column_pointer<aliased_type, F O::*>>;
-        return alias_column_t<A, C1>{{field}};
-    }
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    /**
-     *  Create a column reference to an aliased table column.
-     *  
-     *  @note An object member pointer can be from a derived class without explicitly forming a column pointer.
-     *  
-     *  Example:
-     *  constexpr auto als = "u"_alias.for_<User>();
-     *  select(alias_column<als>(&User::id))
-     */
-    template<orm_table_alias auto als, class C>
-        requires(!orm_cte_moniker<internal::auto_type_t<als>>)
-    constexpr auto alias_column(C field) {
-        using namespace ::sqlite_orm::internal;
-        using A = decltype(als);
-        using aliased_type = type_t<A>;
-        static_assert(is_field_of_v<C, aliased_type>, "Column must be from aliased table");
-
-        if constexpr(is_column_pointer_v<C>) {
-            return alias_column_t<A, C>{std::move(field)};
-        } else if constexpr(std::is_same_v<member_object_type_t<C>, aliased_type>) {
-            return alias_column_t<A, C>{field};
-        } else {
-            // wrap in column_pointer
-            using C1 = column_pointer<aliased_type, C>;
-            return alias_column_t<A, C1>{{field}};
-        }
-    }
-
-    /**
-        *  Create a column reference to an aliased table column.
-        *  
-        *  @note An object member pointer can be from a derived class without explicitly forming a column pointer.
-        *  
-        *  @note (internal) Intentionally not placed in the internal namespace for ADL (Argument Dependent Lookup)
-        *  because recordset aliases are derived from `sqlite_orm::alias_tag`
-        *  
-        *  Example:
-        *  constexpr auto als = "u"_alias.for_<User>();
-        *  select(als->*&User::id)
-        */
-    template<orm_table_alias A, class F>
-        requires(!orm_cte_moniker<internal::type_t<A>>)
-    constexpr auto operator->*(const A& /*tableAlias*/, F field) {
-        return alias_column<A>(std::move(field));
-    }
-#endif
-
-#ifdef SQLITE_ORM_WITH_CTE
-    /**
-     *  Create a column reference to an aliased CTE column.
-     */
-    template<class A,
-             class C,
-             std::enable_if_t<
-                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_moniker<internal::type_t<A>>>,
-                 bool> = true>
-    constexpr auto alias_column(C c) {
-        using namespace internal;
-        using cte_moniker_t = type_t<A>;
-
-        if constexpr(is_column_pointer_v<C>) {
-            static_assert(std::is_same<table_type_of_t<C>, cte_moniker_t>::value,
-                          "Column pointer must match aliased CTE");
-            return alias_column_t<A, C>{c};
-        } else {
-            auto cp = column<cte_moniker_t>(c);
-            return alias_column_t<A, decltype(cp)>{std::move(cp)};
-        }
-    }
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    /**
-     *  Create a column reference to an aliased CTE column.
-     */
-    template<orm_table_alias A, class C>
-        requires(orm_cte_moniker<internal::type_t<A>>)
-    constexpr auto operator->*(const A& /*tableAlias*/, C c) {
-        return alias_column<A>(std::move(c));
-    }
-
-    /**
-     *  Create a column reference to an aliased CTE column.
-     */
-    template<orm_table_alias auto als, class C>
-        requires(orm_cte_moniker<internal::auto_type_t<als>>)
-    constexpr auto alias_column(C c) {
-        using A = std::remove_const_t<decltype(als)>;
-        return alias_column<A>(std::move(c));
-    }
-#endif
-#endif
-
-    /** 
-     *  Alias a column expression.
-     */
-    template<class A, class E, internal::satisfies<internal::is_column_alias, A> = true>
-    internal::as_t<A, E> as(E expression) {
-        return {std::move(expression)};
-    }
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    /** 
-     *  Alias a column expression.
-     */
-    template<orm_column_alias auto als, class E>
-    auto as(E expression) {
-        return internal::as_t<decltype(als), E>{std::move(expression)};
-    }
-
-    /**
-     *  Alias a column expression.
-     */
-    template<orm_column_alias A, class E>
-    internal::as_t<A, E> operator>>=(E expression, const A&) {
-        return {std::move(expression)};
-    }
-#else
-    /**
-     *  Alias a column expression.
-     */
-    template<class A, class E, internal::satisfies<internal::is_column_alias, A> = true>
-    internal::as_t<A, E> operator>>=(E expression, const A&) {
-        return {std::move(expression)};
-    }
-#endif
-
-    /**
-     *  Wrap a column alias in an alias holder.
-     */
-    template<class T>
-    internal::alias_holder<T> get() {
-        static_assert(internal::is_column_alias_v<T>, "");
-        return {};
-    }
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    template<orm_column_alias auto als>
-    auto get() {
-        return internal::alias_holder<decltype(als)>{};
-    }
-#endif
-
-    template<class T>
-    using alias_a = internal::recordset_alias<T, 'a'>;
-    template<class T>
-    using alias_b = internal::recordset_alias<T, 'b'>;
-    template<class T>
-    using alias_c = internal::recordset_alias<T, 'c'>;
-    template<class T>
-    using alias_d = internal::recordset_alias<T, 'd'>;
-    template<class T>
-    using alias_e = internal::recordset_alias<T, 'e'>;
-    template<class T>
-    using alias_f = internal::recordset_alias<T, 'f'>;
-    template<class T>
-    using alias_g = internal::recordset_alias<T, 'g'>;
-    template<class T>
-    using alias_h = internal::recordset_alias<T, 'h'>;
-    template<class T>
-    using alias_i = internal::recordset_alias<T, 'i'>;
-    template<class T>
-    using alias_j = internal::recordset_alias<T, 'j'>;
-    template<class T>
-    using alias_k = internal::recordset_alias<T, 'k'>;
-    template<class T>
-    using alias_l = internal::recordset_alias<T, 'l'>;
-    template<class T>
-    using alias_m = internal::recordset_alias<T, 'm'>;
-    template<class T>
-    using alias_n = internal::recordset_alias<T, 'n'>;
-    template<class T>
-    using alias_o = internal::recordset_alias<T, 'o'>;
-    template<class T>
-    using alias_p = internal::recordset_alias<T, 'p'>;
-    template<class T>
-    using alias_q = internal::recordset_alias<T, 'q'>;
-    template<class T>
-    using alias_r = internal::recordset_alias<T, 'r'>;
-    template<class T>
-    using alias_s = internal::recordset_alias<T, 's'>;
-    template<class T>
-    using alias_t = internal::recordset_alias<T, 't'>;
-    template<class T>
-    using alias_u = internal::recordset_alias<T, 'u'>;
-    template<class T>
-    using alias_v = internal::recordset_alias<T, 'v'>;
-    template<class T>
-    using alias_w = internal::recordset_alias<T, 'w'>;
-    template<class T>
-    using alias_x = internal::recordset_alias<T, 'x'>;
-    template<class T>
-    using alias_y = internal::recordset_alias<T, 'y'>;
-    template<class T>
-    using alias_z = internal::recordset_alias<T, 'z'>;
-
-    using colalias_a = internal::column_alias<'a'>;
-    using colalias_b = internal::column_alias<'b'>;
-    using colalias_c = internal::column_alias<'c'>;
-    using colalias_d = internal::column_alias<'d'>;
-    using colalias_e = internal::column_alias<'e'>;
-    using colalias_f = internal::column_alias<'f'>;
-    using colalias_g = internal::column_alias<'g'>;
-    using colalias_h = internal::column_alias<'h'>;
-    using colalias_i = internal::column_alias<'i'>;
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    /** @short Create a table alias.
-     *
-     *  Examples:
-     *  constexpr auto z_alias = alias<'z'>.for_<User>();
-     */
-    template<char A, char... X>
-    inline constexpr internal::recordset_alias_builder<A, X...> alias{};
-
-    inline namespace literals {
-        /** @short Create a table alias.
-         *
-         *  Examples:
-         *  constexpr auto z_alias = "z"_alias.for_<User>();
-         */
-        template<internal::cstring_literal name>
-        [[nodiscard]] consteval auto operator"" _alias() {
-            return internal::explode_into<internal::recordset_alias_builder, name>(
-                std::make_index_sequence<name.size()>{});
-        }
-
-        /** @short Create a column alias.
-         *  column_alias<'a'[, ...]> from a string literal.
-         *  E.g. "a"_col, "b"_col
-         */
-        template<internal::cstring_literal name>
-        [[nodiscard]] consteval auto operator"" _col() {
-            return internal::explode_into<internal::column_alias, name>(std::make_index_sequence<name.size()>{});
-        }
-    }
-#endif
-
-#ifdef SQLITE_ORM_WITH_CTE
-    /**
-     *  column_alias<'1'[, ...]> from a numeric literal.
-     *  E.g. 1_colalias, 2_colalias
-     */
-    template<char... Chars>
-    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _colalias() {
-        // numeric identifiers are used for automatically assigning implicit aliases to unaliased column expressions,
-        // which start at "1".
-        static_assert(std::array{Chars...}[0] > '0');
-        return internal::column_alias<Chars...>{};
-    }
-#endif
-}
+#pragma once
+
+#include <type_traits>  //  std::enable_if, std::is_same, std::conditional
+#include <utility>  //  std::make_index_sequence, std::move
+#include <string>  //  std::string
+#include <sstream>  //  std::stringstream
+#include <string>  //  std::string
+#ifdef SQLITE_ORM_WITH_CTE
+#include <array>
+#endif
+
+#include "functional/cxx_type_traits_polyfill.h"
+#include "functional/cstring_literal.h"
+#include "type_traits.h"
+#include "alias_traits.h"
+#include "table_type_of.h"
+#include "tags.h"
+#include "column_pointer.h"
+
+namespace sqlite_orm {
+
+    namespace internal {
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        template<class T>
+        inline constexpr bool is_operator_argument_v<T, std::enable_if_t<orm_column_alias<T>>> = true;
+#endif
+
+        /**
+         *  This is a common built-in class used for character based table aliases.
+         *  For convenience there exist public type aliases `alias_a`, `alias_b`, ...
+         *  The easiest way to create a table alias is using `"z"_alias.for_<Object>()`.
+         */
+        template<class T, char A, char... X>
+        struct recordset_alias : alias_tag {
+            using type = T;
+
+            static std::string get() {
+                return {A, X...};
+            }
+        };
+
+        /**
+         *  Column expression with table alias attached like 'C.ID'. This is not a column alias
+         */
+        template<class T, class C>
+        struct alias_column_t {
+            using alias_type = T;
+            using column_type = C;
+
+            column_type column;
+        };
+
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool
+            is_operator_argument_v<T, std::enable_if_t<polyfill::is_specialization_of_v<T, alias_column_t>>> = true;
+
+        struct basic_table;
+
+        /*
+         * Encapsulates extracting the alias identifier of a non-alias.
+         * 
+         * `extract()` always returns the empty string.
+         * `as_alias()` is used in contexts where a table might be aliased, and the empty string is returned.
+         * `as_qualifier()` is used in contexts where a table might be aliased, and the given table's name is returned.
+         */
+        template<class T, class SFINAE = void>
+        struct alias_extractor {
+            static std::string extract() {
+                return {};
+            }
+
+            static std::string as_alias() {
+                return {};
+            }
+
+            template<class X = basic_table>
+            static const std::string& as_qualifier(const X& table) {
+                return table.name;
+            }
+        };
+
+        /*
+         * Encapsulates extracting the alias identifier of an alias.
+         * 
+         * `extract()` always returns the alias identifier or CTE moniker.
+         * `as_alias()` is used in contexts where a recordset is aliased, and the alias identifier is returned.
+         * `as_qualifier()` is used in contexts where a table is aliased, and the alias identifier is returned.
+         */
+        template<class A>
+        struct alias_extractor<A, match_if<is_alias, A>> {
+            static std::string extract() {
+                std::stringstream ss;
+                ss << A::get();
+                return ss.str();
+            }
+
+            // for column and regular table aliases -> alias identifier
+            template<class T = A, satisfies_not<std::is_same, polyfill::detected_t<type_t, T>, A> = true>
+            static std::string as_alias() {
+                return alias_extractor::extract();
+            }
+
+#ifdef SQLITE_ORM_WITH_CTE
+            // for CTE monikers -> empty
+            template<class T = A, satisfies<std::is_same, polyfill::detected_t<type_t, T>, A> = true>
+            static std::string as_alias() {
+                return {};
+            }
+#endif
+
+            // for regular table aliases -> alias identifier
+            template<class T = A, satisfies<is_table_alias, T> = true>
+            static std::string as_qualifier(const basic_table&) {
+                return alias_extractor::extract();
+            }
+        };
+
+        /**
+         * Used to store alias for expression
+         */
+        template<class T, class E>
+        struct as_t {
+            using alias_type = T;
+            using expression_type = E;
+
+            expression_type expression;
+        };
+
+        /**
+         *  Built-in column alias.
+         *  For convenience there exist type aliases `colalias_a`, `colalias_b`, ...
+         *  The easiest way to create a column alias is using `"xyz"_col`.
+         */
+        template<char A, char... X>
+        struct column_alias : alias_tag {
+            static std::string get() {
+                return {A, X...};
+            }
+        };
+
+        template<class T>
+        struct alias_holder {
+            using type = T;
+
+            alias_holder() = default;
+            // CTE feature needs it to implicitly convert a column alias to an alias_holder; see `cte()` factory function
+            alias_holder(const T&) noexcept {}
+        };
+
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool
+            is_operator_argument_v<T, std::enable_if_t<polyfill::is_specialization_of_v<T, alias_holder>>> = true;
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+        template<char A, char... X>
+        struct recordset_alias_builder {
+            template<class T>
+            [[nodiscard]] consteval recordset_alias<T, A, X...> for_() const {
+                return {};
+            }
+
+            template<auto t>
+            [[nodiscard]] consteval auto for_() const {
+                using T = std::remove_const_t<decltype(t)>;
+                return recordset_alias<T, A, X...>{};
+            }
+        };
+#endif
+
+#ifdef SQLITE_ORM_WITH_CTE
+        template<size_t n, char... C>
+        SQLITE_ORM_CONSTEVAL auto n_to_colalias() {
+            constexpr column_alias<'1' + n % 10, C...> colalias{};
+            if constexpr(n > 10) {
+                return n_to_colalias<n / 10, '1' + n % 10, C...>();
+            } else {
+                return colalias;
+            }
+        }
+
+        template<class T>
+        inline constexpr bool is_builtin_numeric_column_alias_v = false;
+        template<char... C>
+        inline constexpr bool is_builtin_numeric_column_alias_v<column_alias<C...>> = ((C >= '0' && C <= '9') && ...);
+#endif
+    }
+
+    /**
+     *  Using a column pointer, create a column reference to an aliased table column.
+     *  
+     *  Example:
+     *  using als = alias_u<User>;
+     *  select(alias_column<als>(column<User>(&User::id)))
+     */
+    template<
+        class A,
+        class C,
+        std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<A>,
+                                                 polyfill::negation<internal::is_cte_moniker<internal::type_t<A>>>>,
+                         bool> = true>
+    constexpr auto alias_column(C field) {
+        using namespace ::sqlite_orm::internal;
+        using aliased_type = type_t<A>;
+        static_assert(is_field_of_v<C, aliased_type>, "Column must be from aliased table");
+
+        return alias_column_t<A, C>{std::move(field)};
+    }
+
+    /**
+     *  Using an object member field, create a column reference to an aliased table column.
+     *  
+     *  @note The object member pointer can be from a derived class without explicitly forming a column pointer.
+     *  
+     *  Example:
+     *  using als = alias_u<User>;
+     *  select(alias_column<als>(&User::id))
+     */
+    template<
+        class A,
+        class F,
+        class O,
+        std::enable_if_t<polyfill::conjunction_v<internal::is_table_alias<A>,
+                                                 polyfill::negation<internal::is_cte_moniker<internal::type_t<A>>>>,
+                         bool> = true>
+    constexpr auto alias_column(F O::*field) {
+        using namespace ::sqlite_orm::internal;
+        using aliased_type = type_t<A>;
+        static_assert(is_field_of_v<F O::*, aliased_type>, "Column must be from aliased table");
+
+        using C1 =
+            std::conditional_t<std::is_same<O, aliased_type>::value, F O::*, column_pointer<aliased_type, F O::*>>;
+        return alias_column_t<A, C1>{{field}};
+    }
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Create a column reference to an aliased table column.
+     *  
+     *  @note An object member pointer can be from a derived class without explicitly forming a column pointer.
+     *  
+     *  Example:
+     *  constexpr auto als = "u"_alias.for_<User>();
+     *  select(alias_column<als>(&User::id))
+     */
+    template<orm_table_alias auto als, class C>
+        requires(!orm_cte_moniker<internal::auto_type_t<als>>)
+    constexpr auto alias_column(C field) {
+        using namespace ::sqlite_orm::internal;
+        using A = decltype(als);
+        using aliased_type = type_t<A>;
+        static_assert(is_field_of_v<C, aliased_type>, "Column must be from aliased table");
+
+        if constexpr(is_column_pointer_v<C>) {
+            return alias_column_t<A, C>{std::move(field)};
+        } else if constexpr(std::is_same_v<member_object_type_t<C>, aliased_type>) {
+            return alias_column_t<A, C>{field};
+        } else {
+            // wrap in column_pointer
+            using C1 = column_pointer<aliased_type, C>;
+            return alias_column_t<A, C1>{{field}};
+        }
+    }
+
+    /**
+     *  Create a column reference to an aliased table column.
+     *  
+     *  @note An object member pointer can be from a derived class without explicitly forming a column pointer.
+     *  
+     *  @note (internal) Intentionally not placed in the internal namespace for ADL (Argument Dependent Lookup)
+     *  because recordset aliases are derived from `sqlite_orm::alias_tag`
+     *  
+     *  Example:
+     *  constexpr auto als = "u"_alias.for_<User>();
+     *  select(als->*&User::id)
+     */
+    template<orm_table_alias A, class F>
+        requires(!orm_cte_moniker<internal::type_t<A>>)
+    constexpr auto operator->*(const A& /*tableAlias*/, F field) {
+        return alias_column<A>(std::move(field));
+    }
+#endif
+
+#ifdef SQLITE_ORM_WITH_CTE
+    /**
+     *  Create a column reference to an aliased CTE column.
+     */
+    template<class A,
+             class C,
+             std::enable_if_t<
+                 polyfill::conjunction_v<internal::is_table_alias<A>, internal::is_cte_moniker<internal::type_t<A>>>,
+                 bool> = true>
+    constexpr auto alias_column(C c) {
+        using namespace internal;
+        using cte_moniker_t = type_t<A>;
+
+        if constexpr(is_column_pointer_v<C>) {
+            static_assert(std::is_same<table_type_of_t<C>, cte_moniker_t>::value,
+                          "Column pointer must match aliased CTE");
+            return alias_column_t<A, C>{c};
+        } else {
+            auto cp = column<cte_moniker_t>(c);
+            return alias_column_t<A, decltype(cp)>{std::move(cp)};
+        }
+    }
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Create a column reference to an aliased CTE column.
+     *  
+     *  @note (internal) Intentionally not placed in the internal namespace for ADL (Argument Dependent Lookup)
+     *  because recordset aliases are derived from `sqlite_orm::alias_tag`
+     */
+    template<orm_table_alias A, class C>
+        requires(orm_cte_moniker<internal::type_t<A>>)
+    constexpr auto operator->*(const A& /*tableAlias*/, C c) {
+        return alias_column<A>(std::move(c));
+    }
+
+    /**
+     *  Create a column reference to an aliased CTE column.
+     */
+    template<orm_table_alias auto als, class C>
+        requires(orm_cte_moniker<internal::auto_type_t<als>>)
+    constexpr auto alias_column(C c) {
+        using A = std::remove_const_t<decltype(als)>;
+        return alias_column<A>(std::move(c));
+    }
+#endif
+#endif
+
+    /** 
+     *  Alias a column expression.
+     */
+    template<class A, class E, internal::satisfies<internal::is_column_alias, A> = true>
+    internal::as_t<A, E> as(E expression) {
+        return {std::move(expression)};
+    }
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /** 
+     *  Alias a column expression.
+     */
+    template<orm_column_alias auto als, class E>
+    auto as(E expression) {
+        return internal::as_t<decltype(als), E>{std::move(expression)};
+    }
+
+    /**
+     *  Alias a column expression.
+     */
+    template<orm_column_alias A, class E>
+    internal::as_t<A, E> operator>>=(E expression, const A&) {
+        return {std::move(expression)};
+    }
+#else
+    /**
+     *  Alias a column expression.
+     */
+    template<class A, class E, internal::satisfies<internal::is_column_alias, A> = true>
+    internal::as_t<A, E> operator>>=(E expression, const A&) {
+        return {std::move(expression)};
+    }
+#endif
+
+    /**
+     *  Wrap a column alias in an alias holder.
+     */
+    template<class T>
+    internal::alias_holder<T> get() {
+        static_assert(internal::is_column_alias_v<T>, "");
+        return {};
+    }
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    template<orm_column_alias auto als>
+    auto get() {
+        return internal::alias_holder<decltype(als)>{};
+    }
+#endif
+
+    template<class T>
+    using alias_a = internal::recordset_alias<T, 'a'>;
+    template<class T>
+    using alias_b = internal::recordset_alias<T, 'b'>;
+    template<class T>
+    using alias_c = internal::recordset_alias<T, 'c'>;
+    template<class T>
+    using alias_d = internal::recordset_alias<T, 'd'>;
+    template<class T>
+    using alias_e = internal::recordset_alias<T, 'e'>;
+    template<class T>
+    using alias_f = internal::recordset_alias<T, 'f'>;
+    template<class T>
+    using alias_g = internal::recordset_alias<T, 'g'>;
+    template<class T>
+    using alias_h = internal::recordset_alias<T, 'h'>;
+    template<class T>
+    using alias_i = internal::recordset_alias<T, 'i'>;
+    template<class T>
+    using alias_j = internal::recordset_alias<T, 'j'>;
+    template<class T>
+    using alias_k = internal::recordset_alias<T, 'k'>;
+    template<class T>
+    using alias_l = internal::recordset_alias<T, 'l'>;
+    template<class T>
+    using alias_m = internal::recordset_alias<T, 'm'>;
+    template<class T>
+    using alias_n = internal::recordset_alias<T, 'n'>;
+    template<class T>
+    using alias_o = internal::recordset_alias<T, 'o'>;
+    template<class T>
+    using alias_p = internal::recordset_alias<T, 'p'>;
+    template<class T>
+    using alias_q = internal::recordset_alias<T, 'q'>;
+    template<class T>
+    using alias_r = internal::recordset_alias<T, 'r'>;
+    template<class T>
+    using alias_s = internal::recordset_alias<T, 's'>;
+    template<class T>
+    using alias_t = internal::recordset_alias<T, 't'>;
+    template<class T>
+    using alias_u = internal::recordset_alias<T, 'u'>;
+    template<class T>
+    using alias_v = internal::recordset_alias<T, 'v'>;
+    template<class T>
+    using alias_w = internal::recordset_alias<T, 'w'>;
+    template<class T>
+    using alias_x = internal::recordset_alias<T, 'x'>;
+    template<class T>
+    using alias_y = internal::recordset_alias<T, 'y'>;
+    template<class T>
+    using alias_z = internal::recordset_alias<T, 'z'>;
+
+    using colalias_a = internal::column_alias<'a'>;
+    using colalias_b = internal::column_alias<'b'>;
+    using colalias_c = internal::column_alias<'c'>;
+    using colalias_d = internal::column_alias<'d'>;
+    using colalias_e = internal::column_alias<'e'>;
+    using colalias_f = internal::column_alias<'f'>;
+    using colalias_g = internal::column_alias<'g'>;
+    using colalias_h = internal::column_alias<'h'>;
+    using colalias_i = internal::column_alias<'i'>;
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /** @short Create a table alias.
+     *
+     *  Examples:
+     *  constexpr auto z_alias = alias<'z'>.for_<User>();
+     */
+    template<char A, char... X>
+    inline constexpr internal::recordset_alias_builder<A, X...> alias{};
+
+    inline namespace literals {
+        /** @short Create a table alias.
+         *
+         *  Examples:
+         *  constexpr auto z_alias = "z"_alias.for_<User>();
+         */
+        template<internal::cstring_literal name>
+        [[nodiscard]] consteval auto operator"" _alias() {
+            return internal::explode_into<internal::recordset_alias_builder, name>(
+                std::make_index_sequence<name.size()>{});
+        }
+
+        /** @short Create a column alias.
+         *  column_alias<'a'[, ...]> from a string literal.
+         *  E.g. "a"_col, "b"_col
+         */
+        template<internal::cstring_literal name>
+        [[nodiscard]] consteval auto operator"" _col() {
+            return internal::explode_into<internal::column_alias, name>(std::make_index_sequence<name.size()>{});
+        }
+    }
+#endif
+
+#ifdef SQLITE_ORM_WITH_CTE
+    /**
+     *  column_alias<'1'[, ...]> from a numeric literal.
+     *  E.g. 1_colalias, 2_colalias
+     */
+    template<char... Chars>
+    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _colalias() {
+        // numeric identifiers are used for automatically assigning implicit aliases to unaliased column expressions,
+        // which start at "1".
+        static_assert(std::array{Chars...}[0] > '0');
+        return internal::column_alias<Chars...>{};
+    }
+#endif
+}
diff --git a/dev/column_pointer.h b/dev/column_pointer.h
index 56a6c6bcc..68c26d378 100644
--- a/dev/column_pointer.h
+++ b/dev/column_pointer.h
@@ -1,156 +1,159 @@
-#pragma once
-
-#include <type_traits>  //  std::enable_if
-#include <utility>  // std::move
-
-#include "functional/cxx_core_features.h"
-#include "functional/cxx_type_traits_polyfill.h"
-#include "type_traits.h"
-#include "alias_traits.h"
-#include "tags.h"
-
-namespace sqlite_orm {
-    namespace internal {
-        /**
-         *  This class is used to store explicit mapped type T and its column descriptor (member pointer/getter/setter).
-         *  Is useful when mapped type is derived from other type and base class has members mapped to a storage.
-         */
-        template<class T, class F>
-        struct column_pointer {
-            using type = T;
-            using field_type = F;
-
-            field_type field;
-        };
-
-        template<class T>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_column_pointer_v = polyfill::is_specialization_of_v<T, column_pointer>;
-
-        template<class T>
-        using is_column_pointer = polyfill::bool_constant<is_column_pointer_v<T>>;
-
-        template<class T>
-        SQLITE_ORM_INLINE_VAR constexpr bool is_operator_argument_v<T, std::enable_if_t<is_column_pointer_v<T>>> = true;
-
-#ifdef SQLITE_ORM_WITH_CTE
-        template<class A>
-        struct alias_holder;
-#endif
-    }
-
-    /**
-     *  Explicitly refer to a column, used in contexts
-     *  where the automatic object mapping deduction needs to be overridden.
-     *
-     *  Example:
-     *  struct BaseType : { int64 id; };
-     *  struct MyType : BaseType { ... };
-     *  storage.select(column<MyType>(&BaseType::id));
-     */
-    template<class Object, class F, class O, internal::satisfies_not<internal::is_recordset_alias, Object> = true>
-    constexpr internal::column_pointer<Object, F O::*> column(F O::*field) {
-        static_assert(internal::is_field_of_v<F O::*, Object>, "Column must be from derived class");
-        return {field};
-    }
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    /**
-     *  Explicitly refer to a column.
-     */
-    template<orm_table_reference auto table, class O, class F>
-    constexpr auto column(F O::*field) {
-        return column<internal::auto_type_t<table>>(field);
-    }
-
-    // Intentionally place pointer-to-member operator for table references in the internal namespace
-    // to facilitate ADL (Argument Dependent Lookup)
-    namespace internal {
-        /**
-         *  Explicitly refer to a column.
-         */
-        template<orm_table_reference R, class O, class F>
-        constexpr auto operator->*(const R& /*table*/, F O::*field) {
-            return column<typename R::type>(field);
-        }
-    }
-
-    /**
-     *  Make a table reference.
-     */
-    template<class O>
-        requires(!orm_recordset_alias<O>)
-    consteval internal::table_reference<O> column() {
-        return {};
-    }
-
-    /**
-     *  Make a table reference.
-     */
-    template<class O>
-        requires(!orm_recordset_alias<O>)
-    consteval internal::table_reference<O> c() {
-        return {};
-    }
-#endif
-
-#ifdef SQLITE_ORM_WITH_CTE
-    /**
-     *  Explicitly refer to a column alias mapped into a CTE or subquery.
-     *
-     *  Example:
-     *  struct Object { ... };
-     *  using cte_1 = decltype(1_ctealias);
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
-     *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
-     *  storage.with(cte<cte_1>(colalias_a{})(select(&Object::id)), select(column<cte_1>(colalias_a{})));
-     *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
-     */
-    template<class Moniker, class F, internal::satisfies<internal::is_recordset_alias, Moniker> = true>
-    constexpr auto column(F field) {
-        using namespace ::sqlite_orm::internal;
-
-        static_assert(is_cte_moniker_v<Moniker>, "`Moniker' must be a CTE moniker");
-
-        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
-            static_assert(is_column_alias_v<type_t<F>>);
-            return column_pointer<Moniker, F>{{}};
-        } else if constexpr(is_column_alias_v<F>) {
-            return column_pointer<Moniker, alias_holder<F>>{{}};
-        } else {
-            return column_pointer<Moniker, F>{std::move(field)};
-        }
-        (void)field;
-    }
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    /**
-     *  Explicitly refer to a column mapped into a CTE or subquery.
-     *
-     *  Example:
-     *  struct Object { ... };
-     *  storage.with(cte<"z"_cte>()(select(&Object::id)), select(column<"z"_cte>(&Object::id)));
-     *  storage.with(cte<"z"_cte>()(select(&Object::id)), select(column<"z"_cte>(1_colalias)));
-     */
-    template<orm_cte_moniker auto moniker, class F>
-    constexpr auto column(F field) {
-        using Moniker = std::remove_const_t<decltype(moniker)>;
-        return column<Moniker>(std::forward<F>(field));
-    }
-
-    /**
-     *  Explicitly refer to a column mapped into a CTE or subquery.
-     *
-     *  Example:
-     *  struct Object { ... };
-     *  using cte_1 = decltype(1_ctealias);
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
-     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
-     */
-    template<orm_cte_moniker Moniker, class F>
-    constexpr auto operator->*(const Moniker& /*moniker*/, F field) {
-        return column<Moniker>(std::forward<F>(field));
-    }
-#endif
-#endif
+#pragma once
+
+#include <type_traits>  //  std::enable_if
+#include <utility>  // std::move
+
+#include "functional/cxx_core_features.h"
+#include "functional/cxx_type_traits_polyfill.h"
+#include "type_traits.h"
+#include "alias_traits.h"
+#include "tags.h"
+
+namespace sqlite_orm {
+    namespace internal {
+        /**
+         *  This class is used to store explicit mapped type T and its column descriptor (member pointer/getter/setter).
+         *  Is useful when mapped type is derived from other type and base class has members mapped to a storage.
+         */
+        template<class T, class F>
+        struct column_pointer {
+            using type = T;
+            using field_type = F;
+
+            field_type field;
+        };
+
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_column_pointer_v = polyfill::is_specialization_of_v<T, column_pointer>;
+
+        template<class T>
+        using is_column_pointer = polyfill::bool_constant<is_column_pointer_v<T>>;
+
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool is_operator_argument_v<T, std::enable_if_t<is_column_pointer_v<T>>> = true;
+
+#ifdef SQLITE_ORM_WITH_CTE
+        template<class A>
+        struct alias_holder;
+#endif
+    }
+
+    /**
+     *  Explicitly refer to a column, used in contexts
+     *  where the automatic object mapping deduction needs to be overridden.
+     *
+     *  Example:
+     *  struct BaseType : { int64 id; };
+     *  struct MyType : BaseType { ... };
+     *  storage.select(column<MyType>(&BaseType::id));
+     */
+    template<class Object, class F, class O, internal::satisfies_not<internal::is_recordset_alias, Object> = true>
+    constexpr internal::column_pointer<Object, F O::*> column(F O::*field) {
+        static_assert(internal::is_field_of_v<F O::*, Object>, "Column must be from derived class");
+        return {field};
+    }
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Explicitly refer to a column.
+     */
+    template<orm_table_reference auto table, class O, class F>
+    constexpr auto column(F O::*field) {
+        return column<internal::auto_type_t<table>>(field);
+    }
+
+    // Intentionally place pointer-to-member operator for table references in the internal namespace
+    // to facilitate ADL (Argument Dependent Lookup)
+    namespace internal {
+        /**
+         *  Explicitly refer to a column.
+         */
+        template<orm_table_reference R, class O, class F>
+        constexpr auto operator->*(const R& /*table*/, F O::*field) {
+            return column<typename R::type>(field);
+        }
+    }
+
+    /**
+     *  Make a table reference.
+     */
+    template<class O>
+        requires(!orm_recordset_alias<O>)
+    consteval internal::table_reference<O> column() {
+        return {};
+    }
+
+    /**
+     *  Make a table reference.
+     */
+    template<class O>
+        requires(!orm_recordset_alias<O>)
+    consteval internal::table_reference<O> c() {
+        return {};
+    }
+#endif
+
+#ifdef SQLITE_ORM_WITH_CTE
+    /**
+     *  Explicitly refer to a column alias mapped into a CTE or subquery.
+     *
+     *  Example:
+     *  struct Object { ... };
+     *  using cte_1 = decltype(1_ctealias);
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(&Object::id)));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(column<cte_1>(1_colalias)));
+     *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(colalias_a{})));
+     *  storage.with(cte<cte_1>(colalias_a{})(select(&Object::id)), select(column<cte_1>(colalias_a{})));
+     *  storage.with(cte<cte_1>()(select(as<colalias_a>(&Object::id))), select(column<cte_1>(get<colalias_a>())));
+     */
+    template<class Moniker, class F, internal::satisfies<internal::is_recordset_alias, Moniker> = true>
+    constexpr auto column(F field) {
+        using namespace ::sqlite_orm::internal;
+
+        static_assert(is_cte_moniker_v<Moniker>, "`Moniker' must be a CTE moniker");
+
+        if constexpr(polyfill::is_specialization_of_v<F, alias_holder>) {
+            static_assert(is_column_alias_v<type_t<F>>);
+            return column_pointer<Moniker, F>{{}};
+        } else if constexpr(is_column_alias_v<F>) {
+            return column_pointer<Moniker, alias_holder<F>>{{}};
+        } else {
+            return column_pointer<Moniker, F>{std::move(field)};
+        }
+        (void)field;
+    }
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  Explicitly refer to a column mapped into a CTE or subquery.
+     *
+     *  Example:
+     *  struct Object { ... };
+     *  storage.with(cte<"z"_cte>()(select(&Object::id)), select(column<"z"_cte>(&Object::id)));
+     *  storage.with(cte<"z"_cte>()(select(&Object::id)), select(column<"z"_cte>(1_colalias)));
+     */
+    template<orm_cte_moniker auto moniker, class F>
+    constexpr auto column(F field) {
+        using Moniker = std::remove_const_t<decltype(moniker)>;
+        return column<Moniker>(std::forward<F>(field));
+    }
+
+    /**
+     *  Explicitly refer to a column mapped into a CTE or subquery.
+     *  
+     *  @note (internal) Intentionally not placed in the internal namespace for ADL (Argument Dependent Lookup)
+     *  because recordset aliases are derived from `sqlite_orm::alias_tag`
+     *
+     *  Example:
+     *  struct Object { ... };
+     *  using cte_1 = decltype(1_ctealias);
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*&Object::id));
+     *  storage.with(cte<cte_1>()(select(&Object::id)), select(1_ctealias->*1_colalias));
+     */
+    template<orm_cte_moniker Moniker, class F>
+    constexpr auto operator->*(const Moniker& /*moniker*/, F field) {
+        return column<Moniker>(std::forward<F>(field));
+    }
+#endif
+#endif
 }
\ No newline at end of file
diff --git a/dev/cte_moniker.h b/dev/cte_moniker.h
index 3332ca4ec..24519fdbb 100644
--- a/dev/cte_moniker.h
+++ b/dev/cte_moniker.h
@@ -65,23 +65,25 @@ namespace sqlite_orm {
         };
     }
 
-    /**
-     *  cte_moniker<'n'> from a numeric literal.
-     *  E.g. 1_ctealias, 2_ctealias
-     */
-    template<char... Chars>
-    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
-        return internal::cte_moniker<Chars...>{};
-    }
+    inline namespace literals {
+        /**
+         *  cte_moniker<'n'> from a numeric literal.
+         *  E.g. 1_ctealias, 2_ctealias
+         */
+        template<char... Chars>
+        [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
+            return internal::cte_moniker<Chars...>{};
+        }
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    /**
-     *  cte_moniker<'1'[, ...]> from a string literal.
-     *  E.g. "1"_cte, "2"_cte
-     */
-    template<internal::cstring_literal moniker>
-    [[nodiscard]] consteval auto operator"" _cte() {
-        return internal::explode_into<internal::cte_moniker, moniker>(std::make_index_sequence<moniker.size()>{});
-    }
+        /**
+         *  cte_moniker<'1'[, ...]> from a string literal.
+         *  E.g. "1"_cte, "2"_cte
+         */
+        template<internal::cstring_literal moniker>
+        [[nodiscard]] consteval auto operator"" _cte() {
+            return internal::explode_into<internal::cte_moniker, moniker>(std::make_index_sequence<moniker.size()>{});
+        }
 #endif
+    }
 }
 #endif
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 7fac6fa09..8b3be36f0 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3453,6 +3453,9 @@ namespace sqlite_orm {
 
     /**
      *  Explicitly refer to a column mapped into a CTE or subquery.
+     *  
+     *  @note (internal) Intentionally not placed in the internal namespace for ADL (Argument Dependent Lookup)
+     *  because recordset aliases are derived from `sqlite_orm::alias_tag`
      *
      *  Example:
      *  struct Object { ... };
@@ -5047,17 +5050,17 @@ namespace sqlite_orm {
     }
 
     /**
-        *  Create a column reference to an aliased table column.
-        *  
-        *  @note An object member pointer can be from a derived class without explicitly forming a column pointer.
-        *  
-        *  @note (internal) Intentionally not placed in the internal namespace for ADL (Argument Dependent Lookup)
-        *  because recordset aliases are derived from `sqlite_orm::alias_tag`
-        *  
-        *  Example:
-        *  constexpr auto als = "u"_alias.for_<User>();
-        *  select(als->*&User::id)
-        */
+     *  Create a column reference to an aliased table column.
+     *  
+     *  @note An object member pointer can be from a derived class without explicitly forming a column pointer.
+     *  
+     *  @note (internal) Intentionally not placed in the internal namespace for ADL (Argument Dependent Lookup)
+     *  because recordset aliases are derived from `sqlite_orm::alias_tag`
+     *  
+     *  Example:
+     *  constexpr auto als = "u"_alias.for_<User>();
+     *  select(als->*&User::id)
+     */
     template<orm_table_alias A, class F>
         requires(!orm_cte_moniker<internal::type_t<A>>)
     constexpr auto operator->*(const A& /*tableAlias*/, F field) {
@@ -5091,6 +5094,9 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
      *  Create a column reference to an aliased CTE column.
+     *  
+     *  @note (internal) Intentionally not placed in the internal namespace for ADL (Argument Dependent Lookup)
+     *  because recordset aliases are derived from `sqlite_orm::alias_tag`
      */
     template<orm_table_alias A, class C>
         requires(orm_cte_moniker<internal::type_t<A>>)
@@ -7825,24 +7831,26 @@ namespace sqlite_orm {
         };
     }
 
-    /**
-     *  cte_moniker<'n'> from a numeric literal.
-     *  E.g. 1_ctealias, 2_ctealias
-     */
-    template<char... Chars>
-    [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
-        return internal::cte_moniker<Chars...>{};
-    }
+    inline namespace literals {
+        /**
+         *  cte_moniker<'n'> from a numeric literal.
+         *  E.g. 1_ctealias, 2_ctealias
+         */
+        template<char... Chars>
+        [[nodiscard]] SQLITE_ORM_CONSTEVAL auto operator"" _ctealias() {
+            return internal::cte_moniker<Chars...>{};
+        }
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    /**
-     *  cte_moniker<'1'[, ...]> from a string literal.
-     *  E.g. "1"_cte, "2"_cte
-     */
-    template<internal::cstring_literal moniker>
-    [[nodiscard]] consteval auto operator"" _cte() {
-        return internal::explode_into<internal::cte_moniker, moniker>(std::make_index_sequence<moniker.size()>{});
-    }
+        /**
+         *  cte_moniker<'1'[, ...]> from a string literal.
+         *  E.g. "1"_cte, "2"_cte
+         */
+        template<internal::cstring_literal moniker>
+        [[nodiscard]] consteval auto operator"" _cte() {
+            return internal::explode_into<internal::cte_moniker, moniker>(std::make_index_sequence<moniker.size()>{});
+        }
 #endif
+    }
 }
 #endif
 
diff --git a/tests/static_tests/operators_adl.cpp b/tests/static_tests/operators_adl.cpp
index c635553da..4f712ad93 100644
--- a/tests/static_tests/operators_adl.cpp
+++ b/tests/static_tests/operators_adl.cpp
@@ -1,143 +1,147 @@
-#include <sqlite_orm/sqlite_orm.h>
-#include <catch2/catch_all.hpp>
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-using namespace sqlite_orm::literals;
-#endif
-using sqlite_orm::alias_a;
-using sqlite_orm::alias_column;
-using sqlite_orm::and_;
-using sqlite_orm::c;
-using sqlite_orm::colalias_a;
-using sqlite_orm::column;
-using sqlite_orm::func;
-using sqlite_orm::get;
-using sqlite_orm::or_;
-using sqlite_orm::internal::and_condition_t;
-using sqlite_orm::internal::binary_operator;
-using sqlite_orm::internal::greater_or_equal_t;
-using sqlite_orm::internal::greater_than_t;
-using sqlite_orm::internal::is_equal_t;
-using sqlite_orm::internal::is_not_equal_t;
-using sqlite_orm::internal::less_or_equal_t;
-using sqlite_orm::internal::less_than_t;
-using sqlite_orm::internal::negated_condition_t;
-using sqlite_orm::internal::or_condition_t;
-using sqlite_orm::polyfill::is_specialization_of_v;
-
-template<class E>
-void runTests(E expression) {
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression < 42), less_than_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 < expression), less_than_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression < expression), less_than_t>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression <= 42), less_or_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 <= expression), less_or_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression <= expression), less_or_equal_t>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression > 42), greater_than_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 > expression), greater_than_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression > expression), greater_than_t>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression >= 42), greater_or_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 >= expression), greater_or_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression >= expression), greater_or_equal_t>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression == 42), is_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 == expression), is_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression == expression), is_equal_t>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression != 42), is_not_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 != expression), is_not_equal_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression != expression), is_not_equal_t>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression || 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 || expression), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression || expression), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression || 42 || 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression || 42 || c(42)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 || (expression || 42)), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(c(42) || (expression || 42)), binary_operator>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression + 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 + expression), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression + expression), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 + expression + 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 + (expression + 42)), binary_operator>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression - 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 - expression), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression - expression), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 - expression - 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 - (expression - 42)), binary_operator>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression * 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 * expression), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression * expression), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 * expression * 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 * (expression * 42)), binary_operator>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression / 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 / expression), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression / expression), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 / expression / 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 / (expression / 42)), binary_operator>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression % 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 % expression), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression % expression), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 % expression % 42), binary_operator>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 % (expression % 42)), binary_operator>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression), negated_condition_t>);
-
-    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression || expression), or_condition_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression || 42), or_condition_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 || !expression), or_condition_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression && 43), and_condition_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(expression && expression), and_condition_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression && 42), and_condition_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(42 && !expression), and_condition_t>);
-
-    // conc_t + condition_t yield or_condition_t
-    STATIC_REQUIRE(is_specialization_of_v<decltype((expression && 42) || !expression), or_condition_t>);
-    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression || (expression && 42)), or_condition_t>);
-}
-
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-TEST_CASE("inline namespace literals expressions") {
-    constexpr auto u_alias_builder = "u"_alias;
-    constexpr auto c_alias = "c"_col;
-    constexpr auto f_scalar_builder = "f"_scalar;
-}
-
-TEST_CASE("ADL and pointer-to-member expressions") {
-    struct User {
-        int id;
-    };
-    constexpr auto user_table = c<User>();
-    constexpr auto u_alias = "u"_alias.for_<User>();
-
-    user_table->*&User::id;
-    u_alias->*&User::id;
-}
-#endif
-
-TEST_CASE("ADL and expression operators") {
-    struct User {
-        int id;
-    };
-    struct ScalarFunction {
-        static const char* name();
-        int operator()() const;
-    };
-
-    runTests(c(&User::id));
-    runTests(column<User>(&User::id));
-    runTests(get<colalias_a>());
-    runTests(alias_column<alias_a<User>>(&User::id));
-    runTests(func<ScalarFunction>());
-#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
-    runTests("a"_col);
-#endif
-}
+#include <sqlite_orm/sqlite_orm.h>
+#include <catch2/catch_all.hpp>
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+using namespace sqlite_orm::literals;
+#endif
+using sqlite_orm::alias_a;
+using sqlite_orm::alias_column;
+using sqlite_orm::and_;
+using sqlite_orm::c;
+using sqlite_orm::colalias_a;
+using sqlite_orm::column;
+using sqlite_orm::func;
+using sqlite_orm::get;
+using sqlite_orm::or_;
+using sqlite_orm::internal::and_condition_t;
+using sqlite_orm::internal::binary_operator;
+using sqlite_orm::internal::greater_or_equal_t;
+using sqlite_orm::internal::greater_than_t;
+using sqlite_orm::internal::is_equal_t;
+using sqlite_orm::internal::is_not_equal_t;
+using sqlite_orm::internal::less_or_equal_t;
+using sqlite_orm::internal::less_than_t;
+using sqlite_orm::internal::negated_condition_t;
+using sqlite_orm::internal::or_condition_t;
+using sqlite_orm::polyfill::is_specialization_of_v;
+
+template<class E>
+void runTests(E expression) {
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression < 42), less_than_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 < expression), less_than_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression < expression), less_than_t>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression <= 42), less_or_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 <= expression), less_or_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression <= expression), less_or_equal_t>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression > 42), greater_than_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 > expression), greater_than_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression > expression), greater_than_t>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression >= 42), greater_or_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 >= expression), greater_or_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression >= expression), greater_or_equal_t>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression == 42), is_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 == expression), is_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression == expression), is_equal_t>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression != 42), is_not_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 != expression), is_not_equal_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression != expression), is_not_equal_t>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression || 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 || expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression || expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression || 42 || 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression || 42 || c(42)), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 || (expression || 42)), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(c(42) || (expression || 42)), binary_operator>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression + 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 + expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression + expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 + expression + 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 + (expression + 42)), binary_operator>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression - 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 - expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression - expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 - expression - 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 - (expression - 42)), binary_operator>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression * 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 * expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression * expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 * expression * 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 * (expression * 42)), binary_operator>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression / 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 / expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression / expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 / expression / 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 / (expression / 42)), binary_operator>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression % 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 % expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression % expression), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 % expression % 42), binary_operator>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 % (expression % 42)), binary_operator>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression), negated_condition_t>);
+
+    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression || expression), or_condition_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression || 42), or_condition_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 || !expression), or_condition_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression && 43), and_condition_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(expression && expression), and_condition_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression && 42), and_condition_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(42 && !expression), and_condition_t>);
+
+    // conc_t + condition_t yield or_condition_t
+    STATIC_REQUIRE(is_specialization_of_v<decltype((expression && 42) || !expression), or_condition_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(!expression || (expression && 42)), or_condition_t>);
+}
+
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+TEST_CASE("inline namespace literals expressions") {
+    constexpr auto u_alias_builder = "u"_alias;
+    constexpr auto c_alias = "c"_col;
+    constexpr auto f_scalar_builder = "f"_scalar;
+    constexpr auto numeric_cte_alias_builder = 1_ctealias;
+    constexpr auto cte_alias_builder = "1"_cte;
+}
+
+TEST_CASE("ADL and pointer-to-member expressions") {
+    struct User {
+        int id;
+    };
+    constexpr auto user_table = c<User>();
+    constexpr auto u_alias = "u"_alias.for_<User>();
+    constexpr auto cte = "1"_cte;
+
+    user_table->*&User::id;
+    u_alias->*&User::id;
+    cte->*&User::id;
+}
+#endif
+
+TEST_CASE("ADL and expression operators") {
+    struct User {
+        int id;
+    };
+    struct ScalarFunction {
+        static const char* name();
+        int operator()() const;
+    };
+
+    runTests(c(&User::id));
+    runTests(column<User>(&User::id));
+    runTests(get<colalias_a>());
+    runTests(alias_column<alias_a<User>>(&User::id));
+    runTests(func<ScalarFunction>());
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    runTests("a"_col);
+#endif
+}

From b2c77f268fc847c611040402c715539f7ef5c6bf Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 21 Dec 2023 20:25:00 +0200
Subject: [PATCH 155/161] Rephrased comment

---
 dev/alias.h                     | 2 +-
 dev/column_pointer.h            | 2 +-
 include/sqlite_orm/sqlite_orm.h | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 83b1163a9..eebbf1bbc 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -307,7 +307,7 @@ namespace sqlite_orm {
     /**
      *  Create a column reference to an aliased CTE column.
      *  
-     *  @note (internal) Intentionally not placed in the internal namespace for ADL (Argument Dependent Lookup)
+     *  @note (internal) Intentionally place in the sqlite_orm namespace for ADL (Argument Dependent Lookup)
      *  because recordset aliases are derived from `sqlite_orm::alias_tag`
      */
     template<orm_table_alias A, class C>
diff --git a/dev/column_pointer.h b/dev/column_pointer.h
index 68c26d378..ee12ebe69 100644
--- a/dev/column_pointer.h
+++ b/dev/column_pointer.h
@@ -141,7 +141,7 @@ namespace sqlite_orm {
     /**
      *  Explicitly refer to a column mapped into a CTE or subquery.
      *  
-     *  @note (internal) Intentionally not placed in the internal namespace for ADL (Argument Dependent Lookup)
+     *  @note (internal) Intentionally place in the sqlite_orm namespace for ADL (Argument Dependent Lookup)
      *  because recordset aliases are derived from `sqlite_orm::alias_tag`
      *
      *  Example:
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 997d3a5a7..a0bd1af7c 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3454,7 +3454,7 @@ namespace sqlite_orm {
     /**
      *  Explicitly refer to a column mapped into a CTE or subquery.
      *  
-     *  @note (internal) Intentionally not placed in the internal namespace for ADL (Argument Dependent Lookup)
+     *  @note (internal) Intentionally place in the sqlite_orm namespace for ADL (Argument Dependent Lookup)
      *  because recordset aliases are derived from `sqlite_orm::alias_tag`
      *
      *  Example:
@@ -5095,7 +5095,7 @@ namespace sqlite_orm {
     /**
      *  Create a column reference to an aliased CTE column.
      *  
-     *  @note (internal) Intentionally not placed in the internal namespace for ADL (Argument Dependent Lookup)
+     *  @note (internal) Intentionally place in the sqlite_orm namespace for ADL (Argument Dependent Lookup)
      *  because recordset aliases are derived from `sqlite_orm::alias_tag`
      */
     template<orm_table_alias A, class C>

From fcf85d69c17dcce5927e69c4699ca825d938f17d Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 28 Dec 2023 22:08:40 +0200
Subject: [PATCH 156/161] Streamlined tuple traits and algorithms

* Metafunctions for finding, counting and checking type lists (tuples)
---
 dev/ast/set.h                                 |   1 +
 dev/column_names_getter.h                     |   3 +-
 dev/column_result.h                           |  15 +-
 dev/constraints.h                             |   6 +-
 dev/core_functions.h                          |   2 +-
 dev/cte_storage.h                             |   4 +-
 dev/functional/index_sequence_util.h          |   2 +-
 dev/functional/mpl.h                          | 192 +++++++-
 dev/implementations/column_definitions.h      |  17 +-
 dev/prepared_statement.h                      |   2 +-
 dev/schema/column.h                           |   6 +-
 dev/schema/index.h                            |   2 +-
 dev/select_constraints.h                      |  22 +-
 dev/serializing_util.h                        |   2 +-
 dev/statement_serializer.h                    |   2 +-
 dev/storage.h                                 |   2 +-
 dev/storage_impl.h                            |  36 +-
 dev/tuple_helper/tuple_filter.h               |  10 -
 dev/tuple_helper/tuple_traits.h               |  83 ++--
 include/sqlite_orm/sqlite_orm.h               | 413 +++++++++++-------
 tests/static_tests/functional/mpl.cpp         |  24 +-
 .../static_tests/functional/tuple_traits.cpp  |  22 +-
 22 files changed, 554 insertions(+), 314 deletions(-)

diff --git a/dev/ast/set.h b/dev/ast/set.h
index 0146acbc4..e5e66f2ea 100644
--- a/dev/ast/set.h
+++ b/dev/ast/set.h
@@ -6,6 +6,7 @@
 #include <sstream>  //  std::stringstream
 #include <type_traits>  //  std::false_type, std::true_type
 
+#include "../tuple_helper/tuple_traits.h"
 #include "../table_name_collector.h"
 
 namespace sqlite_orm {
diff --git a/dev/column_names_getter.h b/dev/column_names_getter.h
index 7a7b94b29..990b52442 100644
--- a/dev/column_names_getter.h
+++ b/dev/column_names_getter.h
@@ -98,8 +98,7 @@ namespace sqlite_orm {
                     (*this)(colExpr, context);
                 });
                 // note: `capacity() > size()` can occur in case `asterisk_t<>` does spell out the columns in defined order
-                if(mpl::invoke_t<check_if_tuple_has_template<asterisk_t>,
-                                 typename columns_t<Args...>::columns_type>::value &&
+                if(tuple_has_template<typename columns_t<Args...>::columns_type, asterisk_t>::value &&
                    this->collectedExpressions.capacity() > this->collectedExpressions.size()) {
                     this->collectedExpressions.shrink_to_fit();
                 }
diff --git a/dev/column_result.h b/dev/column_result.h
index 75fcaabff..63d2cab5a 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -233,15 +233,12 @@ namespace sqlite_orm {
             using table_type = storage_pick_table_t<Moniker, DBOs>;
             using cte_mapper_type = cte_mapper_type_t<table_type>;
 
-            // filter all column references being `alias_holder<>`
-            using alias_types_tuple =
-                transform_tuple_t<typename cte_mapper_type::final_colrefs_tuple, alias_holder_type_or_none_t>;
-
-            // lookup index of ColAlias in alias_types_tuple
-            static constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
-            static_assert(ColIdx != -1, "No such column mapped into the CTE.");
-
-            using type = std::tuple_element_t<ColIdx, typename cte_mapper_type::fields_type>;
+            // lookup ColAlias in the final column references
+            using colalias_index =
+                find_tuple_type<typename cte_mapper_type::final_colrefs_tuple, alias_holder<ColAlias>>;
+            static_assert(colalias_index::value < std::tuple_size_v<typename cte_mapper_type::final_colrefs_tuple>,
+                          "No such column mapped into the CTE.");
+            using type = std::tuple_element_t<colalias_index::value, typename cte_mapper_type::fields_type>;
         };
 #endif
 
diff --git a/dev/constraints.h b/dev/constraints.h
index cf7bb4ea9..5e6730e88 100644
--- a/dev/constraints.h
+++ b/dev/constraints.h
@@ -458,12 +458,12 @@ namespace sqlite_orm {
         template<typename T>
         struct is_primary_key_insertable
             : polyfill::disjunction<
-                  mpl::invoke_t<mpl::disjunction<check_if_tuple_has_template<default_t>,
-                                                 check_if_tuple_has_template<primary_key_with_autoincrement>>,
+                  mpl::invoke_t<mpl::disjunction<check_if_has_template<default_t>,
+                                                 check_if_has_template<primary_key_with_autoincrement>>,
                                 constraints_type_t<T>>,
                   std::is_base_of<integer_printer, type_printer<field_type_t<T>>>> {
 
-            static_assert(tuple_has<is_primary_key, constraints_type_t<T>>::value, "an unexpected type was passed");
+            static_assert(tuple_has<constraints_type_t<T>, is_primary_key>::value, "an unexpected type was passed");
         };
 
         template<class T>
diff --git a/dev/core_functions.h b/dev/core_functions.h
index f5f2905fd..1bd17e81a 100644
--- a/dev/core_functions.h
+++ b/dev/core_functions.h
@@ -8,7 +8,7 @@
 
 #include "functional/cxx_type_traits_polyfill.h"
 #include "is_base_of_template.h"
-#include "tuple_helper/tuple_filter.h"
+#include "tuple_helper/tuple_traits.h"
 #include "conditions.h"
 #include "serialize_result_type.h"
 #include "operators.h"
diff --git a/dev/cte_storage.h b/dev/cte_storage.h
index b0b8f44ed..60efc82e0 100644
--- a/dev/cte_storage.h
+++ b/dev/cte_storage.h
@@ -236,9 +236,9 @@ namespace sqlite_orm {
                                    const SubselectColRefs& subselectColRefs,
                                    [[maybe_unused]] const ExplicitColRefs& explicitColRefs,
                                    std::index_sequence<Idx...>) {
-            if constexpr(std::tuple_size_v < ExplicitColRefs >> 0) {
+            if constexpr(std::tuple_size_v<ExplicitColRefs> != 0) {
                 static_assert(
-                    (!internal::is_builtin_numeric_column_alias_v<
+                    (!is_builtin_numeric_column_alias_v<
                          alias_holder_type_or_none_t<std::tuple_element_t<Idx, ExplicitColRefs>>> &&
                      ...),
                     "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
diff --git a/dev/functional/index_sequence_util.h b/dev/functional/index_sequence_util.h
index 2109d52fc..64a26e086 100644
--- a/dev/functional/index_sequence_util.h
+++ b/dev/functional/index_sequence_util.h
@@ -2,7 +2,7 @@
 
 #include <utility>  //  std::index_sequence
 
-#include "../functional/cxx_universal.h"
+#include "../functional/cxx_universal.h"  //  ::size_t
 
 namespace sqlite_orm {
     namespace internal {
diff --git a/dev/functional/mpl.h b/dev/functional/mpl.h
index 7a47a5089..f6460ce2c 100644
--- a/dev/functional/mpl.h
+++ b/dev/functional/mpl.h
@@ -29,8 +29,9 @@
  */
 
 #include <type_traits>  //  std::enable_if, std::is_same
+#include <initializer_list>
 
-#include "cxx_universal.h"
+#include "cxx_universal.h"  //  ::size_t
 #include "cxx_type_traits_polyfill.h"
 
 namespace sqlite_orm {
@@ -62,34 +63,35 @@ namespace sqlite_orm {
             /*
              *  The indirection through `defer_fn` works around the language inability
              *  to expand `Args...` into a fixed parameter list of an alias template.
+             *  
+             *  Also, legacy compilers need an extra layer of indirection, otherwise type replacement may fail
+             *  if alias template `Fn` has a dependent expression in it.
              */
             template<template<class...> class Fn, class... Args>
-            struct defer {
+            struct defer_fn {
                 using type = Fn<Args...>;
             };
 
-#ifndef SQLITE_ORM_BROKEN_ALIAS_TEMPLATE_DEPENDENT_EXPR_SFINAE
             /*
-             *  Invoke metafunction.
+             *  The indirection through `defer` works around the language inability
+             *  to expand `Args...` into a fixed parameter list of an alias template.
              */
-            template<template<class...> class Fn, class... Args>
-            using invoke_fn_t = Fn<Args...>;
-#else
+            template<class Q, class... Args>
+            struct defer {
+                using type = typename Q::template fn<Args...>;
+            };
+
             /*
              *  Invoke metafunction.
-             *  
-             *  Note: legacy compilers need an extra layer of indirection, otherwise type replacement may fail
-             *  if alias template `Fn` has a dependent expression in it.
              */
             template<template<class...> class Fn, class... Args>
-            using invoke_fn_t = typename defer<Fn, Args...>::type;
-#endif
+            using invoke_fn_t = typename defer_fn<Fn, Args...>::type;
 
             /*
              *  Invoke quoted metafunction by invoking its nested metafunction.
              */
             template<class Q, class... Args>
-            using invoke_t = typename Q::template fn<Args...>;
+            using invoke_t = typename defer<Q, Args...>::type;
 
             /*
              *  Turn metafunction into a quoted metafunction.
@@ -121,13 +123,18 @@ namespace sqlite_orm {
 
             template<>
             struct higherorder<0u> {
+                template<template<template<class...> class Fn, class... Args2> class HigherFn, class Q, class... Args>
+                struct defer_higher_fn {
+                    using type = HigherFn<Q::template fn, Args...>;
+                };
+
                 /*
                  *  Turn higher-order metafunction into a quoted metafunction.
                  */
                 template<template<template<class...> class Fn, class... Args2> class HigherFn>
                 struct quote_fn {
                     template<class Q, class... Args>
-                    using fn = HigherFn<Q::template fn, Args...>;
+                    using fn = typename defer_higher_fn<HigherFn, Q, Args...>::type;
                 };
             };
 
@@ -161,7 +168,7 @@ namespace sqlite_orm {
             struct pass_result_of {
                 // invoke `Fn`, pass on their result
                 template<class... Args>
-                using fn = typename Q::template fn<typename defer<Fn, Args...>::type...>;
+                using fn = typename Q::template fn<typename defer_fn<Fn, Args...>::type...>;
             };
 
             /*
@@ -254,6 +261,102 @@ namespace sqlite_orm {
                      class... Bound>
             using bind_front_higherorder_fn =
                 bind_front<higherorder<0>::quote_fn<HigherFn>, quote_fn<BoundFn>, Bound...>;
+
+#ifdef SQLITE_ORM_RELAXED_CONSTEXPR_SUPPORTED
+            constexpr size_t find_first_true_helper(std::initializer_list<bool> values) {
+                size_t i = 0;
+                for(auto first = values.begin(); first != values.end() && !*first; ++first) {
+                    ++i;
+                }
+                return i;
+            }
+
+            constexpr size_t count_true_helper(std::initializer_list<bool> values) {
+                size_t n = 0;
+                for(auto first = values.begin(); first != values.end(); ++first) {
+                    n += *first;
+                }
+                return n;
+            }
+#else
+            constexpr size_t find_first_true_helper(const bool* first, const bool* end) {
+                return first == end || *first ? 0 : 1 + find_first_true_helper(first + 1, end);
+            }
+            constexpr size_t find_first_true_helper(const std::initializer_list<bool>& values) {
+                return find_first_true_helper(values.begin(), values.end());
+            }
+
+            constexpr size_t count_true_helper(const bool* first, const bool* end) {
+                return first == end ? 0 : *first + count_true_helper(first + 1, end);
+            }
+            constexpr size_t count_true_helper(const std::initializer_list<bool>& values) {
+                return count_true_helper(values.begin(), values.end());
+            }
+#endif
+
+            /*
+             *  Quoted metafunction that invokes the specified quoted predicate metafunction on each element of a type list,
+             *  and returns the index constant of the first element for which the predicate returns true.
+             */
+            template<class PredicateQ>
+            struct finds {
+                template<class Pack, class ProjectQ>
+                struct invoke_this_fn {
+                    static_assert(polyfill::always_false_v<Pack>,
+                                  "`finds` must be invoked with a type list as first argument.");
+                };
+
+                template<template<class...> class Pack, class... T, class ProjectQ>
+                struct invoke_this_fn<Pack<T...>, ProjectQ> {
+                    using type = polyfill::index_constant<find_first_true_helper(
+                        {PredicateQ::template fn<typename ProjectQ::template fn<T>>::value...})>;
+                };
+
+                template<class Pack, class ProjectQ = identity>
+                using fn = typename invoke_this_fn<Pack, ProjectQ>::type;
+            };
+
+            template<template<class...> class PredicateFn>
+            using finds_fn = finds<quote_fn<PredicateFn>>;
+
+            /*
+             *  Quoted metafunction that invokes the specified quoted predicate metafunction on each element of a type list,
+             *  and returns the index constant of the first element for which the predicate returns true.
+             */
+            template<class PredicateQ>
+            struct counts {
+                template<class Pack, class ProjectQ>
+                struct invoke_this_fn {
+                    static_assert(polyfill::always_false_v<Pack>,
+                                  "`counts` must be invoked with a type list as first argument.");
+                };
+
+                template<template<class...> class Pack, class... T, class ProjectQ>
+                struct invoke_this_fn<Pack<T...>, ProjectQ> {
+                    using type = polyfill::index_constant<count_true_helper(
+                        {PredicateQ::template fn<typename ProjectQ::template fn<T>>::value...})>;
+                };
+
+                template<class Pack, class ProjectQ = identity>
+                using fn = typename invoke_this_fn<Pack, ProjectQ>::type;
+            };
+
+            template<template<class...> class PredicateFn>
+            using counts_fn = counts<quote_fn<PredicateFn>>;
+
+            /*
+             *  Quoted metafunction that invokes the specified quoted predicate metafunction on each element of a type list,
+             *  and returns the index constant of the first element for which the predicate returns true.
+             */
+            template<class TraitQ>
+            struct contains {
+                template<class Pack, class ProjectQ = identity>
+                using fn =
+                    polyfill::bool_constant<static_cast<bool>(defer<counts<TraitQ>, Pack, ProjectQ>::type::value)>;
+            };
+
+            template<template<class...> class TraitFn>
+            using contains_fn = contains<quote_fn<TraitFn>>;
         }
     }
 
@@ -274,12 +377,10 @@ namespace sqlite_orm {
         using check_if_not = mpl::not_fn<TraitFn>;
 
         /*
-         *  Quoted trait metafunction that checks if a type (possibly projected) is the same as the specified type.
-         *  
-         *  `ProjOp` is a projection applied to `Type` and must be a metafunction.
+         *  Quoted trait metafunction that checks if a type is the same as the specified type.
          */
-        template<class Type, template<class...> class ProjOp = polyfill::type_identity_t>
-        using check_if_is_type = mpl::pass_result_of<mpl::bind_front_fn<std::is_same, Type>, ProjOp>;
+        template<class Type>
+        using check_if_is_type = mpl::bind_front_fn<std::is_same, Type>;
 
         /*
          *  Quoted trait metafunction that checks if a type's template matches the specified template
@@ -288,5 +389,56 @@ namespace sqlite_orm {
         template<template<class...> class Template>
         using check_if_is_template =
             mpl::pass_extracted_fn_to<mpl::bind_front_fn<std::is_same, mpl::quote_fn<Template>>>;
+
+        /*
+         *  Quoted metafunction that finds the index of the given type in a tuple.
+         */
+        template<class Type>
+        using finds_if_has_type = mpl::finds<check_if_is_type<Type>>;
+
+        /*
+         *  Quoted metafunction that finds the index of the given class template in a tuple.
+         */
+        template<template<class...> class Template>
+        using finds_if_has_template = mpl::finds<check_if_is_template<Template>>;
+
+        /*
+         *  Quoted trait metafunction that counts tuple elements having a given trait.
+         */
+        template<template<class...> class TraitFn>
+        using counts_if_has = mpl::counts_fn<TraitFn>;
+
+        /*
+         *  Quoted trait metafunction that checks whether a tuple contains a type with given trait.
+         */
+        template<template<class...> class TraitFn>
+        using check_if_has = mpl::contains_fn<TraitFn>;
+
+        /*
+         *  Quoted trait metafunction that checks whether a tuple doesn't contain a type with given trait.
+         */
+        template<template<class...> class TraitFn>
+        using check_if_has_not = mpl::not_<check_if_has<TraitFn>>;
+
+        /*
+         *  Quoted metafunction that checks whether a tuple contains given type.
+         */
+        template<class T>
+        using check_if_has_type = mpl::contains<check_if_is_type<T>>;
+
+        /*
+         *  Quoted metafunction that checks whether a tuple contains a given template.
+         *
+         *  Note: we are using 2 small tricks:
+         *  1. A template template parameter can be treated like a metafunction, so we can just "quote" a 'primary'
+         *     template into the MPL system (e.g. `std::vector`).
+         *  2. This quoted metafunction does the opposite of the trait metafunction `is_specialization`:
+         *     `is_specialization` tries to instantiate the primary template template parameter using the
+         *     template parameters of a template type, then compares both instantiated types.
+         *     Here instead, `pass_extracted_fn_to` extracts the template template parameter from a template type,
+         *     then compares the resulting template template parameters.
+         */
+        template<template<class...> class Template>
+        using check_if_has_template = mpl::contains<check_if_is_template<Template>>;
     }
 }
diff --git a/dev/implementations/column_definitions.h b/dev/implementations/column_definitions.h
index f8b70f508..5662e6848 100644
--- a/dev/implementations/column_definitions.h
+++ b/dev/implementations/column_definitions.h
@@ -6,10 +6,7 @@
 
 #include <memory>  //  std::make_unique
 
-#include "../functional/cxx_core_features.h"
 #include "../functional/static_magic.h"
-#include "../functional/index_sequence_util.h"
-#include "../tuple_helper/tuple_filter.h"
 #include "../tuple_helper/tuple_traits.h"
 #include "../default_value_extractor.h"
 #include "../schema/column.h"
@@ -19,18 +16,16 @@ namespace sqlite_orm {
 
         template<class... Op>
         std::unique_ptr<std::string> column_constraints<Op...>::default_value() const {
-            using default_op_index_sequence =
-                filter_tuple_sequence_t<constraints_type, check_if_is_template<default_t>::template fn>;
+            using default_op_index = find_tuple_template<constraints_type, default_t>;
 
             std::unique_ptr<std::string> value;
-            call_if_constexpr<default_op_index_sequence::size()>(
-                [&value](auto& constraints, auto op_index_sequence) {
-                    using default_op_index_sequence = decltype(op_index_sequence);
-                    constexpr size_t opIndex = first_index_sequence_value(default_op_index_sequence{});
-                    value = std::make_unique<std::string>(serialize_default_value(get<opIndex>(constraints)));
+            call_if_constexpr<default_op_index::value != std::tuple_size<constraints_type>::value>(
+                [&value](auto& constraints, auto /*idx*/) {
+                    constexpr size_t opIndex = default_op_index::value;
+                    value = std::make_unique<std::string>(serialize_default_value(std::get<opIndex>(constraints)));
                 },
                 this->constraints,
-                default_op_index_sequence{});
+                default_op_index{});
             return value;
         }
 
diff --git a/dev/prepared_statement.h b/dev/prepared_statement.h
index 50e309996..5a1061ad1 100644
--- a/dev/prepared_statement.h
+++ b/dev/prepared_statement.h
@@ -10,7 +10,7 @@
 #include "functional/cxx_universal.h"
 #include "functional/cxx_type_traits_polyfill.h"
 #include "functional/cxx_functional_polyfill.h"
-#include "tuple_helper/tuple_filter.h"
+#include "tuple_helper/tuple_traits.h"
 #include "connection_holder.h"
 #include "select_constraints.h"
 #include "values.h"
diff --git a/dev/schema/column.h b/dev/schema/column.h
index 5659ad4a2..94481df38 100644
--- a/dev/schema/column.h
+++ b/dev/schema/column.h
@@ -80,7 +80,7 @@ namespace sqlite_orm {
              */
             template<template<class...> class Trait>
             constexpr static bool is() {
-                return tuple_has<Trait, constraints_type>::value;
+                return tuple_has<constraints_type, Trait>::value;
             }
 
             /**
@@ -132,13 +132,13 @@ namespace sqlite_orm {
 
         template<class Elements, template<class...> class TraitFn>
         using col_index_sequence_with = filter_tuple_sequence_t<Elements,
-                                                                check_if_tuple_has<TraitFn>::template fn,
+                                                                check_if_has<TraitFn>::template fn,
                                                                 constraints_type_t,
                                                                 filter_tuple_sequence_t<Elements, is_column>>;
 
         template<class Elements, template<class...> class TraitFn>
         using col_index_sequence_excluding = filter_tuple_sequence_t<Elements,
-                                                                     check_if_tuple_has_not<TraitFn>::template fn,
+                                                                     check_if_has_not<TraitFn>::template fn,
                                                                      constraints_type_t,
                                                                      filter_tuple_sequence_t<Elements, is_column>>;
     }
diff --git a/dev/schema/index.h b/dev/schema/index.h
index 627c3fa6b..a846e51d9 100644
--- a/dev/schema/index.h
+++ b/dev/schema/index.h
@@ -5,7 +5,7 @@
 #include <utility>  //  std::forward
 
 #include "../functional/cxx_universal.h"
-#include "../tuple_helper/tuple_filter.h"
+#include "../tuple_helper/tuple_traits.h"
 #include "../indexed_column.h"
 #include "../table_type_of.h"
 
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index c5a60be30..9f27eeda0 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -9,10 +9,10 @@
 #include <tuple>  //  std::tuple, std::get, std::tuple_size
 #include "functional/cxx_optional.h"
 
-#include "functional/cxx_universal.h"
+#include "functional/cxx_universal.h"  //  ::size_t
 #include "functional/cxx_type_traits_polyfill.h"
 #include "is_base_of_template.h"
-#include "tuple_helper/tuple_filter.h"
+#include "tuple_helper/tuple_traits.h"
 #include "tuple_helper/tuple_transformer.h"
 #include "tuple_helper/tuple_iteration.h"
 #include "optional_container.h"
@@ -533,13 +533,13 @@ namespace sqlite_orm {
                                   std::is_convertible<ExplicitCols, std::string>>...>,
                               bool> = true>
     auto cte(ExplicitCols... explicitColumns) {
-        static_assert(internal::is_cte_moniker_v<Moniker>, "Moniker must be a CTE moniker");
-        static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
+        using namespace ::sqlite_orm::internal;
+        static_assert(is_cte_moniker_v<Moniker>, "Moniker must be a CTE moniker");
+        static_assert((!is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
                       "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
 
-        using builder_type = internal::cte_builder<
-            Moniker,
-            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column_t>>;
+        using builder_type =
+            cte_builder<Moniker, transform_tuple_t<std::tuple<ExplicitCols...>, decay_explicit_column_t>>;
         return builder_type{{std::move(explicitColumns)...}};
     }
 
@@ -551,12 +551,12 @@ namespace sqlite_orm {
                   std::convertible_to<ExplicitCols, std::string>) &&
                  ...)
     auto cte(ExplicitCols... explicitColumns) {
-        static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
+        using namespace ::sqlite_orm::internal;
+        static_assert((!is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
                       "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
 
-        using builder_type = internal::cte_builder<
-            decltype(moniker),
-            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column_t>>;
+        using builder_type =
+            cte_builder<decltype(moniker), transform_tuple_t<std::tuple<ExplicitCols...>, decay_explicit_column_t>>;
         return builder_type{{std::move(explicitColumns)...}};
     }
 #endif
diff --git a/dev/serializing_util.h b/dev/serializing_util.h
index b597077be..36fbc26dd 100644
--- a/dev/serializing_util.h
+++ b/dev/serializing_util.h
@@ -410,7 +410,7 @@ namespace sqlite_orm {
             });
             using constraints_tuple = decltype(column.constraints);
             constexpr bool hasExplicitNullableConstraint =
-                mpl::invoke_t<mpl::disjunction<check_if_tuple_has_type<null_t>, check_if_tuple_has_type<not_null_t>>,
+                mpl::invoke_t<mpl::disjunction<check_if_has_type<null_t>, check_if_has_type<not_null_t>>,
                               constraints_tuple>::value;
             if(!hasExplicitNullableConstraint) {
                 if(isNotNull) {
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index b12864af5..ed4c67aff 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -1688,7 +1688,7 @@ namespace sqlite_orm {
                 }
                 ss << streaming_serialized(get_column_names(sel.col, subCtx));
                 using conditions_tuple = typename statement_type::conditions_type;
-                constexpr bool hasExplicitFrom = tuple_has<is_from, conditions_tuple>::value;
+                constexpr bool hasExplicitFrom = tuple_has<conditions_tuple, is_from>::value;
                 if(!hasExplicitFrom) {
                     auto tableNames = collect_table_names(sel, context);
                     using joins_index_sequence = filter_tuple_sequence_t<conditions_tuple, is_constrained_join>;
diff --git a/dev/storage.h b/dev/storage.h
index 724c038f3..bf532051b 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -171,7 +171,7 @@ namespace sqlite_orm {
 
             template<class O>
             void assert_mapped_type() const {
-                static_assert(mpl::invoke_t<check_if_tuple_has_type<O, object_type_t>, db_objects_type>::value,
+                static_assert(mpl::invoke_t<check_if_has_type<O>, db_objects_type, mpl::quote_fn<object_type_t>>::value,
                               "type is not mapped to storage");
             }
 
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index b82cd64a4..ac2611865 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -2,8 +2,9 @@
 
 #include <string>  //  std::string
 
-#include "functional/cxx_universal.h"  //  ::nullptr_t
+#include "functional/cxx_universal.h"  //  ::size_t
 #include "functional/static_magic.h"
+#include "functional/index_sequence_util.h"
 #include "tuple_helper/tuple_traits.h"
 #include "tuple_helper/tuple_filter.h"
 #include "tuple_helper/tuple_iteration.h"
@@ -68,15 +69,15 @@ namespace sqlite_orm {
             using table_type = storage_pick_table_t<Moniker, DBOs>;
             using cte_mapper_type = cte_mapper_type_t<table_type>;
 
-            // filter all column references [`alias_holder<>`]
-            using alias_types_tuple =
-                transform_tuple_t<typename cte_mapper_type::final_colrefs_tuple, alias_holder_type_or_none_t>;
+            // lookup ColAlias in the final column references
+            using colalias_index =
+                find_tuple_type<typename cte_mapper_type::final_colrefs_tuple, alias_holder<ColAlias>>;
+            static_assert(colalias_index::value < std::tuple_size_v<typename cte_mapper_type::final_colrefs_tuple>,
+                          "No such column mapped into the CTE.");
 
-            // lookup index in alias_types_tuple by Alias
-            constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
-            static_assert(ColIdx != -1, "No such column mapped into the CTE.");
-
-            return &aliased_field<ColAlias, std::tuple_element_t<ColIdx, typename cte_mapper_type::fields_type>>::field;
+            return &aliased_field<
+                ColAlias,
+                std::tuple_element_t<colalias_index::value, typename cte_mapper_type::fields_type>>::field;
         }
 #endif
 
@@ -101,22 +102,19 @@ namespace sqlite_orm {
                                                   const column_pointer<Moniker, alias_holder<ColAlias>>&) {
             using table_type = storage_pick_table_t<Moniker, DBOs>;
             using cte_mapper_type = cte_mapper_type_t<table_type>;
-            using elements_t = typename table_type::elements_type;
-            using column_idxs = filter_tuple_sequence_t<elements_t, is_column>;
+            using column_index_sequence = filter_tuple_sequence_t<elements_type_t<table_type>, is_column>;
 
             // note: even though the columns contain the [`aliased_field<>::*`] we perform the lookup using the column references.
-            // filter all column references [`alias_holder<>`]
-            using alias_types_tuple =
-                transform_tuple_t<typename cte_mapper_type::final_colrefs_tuple, alias_holder_type_or_none_t>;
-
-            // lookup index of ColAlias in alias_types_tuple
-            constexpr auto I = tuple_index_of_v<ColAlias, alias_types_tuple>;
-            static_assert(I != -1, "No such column mapped into the CTE.");
+            // lookup ColAlias in the final column references
+            using colalias_index =
+                find_tuple_type<typename cte_mapper_type::final_colrefs_tuple, alias_holder<ColAlias>>;
+            static_assert(colalias_index::value < std::tuple_size_v<typename cte_mapper_type::final_colrefs_tuple>,
+                          "No such column mapped into the CTE.");
 
             // note: we could "materialize" the alias to an `aliased_field<>::*` and use the regular `table_t<>::find_column_name()` mechanism;
             //       however we have the column index already.
             // lookup column in table_t<>'s elements
-            constexpr size_t ColIdx = index_sequence_value(I, column_idxs{});
+            constexpr size_t ColIdx = index_sequence_value(colalias_index::value, column_index_sequence{});
             auto& table = pick_table<Moniker>(dboObjects);
             return &std::get<ColIdx>(table.elements).name;
         }
diff --git a/dev/tuple_helper/tuple_filter.h b/dev/tuple_helper/tuple_filter.h
index ea58ace1f..523a01206 100644
--- a/dev/tuple_helper/tuple_filter.h
+++ b/dev/tuple_helper/tuple_filter.h
@@ -77,16 +77,6 @@ namespace sqlite_orm {
                  class Seq = std::make_index_sequence<std::tuple_size<Tpl>::value>>
         using filter_tuple_t = tuple_from_index_sequence_t<Tpl, filter_tuple_sequence_t<Tpl, Pred, FilterProj, Seq>>;
 
-        /*
-         *  `Pred` is a metafunction that defines a bool member named `value`
-         *  `FilterProj` is a metafunction
-         */
-        template<class Tpl,
-                 template<class...>
-                 class Pred,
-                 template<class...> class FilterProj = polyfill::type_identity_t>
-        struct count_tuple : std::integral_constant<int, filter_tuple_sequence_t<Tpl, Pred, FilterProj>::size()> {};
-
         /*
          *  Count a tuple, picking only those elements specified in the index sequence.
          *  
diff --git a/dev/tuple_helper/tuple_traits.h b/dev/tuple_helper/tuple_traits.h
index 0f8154117..f596a3b09 100644
--- a/dev/tuple_helper/tuple_traits.h
+++ b/dev/tuple_helper/tuple_traits.h
@@ -1,76 +1,51 @@
 #pragma once
 
-#include <type_traits>  //  std::is_same
-#include <utility>  //  std::index_sequence, std::index_sequence_for
-#include <algorithm>  //  std::max
-#include <tuple>
-
-#include "../functional/cxx_universal.h"
 #include "../functional/cxx_type_traits_polyfill.h"
 #include "../functional/mpl.h"
 
 namespace sqlite_orm {
+    // convenience metafunction algorithms
     namespace internal {
-
-#ifdef SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
-        // cudos to OznOg https://stackoverflow.com/a/64606884/279251
-        template<class X, class Tuple>
-        struct tuple_index_of;
-
-        template<class X, class... T>
-        struct tuple_index_of<X, std::tuple<T...>> {
-            template<size_t... idx>
-            static constexpr ptrdiff_t find_idx(std::index_sequence<idx...>) {
-                return std::max({static_cast<ptrdiff_t>(std::is_same<X, T>::value ? idx : -1)...});
-            }
-
-            static constexpr ptrdiff_t value = find_idx(std::index_sequence_for<T...>{});
-        };
-        template<class X, class Tuple>
-        inline constexpr ptrdiff_t tuple_index_of_v = tuple_index_of<X, Tuple>::value;
-#endif
-
         /*
-         *  Higher-order trait metafunction that checks whether a tuple contains a type with given trait.
+         *  Higher-order trait metafunction that checks whether a tuple contains a type with given trait (possibly projected).
          */
-        template<template<class...> class TraitFn, class Tuple>
-        struct tuple_has {};
-        template<template<class...> class TraitFn, class... Types>
-        struct tuple_has<TraitFn, std::tuple<Types...>> : polyfill::disjunction<mpl::invoke_fn_t<TraitFn, Types>...> {};
+        template<class Pack,
+                 template<class...>
+                 class TraitFn,
+                 template<class...> class ProjOp = polyfill::type_identity_t>
+        using tuple_has = mpl::invoke_t<check_if_has<TraitFn>, Pack, mpl::quote_fn<ProjOp>>;
 
         /*
-         *  Trait metafunction class that checks whether a tuple contains a type with given trait.
+         *  Higher-order trait metafunction that checks whether a tuple contains the specified class template (possibly projected).
          */
-        template<template<class...> class TraitFn>
-        using check_if_tuple_has = mpl::bind_front_higherorder_fn<tuple_has, TraitFn>;
+        template<class Pack,
+                 template<class...>
+                 class Template,
+                 template<class...> class ProjOp = polyfill::type_identity_t>
+        using tuple_has_template = mpl::invoke_t<check_if_has_template<Template>, Pack, mpl::quote_fn<ProjOp>>;
 
         /*
-         *  Trait metafunction class that checks whether a tuple doesn't contain a type with given trait.
+         *  Higher-order metafunction returning the first index constant of the desired type in a tuple (possibly projected).
          */
-        template<template<class...> class TraitFn>
-        using check_if_tuple_has_not = mpl::not_<check_if_tuple_has<TraitFn>>;
+        template<class Pack, class Type, template<class...> class ProjOp = polyfill::type_identity_t>
+        using find_tuple_type = mpl::invoke_t<finds_if_has_type<Type>, Pack, mpl::quote_fn<ProjOp>>;
 
         /*
-         *  Metafunction class that checks whether a tuple contains given type.
+         *  Higher-order metafunction returning the first index constant of the desired class template in a tuple (possibly projected).
          */
-        template<class T, template<class...> class Proj = polyfill::type_identity_t>
-        using check_if_tuple_has_type =
-            mpl::bind_front_higherorder_fn<tuple_has, check_if_is_type<T, Proj>::template fn>;
+        template<class Pack,
+                 template<class...>
+                 class Template,
+                 template<class...> class ProjOp = polyfill::type_identity_t>
+        using find_tuple_template = mpl::invoke_t<finds_if_has_template<Template>, Pack, mpl::quote_fn<ProjOp>>;
 
         /*
-         *  Metafunction class that checks whether a tuple contains a given template.
-         *
-         *  Note: we are using 2 small tricks:
-         *  1. A template template parameter can be treated like a metafunction, so we can just "quote" a 'primary'
-         *     template into the MPL system (e.g. `std::vector`).
-         *  2. This metafunction class does the opposite of the trait function `is_specialization`:
-         *     `is_specialization` tries to instantiate the primary template template parameter using the
-         *     template parameters of a template type, then compares both instantiated types.
-         *     Here instead, `pass_extracted_fn_to` extracts the template template parameter from a template type,
-         *     then compares the resulting template template parameters.
+         *  Higher-order trait metafunction that counts the types having the specified trait in a tuple (possibly projected).
+         *  
+         *  `Pred` is a predicate metafunction with a nested bool member named `value`
+         *  `Proj` is a metafunction
          */
-        template<template<class...> class Primary>
-        using check_if_tuple_has_template =
-            mpl::bind_front_higherorder_fn<tuple_has, check_if_is_template<Primary>::template fn>;
+        template<class Pack, template<class...> class Pred, template<class...> class ProjOp = polyfill::type_identity_t>
+        using count_tuple = mpl::invoke_t<counts_if_has<Pred>, Pack, mpl::quote_fn<ProjOp>>;
     }
-}
\ No newline at end of file
+}
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 84e65e037..fc16b43a4 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -862,9 +862,10 @@ namespace sqlite_orm {
  */
 
 #include <type_traits>  //  std::enable_if, std::is_same
+#include <initializer_list>
 
 // #include "cxx_universal.h"
-
+//  ::size_t
 // #include "cxx_type_traits_polyfill.h"
 
 namespace sqlite_orm {
@@ -896,34 +897,35 @@ namespace sqlite_orm {
             /*
              *  The indirection through `defer_fn` works around the language inability
              *  to expand `Args...` into a fixed parameter list of an alias template.
+             *  
+             *  Also, legacy compilers need an extra layer of indirection, otherwise type replacement may fail
+             *  if alias template `Fn` has a dependent expression in it.
              */
             template<template<class...> class Fn, class... Args>
-            struct defer {
+            struct defer_fn {
                 using type = Fn<Args...>;
             };
 
-#ifndef SQLITE_ORM_BROKEN_ALIAS_TEMPLATE_DEPENDENT_EXPR_SFINAE
             /*
-             *  Invoke metafunction.
+             *  The indirection through `defer` works around the language inability
+             *  to expand `Args...` into a fixed parameter list of an alias template.
              */
-            template<template<class...> class Fn, class... Args>
-            using invoke_fn_t = Fn<Args...>;
-#else
+            template<class Q, class... Args>
+            struct defer {
+                using type = typename Q::template fn<Args...>;
+            };
+
             /*
              *  Invoke metafunction.
-             *  
-             *  Note: legacy compilers need an extra layer of indirection, otherwise type replacement may fail
-             *  if alias template `Fn` has a dependent expression in it.
              */
             template<template<class...> class Fn, class... Args>
-            using invoke_fn_t = typename defer<Fn, Args...>::type;
-#endif
+            using invoke_fn_t = typename defer_fn<Fn, Args...>::type;
 
             /*
              *  Invoke quoted metafunction by invoking its nested metafunction.
              */
             template<class Q, class... Args>
-            using invoke_t = typename Q::template fn<Args...>;
+            using invoke_t = typename defer<Q, Args...>::type;
 
             /*
              *  Turn metafunction into a quoted metafunction.
@@ -955,13 +957,18 @@ namespace sqlite_orm {
 
             template<>
             struct higherorder<0u> {
+                template<template<template<class...> class Fn, class... Args2> class HigherFn, class Q, class... Args>
+                struct defer_higher_fn {
+                    using type = HigherFn<Q::template fn, Args...>;
+                };
+
                 /*
                  *  Turn higher-order metafunction into a quoted metafunction.
                  */
                 template<template<template<class...> class Fn, class... Args2> class HigherFn>
                 struct quote_fn {
                     template<class Q, class... Args>
-                    using fn = HigherFn<Q::template fn, Args...>;
+                    using fn = typename defer_higher_fn<HigherFn, Q, Args...>::type;
                 };
             };
 
@@ -995,7 +1002,7 @@ namespace sqlite_orm {
             struct pass_result_of {
                 // invoke `Fn`, pass on their result
                 template<class... Args>
-                using fn = typename Q::template fn<typename defer<Fn, Args...>::type...>;
+                using fn = typename Q::template fn<typename defer_fn<Fn, Args...>::type...>;
             };
 
             /*
@@ -1088,6 +1095,102 @@ namespace sqlite_orm {
                      class... Bound>
             using bind_front_higherorder_fn =
                 bind_front<higherorder<0>::quote_fn<HigherFn>, quote_fn<BoundFn>, Bound...>;
+
+#ifdef SQLITE_ORM_RELAXED_CONSTEXPR_SUPPORTED
+            constexpr size_t find_first_true_helper(std::initializer_list<bool> values) {
+                size_t i = 0;
+                for(auto first = values.begin(); first != values.end() && !*first; ++first) {
+                    ++i;
+                }
+                return i;
+            }
+
+            constexpr size_t count_true_helper(std::initializer_list<bool> values) {
+                size_t n = 0;
+                for(auto first = values.begin(); first != values.end(); ++first) {
+                    n += *first;
+                }
+                return n;
+            }
+#else
+            constexpr size_t find_first_true_helper(const bool* first, const bool* end) {
+                return first == end || *first ? 0 : 1 + find_first_true_helper(first + 1, end);
+            }
+            constexpr size_t find_first_true_helper(const std::initializer_list<bool>& values) {
+                return find_first_true_helper(values.begin(), values.end());
+            }
+
+            constexpr size_t count_true_helper(const bool* first, const bool* end) {
+                return first == end ? 0 : *first + count_true_helper(first + 1, end);
+            }
+            constexpr size_t count_true_helper(const std::initializer_list<bool>& values) {
+                return count_true_helper(values.begin(), values.end());
+            }
+#endif
+
+            /*
+             *  Quoted metafunction that invokes the specified quoted predicate metafunction on each element of a type list,
+             *  and returns the index constant of the first element for which the predicate returns true.
+             */
+            template<class PredicateQ>
+            struct finds {
+                template<class Pack, class ProjectQ>
+                struct invoke_this_fn {
+                    static_assert(polyfill::always_false_v<Pack>,
+                                  "`finds` must be invoked with a type list as first argument.");
+                };
+
+                template<template<class...> class Pack, class... T, class ProjectQ>
+                struct invoke_this_fn<Pack<T...>, ProjectQ> {
+                    using type = polyfill::index_constant<find_first_true_helper(
+                        {PredicateQ::template fn<typename ProjectQ::template fn<T>>::value...})>;
+                };
+
+                template<class Pack, class ProjectQ = identity>
+                using fn = typename invoke_this_fn<Pack, ProjectQ>::type;
+            };
+
+            template<template<class...> class PredicateFn>
+            using finds_fn = finds<quote_fn<PredicateFn>>;
+
+            /*
+             *  Quoted metafunction that invokes the specified quoted predicate metafunction on each element of a type list,
+             *  and returns the index constant of the first element for which the predicate returns true.
+             */
+            template<class PredicateQ>
+            struct counts {
+                template<class Pack, class ProjectQ>
+                struct invoke_this_fn {
+                    static_assert(polyfill::always_false_v<Pack>,
+                                  "`counts` must be invoked with a type list as first argument.");
+                };
+
+                template<template<class...> class Pack, class... T, class ProjectQ>
+                struct invoke_this_fn<Pack<T...>, ProjectQ> {
+                    using type = polyfill::index_constant<count_true_helper(
+                        {PredicateQ::template fn<typename ProjectQ::template fn<T>>::value...})>;
+                };
+
+                template<class Pack, class ProjectQ = identity>
+                using fn = typename invoke_this_fn<Pack, ProjectQ>::type;
+            };
+
+            template<template<class...> class PredicateFn>
+            using counts_fn = counts<quote_fn<PredicateFn>>;
+
+            /*
+             *  Quoted metafunction that invokes the specified quoted predicate metafunction on each element of a type list,
+             *  and returns the index constant of the first element for which the predicate returns true.
+             */
+            template<class TraitQ>
+            struct contains {
+                template<class Pack, class ProjectQ = identity>
+                using fn =
+                    polyfill::bool_constant<static_cast<bool>(defer<counts<TraitQ>, Pack, ProjectQ>::type::value)>;
+            };
+
+            template<template<class...> class TraitFn>
+            using contains_fn = contains<quote_fn<TraitFn>>;
         }
     }
 
@@ -1108,12 +1211,10 @@ namespace sqlite_orm {
         using check_if_not = mpl::not_fn<TraitFn>;
 
         /*
-         *  Quoted trait metafunction that checks if a type (possibly projected) is the same as the specified type.
-         *  
-         *  `ProjOp` is a projection applied to `Type` and must be a metafunction.
+         *  Quoted trait metafunction that checks if a type is the same as the specified type.
          */
-        template<class Type, template<class...> class ProjOp = polyfill::type_identity_t>
-        using check_if_is_type = mpl::pass_result_of<mpl::bind_front_fn<std::is_same, Type>, ProjOp>;
+        template<class Type>
+        using check_if_is_type = mpl::bind_front_fn<std::is_same, Type>;
 
         /*
          *  Quoted trait metafunction that checks if a type's template matches the specified template
@@ -1122,6 +1223,57 @@ namespace sqlite_orm {
         template<template<class...> class Template>
         using check_if_is_template =
             mpl::pass_extracted_fn_to<mpl::bind_front_fn<std::is_same, mpl::quote_fn<Template>>>;
+
+        /*
+         *  Quoted metafunction that finds the index of the given type in a tuple.
+         */
+        template<class Type>
+        using finds_if_has_type = mpl::finds<check_if_is_type<Type>>;
+
+        /*
+         *  Quoted metafunction that finds the index of the given class template in a tuple.
+         */
+        template<template<class...> class Template>
+        using finds_if_has_template = mpl::finds<check_if_is_template<Template>>;
+
+        /*
+         *  Quoted trait metafunction that counts tuple elements having a given trait.
+         */
+        template<template<class...> class TraitFn>
+        using counts_if_has = mpl::counts_fn<TraitFn>;
+
+        /*
+         *  Quoted trait metafunction that checks whether a tuple contains a type with given trait.
+         */
+        template<template<class...> class TraitFn>
+        using check_if_has = mpl::contains_fn<TraitFn>;
+
+        /*
+         *  Quoted trait metafunction that checks whether a tuple doesn't contain a type with given trait.
+         */
+        template<template<class...> class TraitFn>
+        using check_if_has_not = mpl::not_<check_if_has<TraitFn>>;
+
+        /*
+         *  Quoted metafunction that checks whether a tuple contains given type.
+         */
+        template<class T>
+        using check_if_has_type = mpl::contains<check_if_is_type<T>>;
+
+        /*
+         *  Quoted metafunction that checks whether a tuple contains a given template.
+         *
+         *  Note: we are using 2 small tricks:
+         *  1. A template template parameter can be treated like a metafunction, so we can just "quote" a 'primary'
+         *     template into the MPL system (e.g. `std::vector`).
+         *  2. This quoted metafunction does the opposite of the trait metafunction `is_specialization`:
+         *     `is_specialization` tries to instantiate the primary template template parameter using the
+         *     template parameters of a template type, then compares both instantiated types.
+         *     Here instead, `pass_extracted_fn_to` extracts the template template parameter from a template type,
+         *     then compares the resulting template template parameters.
+         */
+        template<template<class...> class Template>
+        using check_if_has_template = mpl::contains<check_if_is_template<Template>>;
     }
 }
 
@@ -1174,82 +1326,57 @@ namespace sqlite_orm {
 
 // #include "tuple_helper/tuple_traits.h"
 
-#include <type_traits>  //  std::is_same
-#include <utility>  //  std::index_sequence, std::index_sequence_for
-#include <algorithm>  //  std::max
-#include <tuple>
-
-// #include "../functional/cxx_universal.h"
-
 // #include "../functional/cxx_type_traits_polyfill.h"
 
 // #include "../functional/mpl.h"
 
 namespace sqlite_orm {
+    // convenience metafunction algorithms
     namespace internal {
-
-#ifdef SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
-        // cudos to OznOg https://stackoverflow.com/a/64606884/279251
-        template<class X, class Tuple>
-        struct tuple_index_of;
-
-        template<class X, class... T>
-        struct tuple_index_of<X, std::tuple<T...>> {
-            template<size_t... idx>
-            static constexpr ptrdiff_t find_idx(std::index_sequence<idx...>) {
-                return std::max({static_cast<ptrdiff_t>(std::is_same<X, T>::value ? idx : -1)...});
-            }
-
-            static constexpr ptrdiff_t value = find_idx(std::index_sequence_for<T...>{});
-        };
-        template<class X, class Tuple>
-        inline constexpr ptrdiff_t tuple_index_of_v = tuple_index_of<X, Tuple>::value;
-#endif
-
         /*
-         *  Higher-order trait metafunction that checks whether a tuple contains a type with given trait.
+         *  Higher-order trait metafunction that checks whether a tuple contains a type with given trait (possibly projected).
          */
-        template<template<class...> class TraitFn, class Tuple>
-        struct tuple_has {};
-        template<template<class...> class TraitFn, class... Types>
-        struct tuple_has<TraitFn, std::tuple<Types...>> : polyfill::disjunction<mpl::invoke_fn_t<TraitFn, Types>...> {};
+        template<class Pack,
+                 template<class...>
+                 class TraitFn,
+                 template<class...> class ProjOp = polyfill::type_identity_t>
+        using tuple_has = mpl::invoke_t<check_if_has<TraitFn>, Pack, mpl::quote_fn<ProjOp>>;
 
         /*
-         *  Trait metafunction class that checks whether a tuple contains a type with given trait.
+         *  Higher-order trait metafunction that checks whether a tuple contains the specified class template (possibly projected).
          */
-        template<template<class...> class TraitFn>
-        using check_if_tuple_has = mpl::bind_front_higherorder_fn<tuple_has, TraitFn>;
+        template<class Pack,
+                 template<class...>
+                 class Template,
+                 template<class...> class ProjOp = polyfill::type_identity_t>
+        using tuple_has_template = mpl::invoke_t<check_if_has_template<Template>, Pack, mpl::quote_fn<ProjOp>>;
 
         /*
-         *  Trait metafunction class that checks whether a tuple doesn't contain a type with given trait.
+         *  Higher-order metafunction returning the first index constant of the desired type in a tuple (possibly projected).
          */
-        template<template<class...> class TraitFn>
-        using check_if_tuple_has_not = mpl::not_<check_if_tuple_has<TraitFn>>;
+        template<class Pack, class Type, template<class...> class ProjOp = polyfill::type_identity_t>
+        using find_tuple_type = mpl::invoke_t<finds_if_has_type<Type>, Pack, mpl::quote_fn<ProjOp>>;
 
         /*
-         *  Metafunction class that checks whether a tuple contains given type.
+         *  Higher-order metafunction returning the first index constant of the desired class template in a tuple (possibly projected).
          */
-        template<class T, template<class...> class Proj = polyfill::type_identity_t>
-        using check_if_tuple_has_type =
-            mpl::bind_front_higherorder_fn<tuple_has, check_if_is_type<T, Proj>::template fn>;
+        template<class Pack,
+                 template<class...>
+                 class Template,
+                 template<class...> class ProjOp = polyfill::type_identity_t>
+        using find_tuple_template = mpl::invoke_t<finds_if_has_template<Template>, Pack, mpl::quote_fn<ProjOp>>;
 
         /*
-         *  Metafunction class that checks whether a tuple contains a given template.
-         *
-         *  Note: we are using 2 small tricks:
-         *  1. A template template parameter can be treated like a metafunction, so we can just "quote" a 'primary'
-         *     template into the MPL system (e.g. `std::vector`).
-         *  2. This metafunction class does the opposite of the trait function `is_specialization`:
-         *     `is_specialization` tries to instantiate the primary template template parameter using the
-         *     template parameters of a template type, then compares both instantiated types.
-         *     Here instead, `pass_extracted_fn_to` extracts the template template parameter from a template type,
-         *     then compares the resulting template template parameters.
+         *  Higher-order trait metafunction that counts the types having the specified trait in a tuple (possibly projected).
+         *  
+         *  `Pred` is a predicate metafunction with a nested bool member named `value`
+         *  `Proj` is a metafunction
          */
-        template<template<class...> class Primary>
-        using check_if_tuple_has_template =
-            mpl::bind_front_higherorder_fn<tuple_has, check_if_is_template<Primary>::template fn>;
+        template<class Pack, template<class...> class Pred, template<class...> class ProjOp = polyfill::type_identity_t>
+        using count_tuple = mpl::invoke_t<counts_if_has<Pred>, Pack, mpl::quote_fn<ProjOp>>;
     }
 }
+
 // #include "tuple_helper/tuple_filter.h"
 
 #include <type_traits>  //  std::integral_constant, std::index_sequence, std::conditional, std::declval
@@ -1262,6 +1389,7 @@ namespace sqlite_orm {
 #include <utility>  //  std::index_sequence
 
 // #include "../functional/cxx_universal.h"
+//  ::size_t
 
 namespace sqlite_orm {
     namespace internal {
@@ -1381,16 +1509,6 @@ namespace sqlite_orm {
                  class Seq = std::make_index_sequence<std::tuple_size<Tpl>::value>>
         using filter_tuple_t = tuple_from_index_sequence_t<Tpl, filter_tuple_sequence_t<Tpl, Pred, FilterProj, Seq>>;
 
-        /*
-         *  `Pred` is a metafunction that defines a bool member named `value`
-         *  `FilterProj` is a metafunction
-         */
-        template<class Tpl,
-                 template<class...>
-                 class Pred,
-                 template<class...> class FilterProj = polyfill::type_identity_t>
-        struct count_tuple : std::integral_constant<int, filter_tuple_sequence_t<Tpl, Pred, FilterProj>::size()> {};
-
         /*
          *  Count a tuple, picking only those elements specified in the index sequence.
          *  
@@ -1926,12 +2044,12 @@ namespace sqlite_orm {
         template<typename T>
         struct is_primary_key_insertable
             : polyfill::disjunction<
-                  mpl::invoke_t<mpl::disjunction<check_if_tuple_has_template<default_t>,
-                                                 check_if_tuple_has_template<primary_key_with_autoincrement>>,
+                  mpl::invoke_t<mpl::disjunction<check_if_has_template<default_t>,
+                                                 check_if_has_template<primary_key_with_autoincrement>>,
                                 constraints_type_t<T>>,
                   std::is_base_of<integer_printer, type_printer<field_type_t<T>>>> {
 
-            static_assert(tuple_has<is_primary_key, constraints_type_t<T>>::value, "an unexpected type was passed");
+            static_assert(tuple_has<constraints_type_t<T>, is_primary_key>::value, "an unexpected type was passed");
         };
 
         template<class T>
@@ -2695,7 +2813,7 @@ namespace sqlite_orm {
              */
             template<template<class...> class Trait>
             constexpr static bool is() {
-                return tuple_has<Trait, constraints_type>::value;
+                return tuple_has<constraints_type, Trait>::value;
             }
 
             /**
@@ -2747,13 +2865,13 @@ namespace sqlite_orm {
 
         template<class Elements, template<class...> class TraitFn>
         using col_index_sequence_with = filter_tuple_sequence_t<Elements,
-                                                                check_if_tuple_has<TraitFn>::template fn,
+                                                                check_if_has<TraitFn>::template fn,
                                                                 constraints_type_t,
                                                                 filter_tuple_sequence_t<Elements, is_column>>;
 
         template<class Elements, template<class...> class TraitFn>
         using col_index_sequence_excluding = filter_tuple_sequence_t<Elements,
-                                                                     check_if_tuple_has_not<TraitFn>::template fn,
+                                                                     check_if_has_not<TraitFn>::template fn,
                                                                      constraints_type_t,
                                                                      filter_tuple_sequence_t<Elements, is_column>>;
     }
@@ -5307,7 +5425,7 @@ namespace sqlite_orm {
 
 // #include "is_base_of_template.h"
 
-// #include "tuple_helper/tuple_filter.h"
+// #include "tuple_helper/tuple_traits.h"
 
 // #include "conditions.h"
 
@@ -7454,12 +7572,12 @@ namespace sqlite_orm {
 // #include "functional/cxx_optional.h"
 
 // #include "functional/cxx_universal.h"
-
+//  ::size_t
 // #include "functional/cxx_type_traits_polyfill.h"
 
 // #include "is_base_of_template.h"
 
-// #include "tuple_helper/tuple_filter.h"
+// #include "tuple_helper/tuple_traits.h"
 
 // #include "tuple_helper/tuple_transformer.h"
 
@@ -8385,13 +8503,13 @@ namespace sqlite_orm {
                                   std::is_convertible<ExplicitCols, std::string>>...>,
                               bool> = true>
     auto cte(ExplicitCols... explicitColumns) {
-        static_assert(internal::is_cte_moniker_v<Moniker>, "Moniker must be a CTE moniker");
-        static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
+        using namespace ::sqlite_orm::internal;
+        static_assert(is_cte_moniker_v<Moniker>, "Moniker must be a CTE moniker");
+        static_assert((!is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
                       "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
 
-        using builder_type = internal::cte_builder<
-            Moniker,
-            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column_t>>;
+        using builder_type =
+            cte_builder<Moniker, transform_tuple_t<std::tuple<ExplicitCols...>, decay_explicit_column_t>>;
         return builder_type{{std::move(explicitColumns)...}};
     }
 
@@ -8403,12 +8521,12 @@ namespace sqlite_orm {
                   std::convertible_to<ExplicitCols, std::string>) &&
                  ...)
     auto cte(ExplicitCols... explicitColumns) {
-        static_assert((!internal::is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
+        using namespace ::sqlite_orm::internal;
+        static_assert((!is_builtin_numeric_column_alias_v<ExplicitCols> && ...),
                       "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
 
-        using builder_type = internal::cte_builder<
-            decltype(moniker),
-            internal::transform_tuple_t<std::tuple<ExplicitCols...>, internal::decay_explicit_column_t>>;
+        using builder_type =
+            cte_builder<decltype(moniker), transform_tuple_t<std::tuple<ExplicitCols...>, decay_explicit_column_t>>;
         return builder_type{{std::move(explicitColumns)...}};
     }
 #endif
@@ -10506,7 +10624,7 @@ namespace sqlite_orm {
 
 // #include "../functional/cxx_universal.h"
 
-// #include "../tuple_helper/tuple_filter.h"
+// #include "../tuple_helper/tuple_traits.h"
 
 // #include "../indexed_column.h"
 
@@ -11257,9 +11375,11 @@ namespace sqlite_orm {
 #include <string>  //  std::string
 
 // #include "functional/cxx_universal.h"
-//  ::nullptr_t
+//  ::size_t
 // #include "functional/static_magic.h"
 
+// #include "functional/index_sequence_util.h"
+
 // #include "tuple_helper/tuple_traits.h"
 
 // #include "tuple_helper/tuple_filter.h"
@@ -11558,15 +11678,15 @@ namespace sqlite_orm {
             using table_type = storage_pick_table_t<Moniker, DBOs>;
             using cte_mapper_type = cte_mapper_type_t<table_type>;
 
-            // filter all column references [`alias_holder<>`]
-            using alias_types_tuple =
-                transform_tuple_t<typename cte_mapper_type::final_colrefs_tuple, alias_holder_type_or_none_t>;
+            // lookup ColAlias in the final column references
+            using colalias_index =
+                find_tuple_type<typename cte_mapper_type::final_colrefs_tuple, alias_holder<ColAlias>>;
+            static_assert(colalias_index::value < std::tuple_size_v<typename cte_mapper_type::final_colrefs_tuple>,
+                          "No such column mapped into the CTE.");
 
-            // lookup index in alias_types_tuple by Alias
-            constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
-            static_assert(ColIdx != -1, "No such column mapped into the CTE.");
-
-            return &aliased_field<ColAlias, std::tuple_element_t<ColIdx, typename cte_mapper_type::fields_type>>::field;
+            return &aliased_field<
+                ColAlias,
+                std::tuple_element_t<colalias_index::value, typename cte_mapper_type::fields_type>>::field;
         }
 #endif
 
@@ -11591,22 +11711,19 @@ namespace sqlite_orm {
                                                   const column_pointer<Moniker, alias_holder<ColAlias>>&) {
             using table_type = storage_pick_table_t<Moniker, DBOs>;
             using cte_mapper_type = cte_mapper_type_t<table_type>;
-            using elements_t = typename table_type::elements_type;
-            using column_idxs = filter_tuple_sequence_t<elements_t, is_column>;
+            using column_index_sequence = filter_tuple_sequence_t<elements_type_t<table_type>, is_column>;
 
             // note: even though the columns contain the [`aliased_field<>::*`] we perform the lookup using the column references.
-            // filter all column references [`alias_holder<>`]
-            using alias_types_tuple =
-                transform_tuple_t<typename cte_mapper_type::final_colrefs_tuple, alias_holder_type_or_none_t>;
-
-            // lookup index of ColAlias in alias_types_tuple
-            constexpr auto I = tuple_index_of_v<ColAlias, alias_types_tuple>;
-            static_assert(I != -1, "No such column mapped into the CTE.");
+            // lookup ColAlias in the final column references
+            using colalias_index =
+                find_tuple_type<typename cte_mapper_type::final_colrefs_tuple, alias_holder<ColAlias>>;
+            static_assert(colalias_index::value < std::tuple_size_v<typename cte_mapper_type::final_colrefs_tuple>,
+                          "No such column mapped into the CTE.");
 
             // note: we could "materialize" the alias to an `aliased_field<>::*` and use the regular `table_t<>::find_column_name()` mechanism;
             //       however we have the column index already.
             // lookup column in table_t<>'s elements
-            constexpr size_t ColIdx = index_sequence_value(I, column_idxs{});
+            constexpr size_t ColIdx = index_sequence_value(colalias_index::value, column_index_sequence{});
             auto& table = pick_table<Moniker>(dboObjects);
             return &std::get<ColIdx>(table.elements).name;
         }
@@ -12678,15 +12795,12 @@ namespace sqlite_orm {
             using table_type = storage_pick_table_t<Moniker, DBOs>;
             using cte_mapper_type = cte_mapper_type_t<table_type>;
 
-            // filter all column references being `alias_holder<>`
-            using alias_types_tuple =
-                transform_tuple_t<typename cte_mapper_type::final_colrefs_tuple, alias_holder_type_or_none_t>;
-
-            // lookup index of ColAlias in alias_types_tuple
-            static constexpr auto ColIdx = tuple_index_of_v<ColAlias, alias_types_tuple>;
-            static_assert(ColIdx != -1, "No such column mapped into the CTE.");
-
-            using type = std::tuple_element_t<ColIdx, typename cte_mapper_type::fields_type>;
+            // lookup ColAlias in the final column references
+            using colalias_index =
+                find_tuple_type<typename cte_mapper_type::final_colrefs_tuple, alias_holder<ColAlias>>;
+            static_assert(colalias_index::value < std::tuple_size_v<typename cte_mapper_type::final_colrefs_tuple>,
+                          "No such column mapped into the CTE.");
+            using type = std::tuple_element_t<colalias_index::value, typename cte_mapper_type::fields_type>;
         };
 #endif
 
@@ -12988,7 +13102,7 @@ namespace sqlite_orm {
 
 // #include "functional/cxx_functional_polyfill.h"
 
-// #include "tuple_helper/tuple_filter.h"
+// #include "tuple_helper/tuple_traits.h"
 
 // #include "connection_holder.h"
 
@@ -13193,6 +13307,8 @@ namespace sqlite_orm {
 #include <sstream>  //  std::stringstream
 #include <type_traits>  //  std::false_type, std::true_type
 
+// #include "../tuple_helper/tuple_traits.h"
+
 // #include "../table_name_collector.h"
 
 #include <set>  //  std::set
@@ -15460,7 +15576,7 @@ namespace sqlite_orm {
             });
             using constraints_tuple = decltype(column.constraints);
             constexpr bool hasExplicitNullableConstraint =
-                mpl::invoke_t<mpl::disjunction<check_if_tuple_has_type<null_t>, check_if_tuple_has_type<not_null_t>>,
+                mpl::invoke_t<mpl::disjunction<check_if_has_type<null_t>, check_if_has_type<not_null_t>>,
                               constraints_tuple>::value;
             if(!hasExplicitNullableConstraint) {
                 if(isNotNull) {
@@ -17573,8 +17689,7 @@ namespace sqlite_orm {
                     (*this)(colExpr, context);
                 });
                 // note: `capacity() > size()` can occur in case `asterisk_t<>` does spell out the columns in defined order
-                if(mpl::invoke_t<check_if_tuple_has_template<asterisk_t>,
-                                 typename columns_t<Args...>::columns_type>::value &&
+                if(tuple_has_template<typename columns_t<Args...>::columns_type, asterisk_t>::value &&
                    this->collectedExpressions.capacity() > this->collectedExpressions.size()) {
                     this->collectedExpressions.shrink_to_fit();
                 }
@@ -19537,7 +19652,7 @@ namespace sqlite_orm {
                 }
                 ss << streaming_serialized(get_column_names(sel.col, subCtx));
                 using conditions_tuple = typename statement_type::conditions_type;
-                constexpr bool hasExplicitFrom = tuple_has<is_from, conditions_tuple>::value;
+                constexpr bool hasExplicitFrom = tuple_has<conditions_tuple, is_from>::value;
                 if(!hasExplicitFrom) {
                     auto tableNames = collect_table_names(sel, context);
                     using joins_index_sequence = filter_tuple_sequence_t<conditions_tuple, is_constrained_join>;
@@ -20442,9 +20557,9 @@ namespace sqlite_orm {
                                    const SubselectColRefs& subselectColRefs,
                                    [[maybe_unused]] const ExplicitColRefs& explicitColRefs,
                                    std::index_sequence<Idx...>) {
-            if constexpr(std::tuple_size_v < ExplicitColRefs >> 0) {
+            if constexpr(std::tuple_size_v<ExplicitColRefs> != 0) {
                 static_assert(
-                    (!internal::is_builtin_numeric_column_alias_v<
+                    (!is_builtin_numeric_column_alias_v<
                          alias_holder_type_or_none_t<std::tuple_element_t<Idx, ExplicitColRefs>>> &&
                      ...),
                     "Numeric column aliases are reserved for referencing columns locally within a single CTE.");
@@ -20659,7 +20774,7 @@ namespace sqlite_orm {
 
             template<class O>
             void assert_mapped_type() const {
-                static_assert(mpl::invoke_t<check_if_tuple_has_type<O, object_type_t>, db_objects_type>::value,
+                static_assert(mpl::invoke_t<check_if_has_type<O>, db_objects_type, mpl::quote_fn<object_type_t>>::value,
                               "type is not mapped to storage");
             }
 
@@ -22732,14 +22847,8 @@ namespace sqlite_orm {
 
 #include <memory>  //  std::make_unique
 
-// #include "../functional/cxx_core_features.h"
-
 // #include "../functional/static_magic.h"
 
-// #include "../functional/index_sequence_util.h"
-
-// #include "../tuple_helper/tuple_filter.h"
-
 // #include "../tuple_helper/tuple_traits.h"
 
 // #include "../default_value_extractor.h"
@@ -22751,18 +22860,16 @@ namespace sqlite_orm {
 
         template<class... Op>
         std::unique_ptr<std::string> column_constraints<Op...>::default_value() const {
-            using default_op_index_sequence =
-                filter_tuple_sequence_t<constraints_type, check_if_is_template<default_t>::template fn>;
+            using default_op_index = find_tuple_template<constraints_type, default_t>;
 
             std::unique_ptr<std::string> value;
-            call_if_constexpr<default_op_index_sequence::size()>(
-                [&value](auto& constraints, auto op_index_sequence) {
-                    using default_op_index_sequence = decltype(op_index_sequence);
-                    constexpr size_t opIndex = first_index_sequence_value(default_op_index_sequence{});
-                    value = std::make_unique<std::string>(serialize_default_value(get<opIndex>(constraints)));
+            call_if_constexpr<default_op_index::value != std::tuple_size<constraints_type>::value>(
+                [&value](auto& constraints, auto /*idx*/) {
+                    constexpr size_t opIndex = default_op_index::value;
+                    value = std::make_unique<std::string>(serialize_default_value(std::get<opIndex>(constraints)));
                 },
                 this->constraints,
-                default_op_index_sequence{});
+                default_op_index{});
             return value;
         }
 
diff --git a/tests/static_tests/functional/mpl.cpp b/tests/static_tests/functional/mpl.cpp
index 0646d8e8d..080d1a745 100644
--- a/tests/static_tests/functional/mpl.cpp
+++ b/tests/static_tests/functional/mpl.cpp
@@ -4,6 +4,7 @@
 #include <vector>
 #include <functional>  //  std::less
 
+namespace mpl = sqlite_orm::internal::mpl;
 using namespace sqlite_orm;
 using internal::literal_holder;
 
@@ -23,7 +24,6 @@ TEST_CASE("mpl") {
         mpl::pass_extracted_fn_to<mpl::bind_front_fn<std::is_same, mpl::quote_fn<std::vector>>>;
     using check_if_names_value_type = mpl::bind_front_higherorder_fn<polyfill::is_detected, value_type_t>;
     using predicate_type = std::less<void>;
-    using check_if_is_projected_type = internal::check_if_is_type<predicate_type::is_transparent, transparent_of_t>;
 
     STATIC_REQUIRE_FALSE(mpl::is_quoted_metafuntion_v<std::true_type>);
     STATIC_REQUIRE(mpl::is_quoted_metafuntion_v<mpl_is_same>);
@@ -55,6 +55,26 @@ TEST_CASE("mpl") {
     STATIC_REQUIRE(std::is_same<mpl::invoke_t<mpl::pass_result_of<mpl::identity, transparent_of_t>, predicate_type>,
                                 predicate_type::is_transparent>::value);
 
+    STATIC_REQUIRE(mpl::invoke_t<internal::check_if<std::is_same>, int, int>::value);
+    STATIC_REQUIRE_FALSE(mpl::invoke_t<internal::check_if_not<std::is_same>, int, int>::value);
     STATIC_REQUIRE(mpl::invoke_t<internal::check_if_is_type<predicate_type>, predicate_type>::value);
-    STATIC_REQUIRE(mpl::invoke_t<check_if_is_projected_type, predicate_type>::value);
+    STATIC_REQUIRE(mpl::invoke_t<internal::check_if_is_template<std::vector>, std::vector<int>>::value);
+
+    STATIC_REQUIRE(mpl::invoke_t<internal::check_if_has<std::is_null_pointer>, std::tuple<nullptr_t>>::value);
+    STATIC_REQUIRE_FALSE(mpl::invoke_t<internal::check_if_has_not<std::is_null_pointer>, std::tuple<nullptr_t>>::value);
+    STATIC_REQUIRE(mpl::invoke_t<internal::check_if_has_type<nullptr_t>, std::tuple<nullptr_t>>::value);
+    STATIC_REQUIRE(mpl::invoke_t<internal::check_if_has_type<nullptr_t*>,
+                                 std::tuple<nullptr_t>,
+                                 mpl::quote_fn<std::add_pointer_t>>::value);
+    STATIC_REQUIRE(
+        mpl::invoke_t<internal::check_if_has_template<std::vector>, std::tuple<std::vector<nullptr_t>>>::value);
+    STATIC_REQUIRE(mpl::invoke_t<internal::finds_if_has_type<nullptr_t>, std::tuple<nullptr_t>>::value == 0);
+    STATIC_REQUIRE(mpl::invoke_t<internal::finds_if_has_type<nullptr_t>, std::tuple<int>>::value == 1);
+    STATIC_REQUIRE(mpl::invoke_t<internal::finds_if_has_type<nullptr_t*>,
+                                 std::tuple<nullptr_t>,
+                                 mpl::quote_fn<std::add_pointer_t>>::value == 0);
+    STATIC_REQUIRE(mpl::invoke_t<internal::finds_if_has_template<std::vector>, std::tuple<std::vector<int>>>::value ==
+                   0);
+    STATIC_REQUIRE(mpl::invoke_t<internal::counts_if_has<std::is_null_pointer>, std::tuple<nullptr_t, int>>::value ==
+                   1);
 }
diff --git a/tests/static_tests/functional/tuple_traits.cpp b/tests/static_tests/functional/tuple_traits.cpp
index ae341e940..696a40a6a 100644
--- a/tests/static_tests/functional/tuple_traits.cpp
+++ b/tests/static_tests/functional/tuple_traits.cpp
@@ -2,9 +2,9 @@
 #include <catch2/catch_all.hpp>
 
 using namespace sqlite_orm;
-using internal::check_if_tuple_has;
-using internal::check_if_tuple_has_template;
-using internal::check_if_tuple_has_type;
+using internal::check_if_has;
+using internal::check_if_has_template;
+using internal::check_if_has_type;
 using internal::default_t;
 using internal::is_primary_key;
 using internal::primary_key_t;
@@ -13,9 +13,15 @@ TEST_CASE("tuple traits") {
     using empty_tuple_type = std::tuple<>;
     using tuple_type = std::tuple<int, char, default_t<int>, primary_key_t<>, std::string>;
 
-    STATIC_REQUIRE(mpl::invoke_t<check_if_tuple_has<is_primary_key>, tuple_type>::value);
-    STATIC_REQUIRE(mpl::invoke_t<check_if_tuple_has_type<int>, tuple_type>::value);
-    STATIC_REQUIRE(mpl::invoke_t<check_if_tuple_has_template<default_t>, tuple_type>::value);
-    STATIC_REQUIRE_FALSE(mpl::invoke_t<check_if_tuple_has_template<std::shared_ptr>, tuple_type>::value);
-    STATIC_REQUIRE_FALSE(mpl::invoke_t<check_if_tuple_has_template<default_t>, empty_tuple_type>::value);
+    STATIC_REQUIRE(mpl::invoke_t<check_if_has<is_primary_key>, tuple_type>::value);
+    STATIC_REQUIRE(mpl::invoke_t<check_if_has_type<int>, tuple_type>::value);
+    STATIC_REQUIRE(mpl::invoke_t<check_if_has_template<default_t>, tuple_type>::value);
+    STATIC_REQUIRE_FALSE(mpl::invoke_t<check_if_has_template<std::shared_ptr>, tuple_type>::value);
+    STATIC_REQUIRE_FALSE(mpl::invoke_t<check_if_has_template<default_t>, empty_tuple_type>::value);
+
+    STATIC_REQUIRE(internal::tuple_has<tuple_type, is_primary_key>::value);
+    STATIC_REQUIRE(internal::find_tuple_type<tuple_type, char>::value == 1);
+    STATIC_REQUIRE(internal::find_tuple_type<tuple_type, char*, std::add_pointer_t>::value == 1);
+    STATIC_REQUIRE(internal::find_tuple_type<tuple_type, double>::value == std::tuple_size<tuple_type>::value);
+    STATIC_REQUIRE(internal::count_tuple<tuple_type, is_primary_key>::value == 1);
 }

From 32fef0442efac439f28120899612aceb2b9e7b92 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 4 Apr 2024 11:32:26 +0200
Subject: [PATCH 157/161] Applied changes requested in PR review

---
 dev/alias.h                                   |  1 -
 dev/select_constraints.h                      |  1 +
 dev/statement_serializer.h                    |  5 ++-
 examples/common_table_expressions.cpp         | 37 ++++++++++++++-----
 include/sqlite_orm/sqlite_orm.h               |  7 ++--
 tests/ast_iterator_tests.cpp                  |  6 ---
 .../select_constraints.cpp                    | 17 ---------
 7 files changed, 35 insertions(+), 39 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 67a5f6e7b..18b87019c 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -4,7 +4,6 @@
 #include <utility>  //  std::make_index_sequence, std::move
 #include <string>  //  std::string
 #include <sstream>  //  std::stringstream
-#include <string>  //  std::string
 #ifdef SQLITE_ORM_WITH_CTE
 #include <array>
 #endif
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 8918f6c65..d59e00990 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -243,6 +243,7 @@ namespace sqlite_orm {
                 this->subselect.highest_level = true;
             }
         };
+
         template<class... CTEs>
         using common_table_expressions = std::tuple<CTEs...>;
 
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index e88e762d5..d40feef4f 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -590,16 +590,17 @@ namespace sqlite_orm {
             using statement_type = materialized_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) {
+            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
                 return "MATERIALIZED";
             }
         };
+
         template<>
         struct statement_serializer<not_materialized_t, void> {
             using statement_type = not_materialized_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) {
+            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
                 return "NOT MATERIALIZED";
             }
         };
diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 70d96e47f..349f012e9 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -542,7 +542,17 @@ void select_from_subselect() {
         return true;
     });
 
+    // alternative way of writing a subselect by using a CTE.
+    //
+    // original select from subquery:
     // SELECT * FROM (SELECT salary, comm AS commmission FROM emp) WHERE salary < 5000
+    //
+    // with CTE:
+    // WITH
+    //     sub AS(
+    //         SELECT salary, comm AS commmission FROM emp) WHERE salary < 5000
+    //     )
+    //  SELECT * from sub;
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     constexpr auto sub = "sub"_cte;
     auto expression = with(sub().as(select(columns(&Employee::m_salary, &Employee::m_commission))),
@@ -776,7 +786,7 @@ void show_optimization_fence() {
 
 void show_mapping_and_backreferencing() {
     struct Object {
-        int64 id;
+        int64 id = 0;
     };
 
     // column alias
@@ -790,7 +800,8 @@ void show_mapping_and_backreferencing() {
     auto storage = make_storage("", make_table("object", make_column("id", &Object::id)));
     storage.sync_schema();
 
-    // back-reference via `column_pointer<cte_1, F O::*>`
+    // back-reference via `column_pointer<cte_1, F O::*>`;
+    // WITH "1"("id") AS (SELECT "object"."id" FROM "object") SELECT "1"."id" FROM "1"
     {
         auto ast = with(cte<cte_1>().as(select(&Object::id)), select(column<cte_1>(&Object::id)));
 
@@ -799,7 +810,8 @@ void show_mapping_and_backreferencing() {
     }
 
     // map column via alias_holder into cte,
-    // back-reference via `column_pointer<cte_1, alias_holder>`
+    // back-reference via `column_pointer<cte_1, alias_holder>`;
+    // WITH "1"("x") AS (SELECT 1 AS "counter" UNION ALL SELECT "1"."x" + 1 FROM "1" LIMIT 10) SELECT "1"."x" FROM "1"
     {
         auto ast =
             with(cte<cte_1>("x").as(union_all(select(as<cnt>(1)), select(column<cte_1>(get<cnt>()) + 1, limit(10)))),
@@ -809,7 +821,8 @@ void show_mapping_and_backreferencing() {
         auto stmt = storage.prepare(ast);
     }
     // map column via alias_holder into cte,
-    // back-reference via `column_pointer<cte_1, alias_holder>`
+    // back-reference via `column_pointer<cte_1, alias_holder>`;
+    // WITH "1"("x") AS (SELECT 1 AS "counter" UNION ALL SELECT "1"."x" + 1 FROM "1" LIMIT 10) SELECT "1"."x" FROM "1"
     {
         auto ast = with(cte<cte_1>("x").as(union_all(select(as<cnt>(1)), select(column<cte_1>(cnt{}) + 1, limit(10)))),
                         select(column<cte_1>(cnt{})));
@@ -818,7 +831,8 @@ void show_mapping_and_backreferencing() {
         auto stmt = storage.prepare(ast);
     }
 
-    // implicitly remap column into cte
+    // implicitly remap column into cte;
+    // WITH "1"("id") AS (SELECT "object"."id" FROM "object") SELECT "1"."id" FROM "1"
     {
         auto ast = with(cte<cte_1>(std::ignore).as(select(&Object::id)), select(column<cte_1>(&Object::id)));
 
@@ -826,7 +840,8 @@ void show_mapping_and_backreferencing() {
         auto stmt = storage.prepare(ast);
     }
 
-    // explicitly remap column into cte (independent of subselect)
+    // explicitly remap column into cte (independent of subselect);
+    // WITH "1"("id") AS (SELECT "object"."id" FROM "object") SELECT "1"."id" FROM "1"
     {
         auto ast = with(cte<cte_1>(&Object::id).as(select(&Object::id)), select(column<cte_1>(&Object::id)));
 
@@ -834,7 +849,8 @@ void show_mapping_and_backreferencing() {
         auto stmt = storage.prepare(ast);
     }
 
-    // explicitly remap column as an alias into cte (independent of subselect)
+    // explicitly remap column as an alias into cte (independent of subselect);
+    // WITH "1"("counter") AS (SELECT "object"."id" FROM "object") SELECT "1"."counter" FROM "1"
     {
         auto ast = with(cte<cte_1>(cnt{}).as(select(&Object::id)), select(column<cte_1>(get<cnt>())));
 
@@ -842,7 +858,8 @@ void show_mapping_and_backreferencing() {
         auto stmt = storage.prepare(ast);
     }
 
-    // explicitly state that column name should be taken from subselect
+    // explicitly state that column name should be taken from subselect;
+    // WITH "CTEObj"("xyz") AS (SELECT "object"."id" FROM "object") SELECT "CTEObj"."xyz" FROM "CTEObj"
     {
         struct CTEObject : alias_tag {
             // a CTE object is its own table alias
@@ -852,7 +869,7 @@ void show_mapping_and_backreferencing() {
                 return "CTEObj";
             }
 
-            int64 xyz;
+            int64 xyz = 0;
         };
         auto ast =
             with(cte<CTEObject>(make_column("xyz", &CTEObject::xyz)).as(select(&Object::id)), select(&CTEObject::xyz));
@@ -964,7 +981,7 @@ void greatest_n_per_group() {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     // Having a table consisting of multiple results for items,
     // I want to select a single result row per item, based on a condition like an aggregated value.
-    // This is possible using a (self) join and filtering by aggregated value (in case it is unique), or using window functions.
+    // This is possible using a (self) join and filtering by aggregated value (in case it is unique) or using window functions.
     //
     // In this example, we select the most recent (successful) result per item
 
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 25b2f7003..88fa8302a 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4971,7 +4971,6 @@ namespace sqlite_orm {
 #include <utility>  //  std::make_index_sequence, std::move
 #include <string>  //  std::string
 #include <sstream>  //  std::stringstream
-#include <string>  //  std::string
 #ifdef SQLITE_ORM_WITH_CTE
 #include <array>
 #endif
@@ -8296,6 +8295,7 @@ namespace sqlite_orm {
                 this->subselect.highest_level = true;
             }
         };
+
         template<class... CTEs>
         using common_table_expressions = std::tuple<CTEs...>;
 
@@ -18651,16 +18651,17 @@ namespace sqlite_orm {
             using statement_type = materialized_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) {
+            std::string_view operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
                 return "MATERIALIZED";
             }
         };
+
         template<>
         struct statement_serializer<not_materialized_t, void> {
             using statement_type = not_materialized_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) {
+            std::string_view operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
                 return "NOT MATERIALIZED";
             }
         };
diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index 8effb9d58..632d697b7 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -336,14 +336,12 @@ TEST_CASE("ast_iterator") {
         auto expression = with(cte<cte_1>().as(select(1)), select(column<cte_1>(1_colalias)));
         expected.insert(expected.cend(), {typeid(int), typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>)});
         iterate_ast(expression, lambda);
-        REQUIRE(typeIndexes == expected);
     }
     SECTION("with not enforced recursive") {
         using cte_1 = decltype(1_ctealias);
         auto expression = with_recursive(cte<cte_1>().as(select(1)), select(column<cte_1>(1_colalias)));
         expected.insert(expected.cend(), {typeid(int), typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>)});
         iterate_ast(expression, lambda);
-        REQUIRE(typeIndexes == expected);
     }
     SECTION("with optional recursive") {
         using cte_1 = decltype(1_ctealias);
@@ -359,7 +357,6 @@ TEST_CASE("ast_iterator") {
                          typeid(int),
                          typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>)});
         iterate_ast(expression, lambda);
-        REQUIRE(typeIndexes == expected);
     }
     SECTION("with recursive") {
         using cte_1 = decltype(1_ctealias);
@@ -375,7 +372,6 @@ TEST_CASE("ast_iterator") {
                          typeid(int),
                          typeid(column_pointer<cte_1, alias_holder<column_alias<'1'>>>)});
         iterate_ast(expression, lambda);
-        REQUIRE(typeIndexes == expected);
     }
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     SECTION("aliased CTE column pointer") {
@@ -385,7 +381,6 @@ TEST_CASE("ast_iterator") {
         auto expression = z_alias->*&User::id;
         expected.push_back(typeid(alias_column_t<alias_z<cte_1>, column_pointer<cte_1, decltype(&User::id)>>));
         iterate_ast(expression, lambda);
-        REQUIRE(typeIndexes == expected);
     }
     SECTION("aliased CTE column alias") {
         constexpr auto c = "1"_cte;
@@ -395,7 +390,6 @@ TEST_CASE("ast_iterator") {
         expected.push_back(
             typeid(alias_column_t<alias_z<cte_1>, column_pointer<cte_1, alias_holder<column_alias<'1'>>>>));
         iterate_ast(expression, lambda);
-        REQUIRE(typeIndexes == expected);
     }
 #endif
 #endif
diff --git a/tests/statement_serializer_tests/select_constraints.cpp b/tests/statement_serializer_tests/select_constraints.cpp
index 1f4e91460..4ed04d060 100644
--- a/tests/statement_serializer_tests/select_constraints.cpp
+++ b/tests/statement_serializer_tests/select_constraints.cpp
@@ -103,65 +103,55 @@ TEST_CASE("statement_serializer select constraints") {
             auto expression = from<cte_1>();
             value = serialize(expression, context);
             expected = R"(FROM "1")";
-            REQUIRE(value == expected);
         }
         SECTION("with alias 1") {
             auto expression = from<alias_z<cte_1>>();
             value = serialize(expression, context);
             expected = R"(FROM "1" "z")";
-            REQUIRE(value == expected);
         }
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
         SECTION("without alias 2") {
             auto expression = from<1_ctealias>();
             value = serialize(expression, context);
             expected = R"(FROM "1")";
-            REQUIRE(value == expected);
         }
         SECTION("with alias 2") {
             constexpr auto z_alias = "z"_alias.for_<1_ctealias>();
             auto expression = from<z_alias>();
             value = serialize(expression, context);
             expected = R"(FROM "1" "z")";
-            REQUIRE(value == expected);
         }
         SECTION("as") {
             auto expression = cte<cte_1>().as(select(1));
             value = serialize(expression, context);
             expected = R"("1"("1") AS (SELECT 1))";
-            REQUIRE(value == expected);
         }
         SECTION("as materialized") {
             auto expression = cte<cte_1>().as<materialized()>(select(1));
             value = serialize(expression, context);
             expected = R"("1"("1") AS MATERIALIZED (SELECT 1))";
-            REQUIRE(value == expected);
         }
         SECTION("as not materialized") {
             auto expression = cte<cte_1>().as<not_materialized()>(select(1));
             value = serialize(expression, context);
             expected = R"("1"("1") AS NOT MATERIALIZED (SELECT 1))";
-            REQUIRE(value == expected);
         }
 #endif
         SECTION("with ordinary") {
             auto expression = with(cte<cte_1>().as(select(1)), select(column<cte_1>(1_colalias)));
             value = serialize(expression, context);
             expected = R"(WITH "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1")";
-            REQUIRE(value == expected);
         }
         SECTION("with ordinary, compound") {
             auto expression = with(cte<cte_1>().as(select(1)),
                                    union_all(select(column<cte_1>(1_colalias)), select(column<cte_1>(1_colalias))));
             value = serialize(expression, context);
             expected = R"(WITH "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1" UNION ALL SELECT "1"."1" FROM "1")";
-            REQUIRE(value == expected);
         }
         SECTION("with not enforced recursive") {
             auto expression = with_recursive(cte<cte_1>().as(select(1)), select(column<cte_1>(1_colalias)));
             value = serialize(expression, context);
             expected = R"(WITH RECURSIVE "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1")";
-            REQUIRE(value == expected);
         }
         SECTION("with not enforced recursive, compound") {
             auto expression =
@@ -170,14 +160,12 @@ TEST_CASE("statement_serializer select constraints") {
             value = serialize(expression, context);
             expected =
                 R"(WITH RECURSIVE "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1" UNION ALL SELECT "1"."1" FROM "1")";
-            REQUIRE(value == expected);
         }
         SECTION("with ordinary, multiple") {
             auto expression = with(std::make_tuple(cte<cte_1>().as(select(1)), cte<cte_1>().as(select(1))),
                                    select(column<cte_1>(1_colalias)));
             value = serialize(expression, context);
             expected = R"(WITH "1"("1") AS (SELECT 1), "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1")";
-            REQUIRE(value == expected);
         }
         SECTION("with ordinary, multiple, compound") {
             auto expression = with(std::make_tuple(cte<cte_1>().as(select(1)), cte<cte_1>().as(select(1))),
@@ -185,14 +173,12 @@ TEST_CASE("statement_serializer select constraints") {
             value = serialize(expression, context);
             expected =
                 R"(WITH "1"("1") AS (SELECT 1), "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1" UNION ALL SELECT "1"."1" FROM "1")";
-            REQUIRE(value == expected);
         }
         SECTION("with not enforced recursive, multiple") {
             auto expression = with_recursive(std::make_tuple(cte<cte_1>().as(select(1)), cte<cte_1>().as(select(1))),
                                              select(column<cte_1>(1_colalias)));
             value = serialize(expression, context);
             expected = R"(WITH RECURSIVE "1"("1") AS (SELECT 1), "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1")";
-            REQUIRE(value == expected);
         }
         SECTION("with not enforced recursive, multiple, compound") {
             auto expression =
@@ -201,7 +187,6 @@ TEST_CASE("statement_serializer select constraints") {
             value = serialize(expression, context);
             expected =
                 R"(WITH RECURSIVE "1"("1") AS (SELECT 1), "1"("1") AS (SELECT 1) SELECT "1"."1" FROM "1" UNION ALL SELECT "1"."1" FROM "1")";
-            REQUIRE(value == expected);
         }
         SECTION("with optional recursive") {
             auto expression = with(
@@ -211,7 +196,6 @@ TEST_CASE("statement_serializer select constraints") {
             value = serialize(expression, context);
             expected =
                 R"(WITH "1"("1") AS (SELECT 1 UNION ALL SELECT "1"."1" + 1 FROM "1" WHERE ("1"."1" < 10)) SELECT "1"."1" FROM "1")";
-            REQUIRE(value == expected);
         }
         SECTION("with recursive") {
             auto expression = with_recursive(
@@ -221,7 +205,6 @@ TEST_CASE("statement_serializer select constraints") {
             value = serialize(expression, context);
             expected =
                 R"(WITH RECURSIVE "1"("1") AS (SELECT 1 UNION ALL SELECT "1"."1" + 1 FROM "1" WHERE ("1"."1" < 10)) SELECT "1"."1" FROM "1")";
-            REQUIRE(value == expected);
         }
     }
 #endif

From 4997b7d31b74f49810dabe262762e39829dc842d Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 4 Apr 2024 13:21:21 +0200
Subject: [PATCH 158/161] Use of a string_view for serialization in several
 places

---
 dev/column_names_getter.h        |  2 +-
 dev/cte_column_names_collector.h |  2 +-
 dev/default_value_extractor.h    |  2 +-
 dev/serializing_util.h           |  2 +-
 dev/statement_serializer.h       | 30 +++++++++++++++------------
 include/sqlite_orm/sqlite_orm.h  | 35 ++++++++++++++++++--------------
 6 files changed, 41 insertions(+), 32 deletions(-)

diff --git a/dev/column_names_getter.h b/dev/column_names_getter.h
index 18e443a52..3b95f0018 100644
--- a/dev/column_names_getter.h
+++ b/dev/column_names_getter.h
@@ -22,7 +22,7 @@ namespace sqlite_orm {
     namespace internal {
 
         template<class T, class C>
-        std::string serialize(const T& t, const C& context);
+        auto serialize(const T& t, const C& context);
 
         template<class T, class Ctx>
         std::vector<std::string>& collect_table_column_names(std::vector<std::string>& collectedExpressions,
diff --git a/dev/cte_column_names_collector.h b/dev/cte_column_names_collector.h
index da1f2dd3a..71a2fe58a 100644
--- a/dev/cte_column_names_collector.h
+++ b/dev/cte_column_names_collector.h
@@ -21,7 +21,7 @@ namespace sqlite_orm {
     namespace internal {
         // collecting column names utilizes the statement serializer
         template<class T, class C>
-        std::string serialize(const T& t, const C& context);
+        auto serialize(const T& t, const C& context);
 
         inline void unquote_identifier(std::string& identifier) {
             if(!identifier.empty()) {
diff --git a/dev/default_value_extractor.h b/dev/default_value_extractor.h
index 071a20387..01002cdc4 100644
--- a/dev/default_value_extractor.h
+++ b/dev/default_value_extractor.h
@@ -11,7 +11,7 @@ namespace sqlite_orm {
     namespace internal {
 
         template<class T, class C>
-        std::string serialize(const T& t, const C& context);
+        auto serialize(const T& t, const C& context);
 
         /**
          *  Serialize default value of a column's default valu
diff --git a/dev/serializing_util.h b/dev/serializing_util.h
index 16a4fb8ea..9734965a1 100644
--- a/dev/serializing_util.h
+++ b/dev/serializing_util.h
@@ -21,7 +21,7 @@ namespace sqlite_orm {
         struct order_by_t;
 
         template<class T, class C>
-        std::string serialize(const T& t, const C& context);
+        auto serialize(const T& t, const C& context);
 
         template<class T, class Ctx>
         std::string serialize_order_by(const T&, const Ctx&);
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index d40feef4f..dc37c1747 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -42,6 +42,7 @@
 #include "cte_column_names_collector.h"
 #include "order_by_serializer.h"
 #include "serializing_util.h"
+#include "serialize_result_type.h"
 #include "statement_binder.h"
 #include "values.h"
 #include "schema/triggers.h"
@@ -58,7 +59,7 @@ namespace sqlite_orm {
         struct statement_serializer;
 
         template<class T, class C>
-        std::string serialize(const T& t, const C& context) {
+        auto serialize(const T& t, const C& context) {
             statement_serializer<T> serializer;
             return serializer(t, context);
         }
@@ -148,7 +149,7 @@ namespace sqlite_orm {
             }
 
             template<class Ctx>
-            std::string serialize(const statement_type& statement, const Ctx& context, const std::string& tableName) {
+            auto serialize(const statement_type& statement, const Ctx& context, const std::string& tableName) {
                 std::stringstream ss;
                 ss << "CREATE TABLE " << streaming_identifier(tableName) << " ( "
                    << streaming_expressions_tuple(statement.elements, context) << ")";
@@ -426,7 +427,7 @@ namespace sqlite_orm {
             using statement_type = rank_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& /*statement*/, const Ctx&) const {
+            serialize_result_type operator()(const statement_type& /*statement*/, const Ctx&) const {
                 return "rank";
             }
         };
@@ -590,7 +591,7 @@ namespace sqlite_orm {
             using statement_type = materialized_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
+            std::string_view operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
                 return "MATERIALIZED";
             }
         };
@@ -600,7 +601,7 @@ namespace sqlite_orm {
             using statement_type = not_materialized_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
+            std::string_view operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
                 return "NOT MATERIALIZED";
             }
         };
@@ -950,7 +951,7 @@ namespace sqlite_orm {
             using statement_type = conflict_clause_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx&) const {
+            serialize_result_type operator()(const statement_type& statement, const Ctx&) const {
                 switch(statement) {
                     case conflict_clause_t::rollback:
                         return "ROLLBACK";
@@ -982,7 +983,7 @@ namespace sqlite_orm {
             using statement_type = null_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
+            serialize_result_type operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
                 return "NULL";
             }
         };
@@ -992,7 +993,7 @@ namespace sqlite_orm {
             using statement_type = not_null_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
+            serialize_result_type operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
                 return "NOT NULL";
             }
         };
@@ -1630,7 +1631,7 @@ namespace sqlite_orm {
             using statement_type = conflict_action;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx&) const {
+            serialize_result_type operator()(const statement_type& statement, const Ctx&) const {
                 switch(statement) {
                     case conflict_action::replace:
                         return "REPLACE";
@@ -1653,7 +1654,10 @@ namespace sqlite_orm {
 
             template<class Ctx>
             std::string operator()(const statement_type& statement, const Ctx& context) const {
-                return "OR " + serialize(statement.action, context);
+                std::stringstream ss;
+
+                ss << "OR " << serialize(statement.action, context);
+                return ss.str();
             }
         };
 
@@ -1888,7 +1892,7 @@ namespace sqlite_orm {
             using statement_type = trigger_timing;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx&) const {
+            serialize_result_type operator()(const statement_type& statement, const Ctx&) const {
                 switch(statement) {
                     case trigger_timing::trigger_before:
                         return "BEFORE";
@@ -1906,7 +1910,7 @@ namespace sqlite_orm {
             using statement_type = trigger_type;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx&) const {
+            serialize_result_type operator()(const statement_type& statement, const Ctx&) const {
                 switch(statement) {
                     case trigger_type::trigger_delete:
                         return "DELETE";
@@ -2157,7 +2161,7 @@ namespace sqlite_orm {
             using statement_type = default_values_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type&, const Ctx&) const {
+            serialize_result_type operator()(const statement_type&, const Ctx&) const {
                 return "DEFAULT VALUES";
             }
         };
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 88fa8302a..748ca2c4a 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -11831,7 +11831,7 @@ namespace sqlite_orm {
     namespace internal {
 
         template<class T, class C>
-        std::string serialize(const T& t, const C& context);
+        auto serialize(const T& t, const C& context);
 
         /**
          *  Serialize default value of a column's default valu
@@ -15282,7 +15282,7 @@ namespace sqlite_orm {
         struct order_by_t;
 
         template<class T, class C>
-        std::string serialize(const T& t, const C& context);
+        auto serialize(const T& t, const C& context);
 
         template<class T, class Ctx>
         std::string serialize_order_by(const T&, const Ctx&);
@@ -17710,7 +17710,7 @@ namespace sqlite_orm {
     namespace internal {
 
         template<class T, class C>
-        std::string serialize(const T& t, const C& context);
+        auto serialize(const T& t, const C& context);
 
         template<class T, class Ctx>
         std::vector<std::string>& collect_table_column_names(std::vector<std::string>& collectedExpressions,
@@ -17834,7 +17834,7 @@ namespace sqlite_orm {
     namespace internal {
         // collecting column names utilizes the statement serializer
         template<class T, class C>
-        std::string serialize(const T& t, const C& context);
+        auto serialize(const T& t, const C& context);
 
         inline void unquote_identifier(std::string& identifier) {
             if(!identifier.empty()) {
@@ -18097,6 +18097,8 @@ namespace sqlite_orm {
 
 // #include "serializing_util.h"
 
+// #include "serialize_result_type.h"
+
 // #include "statement_binder.h"
 
 // #include "values.h"
@@ -18119,7 +18121,7 @@ namespace sqlite_orm {
         struct statement_serializer;
 
         template<class T, class C>
-        std::string serialize(const T& t, const C& context) {
+        auto serialize(const T& t, const C& context) {
             statement_serializer<T> serializer;
             return serializer(t, context);
         }
@@ -18209,7 +18211,7 @@ namespace sqlite_orm {
             }
 
             template<class Ctx>
-            std::string serialize(const statement_type& statement, const Ctx& context, const std::string& tableName) {
+            auto serialize(const statement_type& statement, const Ctx& context, const std::string& tableName) {
                 std::stringstream ss;
                 ss << "CREATE TABLE " << streaming_identifier(tableName) << " ( "
                    << streaming_expressions_tuple(statement.elements, context) << ")";
@@ -18487,7 +18489,7 @@ namespace sqlite_orm {
             using statement_type = rank_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& /*statement*/, const Ctx&) const {
+            serialize_result_type operator()(const statement_type& /*statement*/, const Ctx&) const {
                 return "rank";
             }
         };
@@ -19011,7 +19013,7 @@ namespace sqlite_orm {
             using statement_type = conflict_clause_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx&) const {
+            serialize_result_type operator()(const statement_type& statement, const Ctx&) const {
                 switch(statement) {
                     case conflict_clause_t::rollback:
                         return "ROLLBACK";
@@ -19043,7 +19045,7 @@ namespace sqlite_orm {
             using statement_type = null_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
+            serialize_result_type operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
                 return "NULL";
             }
         };
@@ -19053,7 +19055,7 @@ namespace sqlite_orm {
             using statement_type = not_null_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
+            serialize_result_type operator()(const statement_type& /*statement*/, const Ctx& /*context*/) const {
                 return "NOT NULL";
             }
         };
@@ -19691,7 +19693,7 @@ namespace sqlite_orm {
             using statement_type = conflict_action;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx&) const {
+            serialize_result_type operator()(const statement_type& statement, const Ctx&) const {
                 switch(statement) {
                     case conflict_action::replace:
                         return "REPLACE";
@@ -19714,7 +19716,10 @@ namespace sqlite_orm {
 
             template<class Ctx>
             std::string operator()(const statement_type& statement, const Ctx& context) const {
-                return "OR " + serialize(statement.action, context);
+                std::stringstream ss;
+
+                ss << "OR " << serialize(statement.action, context);
+                return ss.str();
             }
         };
 
@@ -19949,7 +19954,7 @@ namespace sqlite_orm {
             using statement_type = trigger_timing;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx&) const {
+            serialize_result_type operator()(const statement_type& statement, const Ctx&) const {
                 switch(statement) {
                     case trigger_timing::trigger_before:
                         return "BEFORE";
@@ -19967,7 +19972,7 @@ namespace sqlite_orm {
             using statement_type = trigger_type;
 
             template<class Ctx>
-            std::string operator()(const statement_type& statement, const Ctx&) const {
+            serialize_result_type operator()(const statement_type& statement, const Ctx&) const {
                 switch(statement) {
                     case trigger_type::trigger_delete:
                         return "DELETE";
@@ -20218,7 +20223,7 @@ namespace sqlite_orm {
             using statement_type = default_values_t;
 
             template<class Ctx>
-            std::string operator()(const statement_type&, const Ctx&) const {
+            serialize_result_type operator()(const statement_type&, const Ctx&) const {
                 return "DEFAULT VALUES";
             }
         };

From 21a1a630be13e69495a2b1c6eed05214a3de3957 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 4 Apr 2024 16:13:58 +0200
Subject: [PATCH 159/161] Used standardized time types

---
 examples/common_table_expressions.cpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/examples/common_table_expressions.cpp b/examples/common_table_expressions.cpp
index 349f012e9..1410980cc 100644
--- a/examples/common_table_expressions.cpp
+++ b/examples/common_table_expressions.cpp
@@ -14,6 +14,9 @@
 #include <tuple>
 #include <iostream>
 #include <iomanip>
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+#include <ctime>
+#endif
 
 using std::cout;
 using std::endl;
@@ -910,7 +913,7 @@ void neevek_issue_222() {
     struct user_activity {
         int64 id;
         int64 uid;
-        __time64_t timestamp;
+        time_t timestamp;
     };
 
     auto storage = make_storage("",
@@ -920,7 +923,7 @@ void neevek_issue_222() {
                                            make_column("timestamp", &user_activity::timestamp)));
     storage.sync_schema();
     storage.transaction([&storage]() {
-        __time64_t now = _time64(nullptr);
+        time_t now = std::time(nullptr);
         auto values = {user_activity{0, 1, now - 86400 * 3},
                        user_activity{0, 1, now - 86400 * 2},
                        user_activity{0, 1, now},
@@ -988,7 +991,7 @@ void greatest_n_per_group() {
     struct some_result {
         int64 result_id;
         int64 item_id;
-        __time64_t timestamp;
+        time_t timestamp;
         bool flag;
     };
 
@@ -1001,7 +1004,7 @@ void greatest_n_per_group() {
                                 make_column("flag", &some_result::flag)));
     storage.sync_schema();
     storage.transaction([&storage]() {
-        __time64_t now = _time64(nullptr);
+        time_t now = std::time(nullptr);
         auto values = std::initializer_list<some_result>{{-1, 1, now - 86400 * 3, false},
                                                          {-1, 1, now - 86400 * 2, true},
                                                          {-1, 1, now, true},

From 18b27acb3a4b80241a57e4bb1f3a14a86f618915 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 4 Apr 2024 16:15:15 +0200
Subject: [PATCH 160/161] appveyor: Updated vcpkg environment to 2024.03.25

---
 appveyor.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/appveyor.yml b/appveyor.yml
index bdd03fd7f..fcdf6b7fc 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -107,7 +107,7 @@ for:
   install:
     - |-
       cd C:\Tools\vcpkg
-      git fetch --tags && git checkout 2023.12.12
+      git fetch --tags && git checkout 2024.03.25
       cd %APPVEYOR_BUILD_FOLDER%
       C:\Tools\vcpkg\bootstrap-vcpkg.bat -disableMetrics
       C:\Tools\vcpkg\vcpkg integrate install
@@ -140,7 +140,7 @@ for:
   install:
     - |-
       pushd $HOME/vcpkg
-      git fetch --tags && git checkout 2023.12.12
+      git fetch --tags && git checkout 2024.03.25
       popd
       $HOME/vcpkg/bootstrap-vcpkg.sh -disableMetrics
       $HOME/vcpkg/vcpkg integrate install --overlay-triplets=vcpkg/triplets
@@ -168,7 +168,7 @@ for:
   # using custom vcpkg triplets for building and linking dynamic dependent libraries
   install:
     - |-
-      git clone --depth 1 --branch 2023.12.12 https://github.com/microsoft/vcpkg.git $HOME/vcpkg
+      git clone --depth 1 --branch 2024.03.25 https://github.com/microsoft/vcpkg.git $HOME/vcpkg
       $HOME/vcpkg/bootstrap-vcpkg.sh -disableMetrics
       $HOME/vcpkg/vcpkg integrate install --overlay-triplets=vcpkg/triplets
       vcpkg install sqlite3[core,dbstat,math,json1,fts5] catch2 --overlay-triplets=vcpkg/triplets

From 4f4155a214591c76b7fb9f3a948008f60bdf5bd9 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Thu, 4 Apr 2024 16:30:04 +0200
Subject: [PATCH 161/161] Silenced warning 'expression result unused'

---
 dev/functional/index_sequence_util.h | 3 ++-
 dev/tuple_helper/tuple_iteration.h   | 3 ++-
 include/sqlite_orm/sqlite_orm.h      | 6 ++++--
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/dev/functional/index_sequence_util.h b/dev/functional/index_sequence_util.h
index 64a26e086..37f244fa5 100644
--- a/dev/functional/index_sequence_util.h
+++ b/dev/functional/index_sequence_util.h
@@ -27,7 +27,8 @@ namespace sqlite_orm {
             size_t result = 0;
 #endif
             size_t i = 0;
-            ((result = Idx, i++ == pos) || ...);
+            // note: `(void)` cast silences warning 'expression result unused'
+            (void)((result = Idx, i++ == pos) || ...);
             return result;
         }
 #endif
diff --git a/dev/tuple_helper/tuple_iteration.h b/dev/tuple_helper/tuple_iteration.h
index 9fd10015a..afea35007 100644
--- a/dev/tuple_helper/tuple_iteration.h
+++ b/dev/tuple_helper/tuple_iteration.h
@@ -14,7 +14,8 @@ namespace sqlite_orm {
             if constexpr(reversed) {
                 // nifty fold expression trick: make use of guaranteed right-to-left evaluation order when folding over operator=
                 int sink;
-                ((lambda(std::get<Idx>(tpl)), sink) = ... = 0);
+                // note: `(void)` cast silences warning 'expression result unused'
+                (void)((lambda(std::get<Idx>(tpl)), sink) = ... = 0);
             } else {
                 (lambda(std::get<Idx>(tpl)), ...);
             }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 748ca2c4a..95faa7385 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -1477,7 +1477,8 @@ namespace sqlite_orm {
             size_t result = 0;
 #endif
             size_t i = 0;
-            ((result = Idx, i++ == pos) || ...);
+            // note: `(void)` cast silences warning 'expression result unused'
+            (void)((result = Idx, i++ == pos) || ...);
             return result;
         }
 #endif
@@ -7797,7 +7798,8 @@ namespace sqlite_orm {
             if constexpr(reversed) {
                 // nifty fold expression trick: make use of guaranteed right-to-left evaluation order when folding over operator=
                 int sink;
-                ((lambda(std::get<Idx>(tpl)), sink) = ... = 0);
+                // note: `(void)` cast silences warning 'expression result unused'
+                (void)((lambda(std::get<Idx>(tpl)), sink) = ... = 0);
             } else {
                 (lambda(std::get<Idx>(tpl)), ...);
             }