diff --git a/dev/alias.h b/dev/alias.h
index b2073dbab..819c26925 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -7,7 +7,7 @@
 namespace sqlite_orm {
 
     /**
-     *  This is base class for every class which is used as a custom table alias.
+     *  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 {};
@@ -16,7 +16,7 @@ namespace sqlite_orm {
 
         /**
          *  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
+         *  For convenience there exist type aliases `alias_a`, `alias_b`, ...
          */
         template<class T, char A>
         struct table_alias : alias_tag {
@@ -37,7 +37,7 @@ namespace sqlite_orm {
 
             column_type column;
 
-            alias_column_t(){};
+            alias_column_t() {}
 
             alias_column_t(column_type column_) : column(std::move(column_)) {}
         };
@@ -72,6 +72,17 @@ namespace sqlite_orm {
             expression_type expression;
         };
 
+        /**
+         *  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>
+        struct column_alias : alias_tag {
+            static std::string get() {
+                return std::string(1u, A);
+            }
+        };
+
         template<class T>
         struct alias_holder {
             using type = T;
@@ -151,4 +162,14 @@ namespace sqlite_orm {
     using alias_y = internal::table_alias<T, 'y'>;
     template<class T>
     using alias_z = internal::table_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'>;
 }
diff --git a/dev/ast_iterator.h b/dev/ast_iterator.h
index 9f7d1e0a3..d260655f4 100644
--- a/dev/ast_iterator.h
+++ b/dev/ast_iterator.h
@@ -654,9 +654,23 @@ namespace sqlite_orm {
             }
         };
 
+        /**
+         *  Column alias or literal
+         */
         template<class T>
-        struct ast_iterator<order_by_t<T>, void> {
-            using node_type = order_by_t<T>;
+        struct ast_iterator<
+            T,
+            std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<T, alias_holder>,
+                                                     polyfill::is_specialization_of<T, literal_holder>>>> {
+            using node_type = T;
+
+            template<class L>
+            void operator()(const node_type& /*node*/, const L& /*l*/) const {}
+        };
+
+        template<class E>
+        struct ast_iterator<order_by_t<E>, void> {
+            using node_type = order_by_t<E>;
 
             template<class L>
             void operator()(const node_type& node, const L& l) const {
diff --git a/dev/conditions.h b/dev/conditions.h
index a1e7755c1..92f6bf16c 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -6,12 +6,16 @@
 #include <tuple>  //  std::tuple, std::tuple_size
 #include <sstream>  //  std::stringstream
 
+#include "cxx_polyfill.h"
+#include "type_traits.h"
 #include "collate_argument.h"
 #include "constraints.h"
 #include "optional_container.h"
 #include "serializer_context.h"
 #include "tags.h"
 #include "expression.h"
+#include "type_printer.h"
+#include "literal.h"
 
 namespace sqlite_orm {
 
@@ -1172,14 +1176,28 @@ namespace sqlite_orm {
     }
 
     /**
-     * ORDER BY column
-     * Example: storage.select(&User::name, order_by(&User::id))
+     * ORDER BY column, column alias or expression
+     * 
+     * Examples:
+     * storage.select(&User::name, order_by(&User::id))
+     * storage.select(as<colalias_a>(&User::name), order_by(get<colalias_a>()))
      */
-    template<class O>
+    template<class O, internal::satisfies_not<std::is_base_of, integer_printer, type_printer<O>> = true>
     internal::order_by_t<O> order_by(O o) {
         return {std::move(o)};
     }
 
+    /**
+     * ORDER BY positional ordinal
+     * 
+     * Examples:
+     * storage.select(&User::name, order_by(1))
+     */
+    template<class O, internal::satisfies<std::is_base_of, integer_printer, type_printer<O>> = true>
+    internal::order_by_t<internal::literal_holder<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())
diff --git a/dev/get_prepared_statement.h b/dev/get_prepared_statement.h
index 16e9d6331..ce6547637 100644
--- a/dev/get_prepared_statement.h
+++ b/dev/get_prepared_statement.h
@@ -123,9 +123,9 @@ namespace sqlite_orm {
     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 node_tuple = internal::node_tuple_t<expression_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;
+        using result_tupe = std::tuple_element_t<static_cast<size_t>(N), bind_tuple>;
         const result_tupe* result = nullptr;
         auto index = -1;
         internal::iterate_ast(statement.expression, [&result, &index](auto& node) {
@@ -146,9 +146,9 @@ namespace sqlite_orm {
     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 node_tuple = internal::node_tuple_t<expression_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;
+        using result_tupe = std::tuple_element_t<static_cast<size_t>(N), bind_tuple>;
         result_tupe* result = nullptr;
         auto index = -1;
         internal::iterate_ast(statement.expression, [&result, &index](auto& node) {
diff --git a/dev/literal.h b/dev/literal.h
new file mode 100644
index 000000000..52683eb9b
--- /dev/null
+++ b/dev/literal.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <utility>  //  std::move
+
+namespace sqlite_orm {
+    namespace internal {
+
+        /* 
+         *  Protect an otherwise bindable element so that it is always serialized as a literal value.
+         */
+        template<class T>
+        struct literal_holder {
+            using type = T;
+
+            T value;
+        };
+
+    }
+}
diff --git a/dev/node_tuple.h b/dev/node_tuple.h
index 3bd7f2c30..3cfff1c1f 100644
--- a/dev/node_tuple.h
+++ b/dev/node_tuple.h
@@ -25,6 +25,12 @@ namespace sqlite_orm {
     namespace internal {
 
         template<class T, class SFINAE = void>
+        struct node_tuple;
+
+        template<class T>
+        using node_tuple_t = typename node_tuple<T>::type;
+
+        template<class T, class SFINAE>
         struct node_tuple {
             using type = std::tuple<T>;
         };
@@ -35,55 +41,58 @@ namespace sqlite_orm {
         };
 #ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
         template<class T>
-        struct node_tuple<as_optional_t<T>, void> {
-            using type = typename node_tuple<T>::type;
-        };
+        struct node_tuple<as_optional_t<T>, void> : node_tuple<T> {};
 #endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
         template<class T>
-        struct node_tuple<std::reference_wrapper<T>, void> {
-            using type = typename node_tuple<T>::type;
-        };
+        struct node_tuple<std::reference_wrapper<T>, void> : node_tuple<T> {};
 
         template<class... Args>
-        struct node_tuple<group_by_t<Args...>, void> {
-            using type = typename node_tuple<std::tuple<Args...>>::type;
-        };
+        struct node_tuple<group_by_t<Args...>, void> : node_tuple<std::tuple<Args...>> {};
 
         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 args_tuple = node_tuple_t<std::tuple<Args...>>;
+            using expression_tuple = node_tuple_t<T>;
             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;
-        };
+        struct node_tuple<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void>
+            : node_tuple<std::tuple<ActionsArgs...>> {};
 
         template<class... Args>
         struct node_tuple<set_t<Args...>, void> {
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::type;
         };
 
         template<class T>
-        struct node_tuple<excluded_t<T>, void> {
-            using type = typename node_tuple<T>::type;
-        };
+        struct node_tuple<excluded_t<T>, void> : node_tuple<T> {};
 
         template<class C>
-        struct node_tuple<where_t<C>, void> {
-            using node_type = where_t<C>;
-            using type = typename node_tuple<C>::type;
-        };
+        struct node_tuple<where_t<C>, void> : node_tuple<C> {};
+
+        /**
+         *  Column alias
+         */
+        template<class A>
+        struct node_tuple<alias_holder<A>, void> : node_tuple<void> {};
+
+        /**
+         *  Literal
+         */
+        template<class T>
+        struct node_tuple<literal_holder<T>, void> : node_tuple<void> {};
+
+        template<class E>
+        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> {
             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 left_node_tuple = node_tuple_t<left_type>;
+            using right_node_tuple = node_tuple_t<right_type>;
             using type = typename conc_tuple<left_node_tuple, right_node_tuple>::type;
         };
 
@@ -92,30 +101,27 @@ namespace sqlite_orm {
             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 left_node_tuple = node_tuple_t<left_type>;
+            using right_node_tuple = node_tuple_t<right_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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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 left_tuple = node_tuple_t<L>;
+            using right_tuple = node_tuple_t<A>;
             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 left_tuple = node_tuple_t<L>;
+            using right_tuple = typename conc_tuple<node_tuple_t<Args>...>::type;
             using type = typename conc_tuple<left_tuple, right_tuple>::type;
         };
 
@@ -124,266 +130,188 @@ namespace sqlite_orm {
             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 left_tuple = node_tuple_t<left_type>;
+            using right_tuple = node_tuple_t<right_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 columns_tuple = node_tuple_t<T>;
+            using args_tuple = typename conc_tuple<node_tuple_t<Args>...>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::type;
         };
 
         template<class T>
-        struct node_tuple<into_t<T>, void> {
-            using node_type = into_t<T>;
-            using type = std::tuple<>;
-        };
+        struct node_tuple<into_t<T>, void> : node_tuple<void> {};
 
         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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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 set_tuple = typename conc_tuple<node_tuple_t<Args>...>::type;
+            using conditions_tuple = typename conc_tuple<node_tuple_t<Wargs>...>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::type;
         };
 
         template<class T>
-        struct node_tuple<having_t<T>, void> {
-            using node_type = having_t<T>;
-            using type = typename node_tuple<T>::type;
-        };
+        struct node_tuple<having_t<T>, void> : node_tuple<T> {};
 
         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;
-        };
+        struct node_tuple<cast_t<T, E>, void> : node_tuple<E> {};
 
         template<class T>
-        struct node_tuple<exists_t<T>, void> {
-            using node_type = exists_t<T>;
-            using type = typename node_tuple<T>::type;
-        };
+        struct node_tuple<exists_t<T>, void> : node_tuple<T> {};
 
         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<>;
-        };
+        struct node_tuple<optional_container<T>, void> : node_tuple<T> {};
 
         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 arg_tuple = node_tuple_t<A>;
+            using pattern_tuple = node_tuple_t<T>;
+            using escape_tuple = node_tuple_t<E>;
             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 arg_tuple = node_tuple_t<A>;
+            using pattern_tuple = node_tuple_t<T>;
             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 expression_tuple = node_tuple_t<A>;
+            using lower_tuple = node_tuple_t<T>;
+            using upper_tuple = node_tuple_t<T>;
             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;
-        };
+        struct node_tuple<named_collate<T>, void> : node_tuple<T> {};
 
         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;
-        };
+        struct node_tuple<is_null_t<T>, void> : node_tuple<T> {};
 
         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;
-        };
+        struct node_tuple<is_not_null_t<T>, void> : node_tuple<T> {};
 
         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;
-        };
+        struct node_tuple<negated_condition_t<C>, void> : node_tuple<C> {};
 
         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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::type;
         };
 
         template<class R, class S, class... Args>
         struct node_tuple<built_in_aggregate_function_t<R, S, Args...>, void> {
-            using node_type = built_in_aggregate_function_t<R, S, Args...>;
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::type;
         };
 
         template<class F, class W>
         struct node_tuple<filtered_aggregate_function<F, W>, void> {
-            using node_type = filtered_aggregate_function<F, W>;
-            using left_tuple = typename node_tuple<F>::type;
-            using right_tuple = typename node_tuple<W>::type;
+            using left_tuple = node_tuple_t<F>;
+            using right_tuple = node_tuple_t<W>;
             using type = typename conc_tuple<left_tuple, right_tuple>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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;
-        };
+        struct node_tuple<left_join_t<T, O>, void> : node_tuple<O> {};
 
         template<class T>
-        struct node_tuple<on_t<T>, void> {
-            using node_type = on_t<T>;
-            using type = typename node_tuple<T>::type;
-        };
+        struct node_tuple<on_t<T>, void> : node_tuple<T> {};
 
         // note: not strictly necessary as there's no binding support for USING;
         // we provide it nevertheless, in line with on_t.
         template<class T, class M>
-        struct node_tuple<using_t<T, M>, void> {
-            using node_type = using_t<T, M>;
-            using type = typename node_tuple<column_pointer<T, M>>::type;
-        };
+        struct node_tuple<using_t<T, M>, void> : node_tuple<column_pointer<T, M>> {};
 
         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;
-        };
+        struct node_tuple<join_t<T, O>, void> : node_tuple<O> {};
 
         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;
-        };
+        struct node_tuple<left_outer_join_t<T, O>, void> : node_tuple<O> {};
 
         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;
-        };
+        struct node_tuple<inner_join_t<T, O>, void> : node_tuple<O> {};
 
         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 case_tuple = node_tuple_t<T>;
+            using args_tuple = typename conc_tuple<node_tuple_t<Args>...>::type;
+            using else_tuple = node_tuple_t<E>;
             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 left_tuple = node_tuple_t<L>;
+            using right_tuple = node_tuple_t<R>;
             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;
-        };
+        struct node_tuple<as_t<T, E>, void> : node_tuple<E> {};
 
         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;
