From 5d75d1b1f2c955f3a39b42692b1b46a407c1da58 Mon Sep 17 00:00:00 2001
From: klaus triendl <klaus@triendl.eu>
Date: Sun, 12 Nov 2023 00:00:32 +0200
Subject: [PATCH] Uniform syntax for column pointer expressions through table
 references

---
 dev/alias_traits.h                            |  37 +-
 dev/column_pointer.h                          |  47 ++-
 dev/conditions.h                              |  29 +-
 dev/core_functions.h                          |  11 +
 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               | 315 +++++++++++++-----
 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_pointer.cpp         | 119 +++++++
 tests/tests.cpp                               |   3 -
 19 files changed, 673 insertions(+), 169 deletions(-)
 create mode 100644 tests/static_tests/column_pointer.cpp

diff --git a/dev/alias_traits.h b/dev/alias_traits.h
index b83960740..489bbba86 100644
--- a/dev/alias_traits.h
+++ b/dev/alias_traits.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#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
@@ -50,6 +50,24 @@ namespace sqlite_orm {
 
         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
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
@@ -82,5 +100,22 @@ 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>;
+
+    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>);
 #endif
 }
diff --git a/dev/column_pointer.h b/dev/column_pointer.h
index f479ff10e..bb8d5af76 100644
--- a/dev/column_pointer.h
+++ b/dev/column_pointer.h
@@ -1,10 +1,11 @@
 #pragma once
 
-#include <type_traits>  //  std::enable_if
+#include <type_traits>  //  std::enable_if, std::remove_const
 #include <utility>  // std::move
 
 #include "functional/cxx_type_traits_polyfill.h"
 #include "tags.h"
+#include "alias_traits.h"
 
 namespace sqlite_orm {
     namespace internal {
@@ -35,8 +36,46 @@ 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
 }
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 d6b467877..51a767e22 100644
--- a/dev/core_functions.h
+++ b/dev/core_functions.h
@@ -1845,6 +1845,17 @@ namespace sqlite_orm {
         return {};
     }
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  COUNT(*) with FROM function. Specified recordset will be serialized as
+     *  a from argument.
+     */
+    template<orm_refers_to_recordset auto mapped>
+    auto count() {
+        return count<internal::decay_table_reference_t<mapped>>();
+    }
+#endif
+
     /**
      *  AVG(X) aggregate function.
      */
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 f38ffc0e0..415ee9296 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -408,9 +408,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
 
@@ -429,4 +429,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 85b1e8c33..a0ebb932e 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -319,18 +319,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
@@ -382,6 +382,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.
@@ -428,8 +435,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()) {
@@ -439,15 +447,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 {
@@ -460,10 +478,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 {
@@ -471,9 +492,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), {});
             }
 
             /**
@@ -481,13 +504,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)...);
             }
 
             /**
@@ -495,22 +519,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)...);
             }
 
             /**
@@ -518,10 +548,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 {
@@ -534,10 +568,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 {
@@ -550,11 +588,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()));
@@ -572,10 +614,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 638e8e64b..bb20e33b0 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -1308,6 +1308,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;
@@ -2931,7 +2933,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
@@ -2983,6 +2985,24 @@ namespace sqlite_orm {
 
         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
     }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
@@ -3015,6 +3035,23 @@ 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>;
+
+    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>);
 #endif
 }
 
@@ -3115,13 +3152,15 @@ namespace sqlite_orm {
 
 // #include "column_pointer.h"
 
-#include <type_traits>  //  std::enable_if
+#include <type_traits>  //  std::enable_if, std::remove_const
 #include <utility>  // std::move
 
 // #include "functional/cxx_type_traits_polyfill.h"
 
 // #include "tags.h"
 
+// #include "alias_traits.h"
+
 namespace sqlite_orm {
     namespace internal {
         /**
@@ -3151,10 +3190,48 @@ 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
 }
 
 // #include "tags.h"
@@ -3990,10 +4067,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
 
@@ -4110,12 +4186,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>
@@ -4139,9 +4215,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
 
@@ -4151,9 +4227,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
 
@@ -4163,9 +4239,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
 
@@ -4175,9 +4251,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
 
@@ -6694,6 +6770,17 @@ namespace sqlite_orm {
         return {};
     }
 
+#ifdef SQLITE_ORM_WITH_CPP20_ALIASES
+    /**
+     *  COUNT(*) with FROM function. Specified recordset will be serialized as
+     *  a from argument.
+     */
+    template<orm_refers_to_recordset auto mapped>
+    auto count() {
+        return count<internal::decay_table_reference_t<mapped>>();
+    }
+#endif
+
     /**
      *  AVG(X) aggregate function.
      */
@@ -7594,9 +7681,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
 
@@ -7615,6 +7702,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
 
@@ -10701,8 +10795,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;
@@ -12543,10 +12642,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.
@@ -12554,8 +12664,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
@@ -12566,8 +12675,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
 
@@ -12600,17 +12708,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
 
@@ -18298,18 +18404,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
@@ -18361,6 +18467,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.
@@ -18407,8 +18520,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()) {
@@ -18418,15 +18532,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 {
@@ -18439,10 +18563,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 {
@@ -18450,9 +18577,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), {});
             }
 
             /**
@@ -18460,13 +18589,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)...);
             }
 
             /**
@@ -18474,22 +18604,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)...);
             }
 
             /**
@@ -18497,10 +18633,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 {
@@ -18513,10 +18653,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 {
@@ -18529,11 +18673,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()));
@@ -18551,10 +18699,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 b15a6baf6..a0e811893 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -28,6 +28,7 @@ add_executable(unit_tests
     static_tests/aggregate_function_return_types.cpp
     static_tests/core_function_return_types.cpp
     static_tests/column_result_t.cpp
+    static_tests/column_pointer.cpp
     static_tests/alias.cpp
     static_tests/is_primary_key_insertable.cpp
     static_tests/is_column_with_insertable_primary_key.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 76f06c63a..d1f9726b0 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
         }
     }
     SECTION("group_concat(X)") {
diff --git a/tests/statement_serializer_tests/select_constraints.cpp b/tests/statement_serializer_tests/select_constraints.cpp
index 60c51c45e..4b7321ac3 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 c7548a2d7..b0e8e4dbd 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;
@@ -59,4 +68,30 @@ TEST_CASE("aliases") {
         runTest<alias_column_t<alias_d<DerivedUser>, column_pointer<DerivedUser, int User::*>>>(d_alias->*&User::id);
 #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_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;