-        };
+        struct node_tuple<limit_t<T, false, false, void>, void> : node_tuple<T> {};
 
         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;
+            using type = typename conc_tuple<node_tuple_t<T>, node_tuple_t<O>>::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;
+            using type = typename conc_tuple<node_tuple_t<O>, node_tuple_t<T>>::type;
         };
     }
 }
diff --git a/dev/order_by_serializer.h b/dev/order_by_serializer.h
index 9314faefd..05f9748e0 100644
--- a/dev/order_by_serializer.h
+++ b/dev/order_by_serializer.h
@@ -27,7 +27,7 @@ namespace sqlite_orm {
                 auto newContext = context;
                 newContext.skip_table_name = false;
                 auto columnName = serialize(orderBy.expression, newContext);
-                ss << columnName << " ";
+                ss << columnName;
                 if(!orderBy._collate_argument.empty()) {
                     ss << " COLLATE " << orderBy._collate_argument;
                 }
@@ -54,16 +54,16 @@ namespace sqlite_orm {
                     std::string entryString;
                     {
                         std::stringstream ss;
-                        ss << entry.name << " ";
+                        ss << entry.name;
                         if(!entry._collate_argument.empty()) {
-                            ss << "COLLATE " << entry._collate_argument << " ";
+                            ss << " COLLATE " << entry._collate_argument;
                         }
                         switch(entry.asc_desc) {
                             case 1:
-                                ss << "ASC";
+                                ss << " ASC";
                                 break;
                             case -1:
-                                ss << "DESC";
+                                ss << " DESC";
                                 break;
                         }
                         entryString = ss.str();
diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
index aa1c55349..e2c6f71e9 100644
--- a/dev/statement_serializer.h
+++ b/dev/statement_serializer.h
@@ -29,6 +29,7 @@
 #include "pointer_value.h"
 #include "type_printer.h"
 #include "field_printer.h"
+#include "literal.h"
 #include "table_name_collector.h"
 #include "column_names_getter.h"
 #include "order_by_serializer.h"
@@ -126,6 +127,24 @@ namespace sqlite_orm {
             }
         };
 
+        /**
+         *  Serializer for literal values.
+         */
+        template<class T>
+        struct statement_serializer<T, internal::match_specialization_of<T, literal_holder>> {
+            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");
+
+                Ctx literalCtx = context;
+                literalCtx.replace_bindable_with_question = false;
+                statement_serializer<type_t<T>> serializer{};
+                return serializer(literal.value, literalCtx);
+            }
+        };
+
         template<class F, class W>
         struct statement_serializer<filtered_aggregate_function<F, W>, void> {
             using statement_type = filtered_aggregate_function<F, W>;
@@ -2095,8 +2114,7 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& orderBy, const Ctx& context) const {
                 std::stringstream ss;
                 ss << static_cast<std::string>(orderBy) << " ";
-                auto orderByString = serialize_order_by(orderBy, context);
-                ss << orderByString << " ";
+                ss << serialize_order_by(orderBy, context);
                 return ss.str();
             }
         };
diff --git a/dev/type_printer.h b/dev/type_printer.h
index 2ae90f87b..2c3c93d2c 100644
--- a/dev/type_printer.h
+++ b/dev/type_printer.h
@@ -13,7 +13,7 @@ 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 type_printer {};
 
     struct integer_printer {
         inline const std::string& print() {
diff --git a/examples/column_aliases.cpp b/examples/column_aliases.cpp
new file mode 100644
index 000000000..671809829
--- /dev/null
+++ b/examples/column_aliases.cpp
@@ -0,0 +1,76 @@
+#include <sqlite_orm/sqlite_orm.h>
+#include <iostream>
+#include <cassert>
+
+using std::cout;
+using std::endl;
+using std::system_error;
+using namespace sqlite_orm;
+
+void marvel_hero_ordered_by_o_pos() {
+    struct MarvelHero {
+        int id = 0;
+        std::string name;
+        std::string abilities;
+        short points = 0;
+    };
+
+    auto storage = make_storage("",
+                                make_table("marvel",
+                                           make_column("id", &MarvelHero::id, primary_key()),
+                                           make_column("name", &MarvelHero::name),
+                                           make_column("abilities", &MarvelHero::abilities),
+                                           make_column("points", &MarvelHero::points)));
+    storage.sync_schema();
+
+    //  insert values
+    storage.transaction([&storage] {
+        storage.insert(MarvelHero{-1, "Tony Stark", "Iron man, playboy, billionaire, philanthropist", 5});
+        storage.insert(MarvelHero{-1, "Thor", "Storm god", -10});
+        storage.insert(MarvelHero{-1, "Vision", "Min Stone", 4});
+        storage.insert(MarvelHero{-1, "Captain America", "Vibranium shield", -3});
+        storage.insert(MarvelHero{-1, "Hulk", "Strength", -15});
+        storage.insert(MarvelHero{-1, "Star Lord", "Humor", 19});
+        storage.insert(MarvelHero{-1, "Peter Parker", "Spiderman", 16});
+        storage.insert(MarvelHero{-1, "Clint Barton", "Hawkeye", -11});
+        storage.insert(MarvelHero{-1, "Natasha Romanoff", "Black widow", 8});
+        storage.insert(MarvelHero{-1, "Groot", "I am Groot!", 2});
+
+        return true;
+    });
+
+    {
+        //  SELECT name, instr(abilities, 'o') i
+        //  FROM marvel
+        //  WHERE i > 0
+        //  ORDER BY i
+        auto rows = storage.select(columns(&MarvelHero::name, as<colalias_i>(instr(&MarvelHero::abilities, "o"))),
+                                   where(greater_than(get<colalias_i>(), 0)),
+                                   order_by(get<colalias_i>()));
+        for(auto& row: rows) {
+            cout << get<0>(row) << '\t' << get<1>(row) << '\n';
+        }
+    }
+    cout << endl;
+    {
+        //  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));
+        for(auto& row: rows) {
+            cout << get<0>(row) << '\t' << get<1>(row) << '\n';
+        }
+    }
+    cout << endl;
+}
+
+int main() {
+    try {
+        marvel_hero_ordered_by_o_pos();
+    } catch(const system_error& e) {
+        cout << "[" << e.code() << "] " << e.what();
+    }
+
+    return 0;
+}
diff --git a/examples/core_functions.cpp b/examples/core_functions.cpp
index 9239a8c82..864d92dbf 100644
--- a/examples/core_functions.cpp
+++ b/examples/core_functions.cpp
@@ -1109,8 +1109,10 @@ int main(int, char** argv) {
         //  SELECT name, instr(abilities, 'o') o_pos
         //  FROM marvel
         //  WHERE o_pos > 0
+        //  ORDER BY o_pos
         auto rows = storage.select(columns(&MarvelHero::name, as<o_pos>(instr(&MarvelHero::abilities, "o"))),
-                                   where(greater_than(get<o_pos>(), 0)));
+                                   where(greater_than(get<o_pos>(), 0)),
+                                   order_by(get<o_pos>()));
         for(auto& row: rows) {
             cout << get<0>(row) << '\t' << get<1>(row) << endl;
         }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 51825903c..8595b6fdb 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -702,7 +702,7 @@ 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 type_printer {};
 
     struct integer_printer {
         inline const std::string& print() {
@@ -2592,6 +2592,10 @@ namespace sqlite_orm {
 #include <tuple>  //  std::tuple, std::tuple_size
 #include <sstream>  //  std::stringstream
 
+// #include "cxx_polyfill.h"
+
+// #include "type_traits.h"
+
 // #include "collate_argument.h"
 
 // #include "constraints.h"
@@ -2748,6 +2752,28 @@ namespace sqlite_orm {
     }
 }
 
+// #include "type_printer.h"
+
+// #include "literal.h"
+
+#include <utility>  //  std::move
+
+namespace sqlite_orm {
+    namespace internal {
+
+        /* 
+         *  Protect an otherwise bindable element so that it is always serialized as a literal value.
+         */
+        template<class T>
+        struct literal_holder {
+            using type = T;
+
+            T value;
+        };
+
+    }
+}
+
 namespace sqlite_orm {
 
     namespace internal {
@@ -3907,14 +3933,28 @@ namespace sqlite_orm {
     }
 
     /**
-     * ORDER BY column
-     * Example: storage.select(&User::name, order_by(&User::id))
+     * ORDER BY column, column alias or expression
+     * 
+     * Examples:
+     * storage.select(&User::name, order_by(&User::id))
+     * storage.select(as<colalias_a>(&User::name), order_by(get<colalias_a>()))
      */
-    template<class O>
+    template<class O, internal::satisfies_not<std::is_base_of, integer_printer, type_printer<O>> = true>
     internal::order_by_t<O> order_by(O o) {
         return {std::move(o)};
     }
 
+    /**
+     * ORDER BY positional ordinal
+     * 
+     * Examples:
+     * storage.select(&User::name, order_by(1))
+     */
+    template<class O, internal::satisfies<std::is_base_of, integer_printer, type_printer<O>> = true>
+    internal::order_by_t<internal::literal_holder<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())
@@ -3997,7 +4037,7 @@ namespace sqlite_orm {
 namespace sqlite_orm {
 
     /**
-     *  This is base class for every class which is used as a custom table alias.
+     *  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 {};
@@ -4006,7 +4046,7 @@ namespace sqlite_orm {
 
         /**
          *  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
+         *  For convenience there exist type aliases `alias_a`, `alias_b`, ...
          */
         template<class T, char A>
         struct table_alias : alias_tag {
@@ -4027,7 +4067,7 @@ namespace sqlite_orm {
 
             column_type column;
 
-            alias_column_t(){};
+            alias_column_t() {}
 
             alias_column_t(column_type column_) : column(std::move(column_)) {}
         };
@@ -4062,6 +4102,17 @@ namespace sqlite_orm {
             expression_type expression;
         };
 
+        /**
+         *  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>
+        struct column_alias : alias_tag {
+            static std::string get() {
+                return std::string(1u, A);
+            }
+        };
+
         template<class T>
         struct alias_holder {
             using type = T;
@@ -4141,6 +4192,16 @@ namespace sqlite_orm {
     using alias_y = internal::table_alias<T, 'y'>;
     template<class T>
     using alias_z = internal::table_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'>;
 }
 #pragma once
 
@@ -12460,9 +12521,23 @@ namespace sqlite_orm {
             }
         };
 
+        /**
+         *  Column alias or literal
+         */
         template<class T>
-        struct ast_iterator<order_by_t<T>, void> {
-            using node_type = order_by_t<T>;
+        struct ast_iterator<
+            T,
+            std::enable_if_t<polyfill::disjunction_v<polyfill::is_specialization_of<T, alias_holder>,
+                                                     polyfill::is_specialization_of<T, literal_holder>>>> {
+            using node_type = T;
+
+            template<class L>
+            void operator()(const node_type& /*node*/, const L& /*l*/) const {}
+        };
+
+        template<class E>
+        struct ast_iterator<order_by_t<E>, void> {
+            using node_type = order_by_t<E>;
 
             template<class L>
             void operator()(const node_type& node, const L& l) const {
@@ -14167,6 +14242,8 @@ namespace sqlite_orm {
 
 // #include "field_printer.h"
 
+// #include "literal.h"
+
 // #include "table_name_collector.h"
 
 #include <set>  //  std::set
@@ -14424,7 +14501,7 @@ namespace sqlite_orm {
                 auto newContext = context;
                 newContext.skip_table_name = false;
                 auto columnName = serialize(orderBy.expression, newContext);
-                ss << columnName << " ";
+                ss << columnName;
                 if(!orderBy._collate_argument.empty()) {
                     ss << " COLLATE " << orderBy._collate_argument;
                 }
@@ -14451,16 +14528,16 @@ namespace sqlite_orm {
                     std::string entryString;
                     {
                         std::stringstream ss;
-                        ss << entry.name << " ";
+                        ss << entry.name;
                         if(!entry._collate_argument.empty()) {
-                            ss << "COLLATE " << entry._collate_argument << " ";
+                            ss << " COLLATE " << entry._collate_argument;
                         }
                         switch(entry.asc_desc) {
                             case 1:
-                                ss << "ASC";
+                                ss << " ASC";
                                 break;
                             case -1:
-                                ss << "DESC";
+                                ss << " DESC";
                                 break;
                         }
                         entryString = ss.str();
@@ -14581,6 +14658,24 @@ namespace sqlite_orm {
             }
         };
 
+        /**
+         *  Serializer for literal values.
+         */
+        template<class T>
+        struct statement_serializer<T, internal::match_specialization_of<T, literal_holder>> {
+            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");
+
+                Ctx literalCtx = context;
+                literalCtx.replace_bindable_with_question = false;
+                statement_serializer<type_t<T>> serializer{};
+                return serializer(literal.value, literalCtx);
+            }
+        };
+
         template<class F, class W>
         struct statement_serializer<filtered_aggregate_function<F, W>, void> {
             using statement_type = filtered_aggregate_function<F, W>;
@@ -16550,8 +16645,7 @@ namespace sqlite_orm {
             std::string operator()(const statement_type& orderBy, const Ctx& context) const {
                 std::stringstream ss;
                 ss << static_cast<std::string>(orderBy) << " ";
-                auto orderByString = serialize_order_by(orderBy, context);
-                ss << orderByString << " ";
+                ss << serialize_order_by(orderBy, context);
                 return ss.str();
             }
         };
@@ -18588,6 +18682,12 @@ namespace sqlite_orm {
     namespace internal {
 
         template<class T, class SFINAE = void>
+        struct node_tuple;
+
+        template<class T>
+        using node_tuple_t = typename node_tuple<T>::type;
+
+        template<class T, class SFINAE>
         struct node_tuple {
             using type = std::tuple<T>;
         };
@@ -18598,55 +18698,58 @@ namespace sqlite_orm {
         };
 #ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
         template<class T>
-        struct node_tuple<as_optional_t<T>, void> {
-            using type = typename node_tuple<T>::type;
-        };
+        struct node_tuple<as_optional_t<T>, void> : node_tuple<T> {};
 #endif  //  SQLITE_ORM_OPTIONAL_SUPPORTED
         template<class T>
-        struct node_tuple<std::reference_wrapper<T>, void> {
-            using type = typename node_tuple<T>::type;
-        };
+        struct node_tuple<std::reference_wrapper<T>, void> : node_tuple<T> {};
 
         template<class... Args>
-        struct node_tuple<group_by_t<Args...>, void> {
-            using type = typename node_tuple<std::tuple<Args...>>::type;
-        };
+        struct node_tuple<group_by_t<Args...>, void> : node_tuple<std::tuple<Args...>> {};
 
         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 args_tuple = node_tuple_t<std::tuple<Args...>>;
+            using expression_tuple = node_tuple_t<T>;
             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;
-        };
+        struct node_tuple<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void>
+            : node_tuple<std::tuple<ActionsArgs...>> {};
 
         template<class... Args>
         struct node_tuple<set_t<Args...>, void> {
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::type;
         };
 
         template<class T>
-        struct node_tuple<excluded_t<T>, void> {
-            using type = typename node_tuple<T>::type;
-        };
+        struct node_tuple<excluded_t<T>, void> : node_tuple<T> {};
 
         template<class C>
-        struct node_tuple<where_t<C>, void> {
-            using node_type = where_t<C>;
-            using type = typename node_tuple<C>::type;
-        };
+        struct node_tuple<where_t<C>, void> : node_tuple<C> {};
+
+        /**
+         *  Column alias
+         */
+        template<class A>
+        struct node_tuple<alias_holder<A>, void> : node_tuple<void> {};
+
+        /**
+         *  Literal
+         */
+        template<class T>
+        struct node_tuple<literal_holder<T>, void> : node_tuple<void> {};
+
+        template<class E>
+        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> {
             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 left_node_tuple = node_tuple_t<left_type>;
+            using right_node_tuple = node_tuple_t<right_type>;
             using type = typename conc_tuple<left_node_tuple, right_node_tuple>::type;
         };
 
@@ -18655,30 +18758,27 @@ namespace sqlite_orm {
             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 left_node_tuple = node_tuple_t<left_type>;
+            using right_node_tuple = node_tuple_t<right_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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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 left_tuple = node_tuple_t<L>;
+            using right_tuple = node_tuple_t<A>;
             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 left_tuple = node_tuple_t<L>;
+            using right_tuple = typename conc_tuple<node_tuple_t<Args>...>::type;
             using type = typename conc_tuple<left_tuple, right_tuple>::type;
         };
 
@@ -18687,266 +18787,188 @@ namespace sqlite_orm {
             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 left_tuple = node_tuple_t<left_type>;
+            using right_tuple = node_tuple_t<right_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 columns_tuple = node_tuple_t<T>;
+            using args_tuple = typename conc_tuple<node_tuple_t<Args>...>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::type;
         };
 
         template<class T>
-        struct node_tuple<into_t<T>, void> {
-            using node_type = into_t<T>;
-            using type = std::tuple<>;
-        };
+        struct node_tuple<into_t<T>, void> : node_tuple<void> {};
 
         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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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 set_tuple = typename conc_tuple<node_tuple_t<Args>...>::type;
+            using conditions_tuple = typename conc_tuple<node_tuple_t<Wargs>...>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::type;
         };
 
         template<class T>
-        struct node_tuple<having_t<T>, void> {
-            using node_type = having_t<T>;
-            using type = typename node_tuple<T>::type;
-        };
+        struct node_tuple<having_t<T>, void> : node_tuple<T> {};
 
         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;
-        };
+        struct node_tuple<cast_t<T, E>, void> : node_tuple<E> {};
 
         template<class T>
-        struct node_tuple<exists_t<T>, void> {
-            using node_type = exists_t<T>;
-            using type = typename node_tuple<T>::type;
-        };
+        struct node_tuple<exists_t<T>, void> : node_tuple<T> {};
 
         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<>;
-        };
+        struct node_tuple<optional_container<T>, void> : node_tuple<T> {};
 
         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 arg_tuple = node_tuple_t<A>;
+            using pattern_tuple = node_tuple_t<T>;
+            using escape_tuple = node_tuple_t<E>;
             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 arg_tuple = node_tuple_t<A>;
+            using pattern_tuple = node_tuple_t<T>;
             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 expression_tuple = node_tuple_t<A>;
+            using lower_tuple = node_tuple_t<T>;
+            using upper_tuple = node_tuple_t<T>;
             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;
-        };
+        struct node_tuple<named_collate<T>, void> : node_tuple<T> {};
 
         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;
-        };
+        struct node_tuple<is_null_t<T>, void> : node_tuple<T> {};
 
         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;
-        };
+        struct node_tuple<is_not_null_t<T>, void> : node_tuple<T> {};
 
         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;
-        };
+        struct node_tuple<negated_condition_t<C>, void> : node_tuple<C> {};
 
         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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::type;
         };
 
         template<class R, class S, class... Args>
         struct node_tuple<built_in_aggregate_function_t<R, S, Args...>, void> {
-            using node_type = built_in_aggregate_function_t<R, S, Args...>;
-            using type = typename conc_tuple<typename node_tuple<Args>::type...>::type;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::type;
         };
 
         template<class F, class W>
         struct node_tuple<filtered_aggregate_function<F, W>, void> {
-            using node_type = filtered_aggregate_function<F, W>;
-            using left_tuple = typename node_tuple<F>::type;
-            using right_tuple = typename node_tuple<W>::type;
+            using left_tuple = node_tuple_t<F>;
+            using right_tuple = node_tuple_t<W>;
             using type = typename conc_tuple<left_tuple, right_tuple>::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;
+            using type = typename conc_tuple<node_tuple_t<Args>...>::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;
-        };
+        struct node_tuple<left_join_t<T, O>, void> : node_tuple<O> {};
 
         template<class T>
-        struct node_tuple<on_t<T>, void> {
-            using node_type = on_t<T>;
-            using type = typename node_tuple<T>::type;
-        };
+        struct node_tuple<on_t<T>, void> : node_tuple<T> {};
 
         // note: not strictly necessary as there's no binding support for USING;
         // we provide it nevertheless, in line with on_t.
         template<class T, class M>
-        struct node_tuple<using_t<T, M>, void> {
-            using node_type = using_t<T, M>;
-            using type = typename node_tuple<column_pointer<T, M>>::type;
-        };
+        struct node_tuple<using_t<T, M>, void> : node_tuple<column_pointer<T, M>> {};
 
         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;
-        };
+        struct node_tuple<join_t<T, O>, void> : node_tuple<O> {};
 
         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;
-        };
+        struct node_tuple<left_outer_join_t<T, O>, void> : node_tuple<O> {};
 
         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;
-        };
+        struct node_tuple<inner_join_t<T, O>, void> : node_tuple<O> {};
 
         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 case_tuple = node_tuple_t<T>;
+            using args_tuple = typename conc_tuple<node_tuple_t<Args>...>::type;
+            using else_tuple = node_tuple_t<E>;
             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 left_tuple = node_tuple_t<L>;
+            using right_tuple = node_tuple_t<R>;
             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;
-        };
+        struct node_tuple<as_t<T, E>, void> : node_tuple<E> {};
 
         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;
-        };
+        struct node_tuple<limit_t<T, false, false, void>, void> : node_tuple<T> {};
 
         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;
+            using type = typename conc_tuple<node_tuple_t<T>, node_tuple_t<O>>::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;
+            using type = typename conc_tuple<node_tuple_t<O>, node_tuple_t<T>>::type;
         };
     }
 }
@@ -19078,9 +19100,9 @@ namespace sqlite_orm {
     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 node_tuple = internal::node_tuple_t<expression_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;
+        using result_tupe = std::tuple_element_t<static_cast<size_t>(N), bind_tuple>;
         const result_tupe* result = nullptr;
         auto index = -1;
         internal::iterate_ast(statement.expression, [&result, &index](auto& node) {
@@ -19101,9 +19123,9 @@ namespace sqlite_orm {
     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 node_tuple = internal::node_tuple_t<expression_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;
+        using result_tupe = std::tuple_element_t<static_cast<size_t>(N), bind_tuple>;
         result_tupe* result = nullptr;
         auto index = -1;
         internal::iterate_ast(statement.expression, [&result, &index](auto& node) {
diff --git a/tests/ast_iterator_tests.cpp b/tests/ast_iterator_tests.cpp
index 96eed6f13..746cfd852 100644
--- a/tests/ast_iterator_tests.cpp
+++ b/tests/ast_iterator_tests.cpp
@@ -13,6 +13,11 @@ TEST_CASE("ast_iterator") {
     auto lambda = [&typeIndexes](auto &value) {
         typeIndexes.push_back(typeid(value));
     };
+    SECTION("bindables") {
+        auto node = select(1);
+        expected.push_back(typeid(int));
+        internal::iterate_ast(node, lambda);
+    }
     SECTION("aggregate functions") {
         SECTION("avg") {
             auto node = avg(&User::id);
@@ -156,10 +161,30 @@ TEST_CASE("ast_iterator") {
         internal::iterate_ast(node, lambda);
     }
     SECTION("order_by") {
-        auto node = order_by(c(&User::id) == 0);
-        expected.push_back(typeid(&User::id));
-        expected.push_back(typeid(int));
-        internal::iterate_ast(node, lambda);
+        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);
+        }
+        SECTION("bindable") {
+            auto node = order_by("");
+            expected.push_back(typeid(const char *));
+            internal::iterate_ast(node, lambda);
+        }
+        SECTION("positional ordinal") {
+            auto node = order_by(1);
+            internal::iterate_ast(node, lambda);
+        }
+        SECTION("sole column alias") {
+            auto node = order_by(get<colalias_a>());
+            internal::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);
+        }
     }
     SECTION("group_by") {
         auto node = group_by(&User::id);
diff --git a/tests/statement_serializer_tests/bindables.cpp b/tests/statement_serializer_tests/bindables.cpp
index 0ac25bcf6..922cdab2e 100644
--- a/tests/statement_serializer_tests/bindables.cpp
+++ b/tests/statement_serializer_tests/bindables.cpp
@@ -1,26 +1,92 @@
 #include <type_traits>
 #include <array>
 #include <tuple>
+#include <algorithm>  //  std::fill_n
 #include <sqlite_orm/sqlite_orm.h>
 #include <catch2/catch.hpp>
 
 using std::array;
+using std::index_sequence;
+using std::index_sequence_for;
+using std::make_index_sequence;
 using std::nullptr_t;
 using std::shared_ptr;
 using std::string;
 using std::tuple;
+using std::tuple_element_t;
+using std::tuple_size;
 using std::unique_ptr;
 using std::vector;
+using std::wstring;
 using namespace sqlite_orm;
 
-inline void require_string(const std::string& value, const std::string& expected) {
+template<typename T>
+constexpr T get_default() {
+    return T{};
+}
+
+template<>
+constexpr auto get_default<const char*>() -> const char* {
+    return "";
+}
+
+template<>
+constexpr auto get_default<const wchar_t*>() -> const wchar_t* {
+    return L"";
+}
+
+template<>
+constexpr auto get_default<internal::literal_holder<const char*>>() -> internal::literal_holder<const char*> {
+    return {""};
+}
+
+template<>
+constexpr auto get_default<internal::literal_holder<const wchar_t*>>() -> internal::literal_holder<const wchar_t*> {
+    return {L""};
+}
+
+#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
+template<>
+constexpr auto get_default<std::nullopt_t>() -> std::nullopt_t {
+    return std::nullopt;
+}
+
+template<>
+constexpr auto get_default<internal::literal_holder<std::nullopt_t>>() -> internal::literal_holder<std::nullopt_t> {
+    return {std::nullopt};
+}
+#endif
+
+template<class Tpl, size_t... Idx>
+constexpr Tpl make_default_tuple(index_sequence<Idx...>) {
+    return {get_default<tuple_element_t<Idx, Tpl>>()...};
+}
+
+template<class Tpl>
+constexpr Tpl make_default_tuple() {
+    return make_default_tuple<Tpl>(make_index_sequence<tuple_size<Tpl>::value>{});
+}
+
+template<size_t N>
+array<string, N> single_value_array(const char* s) {
+    array<string, N> a;
+    std::fill_n(a.data(), a.size(), s);
+    return a;
+}
+
+template<class T>
+struct wrap_in_literal {
+    using type = internal::literal_holder<T>;
+};
+
+inline void require_string(const string& value, const string& expected) {
     REQUIRE(value == expected);
 }
 
 template<size_t... Idx>
 void require_strings(const array<string, sizeof...(Idx)>& values,
                      const array<string, sizeof...(Idx)>& expected,
-                     std::index_sequence<Idx...>) {
+                     index_sequence<Idx...>) {
     for(size_t i = 0; i < sizeof...(Idx); ++i) {
         require_string(values[i], expected[i]);
     }
@@ -28,7 +94,7 @@ void require_strings(const array<string, sizeof...(Idx)>& values,
 
 template<typename Ctx, typename... Ts>
 void test_tuple(const tuple<Ts...>& t, const Ctx& ctx, const array<string, sizeof...(Ts)>& expected) {
-    require_strings({internal::serialize(get<Ts>(t), ctx)...}, expected, std::index_sequence_for<Ts...>{});
+    require_strings({internal::serialize(get<Ts>(t), ctx)...}, expected, index_sequence_for<Ts...>{});
 }
 
 struct Custom {};
@@ -87,66 +153,54 @@ TEST_CASE("bindables") {
 #endif
                             >;
 
-        Tuple t{false,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0.f,
-                0.,
-                0.,
-                "",
-                nullptr
-#ifndef SQLITE_ORM_OMITS_CODECVT
-                ,
-                L""
-#endif
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-                ,
-                std::nullopt
-#endif
-        };
-        array<string, std::tuple_size<Tuple>::value> e{"0",
-                                                       "0",
-                                                       "0",
-                                                       "0",
-                                                       "0",
-                                                       "0",
-                                                       "0",
-                                                       "0",
-                                                       "0",
-                                                       "0",
-                                                       "0",
-                                                       "0",
-                                                       "0",
-                                                       "0",
-                                                       "0",
-                                                       "''",
-                                                       "null"
+        constexpr Tuple t = make_default_tuple<Tuple>();
+
+        array<string, tuple_size<Tuple>::value> e{"0",
+                                                  "0",
+                                                  "0",
+                                                  "0",
+                                                  "0",
+                                                  "0",
+                                                  "0",
+                                                  "0",
+                                                  "0",
+                                                  "0",
+                                                  "0",
+                                                  "0",
+                                                  "0",
+                                                  "0",
+                                                  "0",
+                                                  "''",
+                                                  "null"
 #ifndef SQLITE_ORM_OMITS_CODECVT
-                                                       ,
-                                                       "''"
+                                                  ,
+                                                  "''"
 #endif
 #ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-                                                       ,
-                                                       "null"
+                                                  ,
+                                                  "null"
 #endif
         };
 
-        test_tuple(t, context, e);
+        SECTION("dump") {
+            context.replace_bindable_with_question = false;
+            test_tuple(t, context, e);
+        }
+        SECTION("parametrized") {
+            context.replace_bindable_with_question = true;
+            test_tuple(t, context, single_value_array<tuple_size<Tuple>::value>("?"));
+        }
+        SECTION("non-bindable literals") {
+            context.replace_bindable_with_question = true;
+            constexpr auto t = make_default_tuple<internal::tuple_transformer<Tuple, wrap_in_literal>::type>();
+            test_tuple(t, context, e);
+        }
     }
 
     SECTION("bindable_types") {
         using Tuple = tuple<string,
 #ifndef SQLITE_ORM_OMITS_CODECVT
-                            std::wstring,
+                            wstring,
                             StringVeneer<wchar_t>,
 #endif
                             unique_ptr<int>,
@@ -164,57 +218,50 @@ TEST_CASE("bindables") {
 #endif
                             StringVeneer<char>,
                             Custom,
-                            std::unique_ptr<Custom>>;
+                            unique_ptr<Custom>>;
 
-        Tuple t{"",
-#ifndef SQLITE_ORM_OMITS_CODECVT
-                L"",
-                L"",
-#endif
-                nullptr,
-                nullptr,
-                vector<char>{},
-#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-                std::nullopt,
-                std::nullopt,
-#endif
-#ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
-                "",
-#ifndef SQLITE_ORM_OMITS_CODECVT
-                L"",
-#endif
-#endif
-                "",
-                Custom{},
-                nullptr};
-        array<string, std::tuple_size<Tuple>::value> e{"''",
+        Tuple t = make_default_tuple<Tuple>();
+
+        array<string, tuple_size<Tuple>::value> e{"''",
 #ifndef SQLITE_ORM_OMITS_CODECVT
-                                                       "''",
-                                                       "''",
+                                                  "''",
+                                                  "''",
 #endif
-                                                       "null",
-                                                       "null",
-                                                       "x''",
+                                                  "null",
+                                                  "null",
+                                                  "x''",
 #ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
-                                                       "null",
-                                                       "null",
+                                                  "null",
+                                                  "null",
 #endif
 #ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
-                                                       "''",
+                                                  "''",
 #ifndef SQLITE_ORM_OMITS_CODECVT
-                                                       "''",
+                                                  "''",
 #endif
 #endif
-                                                       "''",
-                                                       "custom",
-                                                       "null"};
+                                                  "''",
+                                                  "custom",
+                                                  "null"};
 
-        test_tuple(t, context, e);
+        SECTION("dump") {
+            context.replace_bindable_with_question = false;
+            test_tuple(t, context, e);
+        }
+        SECTION("parametrized") {
+            context.replace_bindable_with_question = true;
+            test_tuple(t, context, single_value_array<tuple_size<Tuple>::value>("?"));
+        }
+        SECTION("non-bindable literals") {
+            context.replace_bindable_with_question = true;
+            auto t = make_default_tuple<internal::tuple_transformer<Tuple, wrap_in_literal>::type>();
+            test_tuple(t, context, e);
+        }
     }
 
     SECTION("bindable_pointer") {
-        string value;
-        decltype(value) expected;
+        string value, expected;
+        context.replace_bindable_with_question = false;
 
         SECTION("null by itself") {
             auto v = statically_bindable_pointer<carray_pvt, nullptr_t>(nullptr);
diff --git a/tests/statement_serializer_tests/conditions.cpp b/tests/statement_serializer_tests/conditions.cpp
index 82a021aae..cdee7dacf 100644
--- a/tests/statement_serializer_tests/conditions.cpp
+++ b/tests/statement_serializer_tests/conditions.cpp
@@ -4,6 +4,8 @@
 using namespace sqlite_orm;
 
 TEST_CASE("statement_serializer conditions") {
+    std::string value, expected;
+
     SECTION("using") {
         struct User {
             int64 id;
@@ -16,14 +18,28 @@ TEST_CASE("statement_serializer conditions") {
         internal::serializer_context<storage_impl> ctx{storage};
 
         SECTION("using column") {
-            auto ast = using_(&User::id);
-            auto value = serialize(ast, ctx);
-            REQUIRE(value == R"(USING ("id"))");
+            auto expression = using_(&User::id);
+            value = serialize(expression, ctx);
+            expected = R"(USING ("id"))";
         }
         SECTION("using explicit column") {
-            auto ast = using_(column<User>(&User::id));
-            auto value = serialize(ast, ctx);
-            REQUIRE(value == R"(USING ("id"))");
+            auto expression = using_(column<User>(&User::id));
+            value = serialize(expression, ctx);
+            expected = R"(USING ("id"))";
+        }
+    }
+    SECTION("order by") {
+        auto storage = internal::storage_impl<>{};
+        using storage_impl = decltype(storage);
+
+        internal::serializer_context<storage_impl> ctx{storage};
+
+        SECTION("positional ordinal") {
+            auto expression = order_by(1);
+            value = serialize(expression, ctx);
+            expected = "ORDER BY 1";
         }
     }
+
+    REQUIRE(value == expected);
 }
diff --git a/tests/static_tests/is_bindable.cpp b/tests/static_tests/is_bindable.cpp
index 926eff477..c9aa931f3 100644
--- a/tests/static_tests/is_bindable.cpp
+++ b/tests/static_tests/is_bindable.cpp
@@ -70,6 +70,7 @@ TEST_CASE("is_bindable") {
     STATIC_REQUIRE(is_bindable_v<std::unique_ptr<Custom>>);
 
     STATIC_REQUIRE(!is_bindable_v<void>);
+    STATIC_REQUIRE(!is_bindable_v<internal::literal_holder<int>>);
     STATIC_REQUIRE(!is_bindable_v<User>);
     STATIC_REQUIRE(!is_bindable_v<std::unique_ptr<User>>);
     {
diff --git a/tests/static_tests/node_tuple.cpp b/tests/static_tests/node_tuple.cpp
index c0e1daf48..98c0a0ea2 100644
--- a/tests/static_tests/node_tuple.cpp
+++ b/tests/static_tests/node_tuple.cpp
@@ -19,306 +19,315 @@ struct is_tuple<std::tuple<Args...>> : std::true_type {};
 TEST_CASE("Node tuple") {
     using internal::bindable_filter;
     using internal::node_tuple;
+    using internal::node_tuple_t;
     using std::is_same;
+    using std::tuple;
 
     struct User {
         int id = 0;
         std::string name;
     };
 
-    SECTION("simple") {
+    SECTION("bindables") {
         SECTION("int") {
-            using Tuple = node_tuple<int>::type;
-            using Expected = std::tuple<int>;
-            static_assert(is_same<Tuple, Expected>::value, "int");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<int>>::value);
+            using Tuple = node_tuple_t<int>;
+            using Expected = tuple<int>;
+            static_assert(is_same<Tuple, Expected>::value, "bindable int");
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<int>>::value);
         }
         SECTION("float") {
-            using Tuple = node_tuple<float>::type;
-            using Expected = std::tuple<float>;
-            static_assert(is_same<Tuple, Expected>::value, "float");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<float>>::value);
+            using Tuple = node_tuple_t<float>;
+            using Expected = tuple<float>;
+            static_assert(is_same<Tuple, Expected>::value, "bindable float");
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<float>>::value);
         }
     }
+    SECTION("non-bindable literals") {
+        using namespace internal;
+        using Tuple = node_tuple_t<literal_holder<int>>;
+        using Expected = tuple<>;
+        static_assert(is_same<Tuple, Expected>::value, "literal int");
+        STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<>>::value);
+    }
     SECTION("binary_condition") {
         using namespace internal;
         SECTION("5 < 6.0f") {
             auto c = lesser_than(5, 6.0f);
             using C = decltype(c);
-            using Tuple = node_tuple<C>::type;
-            using Expected = std::tuple<int, float>;
+            using Tuple = node_tuple_t<C>;
+            using Expected = tuple<int, float>;
             static_assert(is_same<Tuple, Expected>::value, "lesser_than_t");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<int, float>>::value);
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<int, float>>::value);
         }
         SECTION("id < 10") {
             auto c = lesser_than(&User::id, 10);
             using C = decltype(c);
-            using Tuple = node_tuple<C>::type;
-            using Expected = std::tuple<decltype(&User::id), int>;
+            using Tuple = node_tuple_t<C>;
+            using Expected = tuple<decltype(&User::id), int>;
             static_assert(is_same<Tuple, Expected>::value, "lesser_than_t");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<int>>::value);
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<int>>::value);
         }
         SECTION("5 <= 6.0f") {
             auto c = lesser_or_equal(5, 6.0f);
             using C = decltype(c);
-            using Tuple = node_tuple<C>::type;
-            using Expected = std::tuple<int, float>;
+            using Tuple = node_tuple_t<C>;
+            using Expected = tuple<int, float>;
             static_assert(is_same<Tuple, Expected>::value, "lesser_or_equal_t");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<int, float>>::value);
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<int, float>>::value);
         }
         SECTION("id <= 10.0") {
             auto c = lesser_or_equal(&User::id, 10.0);
             using C = decltype(c);
-            using Tuple = node_tuple<C>::type;
-            using Expected = std::tuple<decltype(&User::id), double>;
+            using Tuple = node_tuple_t<C>;
+            using Expected = tuple<decltype(&User::id), double>;
             static_assert(is_same<Tuple, Expected>::value, "lesser_or_equal_t");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<double>>::value);
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<double>>::value);
         }
         SECTION("5 > 6.0f") {
             auto c = greater_than(5, 6.0f);
             using C = decltype(c);
-            using Tuple = node_tuple<C>::type;
-            using Expected = std::tuple<int, float>;
+            using Tuple = node_tuple_t<C>;
+            using Expected = tuple<int, float>;
             static_assert(is_same<Tuple, Expected>::value, "greater_than_t");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<int, float>>::value);
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<int, float>>::value);
         }
         SECTION("id > 20") {
             auto c = greater_than(&User::id, 20);
             using C = decltype(c);
-            using Tuple = node_tuple<C>::type;
-            using Expected = std::tuple<decltype(&User::id), int>;
+            using Tuple = node_tuple_t<C>;
+            using Expected = tuple<decltype(&User::id), int>;
             static_assert(is_same<Tuple, Expected>::value, "greater_than_t");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<int>>::value);
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<int>>::value);
         }
         SECTION("5 >= 6.0f") {
             auto c = greater_or_equal(5, 6.0f);
             using C = decltype(c);
-            using Tuple = node_tuple<C>::type;
-            using Expected = std::tuple<int, float>;
+            using Tuple = node_tuple_t<C>;
+            using Expected = tuple<int, float>;
             static_assert(is_same<Tuple, Expected>::value, "greater_or_equal_t");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<int, float>>::value);
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<int, float>>::value);
         }
         SECTION("5 >= id") {
             auto c = greater_or_equal(5, &User::id);
             using C = decltype(c);
-            using Tuple = node_tuple<C>::type;
-            using Expected = std::tuple<int, decltype(&User::id)>;
+            using Tuple = node_tuple_t<C>;
+            using Expected = tuple<int, decltype(&User::id)>;
             static_assert(is_same<Tuple, Expected>::value, "greater_or_equal_t");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<int>>::value);
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<int>>::value);
         }
         SECTION("5 == 6.0f") {
             auto c = is_equal(5, 6.0f);
             using C = decltype(c);
-            using Tuple = node_tuple<C>::type;
-            using Expected = std::tuple<int, float>;
+            using Tuple = node_tuple_t<C>;
+            using Expected = tuple<int, float>;
             static_assert(is_same<Tuple, Expected>::value, "is_equal_t");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<int, float>>::value);
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<int, float>>::value);
         }
         SECTION("'ototo' == name") {
             auto c = is_equal("ototo", &User::name);
             using C = decltype(c);
-            using Tuple = node_tuple<C>::type;
-            using Expected = std::tuple<const char*, decltype(&User::name)>;
+            using Tuple = node_tuple_t<C>;
+            using Expected = tuple<const char*, decltype(&User::name)>;
             static_assert(is_same<Tuple, Expected>::value, "is_equal_t");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<const char*>>::value);
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<const char*>>::value);
         }
         SECTION("5 != 6.0f") {
             auto c = is_not_equal(5, 6.0f);
             using C = decltype(c);
-            using Tuple = node_tuple<C>::type;
-            using Expected = std::tuple<int, float>;
+            using Tuple = node_tuple_t<C>;
+            using Expected = tuple<int, float>;
             static_assert(is_same<Tuple, Expected>::value, "is_not_equal_t");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<int, float>>::value);
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<int, float>>::value);
         }
         SECTION("name != std::string('ototo')") {
             auto c = is_not_equal(&User::name, std::string("ototo"));
             using C = decltype(c);
-            using Tuple = node_tuple<C>::type;
-            using Expected = std::tuple<decltype(&User::name), std::string>;
+            using Tuple = node_tuple_t<C>;
+            using Expected = tuple<decltype(&User::name), std::string>;
             static_assert(is_same<Tuple, Expected>::value, "is_not_equal_t");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<std::string>>::value);
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<std::string>>::value);
         }
         SECTION("bool and int") {
             using Tuple = node_tuple<and_condition_t<bool, int>>::type;
-            using Expected = std::tuple<bool, int>;
+            using Expected = tuple<bool, int>;
             static_assert(is_same<Tuple, Expected>::value, "and_condition_t");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<bool, int>>::value);
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<bool, int>>::value);
         }
         SECTION("bool or int") {
             using Tuple = node_tuple<or_condition_t<bool, int>>::type;
-            using Expected = std::tuple<bool, int>;
+            using Expected = tuple<bool, int>;
             static_assert(is_same<Tuple, Expected>::value, "or_condition_t");
-            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, std::tuple<bool, int>>::value);
+            STATIC_REQUIRE(is_same<bindable_filter<Tuple>::type, tuple<bool, int>>::value);
         }
     }
     SECTION("binary_operator") {
         using namespace internal;
 
         using CondTuple = node_tuple<conc_t<std::string, decltype(&User::name)>>::type;
-        static_assert(is_same<CondTuple, std::tuple<std::string, decltype(&User::name)>>::value, "conc_t");
+        static_assert(is_same<CondTuple, tuple<std::string, decltype(&User::name)>>::value, "conc_t");
 
         using AddTuple = node_tuple<add_t<int, decltype(&User::id)>>::type;
-        static_assert(is_same<AddTuple, std::tuple<int, decltype(&User::id)>>::value, "add_t");
+        static_assert(is_same<AddTuple, tuple<int, decltype(&User::id)>>::value, "add_t");
 
         using SubTuple = node_tuple<sub_t<float, double>>::type;
-        static_assert(is_same<SubTuple, std::tuple<float, double>>::value, "sub_t");
+        static_assert(is_same<SubTuple, tuple<float, double>>::value, "sub_t");
 
         using MulTuple = node_tuple<mul_t<double, decltype(&User::id)>>::type;
-        static_assert(is_same<MulTuple, std::tuple<double, decltype(&User::id)>>::value, "mul_t");
+        static_assert(is_same<MulTuple, tuple<double, decltype(&User::id)>>::value, "mul_t");
 
         using DivTuple = node_tuple<sqlite_orm::internal::div_t<int, float>>::type;
-        static_assert(is_same<DivTuple, std::tuple<int, float>>::value, "div_t");
+        static_assert(is_same<DivTuple, tuple<int, float>>::value, "div_t");
 
         using ModTuple = node_tuple<mod_t<decltype(&User::id), int>>::type;
-        static_assert(is_same<ModTuple, std::tuple<decltype(&User::id), int>>::value, "mod_t");
+        static_assert(is_same<ModTuple, tuple<decltype(&User::id), int>>::value, "mod_t");
 
         using AssignTuple = node_tuple<assign_t<decltype(&User::name), std::string>>::type;
-        static_assert(is_same<AssignTuple, std::tuple<decltype(&User::name), std::string>>::value, "assign_t");
+        static_assert(is_same<AssignTuple, tuple<decltype(&User::name), std::string>>::value, "assign_t");
     }
     SECTION("columns") {
         auto cols = columns(&User::id, &User::name);
         using Cols = decltype(cols);
-        using ColsTuple = node_tuple<Cols>::type;
-        static_assert(is_same<ColsTuple, std::tuple<decltype(&User::id), decltype(&User::name)>>::value, "columns_t");
+        using ColsTuple = node_tuple_t<Cols>;
+        static_assert(is_same<ColsTuple, tuple<decltype(&User::id), decltype(&User::name)>>::value, "columns_t");
     }
     SECTION("in") {
         auto inValue = in(&User::id, {1, 2, 3});
         using In = decltype(inValue);
-        using InTuple = node_tuple<In>::type;
-        static_assert(is_same<InTuple, std::tuple<decltype(&User::id), std::vector<int>>>::value, "in_t");
+        using InTuple = node_tuple_t<In>;
+        static_assert(is_same<InTuple, tuple<decltype(&User::id), std::vector<int>>>::value, "in_t");
     }
     SECTION("exists(select(&User::name, where(in(&User::id, {6, 7, 9}))))") {
         auto c = exists(select(&User::name, where(in(&User::id, {6, 7, 9}))));
         using Con = decltype(c);
-        using Tuple = node_tuple<Con>::type;
-        using Expected = std::tuple<decltype(&User::name), decltype(&User::id), std::vector<int>>;
+        using Tuple = node_tuple_t<Con>;
+        using Expected = tuple<decltype(&User::name), decltype(&User::id), std::vector<int>>;
         static_assert(is_same<Tuple, Expected>::value, "exists(select(&User::name, where(in(&User::id, {6, 7, 9}))))");
     }
     SECTION("aggregate functions") {
         SECTION("avg") {
             auto node = avg(&User::id);
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id)>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id)>;
             static_assert(is_same<Tuple, Expected>::value, "avg");
         }
         SECTION("avg filter") {
             auto node = avg(&User::id).filter(where(length(&User::name) > 5));
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id), decltype(&User::name), int>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id), decltype(&User::name), int>;
             static_assert(is_same<Tuple, Expected>::value, "avg filter");
         }
         SECTION("count(*)") {
             auto node = count<User>();
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(node)>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(node)>;
             static_assert(is_same<Tuple, Expected>::value, "count(*)");
         }
         SECTION("count(*) filter") {
             auto node = count<User>().filter(where(length(&User::name) > 5));
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(count<User>()), decltype(&User::name), int>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(count<User>()), decltype(&User::name), int>;
             static_assert(is_same<Tuple, Expected>::value, "count(*) filter");
         }
         SECTION("count(X)") {
             auto node = count(&User::id);
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id)>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id)>;
             static_assert(is_same<Tuple, Expected>::value, "count(X)");
         }
         SECTION("count(X) filter") {
             auto node = count(&User::id).filter(where(length(&User::name) > 5));
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id), decltype(&User::name), int>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id), decltype(&User::name), int>;
             static_assert(is_same<Tuple, Expected>::value, "count(X) filter");
         }
         SECTION("group_concat(X)") {
             auto node = group_concat(&User::id);
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id)>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id)>;
             static_assert(is_same<Tuple, Expected>::value, "group_concat(X)");
         }
         SECTION("group_concat(X) filter") {
             auto node = group_concat(&User::id).filter(where(length(&User::name) > 5));
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id), decltype(&User::name), int>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id), decltype(&User::name), int>;
             static_assert(is_same<Tuple, Expected>::value, "group_concat(X) filter");
         }
         SECTION("group_concat(X,Y)") {
             auto node = group_concat(&User::id, std::string("-"));
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id), std::string>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id), std::string>;
             static_assert(is_same<Tuple, Expected>::value, "group_concat(X,Y)");
         }
         SECTION("group_concat(X,Y) filter") {
             auto node = group_concat(&User::id, std::string("-")).filter(where(length(&User::name) > 5));
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id), std::string, decltype(&User::name), int>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id), std::string, decltype(&User::name), int>;
             static_assert(is_same<Tuple, Expected>::value, "group_concat(X,Y) filter");
         }
         SECTION("max(X)") {
             auto node = max(&User::id);
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id)>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id)>;
             static_assert(is_same<Tuple, Expected>::value, "max(X)");
         }
         SECTION("max(X) filter") {
             auto node = max(&User::id).filter(where(length(&User::name) > 5));
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id), decltype(&User::name), int>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id), decltype(&User::name), int>;
             static_assert(is_same<Tuple, Expected>::value, "max(X) filter");
         }
         SECTION("min(X)") {
             auto node = min(&User::id);
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id)>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id)>;
             static_assert(is_same<Tuple, Expected>::value, "min(X)");
         }
         SECTION("min(X) filter") {
             auto node = min(&User::id).filter(where(length(&User::name) > 5));
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id), decltype(&User::name), int>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id), decltype(&User::name), int>;
             static_assert(is_same<Tuple, Expected>::value, "min(X) filter");
         }
         SECTION("sum(X)") {
             auto node = sum(&User::id);
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id)>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id)>;
             static_assert(is_same<Tuple, Expected>::value, "sum(X)");
         }
         SECTION("sum(X) filter") {
             auto node = sum(&User::id).filter(where(length(&User::name) > 5));
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id), decltype(&User::name), int>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id), decltype(&User::name), int>;
             static_assert(is_same<Tuple, Expected>::value, "sum(X) filter");
         }
         SECTION("total(X)") {
             auto node = total(&User::id);
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id)>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id)>;
             static_assert(is_same<Tuple, Expected>::value, "total(X)");
         }
         SECTION("total(X) filter") {
             auto node = total(&User::id).filter(where(length(&User::name) > 5));
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id), decltype(&User::name), int>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id), decltype(&User::name), int>;
             static_assert(is_same<Tuple, Expected>::value, "total(X) filter");
         }
     }
@@ -326,15 +335,15 @@ TEST_CASE("Node tuple") {
         SECTION("max(X,Y)") {
             auto node = max(&User::id, 4);
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id), int>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id), int>;
             static_assert(is_same<Tuple, Expected>::value, "max(X,Y)");
         }
         SECTION("min(X,Y)") {
             auto node = min(&User::id, 4);
             using Node = decltype(node);
-            using Tuple = node_tuple<Node>::type;
-            using Expected = std::tuple<decltype(&User::id), int>;
+            using Tuple = node_tuple_t<Node>;
+            using Expected = tuple<decltype(&User::id), int>;
             static_assert(is_same<Tuple, Expected>::value, "min(X,Y)");
         }
     }
@@ -342,43 +351,42 @@ TEST_CASE("Node tuple") {
         SECTION("union_(select(1), select(2))") {
             auto un = union_(select(1), select(2));
             using Union = decltype(un);
-            using Tuple = node_tuple<Union>::type;
-            static_assert(is_same<Tuple, std::tuple<int, int>>::value, "union_(select(1), select(2))");
+            using Tuple = node_tuple_t<Union>;
+            static_assert(is_same<Tuple, tuple<int, int>>::value, "union_(select(1), select(2))");
         }
         SECTION("union_all") {
             auto un = union_all(select(&User::id, where(is_equal(&User::name, "Alice"))),
                                 select(&User::id, where(is_equal(std::string("Bob"), &User::name))));
             using Union = decltype(un);
-            using Tuple = node_tuple<Union>::type;
-            using Expected = std::tuple<decltype(&User::id),
-                                        decltype(&User::name),
-                                        const char*,
-                                        decltype(&User::id),
-                                        std::string,
-                                        decltype(&User::name)>;
+            using Tuple = node_tuple_t<Union>;
+            using Expected = tuple<decltype(&User::id),
+                                   decltype(&User::name),
+                                   const char*,
+                                   decltype(&User::id),
+                                   std::string,
+                                   decltype(&User::name)>;
             static_assert(is_same<Tuple, Expected>::value, "union_all");
         }
         SECTION("except") {
             auto un = except(select(columns(&User::id, &User::name), where(is_equal(&User::id, 10L))),
                              select(columns(&User::id, &User::name), where(is_equal(&User::id, 15L))));
             using Union = decltype(un);
-            using Tuple = node_tuple<Union>::type;
-            using Expected = std::tuple<decltype(&User::id),
-                                        decltype(&User::name),
-                                        decltype(&User::id),
-                                        long,
-                                        decltype(&User::id),
-                                        decltype(&User::name),
-                                        decltype(&User::id),
-                                        long>;
+            using Tuple = node_tuple_t<Union>;
+            using Expected = tuple<decltype(&User::id),
+                                   decltype(&User::name),
+                                   decltype(&User::id),
+                                   long,
+                                   decltype(&User::id),
+                                   decltype(&User::name),
+                                   decltype(&User::id),
+                                   long>;
             static_assert(is_same<Tuple, Expected>::value, "except");
         }
         SECTION("intersect") {
             auto un = intersect(select(&User::name), select(&User::name, where(is_equal(&User::name, "Anny"))));
             using Union = decltype(un);
-            using Tuple = node_tuple<Union>::type;
-            using Expected =
-                std::tuple<decltype(&User::name), decltype(&User::name), decltype(&User::name), const char*>;
+            using Tuple = node_tuple_t<Union>;
+            using Expected = tuple<decltype(&User::name), decltype(&User::name), decltype(&User::name), const char*>;
             static_assert(is_same<Tuple, Expected>::value, "intersect");
         }
     }
@@ -386,67 +394,67 @@ TEST_CASE("Node tuple") {
         auto expression =
             replace(into<User>(), columns(&User::id, &User::name), values(std::make_tuple(1, std::string("Ellie"))));
         using Expression = decltype(expression);
-        using Tuple = node_tuple<Expression>::type;
-        STATIC_REQUIRE(is_same<Tuple, std::tuple<decltype(&User::id), decltype(&User::name), int, std::string>>::value);
+        using Tuple = node_tuple_t<Expression>;
+        STATIC_REQUIRE(is_same<Tuple, tuple<decltype(&User::id), decltype(&User::name), int, std::string>>::value);
     }
     SECTION("insert_raw_t") {
         auto expression =
             insert(into<User>(), columns(&User::id, &User::name), values(std::make_tuple(1, std::string("Ellie"))));
         using Expression = decltype(expression);
-        using Tuple = node_tuple<Expression>::type;
-        STATIC_REQUIRE(is_same<Tuple, std::tuple<decltype(&User::id), decltype(&User::name), int, std::string>>::value);
+        using Tuple = node_tuple_t<Expression>;
+        STATIC_REQUIRE(is_same<Tuple, tuple<decltype(&User::id), decltype(&User::name), int, std::string>>::value);
     }
     SECTION("tuple") {
         auto expression = std::make_tuple(1, std::string("hi"));
         using Expression = decltype(expression);
-        using Tuple = node_tuple<Expression>::type;
-        STATIC_REQUIRE(is_same<Tuple, std::tuple<int, std::string>>::value);
+        using Tuple = node_tuple_t<Expression>;
+        STATIC_REQUIRE(is_same<Tuple, tuple<int, std::string>>::value);
     }
     SECTION("values") {
         SECTION("int + string") {
             auto expression = values(1, std::string("hi"));
             using Expression = decltype(expression);
-            using Tuple = node_tuple<Expression>::type;
-            STATIC_REQUIRE(is_same<Tuple, std::tuple<int, std::string>>::value);
+            using Tuple = node_tuple_t<Expression>;
+            STATIC_REQUIRE(is_same<Tuple, tuple<int, std::string>>::value);
         }
         SECTION("tuple") {
             auto expression = values(std::make_tuple(1, std::string("hi")));
             using Expression = decltype(expression);
-            using Tuple = node_tuple<Expression>::type;
-            STATIC_REQUIRE(is_same<Tuple, std::tuple<int, std::string>>::value);
+            using Tuple = node_tuple_t<Expression>;
+            STATIC_REQUIRE(is_same<Tuple, tuple<int, std::string>>::value);
         }
     }
     SECTION("into") {
         auto expression = into<User>();
         using Expression = decltype(expression);
-        using Tuple = node_tuple<Expression>::type;
-        STATIC_REQUIRE(is_same<Tuple, std::tuple<>>::value);
+        using Tuple = node_tuple_t<Expression>;
+        STATIC_REQUIRE(is_same<Tuple, tuple<>>::value);
     }
     SECTION("select") {
         SECTION("select(&User::id)") {
             auto sel = select(&User::id);
             using Sel = decltype(sel);
-            using Tuple = node_tuple<Sel>::type;
-            static_assert(is_same<Tuple, std::tuple<decltype(&User::id)>>::value, "select(&User::id)");
+            using Tuple = node_tuple_t<Sel>;
+            static_assert(is_same<Tuple, tuple<decltype(&User::id)>>::value, "select(&User::id)");
         }
         SECTION("select(&User::name)") {
             auto sel = select(&User::name);
             using Sel = decltype(sel);
-            using Tuple = node_tuple<Sel>::type;
-            static_assert(is_same<Tuple, std::tuple<decltype(&User::name)>>::value, "select(&User::name)");
+            using Tuple = node_tuple_t<Sel>;
+            static_assert(is_same<Tuple, tuple<decltype(&User::name)>>::value, "select(&User::name)");
         }
         SECTION("select(&User::id, where(is_equal(&User::id, 5)))") {
             auto sel = select(&User::id, where(is_equal(&User::id, 5)));
             using Sel = decltype(sel);
-            using Tuple = node_tuple<Sel>::type;
-            static_assert(is_same<Tuple, std::tuple<decltype(&User::id), decltype(&User::id), int>>::value,
+            using Tuple = node_tuple_t<Sel>;
+            static_assert(is_same<Tuple, tuple<decltype(&User::id), decltype(&User::id), int>>::value,
                           "select(&User::id, where(is_equal(&User::id, 5)))");
         }
         SECTION("select(&User::name, where(lesser_than(&User::id, 10)))") {
             auto sel = select(&User::name, where(lesser_than(&User::id, 10)));
             using Sel = decltype(sel);
-            using Tuple = node_tuple<Sel>::type;
-            static_assert(is_same<Tuple, std::tuple<decltype(&User::name), decltype(&User::id), int>>::value,
+            using Tuple = node_tuple_t<Sel>;
+            static_assert(is_same<Tuple, tuple<decltype(&User::name), decltype(&User::id), int>>::value,
                           "select(&User::name, where(lesser_than(&User::id, 10)))");
         }
         SECTION("select(columns(&User::id, &User::name), where(greater_or_equal(&User::id, 10) and "
@@ -454,7 +462,7 @@ TEST_CASE("Node tuple") {
             auto sel = select(columns(&User::id, &User::name),
                               where(greater_or_equal(&User::id, 10) and lesser_or_equal(&User::id, 20)));
             using Sel = decltype(sel);
-            using Tuple = node_tuple<Sel>::type;
+            using Tuple = node_tuple_t<Sel>;
             using Expected = std::
                 tuple<decltype(&User::id), decltype(&User::name), decltype(&User::id), int, decltype(&User::id), int>;
             static_assert(is_same<Tuple, Expected>::value,
@@ -464,8 +472,8 @@ TEST_CASE("Node tuple") {
         SECTION("select(columns('ototo', 25))") {
             auto statement = select(columns("ototo", 25));
             using Statement = decltype(statement);
-            using Tuple = node_tuple<Statement>::type;
-            using ExpectedTuple = std::tuple<const char*, int>;
+            using Tuple = node_tuple_t<Statement>;
+            using ExpectedTuple = tuple<const char*, int>;
             STATIC_REQUIRE(std::is_same<Tuple, ExpectedTuple>::value);
         }
     }
@@ -473,51 +481,50 @@ TEST_CASE("Node tuple") {
         SECTION("get_all<User>()") {
             auto getAll = get_all<User>();
             using GetAll = decltype(getAll);
-            using Tuple = node_tuple<GetAll>::type;
-            static_assert(is_same<Tuple, std::tuple<>>::value, "get_all<User>()");
+            using Tuple = node_tuple_t<GetAll>;
+            static_assert(is_same<Tuple, tuple<>>::value, "get_all<User>()");
         }
         SECTION("get_all<User>(where(is_equal(5.0, &User::id)))") {
             auto getAll = get_all<User>(where(is_equal(5.0, &User::id)));
             using GetAll = decltype(getAll);
-            using Tuple = node_tuple<GetAll>::type;
-            static_assert(is_same<Tuple, std::tuple<double, decltype(&User::id)>>::value,
+            using Tuple = node_tuple_t<GetAll>;
+            static_assert(is_same<Tuple, tuple<double, decltype(&User::id)>>::value,
                           "get_all<User>(where(is_equal(5.0, &User::id)))");
         }
         SECTION("get_all<User>(where(is_equal(5.0, &User::id)))") {
             auto getAll = get_all<User>(where(is_equal(&User::id, 1) or is_equal(std::string("Alex"), &User::name)));
             using GetAll = decltype(getAll);
-            using Tuple = node_tuple<GetAll>::type;
-            static_assert(
-                is_same<Tuple, std::tuple<decltype(&User::id), int, std::string, decltype(&User::name)>>::value,
-                "get_all<User>(where(is_equal(5.0, &User::id)))");
+            using Tuple = node_tuple_t<GetAll>;
+            static_assert(is_same<Tuple, tuple<decltype(&User::id), int, std::string, decltype(&User::name)>>::value,
+                          "get_all<User>(where(is_equal(5.0, &User::id)))");
         }
     }
     SECTION("having_t") {
         using namespace internal;
         auto hav = having(greater_or_equal(&User::id, 10));
         using Having = decltype(hav);
-        using Tuple = node_tuple<Having>::type;
-        static_assert(is_same<Tuple, std::tuple<decltype(&User::id), int>>::value,
+        using Tuple = node_tuple_t<Having>;
+        static_assert(is_same<Tuple, tuple<decltype(&User::id), int>>::value,
                       "having(greater_or_equal(&User::id, 10))");
     }
     SECTION("cast_t") {
         auto sel = select(columns(cast<int>(&User::id), cast<int>(&User::name)));
         using Select = decltype(sel);
-        using Tuple = node_tuple<Select>::type;
-        static_assert(is_same<Tuple, std::tuple<decltype(&User::id), decltype(&User::name)>>::value,
+        using Tuple = node_tuple_t<Select>;
+        static_assert(is_same<Tuple, tuple<decltype(&User::id), decltype(&User::name)>>::value,
                       "select(columns(cast<int>(&User::id), cast<int>(&User::name)))");
     }
     SECTION("optional_container") {
         using namespace internal;
         SECTION("int") {
             using Op = optional_container<int>;
-            using Tuple = node_tuple<Op>::type;
-            static_assert(is_same<Tuple, std::tuple<int>>::value, "optional_container<int>");
+            using Tuple = node_tuple_t<Op>;
+            static_assert(is_same<Tuple, tuple<int>>::value, "optional_container<int>");
         }
         SECTION("void") {
             using Op = optional_container<void>;
-            using Tuple = node_tuple<Op>::type;
-            static_assert(is_same<Tuple, std::tuple<>>::value, "optional_container<void>");
+            using Tuple = node_tuple_t<Op>;
+            static_assert(is_same<Tuple, tuple<>>::value, "optional_container<void>");
         }
     }
     SECTION("like_t") {
@@ -526,137 +533,154 @@ TEST_CASE("Node tuple") {
             using Like = decltype(lk);
             using NodeTuple = node_tuple<Like>;
             using ArgTuple = NodeTuple::arg_tuple;
-            static_assert(is_same<ArgTuple, std::tuple<decltype(&User::name)>>::value, "arg_tuple");
+            static_assert(is_same<ArgTuple, tuple<decltype(&User::name)>>::value, "arg_tuple");
             using PatternTuple = NodeTuple::pattern_tuple;
-            static_assert(is_same<PatternTuple, std::tuple<const char*>>::value, "pattern_tuple");
+            static_assert(is_same<PatternTuple, tuple<const char*>>::value, "pattern_tuple");
             using EscapeTuple = NodeTuple::escape_tuple;
-            static_assert(is_same<EscapeTuple, std::tuple<>>::value, "escape_tuple");
+            static_assert(is_same<EscapeTuple, tuple<>>::value, "escape_tuple");
             using Tuple = NodeTuple::type;
             static_assert(std::tuple_size<Tuple>::value == 2, "like(&User::name, \"S%\") size");
-            using Tuple0 = std::tuple_element<0, Tuple>::type;
+            using Tuple0 = std::tuple_element_t<0, Tuple>;
             static_assert(is_same<Tuple0, decltype(&User::name)>::value, "like(&User::name, \"S%\") type 0");
-            static_assert(is_same<Tuple, std::tuple<decltype(&User::name), const char*>>::value,
+            static_assert(is_same<Tuple, tuple<decltype(&User::name), const char*>>::value,
                           "like(&User::name, \"S%\")");
         }
         SECTION("like(&User::name, std::string('pattern'), '%')") {
             auto lk = like(&User::name, std::string("pattern"), "%");
             using Like = decltype(lk);
-            using NodeTuple = node_tuple<Like>::type;
-            using Expected = std::tuple<decltype(&User::name), std::string, const char*>;
+            using NodeTuple = node_tuple_t<Like>;
+            using Expected = tuple<decltype(&User::name), std::string, const char*>;
             static_assert(is_same<NodeTuple, Expected>::value, "like(&User::name, std::string(\"pattern\"), \"%\")");
         }
         SECTION("like(&User::name, std::string('pattern')).escape('%')") {
             auto lk = like(&User::name, std::string("pattern")).escape("%");
             using Like = decltype(lk);
-            using NodeTuple = node_tuple<Like>::type;
-            using Expected = std::tuple<decltype(&User::name), std::string, const char*>;
+            using NodeTuple = node_tuple_t<Like>;
+            using Expected = tuple<decltype(&User::name), std::string, const char*>;
             static_assert(is_same<NodeTuple, Expected>::value,
                           "like(&User::name, std::string(\"pattern\")).escape(\"%\")");
         }
     }
+    SECTION("order_by_t") {
+        SECTION("expression") {
+            STATIC_REQUIRE(is_same<node_tuple_t<decltype(order_by(&User::name == c(5)))>,
+                                   tuple<decltype(&User::name), int>>::value);
+        }
+        SECTION("bindable") {
+            STATIC_REQUIRE(is_same<node_tuple_t<decltype(order_by(""))>, tuple<const char*>>::value);
+        }
+        SECTION("positional ordinal") {
+            STATIC_REQUIRE(is_same<node_tuple_t<decltype(order_by(1))>, tuple<>>::value);
+        }
+        SECTION("sole column alias") {
+            STATIC_REQUIRE(is_same<node_tuple_t<decltype(order_by(get<colalias_a>()))>, tuple<>>::value);
+        }
+        SECTION("column alias in expression") {
+            STATIC_REQUIRE(is_same<node_tuple_t<decltype(order_by(get<colalias_a>() > c(1)))>, tuple<int>>::value);
+        }
+    }
     SECTION("glob_t") {
         auto gl = glob(&User::name, "H*");
         using Glob = decltype(gl);
-        using Tuple = node_tuple<Glob>::type;
-        static_assert(is_same<Tuple, std::tuple<decltype(&User::name), const char*>>::value,
-                      "glob(&User::name, \"H*\")");
+        using Tuple = node_tuple_t<Glob>;
+        static_assert(is_same<Tuple, tuple<decltype(&User::name), const char*>>::value, "glob(&User::name, \"H*\")");
     }
     SECTION("between_t") {
         auto bet = between(&User::id, 10, 20);
         using Between = decltype(bet);
-        using Tuple = node_tuple<Between>::type;
-        static_assert(is_same<Tuple, std::tuple<decltype(&User::id), int, int>>::value, "between(&User::id, 10, 20)");
+        using Tuple = node_tuple_t<Between>;
+        static_assert(is_same<Tuple, tuple<decltype(&User::id), int, int>>::value, "between(&User::id, 10, 20)");
     }
     SECTION("named_collate") {
         auto sel = select(&User::name, where(is_equal(&User::name, "Mercury").collate("ototo")));
         using Select = decltype(sel);
-        using Tuple = node_tuple<Select>::type;
-        using Expected = std::tuple<decltype(&User::name), decltype(&User::name), const char*>;
+        using Tuple = node_tuple_t<Select>;
+        using Expected = tuple<decltype(&User::name), decltype(&User::name), const char*>;
         static_assert(is_same<Tuple, Expected>::value, "named_collate");
     }
     SECTION("negated_condition_t") {
         SECTION("not is_equal(20, '20')") {
             auto c = not is_equal(20, "20");
             using Con = decltype(c);
-            using Tuple = node_tuple<Con>::type;
-            using Expected = std::tuple<int, const char*>;
+            using Tuple = node_tuple_t<Con>;
+            using Expected = tuple<int, const char*>;
             static_assert(is_same<Tuple, Expected>::value, "not is_equal(20, \"20\")");
         }
         SECTION("not is_not_equal(&User::id, 15.0)") {
             auto c = not is_not_equal(&User::id, 15.0);
             using Con = decltype(c);
-            using Tuple = node_tuple<Con>::type;
-            using Expected = std::tuple<decltype(&User::id), double>;
+            using Tuple = node_tuple_t<Con>;
+            using Expected = tuple<decltype(&User::id), double>;
             static_assert(is_same<Tuple, Expected>::value, "not is_not_equal(&User::id, 15.0)");
         }
         SECTION("not greater_than(20.0f, &User::id)") {
             auto c = not greater_than(20.0f, &User::id);
             using Con = decltype(c);
-            using Tuple = node_tuple<Con>::type;
-            using Expected = std::tuple<float, decltype(&User::id)>;
+            using Tuple = node_tuple_t<Con>;
+            using Expected = tuple<float, decltype(&User::id)>;
             static_assert(is_same<Tuple, Expected>::value, "not greater_than(20.0f, &User::id)");
         }
         SECTION("not greater_or_equal(&User::id, 5)") {
             auto c = not greater_or_equal(&User::id, 5);
             using Con = decltype(c);
-            using Tuple = node_tuple<Con>::type;
-            using Expected = std::tuple<decltype(&User::id), int>;
+            using Tuple = node_tuple_t<Con>;
+            using Expected = tuple<decltype(&User::id), int>;
             static_assert(is_same<Tuple, Expected>::value, "not greater_or_equal(&User::id, 5)");
         }
         SECTION("not lesser_than(&User::id, std::string('6'))") {
             auto c = not lesser_than(&User::id, std::string("6"));
             using Con = decltype(c);
-            using Tuple = node_tuple<Con>::type;
-            using Expected = std::tuple<decltype(&User::id), std::string>;
+            using Tuple = node_tuple_t<Con>;
+            using Expected = tuple<decltype(&User::id), std::string>;
             static_assert(is_same<Tuple, Expected>::value, "not lesser_than(&User::id, std::string(\"6\"))");
         }
         SECTION("not lesser_or_equal(&User::id, 10)") {
             auto c = not lesser_or_equal(&User::id, 10);
             using Con = decltype(c);
-            using Tuple = node_tuple<Con>::type;
-            using Expected = std::tuple<decltype(&User::id), int>;
+            using Tuple = node_tuple_t<Con>;
+            using Expected = tuple<decltype(&User::id), int>;
             static_assert(is_same<Tuple, Expected>::value, "not lesser_or_equal(&User::id, 10)");
         }
         SECTION("not in(&User::id, {1, 2, 3})") {
             auto c = not in(&User::id, {1, 2, 3});
             using Con = decltype(c);
-            using Tuple = node_tuple<Con>::type;
-            using Expected = std::tuple<decltype(&User::id), std::vector<int>>;
+            using Tuple = node_tuple_t<Con>;
+            using Expected = tuple<decltype(&User::id), std::vector<int>>;
             static_assert(is_same<Tuple, Expected>::value, "not in(&User::id, {1, 2, 3})");
         }
         SECTION("not is_null(&User::name)") {
             auto c = not is_null(&User::name);
             using Con = decltype(c);
-            using Tuple = node_tuple<Con>::type;
-            using Expected = std::tuple<decltype(&User::name)>;
+            using Tuple = node_tuple_t<Con>;
+            using Expected = tuple<decltype(&User::name)>;
             static_assert(is_same<Tuple, Expected>::value, "not is_null(&User::name)");
         }
         SECTION("not is_not_null(&User::name)") {
             auto c = not is_not_null(&User::name);
             using Con = decltype(c);
-            using Tuple = node_tuple<Con>::type;
-            using Expected = std::tuple<decltype(&User::name)>;
+            using Tuple = node_tuple_t<Con>;
+            using Expected = tuple<decltype(&User::name)>;
             static_assert(is_same<Tuple, Expected>::value, "not is_not_null(&User::name)");
         }
         SECTION("not like(&User::name, '*D*')") {
             auto c = not like(&User::name, "*D*");
             using Con = decltype(c);
-            using Tuple = node_tuple<Con>::type;
-            using Expected = std::tuple<decltype(&User::name), const char*>;
+            using Tuple = node_tuple_t<Con>;
+            using Expected = tuple<decltype(&User::name), const char*>;
             static_assert(is_same<Tuple, Expected>::value, "not like(&User::name, \"*D*\")");
         }
         SECTION("not glob(&User::name, std::string('_A_'))") {
             auto c = not glob(&User::name, std::string("_A_"));
             using Con = decltype(c);
-            using Tuple = node_tuple<Con>::type;
-            using Expected = std::tuple<decltype(&User::name), std::string>;
+            using Tuple = node_tuple_t<Con>;
+            using Expected = tuple<decltype(&User::name), std::string>;
             static_assert(is_same<Tuple, Expected>::value, "not glob(&User::name, std::string(\"_A_\"))");
         }
         SECTION("not exists(select(&User::name, where(in(&User::id, {6, 7, 9}))))") {
             auto c = not exists(select(&User::name, where(in(&User::id, {6, 7, 9}))));
             using Con = decltype(c);
-            using Tuple = node_tuple<Con>::type;
-            using Expected = std::tuple<decltype(&User::name), decltype(&User::id), std::vector<int>>;
+            using Tuple = node_tuple_t<Con>;
+            using Expected = tuple<decltype(&User::name), decltype(&User::id), std::vector<int>>;
             static_assert(is_same<Tuple, Expected>::value,
                           "not exists(select(&User::name, where(in(&User::id, {6, 7, 9}))))");
         }
@@ -665,132 +689,132 @@ TEST_CASE("Node tuple") {
         SECTION("lower") {
             auto f = lower(&User::name);
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<decltype(&User::name)>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<decltype(&User::name)>;
             static_assert(is_same<Tuple, Expected>::value, "lower");
         }
         SECTION("upper") {
             auto f = upper("hi");
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using ArgType = std::tuple_element<0, Fun::args_type>::type;
+            using Tuple = node_tuple_t<Fun>;
+            using ArgType = std::tuple_element_t<0, Fun::args_type>;
             static_assert(is_same<ArgType, const char*>::value, "upper arg[0]");
-            using Expected = std::tuple<const char*>;
+            using Expected = tuple<const char*>;
             static_assert(is_same<Tuple, Expected>::value, "upper");
         }
         SECTION("total_changes") {
             auto f = total_changes();
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<>;
             static_assert(is_same<Tuple, Expected>::value, "total_changes");
         }
         SECTION("changes") {
             auto f = changes();
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<>;
             static_assert(is_same<Tuple, Expected>::value, "changes");
         }
         SECTION("trim(1)") {
             auto f = trim(&User::name);
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<decltype(&User::name)>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<decltype(&User::name)>;
             static_assert(is_same<Tuple, Expected>::value, "trim(1)");
         }
         SECTION("trim(2)") {
             auto f = trim(&User::name, std::string("pay"));
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<decltype(&User::name), std::string>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<decltype(&User::name), std::string>;
             static_assert(is_same<Tuple, Expected>::value, "trim(2)");
         }
         SECTION("ltrim(1)") {
             auto f = ltrim(&User::id);
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<decltype(&User::id)>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<decltype(&User::id)>;
             static_assert(is_same<Tuple, Expected>::value, "ltrim(1)");
         }
         SECTION("ltrim(2)") {
             auto f = ltrim(&User::id, "see");
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<decltype(&User::id), const char*>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<decltype(&User::id), const char*>;
             static_assert(is_same<Tuple, Expected>::value, "ltrim(2)");
         }
         SECTION("rtrim(1)") {
             auto f = rtrim(&User::name);
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<decltype(&User::name)>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<decltype(&User::name)>;
             static_assert(is_same<Tuple, Expected>::value, "rtrim(1)");
         }
         SECTION("rtrim(2)") {
             auto f = rtrim(&User::name, &User::id);
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<decltype(&User::name), decltype(&User::id)>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<decltype(&User::name), decltype(&User::id)>;
             static_assert(is_same<Tuple, Expected>::value, "rtrim(2)");
         }
 #if SQLITE_VERSION_NUMBER >= 3007016
         SECTION("char_") {
             auto f = char_(100, 20.0);
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<int, double>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<int, double>;
             static_assert(is_same<Tuple, Expected>::value, "char_");
         }
 #endif
         SECTION("coalesce") {
             auto f = char_(10, 20);
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<int, int>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<int, int>;
             static_assert(is_same<Tuple, Expected>::value, "coalesce");
         }
         SECTION("date") {
             auto f =
                 date(std::string("now"), std::string("start of month"), std::string("+1 month"), std::string("-1 day"));
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<std::string, std::string, std::string, std::string>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<std::string, std::string, std::string, std::string>;
             static_assert(is_same<Tuple, Expected>::value, "date");
         }
         SECTION("datetime") {
             auto f = datetime("now");
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<const char*>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<const char*>;
             static_assert(is_same<Tuple, Expected>::value, "datetime");
         }
         SECTION("julianday") {
             auto f = julianday("now");
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<const char*>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<const char*>;
             static_assert(is_same<Tuple, Expected>::value, "julianday");
         }
         SECTION("zeroblob") {
             auto f = zeroblob(10);
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<int>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<int>;
             static_assert(is_same<Tuple, Expected>::value, "zeroblob");
         }
         SECTION("substr(2)") {
             auto f = substr(&User::name, 7);
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<decltype(&User::name), int>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<decltype(&User::name), int>;
             static_assert(is_same<Tuple, Expected>::value, "substr");
         }
         SECTION("substr(3)") {
             auto f = substr(&User::name, 7, 20.f);
             using Fun = decltype(f);
-            using Tuple = node_tuple<Fun>::type;
-            using Expected = std::tuple<decltype(&User::name), int, float>;
+            using Tuple = node_tuple_t<Fun>;
+            using Expected = tuple<decltype(&User::name), int, float>;
             static_assert(is_same<Tuple, Expected>::value, "substr");
         }
     }
@@ -798,44 +822,44 @@ TEST_CASE("Node tuple") {
         SECTION("left_join") {
             auto j = left_join<User>(on(is_equal(&User::id, 2)));
             using Join = decltype(j);
-            using Tuple = node_tuple<Join>::type;
-            using Expected = std::tuple<decltype(&User::id), int>;
+            using Tuple = node_tuple_t<Join>;
+            using Expected = tuple<decltype(&User::id), int>;
             static_assert(is_same<Tuple, Expected>::value, "left_join");
         }
         SECTION("join on") {
             auto j = join<User>(on(is_equal(&User::id, 2)));
             using Join = decltype(j);
-            using Tuple = node_tuple<Join>::type;
-            using Expected = std::tuple<decltype(&User::id), int>;
+            using Tuple = node_tuple_t<Join>;
+            using Expected = tuple<decltype(&User::id), int>;
             static_assert(is_same<Tuple, Expected>::value, "join on");
         }
         SECTION("join using column") {
             auto j = join<User>(using_(&User::id));
             using Join = decltype(j);
-            using Tuple = node_tuple<Join>::type;
-            using Expected = std::tuple<internal::column_pointer<User, decltype(&User::id)>>;
+            using Tuple = node_tuple_t<Join>;
+            using Expected = tuple<internal::column_pointer<User, decltype(&User::id)>>;
             static_assert(is_same<Tuple, Expected>::value, "join using");
         }
         SECTION("join using explicit column") {
             struct Derived : User {};
             auto j = join<User>(using_(column<Derived>(&User::id)));
             using Join = decltype(j);
-            using Tuple = node_tuple<Join>::type;
-            using Expected = std::tuple<internal::column_pointer<Derived, decltype(&User::id)>>;
+            using Tuple = node_tuple_t<Join>;
+            using Expected = tuple<internal::column_pointer<Derived, decltype(&User::id)>>;
             static_assert(is_same<Tuple, Expected>::value, "join using explicit column");
         }
         SECTION("left_outer_join") {
             auto j = left_outer_join<User>(on(is_equal(&User::id, 2)));
             using Join = decltype(j);
-            using Tuple = node_tuple<Join>::type;
-            using Expected = std::tuple<decltype(&User::id), int>;
+            using Tuple = node_tuple_t<Join>;
+            using Expected = tuple<decltype(&User::id), int>;
             static_assert(is_same<Tuple, Expected>::value, "left_outer_join");
         }
         SECTION("inner_join") {
             auto j = inner_join<User>(on(is_equal(&User::id, 2)));
             using Join = decltype(j);
-            using Tuple = node_tuple<Join>::type;
-            using Expected = std::tuple<decltype(&User::id), int>;
+            using Tuple = node_tuple_t<Join>;
+            using Expected = tuple<decltype(&User::id), int>;
             static_assert(is_same<Tuple, Expected>::value, "inner_join");
         }
     }
@@ -843,10 +867,10 @@ TEST_CASE("Node tuple") {
         auto c = case_<std::string>(&User::name).when("USA", then("Dosmetic")).else_("Foreign").end();
         using Case = decltype(c);
         using CaseExpressionTuple = node_tuple<Case::case_expression_type>::type;
-        STATIC_REQUIRE(is_same<CaseExpressionTuple, std::tuple<decltype(&User::name)>>::value);
+        STATIC_REQUIRE(is_same<CaseExpressionTuple, tuple<decltype(&User::name)>>::value);
 
-        STATIC_REQUIRE(is_tuple<std::tuple<>>::value);
-        STATIC_REQUIRE(is_tuple<std::tuple<int, std::string>>::value);
+        STATIC_REQUIRE(is_tuple<tuple<>>::value);
+        STATIC_REQUIRE(is_tuple<tuple<int, std::string>>::value);
         STATIC_REQUIRE(!is_tuple<int>::value);
         STATIC_REQUIRE(is_pair<std::pair<int, std::string>>::value);
         STATIC_REQUIRE(!is_pair<int>::value);
@@ -855,16 +879,16 @@ TEST_CASE("Node tuple") {
         STATIC_REQUIRE(is_tuple<ArgsType>::value);
         STATIC_REQUIRE(std::tuple_size<ArgsType>::value == 1);
 
-        using Arg0 = std::tuple_element<0, ArgsType>::type;
+        using Arg0 = std::tuple_element_t<0, ArgsType>;
         STATIC_REQUIRE(is_pair<Arg0>::value);
         using Arg0First = Arg0::first_type;
         STATIC_REQUIRE(is_same<Arg0First, const char*>::value);
         using Arg0Second = Arg0::second_type;
         STATIC_REQUIRE(is_same<Arg0Second, const char*>::value);
-        STATIC_REQUIRE(is_same<ArgsType, std::tuple<std::pair<const char*, const char*>>>::value);
+        STATIC_REQUIRE(is_same<ArgsType, tuple<std::pair<const char*, const char*>>>::value);
 
         using ElseExpressionTuple = node_tuple<Case::else_expression_type>::type;
-        STATIC_REQUIRE(is_same<ElseExpressionTuple, std::tuple<const char*>>::value);
+        STATIC_REQUIRE(is_same<ElseExpressionTuple, tuple<const char*>>::value);
     }
     SECTION("as") {
         struct GradeAlias : alias_tag {
@@ -875,8 +899,8 @@ TEST_CASE("Node tuple") {
         };
         auto a = as<GradeAlias>(&User::name);
         using A = decltype(a);
-        using Tuple = node_tuple<A>::type;
-        using ExpectedTuple = std::tuple<decltype(&User::name)>;
+        using Tuple = node_tuple_t<A>;
+        using ExpectedTuple = tuple<decltype(&User::name)>;
         STATIC_REQUIRE(is_same<Tuple, ExpectedTuple>::value);
     }
     SECTION("function_call") {
@@ -887,29 +911,29 @@ TEST_CASE("Node tuple") {
         };
         auto statement = func<Func>(8);
         using Statement = decltype(statement);
-        using Tuple = node_tuple<Statement>::type;
-        using ExpectedTuple = std::tuple<int>;
+        using Tuple = node_tuple_t<Statement>;
+        using ExpectedTuple = tuple<int>;
         STATIC_REQUIRE(std::is_same<Tuple, ExpectedTuple>::value);
     }
     SECTION("excluded") {
         auto statement = excluded(&User::id);
         using Statement = decltype(statement);
-        using Tuple = node_tuple<Statement>::type;
-        using ExpectedTuple = std::tuple<decltype(&User::id)>;
+        using Tuple = node_tuple_t<Statement>;
+        using ExpectedTuple = tuple<decltype(&User::id)>;
         STATIC_REQUIRE(std::is_same<Tuple, ExpectedTuple>::value);
     }
     SECTION("upsert_clause") {
         auto statement = on_conflict(&User::id).do_update(set(c(&User::name) = excluded(&User::name)));
         using Statement = decltype(statement);
-        using Tuple = node_tuple<Statement>::type;
-        using ExpectedTuple = std::tuple<decltype(&User::name), decltype(&User::name)>;
+        using Tuple = node_tuple_t<Statement>;
+        using ExpectedTuple = tuple<decltype(&User::name), decltype(&User::name)>;
         STATIC_REQUIRE(std::is_same<Tuple, ExpectedTuple>::value);
     }
     SECTION("group_by") {
         auto statement = group_by(&User::id);
         using Statement = decltype(statement);
-        using Tuple = node_tuple<Statement>::type;
-        using ExpectedTuple = std::tuple<decltype(&User::id)>;
+        using Tuple = node_tuple_t<Statement>;
+        using ExpectedTuple = tuple<decltype(&User::id)>;
         STATIC_REQUIRE(std::is_same<Tuple, ExpectedTuple>::value);
     }
 }