added a todo list

backends/postgres/src/postgres_connection.cpp

@@ -110,7 +110,7 @@ utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> postgres_co
 
 std::string postgres_connection::generate_statement_name(const sql::query_context &query) {
   std::stringstream name;
-  name << query.table.name() << "_" << query.command_name;
+  name << query.table_name.name() << "_" << query.command_name;
   auto result = postgres_connection::statement_name_map_.find(name.str());
 
   if (result == postgres_connection::statement_name_map_.end()) {

demo/main.cpp

@@ -1,4 +1,4 @@
-#include "matador/sql/column.hpp"
+#include "matador/query/column.hpp"
 #include "matador/sql/connection.hpp"
 #include "matador/sql/query_macro.hpp"
 

include/matador/orm/session_query_builder.hpp

@@ -23,9 +23,9 @@
 namespace matador::orm {
 
 struct entity_query_data {
-  std::shared_ptr<sql::table> root_table;
+  std::shared_ptr<query::table> root_table;
   std::string pk_column_name{};
-  std::vector<sql::column> columns{};
+  std::vector<query::column> columns{};
   std::unordered_map<std::string, sql::statement> lazy_loading_statements{};
   std::vector<query::join_data> joins{};
   query::criteria_ptr where_clause{};
@@ -33,7 +33,7 @@ struct entity_query_data {
 
 class criteria_transformer final : public query::criteria_visitor {
 public:
-    criteria_transformer(const object::repository &repo, const std::unordered_map<std::string, std::shared_ptr<sql::table>>& tables_by_name);
+    criteria_transformer(const object::repository &repo, const std::unordered_map<std::string, std::shared_ptr<query::table>>& tables_by_name);
     void visit( const query::between_criteria& node ) override;
     void visit( const query::binary_criteria& node ) override;
     void visit( const query::binary_column_criteria& node ) override;
@@ -48,7 +48,7 @@ private:
 
 private:
     const object::repository &repo_;
-    const std::unordered_map<std::string, std::shared_ptr<sql::table>>& tables_by_name_;
+    const std::unordered_map<std::string, std::shared_ptr<query::table>>& tables_by_name_;
 };
 
 class session_query_builder final {
@@ -63,7 +63,7 @@ public:
     if (!info) {
       return utils::failure(query_build_error::UnknownType);
     }
-    table_info_stack_.push({info.value(), std::make_shared<sql::table>(info.value().get().name(), build_alias('t', ++table_index))});
+    table_info_stack_.push({info.value(), std::make_shared<query::table>(info.value().get().name(), build_alias('t', ++table_index))});
     entity_query_data_ = { table_info_stack_.top().table };
     processed_tables_.insert({info->get().name(), entity_query_data_.root_table});
     try {
@@ -123,7 +123,7 @@ public:
       if (next != processed_tables_.end()) {
         return;
       }
-      table_info_stack_.push({info.value(), std::make_shared<sql::table>(info->get().name(), build_alias('t', ++table_index))});
+      table_info_stack_.push({info.value(), std::make_shared<query::table>(info->get().name(), build_alias('t', ++table_index))});
       next = processed_tables_.insert({info->get().name(), table_info_stack_.top().table}).first;
       typename ContainerType::value_type::value_type obj;
       access::process(*this , obj);
@@ -135,8 +135,8 @@ public:
       }
 
       append_join(
-        sql::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
-        sql::column{next->second, join_column}
+        query::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
+        query::column{next->second, join_column}
       );
     }
   }
@@ -157,10 +157,10 @@ public:
     }
     auto relation = processed_tables_.find(id);
     if (relation == processed_tables_.end()) {
-      relation = processed_tables_.insert({id, std::make_shared<sql::table>(id, build_alias('t', ++table_index))}).first;
+      relation = processed_tables_.insert({id, std::make_shared<query::table>(id, build_alias('t', ++table_index))}).first;
     }
 
-    table_info_stack_.push({info.value(), std::make_shared<sql::table>(info->get().name(), build_alias('t', ++table_index))});
+    table_info_stack_.push({info.value(), std::make_shared<query::table>(info->get().name(), build_alias('t', ++table_index))});
     next = processed_tables_.insert({info->get().name(), table_info_stack_.top().table}).first;
     typename ContainerType::value_type::value_type obj;
     access::process(*this , obj);
@@ -172,12 +172,12 @@ public:
     }
 
     append_join(
-      sql::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
-      sql::column{relation->second, join_column}
+      query::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
+      query::column{relation->second, join_column}
     );
     append_join(
-      sql::column{relation->second, inverse_join_column},
-      sql::column{next->second, pk->name()}
+      query::column{relation->second, inverse_join_column},
+      query::column{next->second, pk->name()}
     );
   }
 
@@ -198,9 +198,9 @@ public:
 
     auto relation = processed_tables_.find(id);
     if (relation == processed_tables_.end()) {
-      relation = processed_tables_.insert({id, std::make_shared<sql::table>(id, build_alias('t', ++table_index))}).first;
+      relation = processed_tables_.insert({id, std::make_shared<query::table>(id, build_alias('t', ++table_index))}).first;
     }
-    table_info_stack_.push({info.value(), std::make_shared<sql::table>(info->get().name(), build_alias('t', ++table_index))});
+    table_info_stack_.push({info.value(), std::make_shared<query::table>(info->get().name(), build_alias('t', ++table_index))});
     next = processed_tables_.insert({info->get().name(), table_info_stack_.top().table}).first;
     typename ContainerType::value_type::value_type obj;
     access::process(*this , obj);
@@ -214,12 +214,12 @@ public:
     const auto join_columns = join_columns_collector_.collect<typename ContainerType::value_type::value_type>();
 
     append_join(
-      sql::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
-      sql::column{relation->second, join_columns.inverse_join_column}
+      query::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
+      query::column{relation->second, join_columns.inverse_join_column}
     );
     append_join(
-      sql::column{relation->second, join_columns.join_column},
-      sql::column{next->second, pk->name()}
+      query::column{relation->second, join_columns.join_column},
+      query::column{next->second, pk->name()}
     );
   }
 
@@ -229,16 +229,16 @@ private:
   void push(const std::string &column_name);
   static std::string build_alias(char prefix, unsigned int count);
   [[nodiscard]] bool is_root_entity() const;
-  void append_join(const sql::column &left, const sql::column &right);
+  void append_join(const query::column &left, const query::column &right);
 
 private:
   struct table_info {
     std::reference_wrapper<const object::basic_object_info> info;
-    std::shared_ptr<sql::table> table;
+    std::shared_ptr<query::table> table;
   };
 
   std::stack<table_info> table_info_stack_{};
-  std::unordered_map<std::string, std::shared_ptr<sql::table>> processed_tables_{};
+  std::unordered_map<std::string, std::shared_ptr<query::table>> processed_tables_{};
   const object::repository &schema_;
   entity_query_data entity_query_data_{};
   unsigned int column_index{0};
@@ -258,7 +258,7 @@ void session_query_builder::on_foreign_object(const char *id, Pointer &, const u
     throw query_builder_exception{query_build_error::MissingPrimaryKey};
   }
 
-  const auto foreign_table = std::make_shared<sql::table>(info->get().name(), build_alias('t', ++table_index));
+  const auto foreign_table = std::make_shared<query::table>(info->get().name(), build_alias('t', ++table_index));
   if (attr.fetch() == utils::fetch_type::EAGER) {
 
     auto next = processed_tables_.find(info->get().name());
@@ -272,8 +272,8 @@ void session_query_builder::on_foreign_object(const char *id, Pointer &, const u
     table_info_stack_.pop();
 
     append_join(
-      sql::column{table_info_stack_.top().table, id},
-      sql::column{next->second, pk->name()}
+      query::column{table_info_stack_.top().table, id},
+      query::column{next->second, pk->name()}
     );
   } else {
     push(id);
@@ -282,7 +282,7 @@ void session_query_builder::on_foreign_object(const char *id, Pointer &, const u
     // create select query
     auto result = matador::query::query::select(generator::columns<typename Pointer::value_type>(schema_, generator::column_generator_options::ForceLazy))
       .from(*foreign_table)
-      .where(sql::column(foreign_table, pk->name(), "") == _)
+      .where(column(foreign_table, pk->name(), "") == _)
       .prepare(executor_);
     if (!result) {
       throw query_builder_exception(query_build_error::QueryError, result.release_error());

include/matador/query/builder.hpp

@@ -0,0 +1,63 @@
+#ifndef MATADOR_BUILDER_HPP
+#define MATADOR_BUILDER_HPP
+
+#include "matador/query/column.hpp"
+#include "matador/query/table.hpp"
+
+#include <string>
+
+namespace matador::query {
+
+class column_builder {
+public:
+  explicit column_builder(std::string column_name);
+
+  // ReSharper disable once CppNonExplicitConversionOperator
+  operator query::column() const; // NOLINT(*-explicit-constructor)
+
+private:
+  std::string column_name;
+};
+
+struct constraint {
+  std::string name;
+};
+
+class table_builder {
+public:
+  explicit table_builder(std::string name);
+
+  table_builder& as(std::string table_alias);
+
+  // ReSharper disable once CppNonExplicitConversionOperator
+  operator query::table() const; // NOLINT(*-explicit-constructor)
+
+private:
+    std::string table_name;
+    std::string alias;
+};
+
+class constraint_builder {
+public:
+  constraint_builder& constraint(std::string name);
+  constraint_builder& primary_key(std::string name);
+  constraint_builder& foreign_key(std::string name);
+  constraint_builder& references(std::string table, std::string column);
+
+  // ReSharper disable once CppNonExplicitConversionOperator
+  operator query::constraint() const; // NOLINT(*-explicit-constructor)
+
+private:
+  std::string constraint_name;
+  std::string pk_column_name;
+  std::string fk_column_name;
+  std::string table_name;
+  std::string column_name;
+};
+
+constraint_builder constraint(std::string name);
+table_builder table(std::string name);
+column_builder column(std::string name);
+
+}
+#endif //MATADOR_BUILDER_HPP

include/matador/query/column.hpp

@@ -1,28 +1,21 @@
 #ifndef QUERY_COLUMN_HPP
 #define QUERY_COLUMN_HPP
 
+#include "matador/sql/sql_functions.hpp"
+
 #include <functional>
 #include <memory>
 #include <string>
 
-namespace matador::sql {
+namespace matador::query {
 
 class table;
 
-enum class sql_function_t {
-  None,
-  Count,
-  Avg,
-  Sum,
-  Min,
-  Max
-};
-
 class column {
 public:
   column(const char *name, const std::string& as = ""); // NOLINT(*-explicit-constructor)
-  explicit column(std::string name, std::string as = "");
-  column(sql_function_t func, std::string name); // NOLINT(*-explicit-constructor)
+  column(std::string name, std::string as = "");
+  column(sql::sql_function_t func, std::string name); // NOLINT(*-explicit-constructor)
   column(const class table &tab, std::string name, std::string as = "");
   column(const std::shared_ptr<table> &t, std::string name, std::string as = "");
 
@@ -34,17 +27,18 @@ public:
   [[nodiscard]] std::string full_name() const;
   [[nodiscard]] const std::string& alias_name() const;
   [[nodiscard]] bool is_function() const;
-  [[nodiscard]] sql_function_t function() const;
+  [[nodiscard]] sql::sql_function_t function() const;
   [[nodiscard]] bool has_alias() const;
   [[nodiscard]] std::string alias() const;
-  [[nodiscard]] std::shared_ptr<sql::table> table() const;
-  void table(const std::shared_ptr<sql::table>& t);
+
+  [[nodiscard]] std::shared_ptr<table> table() const;
+  void table(const std::shared_ptr<query::table>& t);
 
 private:
-  std::shared_ptr<sql::table> table_;
+  std::shared_ptr<query::table> table_;
   std::string name;
   std::string alias_;
-  sql_function_t function_{sql_function_t::None};
+  sql::sql_function_t function_{sql::sql_function_t::None};
 };
 
 column operator ""_col(const char *name, size_t len);

include/matador/query/criteria/abstract_column_criteria.hpp

@@ -3,19 +3,19 @@
 
 #include "matador/query/criteria/abstract_criteria.hpp"
 
-#include "matador/sql/column.hpp"
+#include "matador/query/column.hpp"
 
 namespace matador::query {
 
 class abstract_column_criteria : public abstract_criteria {
 public:
     abstract_column_criteria() = delete;
-    explicit abstract_column_criteria(sql::column column);
+    explicit abstract_column_criteria(column col);
 
-    [[nodiscard]] const sql::column& column() const;
+    [[nodiscard]] const column& col() const;
 
 protected:
-    sql::column column_;
+    column column_;
 };
 
 }

include/matador/query/criteria/between_criteria.hpp

@@ -11,8 +11,8 @@ namespace matador::query {
 class between_criteria final : public abstract_column_criteria {
 public:
     between_criteria() = delete;
-    between_criteria(sql::column column, int64_t min, int64_t max);
-    between_criteria(sql::column column, utils::placeholder min, utils::placeholder max);
+    between_criteria(column col, int64_t min, int64_t max);
+    between_criteria(column col, utils::placeholder min, utils::placeholder max);
 
     void accept(criteria_visitor& visitor) const override;
 

include/matador/query/criteria/binary_criteria.hpp

@@ -4,7 +4,7 @@
 #include "matador/query/criteria/abstract_column_criteria.hpp"
 #include "matador/query/criteria/criteria_utils.hpp"
 
-#include "matador/sql/column.hpp"
+#include "matador/query/column.hpp"
 
 namespace matador::query {
 enum class binary_operator {
@@ -19,7 +19,7 @@ enum class binary_operator {
 class binary_criteria final : public abstract_column_criteria {
 public:
     binary_criteria() = delete;
-    binary_criteria(sql::column column, binary_operator operand, criteria_value value);
+    binary_criteria(column col, binary_operator operand, criteria_value value);
 
     void accept( criteria_visitor& visitor ) const override;
 
@@ -34,18 +34,18 @@ private:
 class binary_column_criteria final : public abstract_criteria {
 public:
     binary_column_criteria() = delete;
-    binary_column_criteria(sql::column left_column, binary_operator operand, sql::column right_column);
+    binary_column_criteria(column left_column, binary_operator operand, column right_column);
 
     void accept(criteria_visitor& visitor) const override;
 
-    [[nodiscard]] const sql::column& left_column() const;
+    [[nodiscard]] const column& left_column() const;
     [[nodiscard]] binary_operator operand() const;
-    [[nodiscard]] const sql::column& right_column() const;
+    [[nodiscard]] const column& right_column() const;
 
 private:
-    sql::column left_column_;
+    column left_column_;
     binary_operator operator_{};
-    sql::column right_column_;
+    column right_column_;
 };
 }
 #endif //CRITERIA_BINARY_CRITERIA_NODE_HPP

include/matador/query/criteria/collection_criteria.hpp

@@ -4,7 +4,7 @@
 #include "matador/query/criteria/abstract_column_criteria.hpp"
 #include "matador/query/criteria/criteria_utils.hpp"
 
-#include "matador/sql/column.hpp"
+#include "matador/query/column.hpp"
 #include "matador/sql/query_context.hpp"
 
 namespace matador::query {
@@ -36,8 +36,8 @@ public:
      * @param operand_ Operator to use
      * @param values List of values
      */
-    collection_criteria(sql::column col, collection_operator operand_, std::vector<criteria_value> values);
-    collection_criteria(sql::column col, collection_operator operand_, std::initializer_list<criteria_value> values);
+    collection_criteria(column col, collection_operator operand_, std::vector<criteria_value> values);
+    collection_criteria(column col, collection_operator operand_, std::initializer_list<criteria_value> values);
 
     void accept(criteria_visitor& visitor) const override;
 
@@ -52,7 +52,7 @@ private:
 class collection_query_criteria final : public abstract_column_criteria {
 public:
     collection_query_criteria() = delete;
-    collection_query_criteria(sql::column col, collection_operator operand_, sql::query_context ctx);
+    collection_query_criteria(column col, collection_operator operand_, sql::query_context ctx);
 
     void accept(criteria_visitor& visitor) const override;
 

include/matador/query/criteria/criteria_operators.hpp

@@ -4,7 +4,7 @@
 #include "matador/query/criteria/binary_criteria.hpp"
 #include "matador/query/criteria/collection_criteria.hpp"
 
-#include "matador/sql/column.hpp"
+#include "matador/query/column.hpp"
 
 #include "matador/utils/placeholder.hpp"
 #include "matador/utils/value.hpp"
@@ -15,48 +15,48 @@ struct query_context;
 namespace matador::query {
 
 template<class Type>
-criteria_ptr operator==(const sql::column &col, Type val) {
+criteria_ptr operator==(const column &col, Type val) {
     return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, utils::value(val));
 }
 
 template<class Type>
-criteria_ptr operator!=(const sql::column &col, Type val) {
+criteria_ptr operator!=(const column &col, Type val) {
     return std::make_unique<binary_criteria>(col, binary_operator::NOT_EQUALS, utils::value(val));
 }
 
 template<class Type>
-criteria_ptr operator>(const sql::column &col, Type val) {
+criteria_ptr operator>(const column &col, Type val) {
     return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN, utils::value(val));
 }
 
 template<class Type>
-criteria_ptr operator>=(const sql::column &col, Type val) {
+criteria_ptr operator>=(const column &col, Type val) {
     return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN_OR_EQUAL, utils::value(val));
 }
 
 template<class Type>
-criteria_ptr operator<(const sql::column &col, Type val) {
+criteria_ptr operator<(const column &col, Type val) {
     return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN, utils::value(val));
 }
 
 template<class Type>
-criteria_ptr operator<=(const sql::column &col, Type val) {
+criteria_ptr operator<=(const column &col, Type val) {
     return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN_OR_EQUAL, utils::value(val));
 }
 
-criteria_ptr operator==(const sql::column &col_left, const sql::column &col_right);
-criteria_ptr operator!=(const sql::column &col_left, const sql::column &col_right);
-criteria_ptr operator>(const sql::column &col_left, const sql::column &col_right);
-criteria_ptr operator>=(const sql::column &col_left, const sql::column &col_right);
-criteria_ptr operator<(const sql::column &col_left, const sql::column &col_right);
-criteria_ptr operator<=(const sql::column &col_left, const sql::column &col_right);
+criteria_ptr operator==(const column &col_left, const column &col_right);
+criteria_ptr operator!=(const column &col_left, const column &col_right);
+criteria_ptr operator>(const column &col_left, const column &col_right);
+criteria_ptr operator>=(const column &col_left, const column &col_right);
+criteria_ptr operator<(const column &col_left, const column &col_right);
+criteria_ptr operator<=(const column &col_left, const column &col_right);
 
-criteria_ptr operator==(const sql::column &col, utils::placeholder p);
-criteria_ptr operator!=(const sql::column &col, utils::placeholder p);
-criteria_ptr operator>(const sql::column &col, utils::placeholder p);
-criteria_ptr operator>=(const sql::column &col, utils::placeholder p);
-criteria_ptr operator<(const sql::column &col, utils::placeholder p);
-criteria_ptr operator<=(const sql::column &col, utils::placeholder p);
+criteria_ptr operator==(const column &col, utils::placeholder p);
+criteria_ptr operator!=(const column &col, utils::placeholder p);
+criteria_ptr operator>(const column &col, utils::placeholder p);
+criteria_ptr operator>=(const column &col, utils::placeholder p);
+criteria_ptr operator<(const column &col, utils::placeholder p);
+criteria_ptr operator<=(const column &col, utils::placeholder p);
 
 criteria_ptr operator&&(criteria_ptr left, criteria_ptr right);
 
@@ -65,7 +65,7 @@ criteria_ptr operator||(criteria_ptr left, criteria_ptr right);
 criteria_ptr operator!(criteria_ptr clause);
 
 template < class Type >
-criteria_ptr in(const sql::column &col, std::initializer_list<Type> args) {
+criteria_ptr in(const column &col, std::initializer_list<Type> args) {
     std::vector<criteria_value> values;
     for ( auto &&arg : args ) {
         values.emplace_back(utils::value{std::move(arg)});
@@ -74,12 +74,12 @@ criteria_ptr in(const sql::column &col, std::initializer_list<Type> args) {
 }
 
 template <>
-criteria_ptr in(const sql::column &col, std::initializer_list<utils::placeholder> args);
+criteria_ptr in(const column &col, std::initializer_list<utils::placeholder> args);
 
-criteria_ptr in(const sql::column &col, sql::query_context &&ctx);
+criteria_ptr in(const column &col, sql::query_context &&ctx);
 
 template < class Type >
-criteria_ptr out(const sql::column &col, std::initializer_list<Type> args) {
+criteria_ptr out(const column &col, std::initializer_list<Type> args) {
     std::vector<criteria_value> values;
     for ( auto &&arg : args ) {
         values.emplace_back(utils::value{std::move(arg)});
@@ -88,14 +88,14 @@ criteria_ptr out(const sql::column &col, std::initializer_list<Type> args) {
 }
 
 template <>
-criteria_ptr out(const sql::column &col, std::initializer_list<utils::placeholder> args);
+criteria_ptr out(const column &col, std::initializer_list<utils::placeholder> args);
 
-criteria_ptr out(const sql::column &col, sql::query_context &&ctx);
+criteria_ptr out(const column &col, sql::query_context &&ctx);
 
-criteria_ptr between(const sql::column &col, int64_t min, int64_t max);
-criteria_ptr between(const sql::column &col, utils::placeholder min, utils::placeholder max);
+criteria_ptr between(const column &col, int64_t min, int64_t max);
+criteria_ptr between(const column &col, utils::placeholder min, utils::placeholder max);
 
-criteria_ptr like(const sql::column &col, const std::string &pattern);
+criteria_ptr like(const column &col, const std::string &pattern);
 
 }
 #endif //CRITERIA_CRITERIA_OPERATORS_HPP

include/matador/query/criteria/like_criteria.hpp

@@ -3,13 +3,13 @@
 
 #include "matador/query/criteria/abstract_column_criteria.hpp"
 
-#include "matador/sql/column.hpp"
+#include "matador/query/column.hpp"
 
 namespace matador::query {
 class like_criteria final : public abstract_column_criteria {
 public:
   like_criteria() = delete;
-  like_criteria(sql::column column, std::string pattern);
+  like_criteria(column col, std::string pattern);
 
   void accept(criteria_visitor &visitor) const override;
 

include/matador/query/generator.hpp

@@ -11,7 +11,7 @@
 #include "matador/query/fk_value_extractor.hpp"
 #include "matador/query/internal/column_value_pair.hpp"
 
-#include "matador/sql/table.hpp"
+#include "matador/query/table.hpp"
 
 #include <vector>
 
@@ -53,13 +53,13 @@ public:
                             column_generator_options options = default_column_generator_options);
 
   template< class Type >
-  std::vector<sql::column> generate() {
+  std::vector<column> generate() {
     Type obj;
     return generate(obj);
   }
 
   template< class Type >
-  std::vector<sql::column> generate(const Type &obj) {
+  std::vector<column> generate(const Type &obj) {
     result_.clear();
     access::process(*this, obj);
 
@@ -101,7 +101,7 @@ public:
 
     if (seen_tables.count(info->get().name()) == 0) {
       auto it = seen_tables.insert(info->get().name()).first;
-      table_stack_.push(std::make_shared<sql::table>(info.value().get().name()));
+      table_stack_.push(std::make_shared<table>(info.value().get().name()));
       typename ContainerType::value_type::value_type obj;
       access::process(*this, obj);
       table_stack_.pop();
@@ -136,7 +136,7 @@ private:
       }
       if (seen_tables.count(info->get().name()) == 0) {
         auto it = seen_tables.insert(info->get().name()).first;
-        table_stack_.push(std::make_shared<sql::table>(info.value().get().name()));
+        table_stack_.push(std::make_shared<table>(info.value().get().name()));
         typename Pointer::value_type obj;
         access::process(*this, obj);
         table_stack_.pop();
@@ -149,8 +149,8 @@ private:
 
 private:
   std::optional<std::reference_wrapper<const object::repository>> repo_;
-  std::vector<sql::column> result_;
-  std::stack<std::shared_ptr<sql::table>> table_stack_;
+  std::vector<column> result_;
+  std::stack<std::shared_ptr<table>> table_stack_;
   std::unordered_set<std::string> seen_tables;
   int column_index{0};
   column_generator_options options_{false};
@@ -296,7 +296,7 @@ std::vector<internal::column_value_pair> column_value_pairs() {
 }
 
 template<typename Type>
-std::vector<sql::column> columns(const object::repository &repo,
+std::vector<column> columns(const object::repository &repo,
                             const std::string &table_name = "",
                             const column_generator_options options = default_column_generator_options) {
     column_generator generator(repo, table_name, options);
@@ -304,7 +304,7 @@ std::vector<sql::column> columns(const object::repository &repo,
 }
 
 template<typename Type>
-std::vector<sql::column> columns(const object::repository &repo,
+std::vector<column> columns(const object::repository &repo,
                             const column_generator_options options) {
     std::string table_name;
     if (const auto result = repo.info<Type>()) {
@@ -315,7 +315,7 @@ std::vector<sql::column> columns(const object::repository &repo,
 }
 
 template<typename Type>
-std::vector<sql::column> columns(const Type &obj,
+std::vector<column> columns(const Type &obj,
                             const object::repository &repo,
                             const std::string &table_name = "",
                             const column_generator_options options = default_column_generator_options) {
@@ -324,14 +324,14 @@ std::vector<sql::column> columns(const Type &obj,
 }
 
 template<typename Type>
-std::vector<sql::column> columns(const std::string &table_name = "",
+std::vector<column> columns(const std::string &table_name = "",
                             const column_generator_options options = default_column_generator_options) {
     column_generator generator(table_name, options);
     return generator.generate<Type>();
 }
 
 template<typename Type>
-std::vector<sql::column> columns(const Type &obj,
+std::vector<column> columns(const Type &obj,
                             const std::string &table_name = "",
                             const column_generator_options options = default_column_generator_options) {
     column_generator generator(table_name, options);

include/matador/query/intermediates/query_alter_intermediate.hpp

@@ -9,7 +9,7 @@ class query_alter_intermediate : public query_intermediate {
 public:
   query_alter_intermediate();
 
-  query_alter_table_intermediate table(const sql::table &table) const;
+  query_alter_table_intermediate table(const table &tab) const;
 };
 
 }

include/matador/query/intermediates/query_alter_table_intermediate.hpp

@@ -13,21 +13,21 @@ class query_add_foreign_key_constraint_intermediate final : public query_interme
 public:
     using query_intermediate::query_intermediate;
 
-    executable_query references(const sql::table& table, const std::vector<sql::column>& columns = {});
+    executable_query references(const table& tab, const std::vector<column>& columns = {});
 
 private:
-    sql::table table_;
-    std::vector<sql::column> columns_;
+    table table_;
+    std::vector<column> columns_;
 };
 
 class query_add_key_constraint_intermediate final : public query_intermediate {
 public:
     using query_intermediate::query_intermediate;
 
-    query_add_primary_key_constraint_intermediate primary_key(const sql::column& column) const;
-    query_add_primary_key_constraint_intermediate primary_keys(const std::vector<sql::column>& columns) const;
-    query_add_foreign_key_constraint_intermediate foreign_key(const sql::column& column) const;
-    query_add_foreign_key_constraint_intermediate foreign_keys(const std::vector<sql::column>& columns) const;
+    [[nodiscard]] query_add_primary_key_constraint_intermediate primary_key(const column& col) const;
+    [[nodiscard]] query_add_primary_key_constraint_intermediate primary_keys(const std::vector<column>& columns) const;
+    [[nodiscard]] query_add_foreign_key_constraint_intermediate foreign_key(const column& col) const;
+    [[nodiscard]] query_add_foreign_key_constraint_intermediate foreign_keys(const std::vector<column>& columns) const;
 };
 
 class query_alter_table_intermediate final : public query_intermediate {

include/matador/query/intermediates/query_create_intermediate.hpp

@@ -13,11 +13,11 @@ class query_create_intermediate : public query_intermediate {
 public:
   query_create_intermediate();
 
-  executable_query table(const sql::table &table, std::initializer_list<object::attribute_definition> columns);
-  executable_query table(const sql::table &table, const std::vector<object::attribute_definition> &columns);
+  executable_query table(const query::table &tab, std::initializer_list<object::attribute_definition> columns);
+  executable_query table(const query::table &tab, const std::vector<object::attribute_definition> &columns);
   template<class Type>
-  executable_query table(const sql::table &table, const object::repository &schema) {
-    return this->table(table, object::attribute_definition_generator::generate<Type>(schema));
+  executable_query table(const query::table &tab, const object::repository &schema) {
+    return this->table(tab, object::attribute_definition_generator::generate<Type>(schema));
   }
   executable_query schema(const std::string &schema_name);
 };

include/matador/query/intermediates/query_delete_intermediate.hpp

@@ -12,7 +12,7 @@ class query_delete_intermediate : public query_intermediate
 public:
   query_delete_intermediate();
 
-  query_delete_from_intermediate from(const sql::table &table);
+  query_delete_from_intermediate from(const table &tab);
 };
 
 }

include/matador/query/intermediates/query_drop_intermediate.hpp

@@ -9,7 +9,7 @@ class query_drop_intermediate : query_intermediate {
 public:
   query_drop_intermediate();
 
-  executable_query table(const sql::table &table);
+  executable_query table(const table &tab);
   executable_query schema(const std::string &schema_name);
 };
 

include/matador/query/intermediates/query_execute_where_intermediate.hpp

@@ -14,7 +14,7 @@ public:
   using executable_query::executable_query;
 
   query_execute_limit_intermediate limit(size_t limit);
-  query_execute_order_by_intermediate order_by(const sql::column &col);
+  query_execute_order_by_intermediate order_by(const column &col);
 };
 
 }

include/matador/query/intermediates/query_from_intermediate.hpp

@@ -15,7 +15,7 @@ class query_from_intermediate : public fetchable_query
 public:
   using fetchable_query::fetchable_query;
 
-  query_join_intermediate join_left(const sql::table &t);
+  query_join_intermediate join_left(const table &t);
   query_from_intermediate join_left(join_data &data);
   query_from_intermediate join_left(std::vector<join_data> &data_vector);
 
@@ -25,8 +25,8 @@ public:
   //   return where_clause(std::make_unique<Condition>(std::move(cond)));
   // }
   query_where_intermediate where(std::unique_ptr<abstract_criteria> &&cond);
-  query_group_by_intermediate group_by(const sql::column &col);
-  query_order_by_intermediate order_by(const sql::column &col);
+  query_group_by_intermediate group_by(const column &col);
+  query_order_by_intermediate order_by(const column &col);
 
 private:
   query_where_intermediate where_clause(std::unique_ptr<abstract_criteria> &&cond);

include/matador/query/intermediates/query_group_by_intermediate.hpp

@@ -12,7 +12,7 @@ class query_group_by_intermediate : public fetchable_query
 public:
   using fetchable_query::fetchable_query;
 
-  query_order_by_intermediate order_by(const sql::column &col);
+  query_order_by_intermediate order_by(const column &col);
 };
 
 }

include/matador/query/intermediates/query_insert_intermediate.hpp

@@ -14,13 +14,13 @@ public:
   query_insert_intermediate();
 
   template<class Type>
-  query_into_intermediate into(const sql::table &table, const object::repository &schema) {
-    return into(table, generator::columns<Type>(schema));
+  query_into_intermediate into(const table &tab, const object::repository &schema) {
+    return into(tab, generator::columns<Type>(schema));
   }
-  query_into_intermediate into(const sql::table &table, std::initializer_list<sql::column> columns);
-  query_into_intermediate into(const sql::table &table, std::vector<sql::column> &&columns);
-  query_into_intermediate into(const sql::table &table, const std::vector<std::string> &column_names);
-  query_into_intermediate into(const sql::table &table);
+  query_into_intermediate into(const table &tab, std::initializer_list<column> columns);
+  query_into_intermediate into(const table &tab, std::vector<column> &&columns);
+  query_into_intermediate into(const table &tab, const std::vector<std::string> &column_names);
+  query_into_intermediate into(const table &tab);
 };
 
 }

include/matador/query/intermediates/query_select_intermediate.hpp

@@ -10,9 +10,9 @@ class query_from_intermediate;
 class query_select_intermediate : public query_intermediate
 {
 public:
-  explicit query_select_intermediate(const std::vector<sql::column>& columns);
+  explicit query_select_intermediate(const std::vector<column>& columns);
 
-  query_from_intermediate from(const sql::table& t);
+  query_from_intermediate from(const table& t);
 };
 
 }

include/matador/query/intermediates/query_update_intermediate.hpp

@@ -13,7 +13,7 @@ namespace matador::query {
 
 class query_update_intermediate : public query_intermediate {
 public:
-  explicit query_update_intermediate(const sql::table& table);
+  explicit query_update_intermediate(const table& tab);
 
   query_set_intermediate set(std::initializer_list<internal::column_value_pair> columns);
   query_set_intermediate set(std::vector<internal::column_value_pair> &&columns);

include/matador/query/intermediates/query_where_intermediate.hpp

@@ -13,8 +13,8 @@ class query_where_intermediate : public fetchable_query
 public:
   using fetchable_query::fetchable_query;
 
-  query_group_by_intermediate group_by(const sql::column &col);
-  query_order_by_intermediate order_by(const sql::column &col);
+  query_group_by_intermediate group_by(const column &col);
+  query_order_by_intermediate order_by(const column &col);
 };
 
 }

include/matador/query/internal/column_value_pair.hpp

@@ -1,7 +1,7 @@
 #ifndef QUERY_KEY_VALUE_PAIR_HPP
 #define QUERY_KEY_VALUE_PAIR_HPP
 
-#include "matador/sql/column.hpp"
+#include "matador/query/column.hpp"
 
 #include "matador/utils/placeholder.hpp"
 #include "matador/utils/types.hpp"
@@ -10,7 +10,7 @@ namespace matador::query::internal {
 
 class column_value_pair {
 public:
-  column_value_pair(const sql::column &col, utils::database_type value);
+  column_value_pair(const column &col, utils::database_type value);
   column_value_pair(std::string name, utils::database_type value);
   column_value_pair(const char *name, utils::database_type value);
   column_value_pair(const char *name, utils::placeholder p);
@@ -18,11 +18,11 @@ public:
   friend bool operator==(const column_value_pair &lhs, const column_value_pair &rhs);
   friend bool operator!=(const column_value_pair &lhs, const column_value_pair &rhs);
 
-  [[nodiscard]] const sql::column& col() const;
+  [[nodiscard]] const column& col() const;
   [[nodiscard]] const std::variant<utils::placeholder, utils::database_type>& value() const;
 
 private:
-  sql::column column_;
+  column column_;
   std::variant<utils::placeholder, utils::database_type> value_;
 };
 

include/matador/query/internal/query_parts.hpp

@@ -6,10 +6,10 @@
 
 #include "matador/query/internal/column_value_pair.hpp"
 #include "matador/query/query_part.hpp"
+#include "matador/query/column.hpp"
+#include "matador/query/table.hpp"
 
-#include "matador/sql/column.hpp"
 #include "matador/object/attribute_definition.hpp"
-#include "matador/sql/table.hpp"
 
 #include "matador/utils/placeholder.hpp"
 
@@ -26,19 +26,19 @@ public:
 
 class query_alter_table_part final : public query_part {
 public:
-  explicit query_alter_table_part(sql::table table);
+  explicit query_alter_table_part(table tab);
 
   void accept(query_part_visitor &visitor) override;
 
-  [[nodiscard]] const sql::table& table() const;
+  [[nodiscard]] const table& table() const;
 
 private:
-  sql::table table_;
+  query::table table_;
 };
 
 class query_add_key_constraint_part final : public query_part {
 public:
-  explicit query_add_key_constraint_part(const std::string& name);
+  explicit query_add_key_constraint_part(std::string  name);
   void accept(query_part_visitor &visitor) override;
 
   [[nodiscard]] const std::string& name() const;
@@ -48,7 +48,7 @@ private:
 
 class query_drop_key_constraint_part final : public query_part {
 public:
-  explicit query_drop_key_constraint_part(const std::string& name);
+  explicit query_drop_key_constraint_part(std::string  name);
   void accept(query_part_visitor &visitor) override;
 
   [[nodiscard]] const std::string& name() const;
@@ -58,35 +58,35 @@ private:
 
 class query_add_foreign_key_constraint_part final : public query_part {
 public:
-  explicit query_add_foreign_key_constraint_part( const std::vector<sql::column>& columns);
+  explicit query_add_foreign_key_constraint_part( const std::vector<column>& columns);
   void accept(query_part_visitor &visitor) override;
 
-  [[nodiscard]] const std::vector<sql::column>& columns() const;
+  [[nodiscard]] const std::vector<column>& columns() const;
 private:
-  std::vector<sql::column> columns_;
+  std::vector<column> columns_;
 };
 
 class query_add_foreign_key_reference_part final : public query_part {
 public:
-  explicit query_add_foreign_key_reference_part(sql::table table, const std::vector<sql::column>& columns);
+  explicit query_add_foreign_key_reference_part(table tab, const std::vector<column>& columns);
   void accept(query_part_visitor &visitor) override;
 
-  [[nodiscard]] const sql::table& table() const;
-  [[nodiscard]] const std::vector<sql::column>& columns() const;
+  [[nodiscard]] const table& table() const;
+  [[nodiscard]] const std::vector<column>& columns() const;
 
 private:
-  sql::table table_;
-  std::vector<sql::column> columns_;
+  query::table table_;
+  std::vector<column> columns_;
 };
 
 class query_add_primary_key_constraint_part final : public query_part {
 public:
-  explicit query_add_primary_key_constraint_part( const std::vector<sql::column>& columns);
+  explicit query_add_primary_key_constraint_part( const std::vector<column>& columns);
   void accept(query_part_visitor &visitor) override;
 
-  [[nodiscard]] const std::vector<sql::column>& columns() const;
+  [[nodiscard]] const std::vector<column>& columns() const;
 private:
-  std::vector<sql::column> columns_;
+  std::vector<column> columns_;
 };
 
 class query_drop_foreign_key_constraint_part final : public query_part {
@@ -101,13 +101,13 @@ public:
 class query_select_part final : public query_part
 {
 public:
-  explicit query_select_part(std::vector<sql::column> columns);
+  explicit query_select_part(std::vector<column> columns);
   void accept(query_part_visitor &visitor) override;
 
-  [[nodiscard]] const std::vector<sql::column>& columns() const;
+  [[nodiscard]] const std::vector<column>& columns() const;
 
 private:
-  std::vector<sql::column> columns_;
+  std::vector<column> columns_;
 };
 
 /**
@@ -116,29 +116,29 @@ private:
 class query_from_part final : public query_part
 {
 public:
-  explicit query_from_part(sql::table t);
+  explicit query_from_part(table t);
 
-  [[nodiscard]] const sql::table& table() const;
+  [[nodiscard]] const table& table() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
 
 private:
-  sql::table table_;
+  class table table_;
 };
 
 class query_join_part final : public query_part
 {
 public:
-  explicit query_join_part(sql::table t);
+  explicit query_join_part(table t);
 
-  [[nodiscard]] const sql::table& table() const;
+  [[nodiscard]] const table& table() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
 
 private:
-  sql::table table_;
+  class table table_;
 };
 
 class query_on_part final : public query_part
@@ -189,29 +189,29 @@ protected:
 class query_group_by_part final : public query_part
 {
 public:
-  explicit query_group_by_part(sql::column  col);
+  explicit query_group_by_part(column  col);
 
-  [[nodiscard]] const sql::column& column() const;
+  [[nodiscard]] const column& column() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
 
 private:
-  sql::column column_;
+  class column column_;
 };
 
 class query_order_by_part final : public query_part
 {
 public:
-  explicit query_order_by_part(sql::column  col);
+  explicit query_order_by_part(column  col);
 
-  [[nodiscard]] const sql::column& column() const;
+  [[nodiscard]] const column& column() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
 
 private:
-  sql::column column_;
+  class column column_;
 };
 
 class query_order_by_asc_part final : public query_part
@@ -272,17 +272,17 @@ private:
 class query_into_part final : public query_part
 {
 public:
-  query_into_part(sql::table t, std::vector<sql::column> columns);
+  query_into_part(table t, std::vector<column> columns);
 
-  [[nodiscard]] const sql::table& table() const;
-  [[nodiscard]] const std::vector<sql::column>& columns() const;
+  [[nodiscard]] const table& table() const;
+  [[nodiscard]] const std::vector<column>& columns() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
 
 private:
-  sql::table table_;
-  std::vector<sql::column> columns_;
+  class table table_;
+  std::vector<column> columns_;
 };
 /**
  * Represents the SQL VALUES part
@@ -304,15 +304,15 @@ private:
 class query_update_part final : public query_part
 {
 public:
-  explicit query_update_part(sql::table table);
+  explicit query_update_part(table table);
 
-  [[nodiscard]] const sql::table& table() const;
+  [[nodiscard]] const table& table() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
 
 private:
-  sql::table table_;
+  class table table_;
 };
 
 class query_set_part final : public query_part
@@ -341,15 +341,15 @@ private:
 class query_delete_from_part final : public query_part
 {
 public:
-  explicit query_delete_from_part(sql::table table);
+  explicit query_delete_from_part(table table);
 
-  [[nodiscard]] const sql::table& table() const;
+  [[nodiscard]] const table& table() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
 
 private:
-  sql::table table_;
+  class table table_;
 };
 
 class query_create_part final : public query_part
@@ -364,16 +364,16 @@ private:
 class query_create_table_part final : public query_part
 {
 public:
-  query_create_table_part(sql::table table, std::vector<object::attribute_definition> columns);
+  query_create_table_part(table table, std::vector<object::attribute_definition> columns);
 
-  [[nodiscard]] const sql::table& table() const;
+  [[nodiscard]] const table& table() const;
   [[nodiscard]] const std::vector<object::attribute_definition>& columns() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
 
 private:
-  sql::table table_;
+  class table table_;
   std::vector<object::attribute_definition> columns_;
 };
 
@@ -402,15 +402,15 @@ private:
 class query_drop_table_part final : public query_part
 {
 public:
-  explicit query_drop_table_part(sql::table table);
+  explicit query_drop_table_part(table table);
 
-  [[nodiscard]] const sql::table& table() const;
+  [[nodiscard]] const table& table() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
 
 private:
-  sql::table table_;
+  class table table_;
 };
 
 class query_drop_schema_part final : public query_part {

include/matador/query/join_data.hpp

@@ -3,14 +3,14 @@
 
 #include "matador/query/criteria/abstract_criteria.hpp"
 
-#include "matador/sql/table.hpp"
+#include "matador/query/table.hpp"
 
 #include <memory>
 
 namespace matador::query {
 
 struct join_data {
-  std::shared_ptr<sql::table> join_table;
+  std::shared_ptr<table> join_table;
   std::unique_ptr<abstract_criteria> condition;
 };
 

include/matador/query/query.hpp

@@ -10,10 +10,10 @@ class connection;
 }
 namespace matador::query {
 
-sql::column alias(const std::string &column, const std::string &as);
-sql::column alias(sql::column &&col, const std::string &as);
-sql::column count(const std::string &column);
-sql::column count_all();
+column alias(const std::string &column, const std::string &as);
+column alias(column &&col, const std::string &as);
+column count(const std::string &column);
+column count_all();
 
 class query
 {
@@ -21,16 +21,16 @@ public:
   [[nodiscard]] static query_create_intermediate create();
   [[nodiscard]] static query_drop_intermediate drop();
   [[nodiscard]] static query_select_intermediate select();
-  [[nodiscard]] static query_select_intermediate select(std::initializer_list<sql::column> columns);
-  [[nodiscard]] static query_select_intermediate select(const std::vector<sql::column>& columns);
+  [[nodiscard]] static query_select_intermediate select(std::initializer_list<column> columns);
+  [[nodiscard]] static query_select_intermediate select(const std::vector<column>& columns);
   [[nodiscard]] static query_select_intermediate select(const std::vector<std::string> &column_names);
-  [[nodiscard]] static query_select_intermediate select(std::vector<sql::column> columns, std::initializer_list<sql::column> additional_columns);
+  [[nodiscard]] static query_select_intermediate select(std::vector<column> columns, std::initializer_list<column> additional_columns);
   template<class Type>
   [[nodiscard]] static query_select_intermediate select(const object::repository &schema) {
     return select(generator::columns<Type>(schema));
   }
   [[nodiscard]] static query_insert_intermediate insert();
-  [[nodiscard]] static query_update_intermediate update(const sql::table &table);
+  [[nodiscard]] static query_update_intermediate update(const table &table);
   [[nodiscard]] static query_delete_intermediate remove();
 
   [[nodiscard]] static query_alter_intermediate alter();

include/matador/query/query_compiler.hpp

@@ -68,8 +68,7 @@ protected:
   void visit(internal::query_drop_table_part &part) override;
   void visit(internal::query_drop_schema_part& part) override;
 
-  static std::string build_table_name(sql::dialect_token token, const sql::dialect &d, const sql::table& t);
-
+  static std::string build_table_name(sql::dialect_token token, const sql::dialect &d, const table& t);
   static std::string determine_value(value_visitor &visitor, const std::variant<utils::placeholder, utils::database_type> &val);
 
 protected:

include/matador/query/query_data.hpp

@@ -6,8 +6,7 @@
 
 #include "matador/object/attribute_definition.hpp"
 
-#include "matador/sql/table.hpp"
-
+#include "matador/query/table.hpp"
 #include "matador/query/query_part.hpp"
 
 namespace matador::query {
@@ -15,7 +14,7 @@ namespace matador::query {
 struct query_data {
   std::vector<std::unique_ptr<query_part>> parts{};
   std::vector<object::attribute_definition> columns{};
-  std::unordered_map<std::string, sql::table> tables{};
+  std::unordered_map<std::string, table> tables{};
 };
 
 }

include/matador/query/query_utils.hpp

@@ -0,0 +1,17 @@
+#ifndef MATADOR_QUERY_UTILS_HPP
+#define MATADOR_QUERY_UTILS_HPP
+
+#include "matador/sql/dialect.hpp"
+
+#include <string>
+
+namespace matador::sql {
+class dialect;
+}
+namespace matador::query {
+class column;
+
+[[nodiscard]] std::string prepare_identifier(const sql::dialect& d, const column &col);
+[[nodiscard]] std::string prepare_criteria(const sql::dialect& d, const column &col);
+}
+#endif //MATADOR_QUERY_UTILS_HPP

include/matador/query/table.hpp

@@ -1,12 +1,12 @@
 #ifndef QUERY_TABLE_HPP
 #define QUERY_TABLE_HPP
 
-#include "matador/sql/column.hpp"
+#include "column.hpp"
 
 #include <string>
 #include <vector>
 
-namespace matador::sql {
+namespace matador::query {
 
 class column;
 

include/matador/sql/dialect.hpp

@@ -1,8 +1,8 @@
 #ifndef QUERY_DIALECT_HPP
 #define QUERY_DIALECT_HPP
 
-#include "matador/sql/column.hpp"
 #include "matador/sql/dialect_token.hpp"
+#include "matador/sql/sql_functions.hpp"
 
 #include "matador/utils/basic_types.hpp"
 #include "matador/utils/types.hpp"
@@ -42,6 +42,7 @@ public:
 public:
   [[nodiscard]] const std::string& token_at(dialect_token token) const;
   [[nodiscard]] const std::string& data_type_at(utils::basic_type type) const;
+  [[nodiscard]] const std::string& sql_function_at(sql_function_t func) const;
 
   /**
    * Prepare sql dialect identifier for execution
@@ -51,9 +52,7 @@ public:
    * @param col The identifier string to be prepared
    * @return The prepared string
    */
-  [[nodiscard]] std::string prepare_identifier(const column &col) const;
   [[nodiscard]] std::string prepare_identifier_string(const std::string &col) const;
-  [[nodiscard]] std::string prepare_condition(const column &col) const;
   [[nodiscard]] std::string table_name(const std::string &table, const std::string &schema_name) const;
 
   [[nodiscard]] const std::string& to_string(bool val) const;

include/matador/sql/interface/connection_impl.hpp

@@ -4,8 +4,10 @@
 #include <memory>
 
 #include "matador/object/attribute_definition.hpp"
+
 #include "matador/sql/connection_info.hpp"
 #include "matador/sql/query_context.hpp"
+
 #include "matador/utils/error.hpp"
 #include "matador/utils/result.hpp"
 #include "matador/utils/version.hpp"

include/matador/sql/query_context.hpp

@@ -2,7 +2,7 @@
 #define QUERY_QUERY_DATA_HPP
 
 #include "matador/object/attribute_definition.hpp"
-#include "matador/sql/table.hpp"
+#include "matador/query/table.hpp"
 
 #include "matador/utils/types.hpp"
 
@@ -35,7 +35,7 @@ struct query_context {
   sql_command command{};
   std::string command_name{};
   std::string schema_name{};
-  sql::table table{""};
+  std::string table_name{};
   std::vector<object::attribute_definition> prototype{};
   std::vector<std::string> result_vars{};
   std::vector<std::string> bind_vars{};

include/matador/sql/query_macro.hpp

@@ -3,8 +3,8 @@
 
 #include "matador/utils/macro_map.hpp"
 
-#include "matador/sql/table.hpp"
-#include "matador/sql/column.hpp"
+#include "matador/query/table.hpp"
+#include "matador/query/column.hpp"
 
 #include <string>
 #include <ostream>

include/matador/sql/record.hpp

@@ -8,8 +8,6 @@
 
 namespace matador::sql {
 
-class column;
-
 class record final {
 private:
   using field_ref = std::reference_wrapper<field>;
@@ -41,11 +39,11 @@ public:
 
   [[nodiscard]] const std::vector<field_ref>& columns() const;
 
-  [[nodiscard]] const field& at(const sql::column &col) const;
+  [[nodiscard]] const field& at(const std::string &name) const;
   [[nodiscard]] const field& at(size_t index) const;
   template<class Type>
-  std::optional<Type> at(const column &col) const {
-    return at(col).as<Type>();
+  std::optional<Type> at(const std::string &name) const {
+    return at(name).as<Type>();
   }
   template<class Type>
   std::optional<Type> at(const size_t index) const {

include/matador/sql/sql_functions.hpp

@@ -0,0 +1,14 @@
+#ifndef MATADOR_SQL_FUNCTIONS_HPP
+#define MATADOR_SQL_FUNCTIONS_HPP
+
+namespace matador::sql {
+enum class sql_function_t {
+  None,
+  Count,
+  Avg,
+  Sum,
+  Min,
+  Max
+};
+}
+#endif //MATADOR_SQL_FUNCTIONS_HPP

source/orm/CMakeLists.txt

@@ -4,6 +4,8 @@ add_library(matador-orm STATIC
   ../../include/matador/orm/session.hpp
   ../../include/matador/orm/session_query_builder.hpp
   ../../include/matador/query/attribute_string_writer.hpp
+  ../../include/matador/query/builder.hpp
+  ../../include/matador/query/column.hpp
   ../../include/matador/query/criteria.hpp
   ../../include/matador/query/criteria/abstract_column_criteria.hpp
   ../../include/matador/query/criteria/abstract_criteria.hpp
@@ -16,6 +18,7 @@ add_library(matador-orm STATIC
   ../../include/matador/query/criteria/logical_criteria.hpp
   ../../include/matador/query/criteria_evaluator.hpp
   ../../include/matador/query/fk_value_extractor.hpp
+  ../../include/matador/query/generator.hpp
   ../../include/matador/query/intermediates/executable_query.hpp
   ../../include/matador/query/intermediates/fetchable_query.hpp
   ../../include/matador/query/intermediates/query_alter_intermediate.hpp
@@ -53,10 +56,11 @@ add_library(matador-orm STATIC
   ../../include/matador/query/query_data.hpp
   ../../include/matador/query/query_intermediates.hpp
   ../../include/matador/query/query_part.hpp
+  ../../include/matador/query/query_utils.hpp
+  ../../include/matador/query/table.hpp
   ../../include/matador/query/value_extractor.hpp
   ../../include/matador/sql/abstract_sql_logger.hpp
   ../../include/matador/sql/backend_provider.hpp
-  ../../include/matador/sql/column.hpp
   ../../include/matador/sql/connection.hpp
   ../../include/matador/sql/connection_info.hpp
   ../../include/matador/sql/dialect.hpp
@@ -77,14 +81,16 @@ add_library(matador-orm STATIC
   ../../include/matador/sql/query_macro.hpp
   ../../include/matador/sql/query_result.hpp
   ../../include/matador/sql/record.hpp
+  ../../include/matador/sql/sql_functions.hpp
   ../../include/matador/sql/statement.hpp
-  ../../include/matador/sql/table.hpp
   orm/error_code.cpp
   orm/query_builder_exception.cpp
   orm/schema.cpp
   orm/session.cpp
   orm/session_query_builder.cpp
   query/attribute_string_writer.cpp
+  query/builder.cpp
+  query/column.cpp
   query/criteria/abstract_column_criteria.cpp
   query/criteria/between_criteria.cpp
   query/criteria/binary_criteria.cpp
@@ -94,6 +100,7 @@ add_library(matador-orm STATIC
   query/criteria/logical_criteria.cpp
   query/criteria/not_criteria.cpp
   query/criteria_evaluator.cpp
+  query/generator.cpp
   query/intermediates/executable_query.cpp
   query/intermediates/fetchable_query.cpp
   query/intermediates/query_alter_intermediate.cpp
@@ -129,16 +136,16 @@ add_library(matador-orm STATIC
   query/query.cpp
   query/query_compiler.cpp
   query/query_part.cpp
+  query/query_utils.cpp
+  query/table.cpp
   query/value_extractor.cpp
   sql/backend_provider.cpp
-  sql/column.cpp
   sql/connection.cpp
   sql/connection_info.cpp
   sql/connection_pool.cpp
   sql/dialect.cpp
   sql/dialect_builder.cpp
   sql/error_code.cpp
-  sql/executor.cpp
   sql/field.cpp
   sql/interface/connection_impl.cpp
   sql/interface/query_result_reader.cpp
@@ -151,9 +158,6 @@ add_library(matador-orm STATIC
   sql/record.cpp
   sql/statement.cpp
   sql/statement_cache.cpp
-  sql/table.cpp
-  ../../include/matador/query/generator.hpp
-  query/generator.cpp
 )
 
 target_include_directories(matador-orm

source/orm/orm/session.cpp

@@ -90,13 +90,13 @@ utils::result<sql::query_result<sql::record>, utils::error> session::fetch_all(c
   if (!c.valid()) {
     return utils::failure(make_error(error_code::NoConnectionAvailable, "Failed to acquire connection."));
   }
-  auto it = prototypes_.find(q.table.name());
+  auto it = prototypes_.find(q.table_name);
   if (it == prototypes_.end()) {
-    auto result = c->describe(q.table.name());
+    auto result = c->describe(q.table_name);
     if (!result) {
       return utils::failure(result.err());
     }
-    it = prototypes_.emplace(q.table.name(), *result).first;
+    it = prototypes_.emplace(q.table_name, *result).first;
   }
   // adjust columns from given query
   for (auto &col: q.prototype) {
@@ -175,7 +175,7 @@ query::fetchable_query session::build_select_query(entity_query_data &&data) {
       .from(*data.root_table)
       .join_left(data.joins)
       .where(std::move(data.where_clause))
-      .order_by(sql::column{data.root_table, data.pk_column_name})
+      .order_by({data.root_table, data.pk_column_name})
       .asc();
 }
 }

source/orm/orm/session_query_builder.cpp

@@ -3,7 +3,7 @@
 #include <iostream>
 
 namespace matador::orm {
-criteria_transformer::criteria_transformer(const object::repository& repo, const std::unordered_map<std::string, std::shared_ptr<sql::table>>& tables_by_name)
+criteria_transformer::criteria_transformer(const object::repository& repo, const std::unordered_map<std::string, std::shared_ptr<query::table>>& tables_by_name)
 : repo_(repo)
 , tables_by_name_(tables_by_name) {}
 
@@ -39,12 +39,12 @@ void criteria_transformer::visit( const query::not_criteria& node ) {
 }
 
 void criteria_transformer::update_criteria_column(const query::abstract_column_criteria& node) const {
-    const auto it = tables_by_name_.find(node.column().table()->name());
+    const auto it = tables_by_name_.find(node.col().table()->name());
     if (it == tables_by_name_.end()) {
         return;
     }
 
-    const_cast<sql::column&>(node.column()).table(it->second);
+    const_cast<query::column&>(node.col()).table(it->second);
 }
 
 void session_query_builder::on_revision(const char *id, uint64_t &/*rev*/) {
@@ -70,7 +70,7 @@ std::string session_query_builder::build_alias(const char prefix, const unsigned
   return table_info_stack_.size() == 1;
 }
 
-void session_query_builder::append_join(const sql::column &left, const sql::column &right) {
+void session_query_builder::append_join(const query::column &left, const query::column &right) {
   using namespace matador::query;
   entity_query_data_.joins.push_back({
     {right.table()},

source/orm/query/builder.cpp

@@ -0,0 +1,62 @@
+#include "matador/query/builder.hpp"
+
+namespace matador::query {
+
+column_builder::column_builder(std::string column_name)
+: column_name( std::move(column_name) ) {}
+
+column_builder::operator class query::column() const {
+  return {column_name};
+}
+
+table_builder::table_builder(std::string name)
+: table_name( std::move(name) ) {}
+
+table_builder& table_builder::as( std::string table_alias ) {
+  this->alias = std::move(table_alias);
+  return *this;
+}
+
+table_builder::operator class query::table() const {
+  return {table_name, alias};
+}
+
+constraint_builder& constraint_builder::constraint( std::string name ) {
+  constraint_name = std::move(name);
+  return *this;
+}
+
+constraint_builder& constraint_builder::primary_key( std::string name ) {
+  pk_column_name = std::move(name);
+  return *this;
+}
+
+constraint_builder& constraint_builder::foreign_key( std::string name ) {
+  fk_column_name = std::move(name);
+  return *this;
+}
+
+constraint_builder& constraint_builder::references( std::string table, std::string column ) {
+  this->table_name = std::move(table);
+  this->column_name = std::move(column);
+  return *this;
+}
+
+constraint_builder::operator struct query::constraint() const {
+  return {constraint_name};
+}
+
+constraint_builder constraint( std::string name ) {
+  constraint_builder builder;
+  return builder.constraint(std::move(name));
+}
+
+table_builder table( std::string name ) {
+return table_builder(std::move(name));
+}
+
+column_builder column( std::string name ) {
+  return column_builder(std::move(name));
+}
+
+}

source/orm/query/column.cpp

@@ -1,12 +1,11 @@
-#include "matador/sql/column.hpp"
+#include "matador/query/column.hpp"
 
-#include "matador/sql/table.hpp"
+#include "matador/query/table.hpp"
 
 #include <stdexcept>
 #include <utility>
 
-
-namespace matador::sql {
+namespace matador::query {
 
 column operator ""_col(const char *name, size_t len) {
   const std::string str(name, len);
@@ -27,23 +26,23 @@ column::column(const char *name, const std::string& as)
 {}
 
 column::column(std::string name, std::string as)
-: table_(std::make_shared<sql::table>())
+: table_(std::make_shared<query::table>())
 , name(std::move(name))
 , alias_(std::move(as)) {}
 
-column::column(const sql_function_t func, std::string name)
-: table_(std::make_shared<sql::table>())
+column::column(const sql::sql_function_t func, std::string name)
+: table_(std::make_shared<query::table>())
 , name(std::move(name))
 , function_(func) {}
 
-column::column(const sql::table& tab, std::string name, std::string as)
-: table_(std::make_shared<sql::table>(tab))
+column::column(const query::table& tab, std::string name, std::string as)
+: table_(std::make_shared<query::table>(tab))
 , name(std::move(name))
 , alias_(std::move(as)) {
     table_->columns_.push_back(*this);
 }
 
-column::column(const std::shared_ptr<sql::table>& t, std::string name, std::string as)
+column::column(const std::shared_ptr<query::table>& t, std::string name, std::string as)
 : table_(t)
 , name(std::move(name))
 , alias_(std::move(as)) {
@@ -77,10 +76,10 @@ const std::string& column::alias_name() const {
 }
 
 bool column::is_function() const {
-  return function_ != sql_function_t::None;
+  return function_ != sql::sql_function_t::None;
 }
 
-sql_function_t column::function() const {
+sql::sql_function_t column::function() const {
   return function_;
 }
 
@@ -96,7 +95,7 @@ std::shared_ptr<table> column::table() const {
   return table_;
 }
 
-void column::table( const std::shared_ptr<sql::table>& t ) {
+void column::table( const std::shared_ptr<query::table>& t ) {
   table_ = t;
 }
 }

source/orm/query/criteria/abstract_column_criteria.cpp

@@ -1,10 +1,10 @@
 #include "matador/query/criteria/abstract_column_criteria.hpp"
 
 namespace matador::query {
-abstract_column_criteria::abstract_column_criteria(sql::column column)
-: column_(std::move(column)) {}
+abstract_column_criteria::abstract_column_criteria(column col)
+: column_(std::move(col)) {}
 
-const sql::column& abstract_column_criteria::column() const {
+const column& abstract_column_criteria::col() const {
   return column_;
 }
 }

source/orm/query/criteria/between_criteria.cpp

@@ -3,14 +3,14 @@
 #include "matador/query/criteria/criteria_visitor.hpp"
 
 namespace matador::query{
-between_criteria::between_criteria(sql::column column, const int64_t min, const int64_t max)
-: abstract_column_criteria(std::move(column))
+between_criteria::between_criteria(column col, const int64_t min, const int64_t max)
+: abstract_column_criteria(std::move(col))
 , min_(utils::value{min})
 , max_(utils::value{max})
 {}
 
-between_criteria::between_criteria(sql::column column, utils::placeholder min, utils::placeholder max)
-: abstract_column_criteria(std::move(column))
+between_criteria::between_criteria(column col, utils::placeholder min, utils::placeholder max)
+: abstract_column_criteria(std::move(col))
 , min_(min)
 , max_(max)
 {}

source/orm/query/criteria/binary_criteria.cpp

@@ -3,8 +3,8 @@
 #include "matador/query/criteria/criteria_visitor.hpp"
 
 namespace matador::query {
-binary_criteria::binary_criteria(sql::column column, const binary_operator operand, criteria_value value)
-: abstract_column_criteria(std::move(column))
+binary_criteria::binary_criteria(column col, const binary_operator operand, criteria_value value)
+: abstract_column_criteria(std::move(col))
 , operator_(operand)
 , value_(std::move(value))
 {}
@@ -21,7 +21,7 @@ const criteria_value& binary_criteria::value() const {
   return value_;
 }
 
-binary_column_criteria::binary_column_criteria( sql::column left_column, binary_operator operand, sql::column right_column )
+binary_column_criteria::binary_column_criteria(column left_column, binary_operator operand, column right_column)
 : left_column_(std::move(left_column))
 , operator_(operand)
 , right_column_(std::move(right_column)){}
@@ -30,7 +30,7 @@ void binary_column_criteria::accept(criteria_visitor& visitor) const {
   visitor.visit(*this);
 }
 
-const sql::column& binary_column_criteria::left_column() const {
+const column& binary_column_criteria::left_column() const {
   return left_column_;
 }
 
@@ -38,7 +38,7 @@ binary_operator binary_column_criteria::operand() const {
   return operator_;
 }
 
-const sql::column& binary_column_criteria::right_column() const {
+const column& binary_column_criteria::right_column() const {
   return right_column_;
 }
 }

source/orm/query/criteria/collection_criteria.cpp

@@ -3,13 +3,13 @@
 #include "matador/query/criteria/criteria_visitor.hpp"
 
 namespace matador::query {
-collection_criteria::collection_criteria(sql::column col, const collection_operator operand_, std::vector<criteria_value> values )
+collection_criteria::collection_criteria(column col, const collection_operator operand_, std::vector<criteria_value> values )
 : abstract_column_criteria(std::move(col))
 , operand_(operand_)
 , values_(std::move(values))
 {}
 
-collection_criteria::collection_criteria(sql::column col, const collection_operator operand_, const std::initializer_list<criteria_value> values )
+collection_criteria::collection_criteria(column col, const collection_operator operand_, const std::initializer_list<criteria_value> values )
 : abstract_column_criteria(std::move(col))
 , operand_(operand_)
 , values_(values)
@@ -27,7 +27,7 @@ const std::vector<criteria_value>& collection_criteria::values() const {
   return values_;
 }
 
-collection_query_criteria::collection_query_criteria(sql::column col, collection_operator operand_, sql::query_context ctx)
+collection_query_criteria::collection_query_criteria(column col, collection_operator operand_, sql::query_context ctx)
 : abstract_column_criteria(std::move(col))
 , operand_(operand_)
 , query_context_(std::move(ctx)){

source/orm/query/criteria/criteria_operators.cpp

@@ -6,51 +6,51 @@
 #include "matador/query/criteria/not_criteria.hpp"
 
 namespace matador::query {
-criteria_ptr operator==(const sql::column &col, utils::placeholder p) {
+criteria_ptr operator==(const column &col, utils::placeholder p) {
   return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, p);
 }
 
-criteria_ptr operator!=(const sql::column &col, utils::placeholder p) {
+criteria_ptr operator!=(const column &col, utils::placeholder p) {
   return std::make_unique<binary_criteria>(col, binary_operator::NOT_EQUALS, p);
 }
 
-criteria_ptr operator>(const sql::column &col, utils::placeholder p) {
+criteria_ptr operator>(const column &col, utils::placeholder p) {
   return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN, p);
 }
 
-criteria_ptr operator>=(const sql::column &col, utils::placeholder p) {
+criteria_ptr operator>=(const column &col, utils::placeholder p) {
   return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN_OR_EQUAL, p);
 }
 
-criteria_ptr operator<(const sql::column &col, utils::placeholder p) {
+criteria_ptr operator<(const column &col, utils::placeholder p) {
   return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN, p);
 }
 
-criteria_ptr operator<=(const sql::column &col, utils::placeholder p) {
+criteria_ptr operator<=(const column &col, utils::placeholder p) {
   return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN_OR_EQUAL, p);
 }
 
-criteria_ptr operator==( const sql::column& col_left, const sql::column& col_right ) {
+criteria_ptr operator==( const column& col_left, const column& col_right ) {
     return std::make_unique<binary_column_criteria>(col_left, binary_operator::EQUALS, col_right);
 }
 
-criteria_ptr operator!=( const sql::column& col_left, const sql::column& col_right ) {
+criteria_ptr operator!=( const column& col_left, const column& col_right ) {
     return std::make_unique<binary_column_criteria>(col_left, binary_operator::NOT_EQUALS, col_right);
 }
 
-criteria_ptr operator>( const sql::column& col_left, const sql::column& col_right ) {
+criteria_ptr operator>( const column& col_left, const column& col_right ) {
     return std::make_unique<binary_column_criteria>(col_left, binary_operator::GREATER_THAN, col_right);
 }
 
-criteria_ptr operator>=( const sql::column& col_left, const sql::column& col_right ) {
+criteria_ptr operator>=( const column& col_left, const column& col_right ) {
     return std::make_unique<binary_column_criteria>(col_left, binary_operator::GREATER_THAN_OR_EQUAL, col_right);
 }
 
-criteria_ptr operator<( const sql::column& col_left, const sql::column& col_right ) {
+criteria_ptr operator<( const column& col_left, const column& col_right ) {
     return std::make_unique<binary_column_criteria>(col_left, binary_operator::LESS_THAN, col_right);
 }
 
-criteria_ptr operator<=( const sql::column& col_left, const sql::column& col_right ) {
+criteria_ptr operator<=( const column& col_left, const column& col_right ) {
     return std::make_unique<binary_column_criteria>(col_left, binary_operator::LESS_THAN_OR_EQUAL, col_right);
 }
 
@@ -67,7 +67,7 @@ criteria_ptr operator!(criteria_ptr clause) {
 }
 
 template <>
-criteria_ptr in(const sql::column &col, const std::initializer_list<utils::placeholder> args) {
+criteria_ptr in(const column &col, const std::initializer_list<utils::placeholder> args) {
   std::vector<criteria_value> values;
   for ( auto &&arg : args ) {
     values.emplace_back(arg);
@@ -75,12 +75,12 @@ criteria_ptr in(const sql::column &col, const std::initializer_list<utils::place
   return std::make_unique<collection_criteria>(col, collection_operator::In, std::move(values));
 }
 
-criteria_ptr in(const sql::column &col, sql::query_context &&ctx) {
+criteria_ptr in(const column &col, sql::query_context &&ctx) {
   return std::make_unique<collection_query_criteria>(col, collection_operator::In, std::move(ctx));
 }
 
 template <>
-criteria_ptr out(const sql::column &col, const std::initializer_list<utils::placeholder> args) {
+criteria_ptr out(const column &col, const std::initializer_list<utils::placeholder> args) {
   std::vector<criteria_value> values;
   for ( auto &&arg : args ) {
     values.emplace_back(arg);
@@ -88,19 +88,19 @@ criteria_ptr out(const sql::column &col, const std::initializer_list<utils::plac
   return std::make_unique<collection_criteria>(col, collection_operator::Out, values);
 }
 
-criteria_ptr out(const sql::column &col, sql::query_context &&ctx) {
+criteria_ptr out(const column &col, sql::query_context &&ctx) {
   return std::make_unique<collection_query_criteria>(col, collection_operator::In, std::move(ctx));
 }
 
-criteria_ptr between(const sql::column &col, const int64_t min, const int64_t max) {
+criteria_ptr between(const column &col, const int64_t min, const int64_t max) {
   return std::make_unique<between_criteria>(col, min, max);
 }
 
-criteria_ptr between(const sql::column &col, utils::placeholder min, utils::placeholder max) {
+criteria_ptr between(const column &col, utils::placeholder min, utils::placeholder max) {
   return std::make_unique<between_criteria>(col, min, max);
 }
 
-criteria_ptr like(const sql::column &col, const std::string &pattern) {
+criteria_ptr like(const column &col, const std::string &pattern) {
   return std::make_unique<like_criteria>(col, pattern);
 }
 }

source/orm/query/criteria/like_criteria.cpp

@@ -3,8 +3,8 @@
 #include "matador/query/criteria/criteria_visitor.hpp"
 
 namespace matador::query {
-like_criteria::like_criteria(sql::column column, std::string pattern)
-: abstract_column_criteria(std::move(column))
+like_criteria::like_criteria(column col, std::string pattern)
+: abstract_column_criteria(std::move(col))
 , pattern_(std::move(pattern)){}
 
 void like_criteria::accept(criteria_visitor &visitor) const {

source/orm/query/criteria_evaluator.cpp

@@ -1,5 +1,6 @@
 #include "matador/query/criteria_evaluator.hpp"
 
+#include "matador/query/query_utils.hpp"
 #include "matador/query/criteria/between_criteria.hpp"
 #include "matador/query/criteria/binary_criteria.hpp"
 #include "matador/query/criteria/collection_criteria.hpp"
@@ -38,9 +39,9 @@ std::string criteria_evaluator::evaluate(const abstract_criteria &node) {
 }
 
 void criteria_evaluator::visit(const between_criteria &node) {
-  query_.bind_vars.emplace_back(node.column().column_name());
-  query_.bind_vars.emplace_back(node.column().column_name());
-  clause_ += dialect_.prepare_identifier(node.column()) + " " + dialect_.token_at(sql::dialect_token::Between) + " ";
+  query_.bind_vars.emplace_back(node.col().column_name());
+  query_.bind_vars.emplace_back(node.col().column_name());
+  clause_ += prepare_identifier(dialect_, node.col()) + " " + dialect_.token_at(sql::dialect_token::Between) + " ";
   evaluate_value(node.minimum());
   clause_ += " " + dialect_.token_at(sql::dialect_token::And) + " ";
   evaluate_value(node.maximum());
@@ -50,23 +51,23 @@ template<class... Ts> struct overload : Ts... { using Ts::operator()...; };
 template<class... Ts> overload(Ts...) -> overload<Ts...>;
 
 void criteria_evaluator::visit(const binary_criteria &node) {
-  query_.bind_vars.emplace_back(node.column().column_name());
-  clause_ += dialect_.prepare_condition(node.column()) + " " + detail::BinaryOperatorEnum.to_string(node.operand()) + " ";
+  query_.bind_vars.emplace_back(node.col().column_name());
+  clause_ += prepare_criteria(dialect_, node.col()) + " " + detail::BinaryOperatorEnum.to_string(node.operand()) + " ";
 
   evaluate_value(node.value());
 }
 
 void criteria_evaluator::visit( const binary_column_criteria& node ) {
-  clause_ += dialect_.prepare_condition(node.left_column()) + " " + detail::BinaryOperatorEnum.to_string(node.operand()) + " " + dialect_.prepare_condition(node.right_column());
+  clause_ += prepare_criteria(dialect_, node.left_column()) + " " + detail::BinaryOperatorEnum.to_string(node.operand()) + " " + prepare_criteria(dialect_, node.right_column());
 }
 
 void criteria_evaluator::visit(const collection_criteria &node) {
   const auto count = node.values().size();
   for (size_t i = 0; i < count; ++i) {
-    query_.bind_vars.emplace_back(node.column().column_name());
+    query_.bind_vars.emplace_back(node.col().column_name());
   }
 
-  clause_ += dialect_.prepare_identifier(node.column()) +
+  clause_ += prepare_identifier(dialect_, node.col()) +
       (node.operand() == collection_operator::Out ? " " + dialect_.token_at(sql::dialect_token::Not) + " " : " ") +
       dialect_.token_at(sql::dialect_token::In) + " (";
   if (node.values().size() < 2) {
@@ -85,13 +86,13 @@ void criteria_evaluator::visit(const collection_criteria &node) {
 }
 
 void criteria_evaluator::visit(const collection_query_criteria &node) {
-  clause_ += dialect_.prepare_identifier(node.column()) +
+  clause_ += prepare_identifier(dialect_, node.col()) +
       (node.operand() == collection_operator::Out ? " " + dialect_.token_at(sql::dialect_token::Not) + " " : " ") +
       dialect_.token_at(sql::dialect_token::In) + " (" +node.context().sql + ")";
 }
 
 void criteria_evaluator::visit(const like_criteria &node) {
-  clause_ += dialect_.prepare_condition(node.column()) + " " + dialect_.token_at(sql::dialect_token::Like) +
+  clause_ += prepare_criteria(dialect_, node.col()) + " " + dialect_.token_at(sql::dialect_token::Like) +
       " " + dialect_.token_at(sql::dialect_token::BeginStringData) + node.pattern() + dialect_.token_at(
         sql::dialect_token::EndStringData);
 }

source/orm/query/generator.cpp

@@ -3,13 +3,13 @@
 namespace matador::query::generator {
 column_generator::column_generator( const std::string& table_name, const column_generator_options options)
 : options_(options) {
-  table_stack_.push(table_name.empty() ? std::make_shared<sql::table>() : std::make_shared<sql::table>(table_name));
+  table_stack_.push(table_name.empty() ? std::make_shared<table>() : std::make_shared<table>(table_name));
 }
 
 column_generator::column_generator(const object::repository& repo, const std::string& table_name, const column_generator_options options)
 : repo_(std::cref(repo))
 , options_(options) {
-  table_stack_.push(table_name.empty() ? std::make_shared<sql::table>() : std::make_shared<sql::table>(table_name));
+  table_stack_.push(table_name.empty() ? std::make_shared<table>() : std::make_shared<table>(table_name));
 }
 
 void column_generator::on_revision( const char* id, uint64_t& ) {

source/orm/query/intermediates/query_alter_intermediate.cpp

@@ -7,8 +7,8 @@ query_alter_intermediate::query_alter_intermediate() {
   context_->parts.push_back(std::make_unique<internal::query_alter_part>());
 }
 
-query_alter_table_intermediate query_alter_intermediate::table( const sql::table& table ) const {
-  context_->parts.push_back(std::make_unique<internal::query_alter_table_part>(table));
+query_alter_table_intermediate query_alter_intermediate::table(const class table& tab) const {
+  context_->parts.push_back(std::make_unique<internal::query_alter_table_part>(tab));
   return {context_};
 }
 }

source/orm/query/intermediates/query_alter_table_intermediate.cpp

@@ -3,27 +3,27 @@
 #include "matador/query/internal/query_parts.hpp"
 
 namespace matador::query {
-executable_query query_add_foreign_key_constraint_intermediate::references( const sql::table& table, const std::vector<sql::column>& columns) {
-  context_->parts.push_back(std::make_unique<internal::query_add_foreign_key_reference_part>(table, columns));
+executable_query query_add_foreign_key_constraint_intermediate::references( const table& tab, const std::vector<column>& columns) {
+  context_->parts.push_back(std::make_unique<internal::query_add_foreign_key_reference_part>(tab, columns));
 
   return {context_};
 }
 
-query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_key(const sql::column& column) const {
-  return primary_keys({column});
+query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_key(const column& col) const {
+  return primary_keys({col});
 }
 
-query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_keys( const std::vector<sql::column>& columns ) const {
+query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_keys( const std::vector<column>& columns) const {
   context_->parts.push_back(std::make_unique<internal::query_add_primary_key_constraint_part>(columns));
 
   return {context_};
 }
 
-query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_key(const sql::column& column) const {
-  return foreign_keys({column});
+query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_key(const column& col) const {
+  return foreign_keys({col});
 }
 
-query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_keys( const std::vector<sql::column>& columns ) const {
+query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_keys(const std::vector<column>& columns) const {
   context_->parts.push_back(std::make_unique<internal::query_add_foreign_key_constraint_part>(columns));
 
   return {context_};

source/orm/query/intermediates/query_create_intermediate.cpp

@@ -8,12 +8,12 @@ query_create_intermediate::query_create_intermediate() {
   context_->parts.push_back(std::make_unique<internal::query_create_part>());
 }
 
-executable_query query_create_intermediate::table(const sql::table &table, const std::initializer_list<object::attribute_definition> columns) {
-  return this->table(table, std::vector<object::attribute_definition>{columns});
+executable_query query_create_intermediate::table(const class table &tab, const std::initializer_list<object::attribute_definition> columns) {
+  return this->table(tab, std::vector<object::attribute_definition>{columns});
 }
 
-executable_query query_create_intermediate::table(const sql::table &table, const std::vector<object::attribute_definition> &columns) {
-  context_->parts.push_back(std::make_unique<internal::query_create_table_part>(table, columns));
+executable_query query_create_intermediate::table(const class table &tab, const std::vector<object::attribute_definition> &columns) {
+  context_->parts.push_back(std::make_unique<internal::query_create_table_part>(tab, columns));
   return {context_};
 }
 

source/orm/query/intermediates/query_delete_intermediate.cpp

@@ -6,14 +6,12 @@
 
 namespace matador::query {
 
-query_delete_intermediate::query_delete_intermediate()
-{
+query_delete_intermediate::query_delete_intermediate() {
   context_->parts.push_back(std::make_unique<internal::query_delete_part>());
 }
 
-query_delete_from_intermediate query_delete_intermediate::from(const sql::table &table)
-{
-  context_->parts.push_back(std::make_unique<internal::query_delete_from_part>(table));
+query_delete_from_intermediate query_delete_intermediate::from(const table &tab) {
+  context_->parts.push_back(std::make_unique<internal::query_delete_from_part>(tab));
   return {context_};
 }
 

source/orm/query/intermediates/query_drop_intermediate.cpp

@@ -8,8 +8,8 @@ query_drop_intermediate::query_drop_intermediate() {
   context_->parts.push_back(std::make_unique<internal::query_drop_part>());
 }
 
-executable_query query_drop_intermediate::table(const sql::table &table) {
-  context_->parts.push_back(std::make_unique<internal::query_drop_table_part>(table));
+executable_query query_drop_intermediate::table(const class table &tab) {
+  context_->parts.push_back(std::make_unique<internal::query_drop_table_part>(tab));
   return {context_};
 }
 

source/orm/query/intermediates/query_execute_where_intermediate.cpp

@@ -7,14 +7,12 @@
 
 namespace matador::query {
 
-query_execute_limit_intermediate query_execute_where_intermediate::limit(size_t limit)
-{
+query_execute_limit_intermediate query_execute_where_intermediate::limit(size_t limit) {
   context_->parts.push_back(std::make_unique<internal::query_limit_part>(limit));
   return {context_};
 }
 
-query_execute_order_by_intermediate query_execute_where_intermediate::order_by(const sql::column &col)
-{
+query_execute_order_by_intermediate query_execute_where_intermediate::order_by(const column &col) {
   context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
   return {context_};
 }

source/orm/query/intermediates/query_from_intermediate.cpp

@@ -8,7 +8,7 @@
 
 namespace matador::query {
 
-query_join_intermediate query_from_intermediate::join_left(const sql::table &t) {
+query_join_intermediate query_from_intermediate::join_left(const table &t) {
   context_->parts.push_back(std::make_unique<internal::query_join_part>(t));
   return {context_};
 }
@@ -38,12 +38,12 @@ query_where_intermediate query_from_intermediate::where_clause(std::unique_ptr<a
   return {context_};
 }
 
-query_group_by_intermediate query_from_intermediate::group_by(const sql::column &col) {
+query_group_by_intermediate query_from_intermediate::group_by(const column &col) {
   context_->parts.push_back(std::make_unique<internal::query_group_by_part>(col));
   return {context_};
 }
 
-query_order_by_intermediate query_from_intermediate::order_by(const sql::column &col) {
+query_order_by_intermediate query_from_intermediate::order_by(const column &col) {
   context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
   return {context_};
 }

source/orm/query/intermediates/query_group_by_intermediate.cpp

@@ -5,8 +5,7 @@
 
 namespace matador::query {
 
-query_order_by_intermediate query_group_by_intermediate::order_by(const sql::column &col)
-{
+query_order_by_intermediate query_group_by_intermediate::order_by(const column &col) {
   context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
   return {context_};
 }

source/orm/query/intermediates/query_insert_intermediate.cpp

@@ -6,33 +6,30 @@
 
 namespace matador::query {
 
-query_insert_intermediate::query_insert_intermediate()
-{
+query_insert_intermediate::query_insert_intermediate() {
   context_->parts.push_back(std::make_unique<internal::query_insert_part>());
 }
 
-query_into_intermediate query_insert_intermediate::into(const sql::table &table, const std::initializer_list<sql::column> columns)
-{
-  return into(table, std::move(std::vector<sql::column>{columns}));
+query_into_intermediate query_insert_intermediate::into(const table &tab, const std::initializer_list<column> columns) {
+  return into(tab, std::move(std::vector<column>{columns}));
 }
 
-query_into_intermediate query_insert_intermediate::into(const sql::table &table, std::vector<sql::column> &&columns)
-{
-  context_->parts.push_back(std::make_unique<internal::query_into_part>(table, columns));
+query_into_intermediate query_insert_intermediate::into(const table &tab, std::vector<column> &&columns) {
+  context_->parts.push_back(std::make_unique<internal::query_into_part>(tab, columns));
   return {context_};
 }
 
-query_into_intermediate query_insert_intermediate::into(const sql::table &table, const std::vector<std::string> &column_names) {
-  std::vector<sql::column> columns;
+query_into_intermediate query_insert_intermediate::into(const table &tab, const std::vector<std::string> &column_names) {
+  std::vector<column> columns;
   columns.reserve(column_names.size());
   for (const auto &col_name : column_names) {
     columns.emplace_back(col_name);
   }
-  return into(table, std::move(columns));
+  return into(tab, std::move(columns));
 }
 
-query_into_intermediate query_insert_intermediate::into(const sql::table &table) {
-  context_->parts.push_back(std::make_unique<internal::query_into_part>(table, table.columns()));
+query_into_intermediate query_insert_intermediate::into(const table &tab) {
+  context_->parts.push_back(std::make_unique<internal::query_into_part>(tab, tab.columns()));
   return {context_};
 }
 

source/orm/query/intermediates/query_select_intermediate.cpp

@@ -6,13 +6,11 @@
 
 namespace matador::query {
 
-query_select_intermediate::query_select_intermediate(const std::vector<sql::column>& columns)
-{
+query_select_intermediate::query_select_intermediate(const std::vector<column>& columns) {
   context_->parts.push_back(std::make_unique<internal::query_select_part>(columns));
 }
 
-query_from_intermediate query_select_intermediate::from(const sql::table& t)
-{
+query_from_intermediate query_select_intermediate::from(const table& t) {
   context_->parts.push_back(std::make_unique<internal::query_from_part>(t));
   context_->tables.insert({t.name(), t});
   return {context_};

source/orm/query/intermediates/query_update_intermediate.cpp

@@ -4,18 +4,15 @@
 
 namespace matador::query {
 
-query_update_intermediate::query_update_intermediate(const sql::table& table)
-{
-  context_->parts.push_back(std::make_unique<internal::query_update_part>(table));
+query_update_intermediate::query_update_intermediate(const table& tab) {
+  context_->parts.push_back(std::make_unique<internal::query_update_part>(tab));
 }
 
-query_set_intermediate query_update_intermediate::set(const std::initializer_list<internal::column_value_pair> columns)
-{
+query_set_intermediate query_update_intermediate::set(const std::initializer_list<internal::column_value_pair> columns) {
   return set(std::vector<internal::column_value_pair>{columns});
 }
 
-query_set_intermediate query_update_intermediate::set(std::vector<internal::column_value_pair> &&columns)
-{
+query_set_intermediate query_update_intermediate::set(std::vector<internal::column_value_pair> &&columns) {
   context_->parts.push_back(std::make_unique<internal::query_set_part>(std::move(columns)));
   return {context_};
 }

source/orm/query/intermediates/query_where_intermediate.cpp

@@ -6,14 +6,12 @@
 
 namespace matador::query {
 
-query_group_by_intermediate query_where_intermediate::group_by(const sql::column &col)
-{
+query_group_by_intermediate query_where_intermediate::group_by(const column &col) {
   context_->parts.push_back(std::make_unique<internal::query_group_by_part>(col));
   return {context_};
 }
 
-query_order_by_intermediate query_where_intermediate::order_by(const sql::column &col)
-{
+query_order_by_intermediate query_where_intermediate::order_by(const column &col) {
   context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
   return {context_};
 }

source/orm/query/internal/column_value_pair.cpp

@@ -9,7 +9,7 @@ column_value_pair::column_value_pair(std::string name, utils::database_type valu
 , value_(std::move(value)) {
 }
 
-column_value_pair::column_value_pair(const sql::column &col, utils::database_type value)
+column_value_pair::column_value_pair(const column &col, utils::database_type value)
 : column_(col)
 , value_(std::move(value)) {
 }
@@ -23,7 +23,7 @@ column_value_pair::column_value_pair( const char* name, utils::placeholder p )
 : column_(name)
 , value_(p) {}
 
-const sql::column &column_value_pair::col() const {
+const column &column_value_pair::col() const {
   return column_;
 }
 

source/orm/query/internal/query_parts.cpp

@@ -10,21 +10,21 @@ void query_alter_part::accept( query_part_visitor& visitor ) {
   visitor.visit(*this);
 }
 
-query_alter_table_part::query_alter_table_part(sql::table table )
+query_alter_table_part::query_alter_table_part(class table tab)
 : query_part(sql::dialect_token::Table)
-, table_(std::move(table)) {}
+, table_(std::move(tab)) {}
 
 void query_alter_table_part::accept(query_part_visitor& visitor) {
   visitor.visit(*this);
 }
 
-const sql::table& query_alter_table_part::table() const {
+const table& query_alter_table_part::table() const {
   return table_;
 }
 
-query_add_key_constraint_part::query_add_key_constraint_part(const std::string& name)
+query_add_key_constraint_part::query_add_key_constraint_part(std::string name)
 : query_part(sql::dialect_token::AddConstraint)
-, name_(name){}
+, name_(std::move(name)){}
 
 void query_add_key_constraint_part::accept( query_part_visitor& visitor ) {
   visitor.visit(*this);
@@ -34,9 +34,9 @@ const std::string& query_add_key_constraint_part::name() const {
    return name_;
 }
 
-query_drop_key_constraint_part::query_drop_key_constraint_part( const std::string& name )
+query_drop_key_constraint_part::query_drop_key_constraint_part(std::string name)
 : query_part( sql::dialect_token::DropConstraint )
-, name_( name ){}
+, name_(std::move( name )){}
 
 void query_drop_key_constraint_part::accept( query_part_visitor& visitor ) {
   visitor.visit(*this);
@@ -53,7 +53,7 @@ void query_drop_foreign_key_constraint_part::accept( query_part_visitor& visitor
     visitor.visit(*this);
 }
 
-query_add_foreign_key_constraint_part::query_add_foreign_key_constraint_part(const std::vector<sql::column>& columns)
+query_add_foreign_key_constraint_part::query_add_foreign_key_constraint_part(const std::vector<column>& columns)
 : query_part(sql::dialect_token::ForeignKey)
 , columns_(columns) {}
 
@@ -61,28 +61,28 @@ void query_add_foreign_key_constraint_part::accept( query_part_visitor& visitor
   visitor.visit(*this);
 }
 
-const std::vector<sql::column>& query_add_foreign_key_constraint_part::columns() const {
+const std::vector<column>& query_add_foreign_key_constraint_part::columns() const {
   return columns_;
 }
 
-query_add_foreign_key_reference_part::query_add_foreign_key_reference_part( sql::table table, const std::vector<sql::column>& columns )
+query_add_foreign_key_reference_part::query_add_foreign_key_reference_part(class table tab, const std::vector<column>& columns)
 : query_part(sql::dialect_token::References)
-, table_(std::move(table))
+, table_(std::move(tab))
 , columns_(columns) {}
 
 void query_add_foreign_key_reference_part::accept( query_part_visitor& visitor ) {
   visitor.visit(*this);
 }
 
-const sql::table& query_add_foreign_key_reference_part::table() const {
+const table& query_add_foreign_key_reference_part::table() const {
   return table_;
 }
 
-const std::vector<sql::column>& query_add_foreign_key_reference_part::columns() const {
+const std::vector<column>& query_add_foreign_key_reference_part::columns() const {
   return columns_;
 }
 
-query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector<sql::column>& columns)
+query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector<column>& columns)
 : query_part(sql::dialect_token::PrimaryKey)
 , columns_(columns) {}
 
@@ -90,11 +90,11 @@ void query_add_primary_key_constraint_part::accept( query_part_visitor& visitor
   visitor.visit(*this);
 }
 
-const std::vector<sql::column>& query_add_primary_key_constraint_part::columns() const {
+const std::vector<column>& query_add_primary_key_constraint_part::columns() const {
   return columns_;
 }
 
-query_select_part::query_select_part(std::vector<sql::column> columns)
+query_select_part::query_select_part(std::vector<column> columns)
   : query_part(sql::dialect_token::Select)
   , columns_(std::move(columns)) {}
 
@@ -103,16 +103,16 @@ void query_select_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
-const std::vector<sql::column>& query_select_part::columns() const
+const std::vector<column>& query_select_part::columns() const
 {
   return columns_;
 }
 
-query_from_part::query_from_part(sql::table t)
+query_from_part::query_from_part(class table t)
   : query_part(sql::dialect_token::From)
   , table_(std::move(t)) {}
 
-const sql::table &query_from_part::table() const
+const table &query_from_part::table() const
 {
   return table_;
 }
@@ -122,11 +122,11 @@ void query_from_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
-query_join_part::query_join_part(sql::table t)
+query_join_part::query_join_part(class table t)
   : query_part(sql::dialect_token::Join)
   , table_(std::move(t)) {}
 
-const sql::table &query_join_part::table() const
+const table &query_join_part::table() const
 {
   return table_;
 }
@@ -168,12 +168,12 @@ query_table_name_part::query_table_name_part(const sql::dialect_token token, std
 : query_part(token)
 , table_name_(std::move(table_name)) {}
 
-query_group_by_part::query_group_by_part(sql::column col)
+query_group_by_part::query_group_by_part(class column col)
 : query_part(sql::dialect_token::GroupBy)
 , column_(std::move(col))
 {}
 
-const sql::column &query_group_by_part::column() const
+const column &query_group_by_part::column() const
 {
   return column_;
 }
@@ -183,12 +183,12 @@ void query_group_by_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
-query_order_by_part::query_order_by_part(sql::column col)
+query_order_by_part::query_order_by_part(class column col)
 : query_part(sql::dialect_token::OrderBy)
 , column_(std::move(col))
 {}
 
-const sql::column &query_order_by_part::column() const
+const column &query_order_by_part::column() const
 {
   return column_;
 }
@@ -252,17 +252,17 @@ void query_insert_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
-query_into_part::query_into_part(sql::table t, std::vector<sql::column> columns)
+query_into_part::query_into_part(class table t, std::vector<column> columns)
 : query_part(sql::dialect_token::Insert)
 , table_(std::move(t))
 , columns_(std::move(columns)) {}
 
-const sql::table &query_into_part::table() const
+const table &query_into_part::table() const
 {
   return table_;
 }
 
-const std::vector<sql::column> &query_into_part::columns() const
+const std::vector<column> &query_into_part::columns() const
 {
   return columns_;
 }
@@ -286,11 +286,11 @@ void query_values_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
-query_update_part::query_update_part(sql::table table)
+query_update_part::query_update_part(class table table)
 : query_part(sql::dialect_token::Update)
 , table_(std::move(table)) {}
 
-const sql::table& query_update_part::table() const
+const table& query_update_part::table() const
 {
   return table_;
 }
@@ -322,11 +322,11 @@ void query_delete_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
-query_delete_from_part::query_delete_from_part(sql::table table)
+query_delete_from_part::query_delete_from_part(class table table)
 : query_part(sql::dialect_token::From)
 , table_(std::move(table)) {}
 
-const sql::table &query_delete_from_part::table() const
+const table &query_delete_from_part::table() const
 {
   return table_;
 }
@@ -344,12 +344,12 @@ void query_create_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
-query_create_table_part::query_create_table_part(sql::table table, std::vector<object::attribute_definition> columns)
+query_create_table_part::query_create_table_part(class table table, std::vector<object::attribute_definition> columns)
 : query_part(sql::dialect_token::Table)
 , table_(std::move(table))
 , columns_(std::move(columns)) {}
 
-const sql::table &query_create_table_part::table() const
+const table &query_create_table_part::table() const
 {
   return table_;
 }
@@ -384,11 +384,11 @@ void query_drop_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
-query_drop_table_part::query_drop_table_part(sql::table table)
+query_drop_table_part::query_drop_table_part(class table table)
 : query_part(sql::dialect_token::Table)
 , table_(std::move(table)) {}
 
-const sql::table &query_drop_table_part::table() const
+const table &query_drop_table_part::table() const
 {
   return table_;
 }

source/orm/query/query.cpp

@@ -2,24 +2,20 @@
 
 namespace matador::query {
 
-sql::column alias(const std::string &column, const std::string &as)
-{
-  return sql::column{column, as};
+column alias(const std::string &column, const std::string &as) {
+  return {column, as};
 }
 
-sql::column alias(sql::column &&col, const std::string &as)
-{
+column alias(column &&col, const std::string &as) {
   col.as(as);
   return std::move(col);
 }
 
-sql::column count(const std::string &column)
-{
+column count(const std::string &column) {
   return {sql::sql_function_t::Count, column};
 }
 
-sql::column count_all()
-{
+column count_all() {
   return count("*");
 }
 
@@ -36,16 +32,16 @@ query_select_intermediate query::select() {
   return query_select_intermediate{{}};
 }
 
-query_select_intermediate query::select( const std::initializer_list<sql::column> columns) {
-  return select(std::vector<sql::column>{columns});
+query_select_intermediate query::select( const std::initializer_list<column> columns) {
+  return select(std::vector<column>{columns});
 }
 
-query_select_intermediate query::select(const std::vector<sql::column>& columns) {
+query_select_intermediate query::select(const std::vector<column>& columns) {
   return query_select_intermediate{columns};
 }
 
 query_select_intermediate query::select(const std::vector<std::string> &column_names) {
-  std::vector<sql::column> columns;
+  std::vector<column> columns;
   columns.reserve(column_names.size());
   for (const auto &col_name : column_names) {
     columns.emplace_back(col_name);
@@ -53,7 +49,7 @@ query_select_intermediate query::select(const std::vector<std::string> &column_n
   return select(columns);
 }
 
-query_select_intermediate query::select(std::vector<sql::column> columns, const std::initializer_list<sql::column> additional_columns) {
+query_select_intermediate query::select(std::vector<column> columns, const std::initializer_list<column> additional_columns) {
   for (const auto &col : additional_columns) {
     columns.push_back(col);
   }
@@ -64,7 +60,7 @@ query_insert_intermediate query::insert() {
   return {};
 }
 
-query_update_intermediate query::update(const sql::table &table) {
+query_update_intermediate query::update(const table &table) {
   return query_update_intermediate{table};
 }
 

source/orm/query/query_compiler.cpp

@@ -1,8 +1,11 @@
 #include "matador/query/query_compiler.hpp"
 
+#include "matador/object/object_definition.hpp"
+
 #include "matador/query/attribute_string_writer.hpp"
 #include "matador/query/query_data.hpp"
 #include "matador/query/criteria_evaluator.hpp"
+#include "matador/query/query_utils.hpp"
 
 #include "matador/query/internal/basic_type_to_string_visitor.hpp"
 #include "matador/query/internal/query_parts.hpp"
@@ -33,7 +36,7 @@ sql::query_context query_compiler::compile(const query_data &data,
   return {query_};
 }
 
-std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const query_data &data, const sql::column &col) {
+std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const query_data &data, const column &col) {
     ctx.result_vars.emplace_back(col.column_name());
     const auto& column_table = col.table().get();
     ctx.column_aliases.insert({column_table->has_alias() ? column_table->alias() : column_table->name() + "." + col.column_name(), col.alias()});
@@ -45,10 +48,10 @@ std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const
     }
 
     if (const auto it = data.tables.find(col.table()->name()); it != data.tables.end()) {
-        return d->prepare_identifier({it->second, col.column_name(), col.alias()});
+        return prepare_identifier(*d, {it->second, col.column_name(), col.alias()});
     }
 
-    return d->prepare_identifier(col);
+    return prepare_identifier(*d, col);
 }
 
 void query_compiler::visit(internal::query_alter_part& part) {
@@ -134,11 +137,10 @@ void query_compiler::visit(internal::query_select_part &part)
   query_.sql += result;
 }
 
-void query_compiler::visit(internal::query_from_part &part)
-{
-  query_.table = part.table();
-  query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table);
-  query_.table_aliases.insert({query_.table.name(), query_.table.alias()});
+void query_compiler::visit(internal::query_from_part &part) {
+  query_.table_name = part.table().alias();
+  query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name);
+  query_.table_aliases.insert({query_.table_name, part.table().alias()});
 }
 
 void query_compiler::visit(internal::query_join_part &part)
@@ -159,13 +161,13 @@ void query_compiler::visit(internal::query_where_part &part) {
 }
 
 void query_compiler::visit(internal::query_group_by_part &part) {
-  query_.sql += " " + dialect_->token_at(sql::dialect_token::GroupBy) + " " + dialect_->prepare_identifier(part.column());
+  query_.sql += " " + dialect_->token_at(sql::dialect_token::GroupBy) + " " + prepare_identifier(*dialect_, part.column());
 }
 
 void query_compiler::visit(internal::query_order_by_part &part)
 {
   query_.sql += " " + dialect_->token_at(sql::dialect_token::OrderBy) +
-                " " + dialect_->prepare_condition(part.column());
+                " " + prepare_criteria(*dialect_, part.column());
 }
 
 void query_compiler::visit(internal::query_order_by_asc_part &/*order_by_asc_part*/)
@@ -196,7 +198,7 @@ void query_compiler::visit(internal::query_insert_part &/*insert_part*/)
 
 void query_compiler::visit(internal::query_into_part &part)
 {
-  query_.table = part.table();
+  query_.table_name = part.table().name();
   query_.sql += " " + dialect_->token_at(sql::dialect_token::Into) +
                 " " + dialect_->prepare_identifier_string(part.table().name());
 
@@ -267,8 +269,8 @@ void query_compiler::visit(internal::query_values_part &part) {
 void query_compiler::visit(internal::query_update_part &part)
 {
   query_.command = sql::sql_command::SQL_UPDATE;
-  query_.table = part.table();
-  query_.sql += query_compiler::build_table_name(part.token(), *dialect_, query_.table);
+  query_.table_name = part.table().name();
+  query_.sql += query_compiler::build_table_name(part.token(), *dialect_, query_.table_name);
 }
 
 void query_compiler::visit(internal::query_delete_part &/*delete_part*/)
@@ -279,8 +281,8 @@ void query_compiler::visit(internal::query_delete_part &/*delete_part*/)
 
 void query_compiler::visit(internal::query_delete_from_part &part)
 {
-  query_.table = part.table();
-  query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table);
+  query_.table_name = part.table().name();
+  query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name);
 }
 
 void query_compiler::visit(internal::query_create_part &/*create_part*/)
@@ -305,7 +307,7 @@ std::string build_create_column(const object::attribute_definition &col, const s
 void query_compiler::visit(internal::query_create_table_part &part)
 {
   query_.sql += " " + dialect_->token_at(sql::dialect_token::Table) + " " + dialect_->prepare_identifier_string(part.table().name()) + " ";
-  query_.table = part.table();
+  query_.table_name = part.table().name();
 
   std::string result = "(";
 
@@ -329,11 +331,11 @@ void query_compiler::visit(internal::query_create_table_part &part)
   }
   for (const auto &[column, reference_column]: context.foreign_contexts) {
     // ALTER TABLE Orders ADD CONSTRAINT FK_PersonOrder FOREIGN KEY (PersonID) REFERENCES Persons(PersonID);
-    std::string fk_cmd = "ALTER TABLE " + dialect_->prepare_identifier_string(query_.table.name()) + " ADD";
-    fk_cmd += " CONSTRAINT FK_" + query_.table.name();
+    std::string fk_cmd = "ALTER TABLE " + dialect_->prepare_identifier_string(query_.table_name) + " ADD";
+    fk_cmd += " CONSTRAINT FK_" + query_.table_name;
     fk_cmd += "_" + column;
     fk_cmd += " FOREIGN KEY (" + dialect_->prepare_identifier_string(column) + ")";
-    fk_cmd += " REFERENCES " + reference_column->table_name() + "(" + reference_column->name() + ")";
+    fk_cmd += " REFERENCES " + reference_column->object()->name() + "(" + reference_column->name() + ")";
     query_.additional_commands.push_back({fk_cmd, sql::sql_command::SQL_ALTER_TABLE});
   }
 
@@ -383,8 +385,8 @@ void query_compiler::visit(internal::query_set_part &part) {
 
 void query_compiler::visit(internal::query_drop_table_part &part)
 {
-  query_.table = part.table();
-  query_.sql += " " + query_compiler::build_table_name(part.token(), *dialect_, query_.table);
+  query_.table_name = part.table().name();
+  query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name);
 }
 
 std::string build_create_column(const object::attribute_definition &col, const sql::dialect &d, column_context &context)
@@ -409,7 +411,7 @@ std::string build_create_column(const object::attribute_definition &col, const s
   return result;
 }
 
-std::string query_compiler::build_table_name(const sql::dialect_token token, const sql::dialect &d, const sql::table& t)
+std::string query_compiler::build_table_name(const sql::dialect_token token, const sql::dialect &d, const table& t)
 {
   return d.token_at(token) + " " +
     (!d.default_schema_name().empty() ? d.prepare_identifier_string(d.default_schema_name()) + "." : "") +

source/orm/query/query_utils.cpp

@@ -0,0 +1,39 @@
+#include "matador/query/query_utils.hpp"
+
+#include "matador/query/table.hpp"
+
+namespace matador::query {
+std::string prepare_identifier( const sql::dialect& d, const column& col ) {
+    std::string result;
+    if (!col.is_function()) {
+        if (!col.table()->name().empty()) {
+            result = d.prepare_identifier_string(col.table()->has_alias() ? col.table()->alias() : col.table()->name()) + ".";
+        }
+        result += d.prepare_identifier_string(col.column_name());
+    } else {
+        result = d.sql_function_at(col.function()) + "(" + col.column_name() + ")";
+    }
+    if (!col.alias().empty()) {
+        result += " AS " + col.alias();
+    }
+    return result;
+}
+
+std::string prepare_criteria(const sql::dialect& d, const column& col) {
+    std::string result;
+    if (!col.is_function()) {
+        // if (!col.alias.empty()) {
+        //     result = col.alias;
+        // } else {
+        if (!col.table()->name().empty()) {
+            result = d.prepare_identifier_string(col.table()->has_alias() ? col.table()->alias() : col.table()->name()) + ".";
+        }
+        result += d.prepare_identifier_string(col.column_name());
+        // }
+    } else {
+        result = d.sql_function_at(col.function()) + "(" + col.column_name() + ")";
+    }
+
+    return result;
+}
+}

source/orm/query/table.cpp

@@ -1,6 +1,6 @@
-#include "matador/sql/table.hpp"
+#include "matador/query/table.hpp"
 
-namespace matador::sql {
+namespace matador::query {
 
 table::table(const char* name)
 : table(std::string(name))

source/orm/sql/connection.cpp

@@ -221,7 +221,7 @@ const class dialect &connection::dialect() const
 
 utils::result<std::unique_ptr<statement_impl>, utils::error> connection::perform_prepare(const query_context& ctx) const {
   if (ctx.command != sql_command::SQL_CREATE_TABLE && (ctx.prototype.empty() || has_unknown_columns(ctx.prototype))) {
-    if (const auto result = describe(ctx.table.name()); result.is_ok()) {
+    if (const auto result = describe(ctx.table_name); result.is_ok()) {
       for (auto &col: ctx.prototype) {
         const auto rit = std::find_if(
           std::begin(*result),

source/orm/sql/dialect.cpp

@@ -6,31 +6,16 @@
 
 namespace matador::sql {
 
-const std::string& dialect::token_at(const dialect_token token) const
-{
+const std::string& dialect::token_at(const dialect_token token) const {
   return tokens_.at(token);
 }
 
-const std::string &dialect::data_type_at(const utils::basic_type type) const
-{
+const std::string &dialect::data_type_at(const utils::basic_type type) const {
   return data_types_.at(type);
 }
 
-std::string dialect::prepare_identifier(const sql::column &col) const
-{
-  std::string result;
-  if (!col.is_function()) {
-    if (!col.table()->name().empty()) {
-      result = prepare_identifier_string(col.table()->has_alias() ? col.table()->alias() : col.table()->name()) + ".";
-    }
-    result += prepare_identifier_string(col.column_name());
-  } else {
-    result = sql_func_map_.at(col.function()) + "(" + col.column_name() + ")";
-  }
-  if (!col.alias().empty()) {
-    result += " AS " + col.alias();
-  }
-  return result;
+const std::string& dialect::sql_function_at(const sql_function_t func) const {
+  return sql_func_map_.at(func);
 }
 
 std::string dialect::table_name( const std::string& table, const std::string& schema_name ) const {
@@ -43,25 +28,6 @@ std::string dialect::table_name( const std::string& table, const std::string& sc
     return prepare_identifier_string( schema_name ) + "." + prepare_identifier_string( table );
 }
 
-std::string dialect::prepare_condition(const sql::column& col) const
-{
-  std::string result;
-  if (!col.is_function()) {
-    // if (!col.alias.empty()) {
-    //     result = col.alias;
-    // } else {
-        if (!col.table()->name().empty()) {
-            result = prepare_identifier_string(col.table()->has_alias() ? col.table()->alias() : col.table()->name()) + ".";
-        }
-        result += prepare_identifier_string(col.column_name());
-    // }
-  } else {
-    result = sql_func_map_.at(col.function()) + "(" + col.column_name() + ")";
-  }
-
-  return result;
-}
-
 const std::string& dialect::to_string(const bool val) const
 {
   return bool_strings_[static_cast<int>(val)];

source/orm/sql/executor.cpp

@@ -1,4 +0,0 @@
-#include "matador/sql/executor.hpp"
-
-namespace matador::sql {
-}

source/orm/sql/record.cpp

@@ -1,5 +1,4 @@
 #include "matador/sql/record.hpp"
-#include "matador/sql/column.hpp"
 
 #include <algorithm>
 #include <stdexcept>
@@ -67,9 +66,8 @@ const std::vector<record::field_ref> &record::columns() const
 //  return columns_[pk_index_];
 //}
 
-const field &record::at(const sql::column &col) const
-{
-  const auto &res = fields_by_name_.at(col.column_name());
+const field &record::at(const std::string &name) const {
+  const auto &res = fields_by_name_.at(name);
   const auto &f = res.first;
   return f;
 }

test/backends/QueryRecordTest.cpp

@@ -1,10 +1,10 @@
 #include <catch2/catch_test_macros.hpp>
 
-#include "matador/sql/column.hpp"
 #include "matador/sql/connection.hpp"
 
 #include "matador/query/criteria.hpp"
 #include "matador/query/query.hpp"
+#include "matador/query/column.hpp"
 
 #include "matador/utils/types.hpp"
 #include "matador/utils/string.hpp"

test/backends/QueryStatementTests.cpp

@@ -1,10 +1,10 @@
 #include <catch2/catch_test_macros.hpp>
 
-#include "matador/sql/column.hpp"
 #include "matador/sql/connection.hpp"
 
 #include "matador/query/criteria.hpp"
 #include "matador/query/query.hpp"
+#include "matador/query/column.hpp"
 
 #include "models/person.hpp"
 

test/orm/orm/SessionQueryBuilderTest.cpp

@@ -3,11 +3,11 @@
 
 #include "matador/sql/backend_provider.hpp"
 #include "matador/sql/connection.hpp"
-#include "matador/sql/column.hpp"
-#include "matador/sql/table.hpp"
 
 #include "matador/query/criteria_evaluator.hpp"
 #include "matador/query/query.hpp"
+#include "matador/query/column.hpp"
+#include "matador/query/table.hpp"
 
 #include "matador/orm/session_query_builder.hpp"
 

test/orm/query/GeneratorTests.cpp

@@ -1,15 +1,13 @@
 #include <catch2/catch_test_macros.hpp>
 
 #include "matador/query/generator.hpp"
-
-#include "matador/sql/column.hpp"
+#include "matador/query/column.hpp"
 
 #include "../../models/airplane.hpp"
 #include "../../models/flight.hpp"
 
 using namespace matador::utils;
 using namespace matador::query;
-using namespace matador::sql;
 using namespace matador::test;
 
 TEST_CASE("Test placeholder generator", "[generator][placeholder]") {

test/orm/query/QueryBuilderTest.cpp

@@ -4,11 +4,11 @@
 
 #include <matador/query/criteria.hpp>
 #include <matador/query/query.hpp>
+#include "matador/query/table.hpp"
 
 #include "matador/object/attribute_definition_generator.hpp"
 
 #include "matador/sql/connection.hpp"
-#include "matador/sql/table.hpp"
 
 #include "matador/utils/placeholder.hpp"
 

test/orm/sql/ColumnGeneratorTest.cpp

@@ -1,6 +1,7 @@
 #include <catch2/catch_test_macros.hpp>
 
 #include "matador/query/generator.hpp"
+#include "matador/query/table.hpp"
 
 #include "matador/object/repository.hpp"
 
@@ -8,9 +9,7 @@
 #include "../test/models/order.hpp"
 #include "../test/models/book.hpp"
 #include "../test/models/author.hpp"
-#include "matador/sql/table.hpp"
 
-using namespace matador::sql;
 using namespace matador::query;
 using namespace matador::object;
 

todo.md

@@ -0,0 +1,89 @@
+# Todo
+
+- replace mk_column with builder style (see `query/builder.hpp`)
+- fix corresponding tests
+- enhance query helper macro to look like the `book` class below
+- add `aliasable_table`(see class below)
+- add `as()` methode to table class
+- move `sql_function_t` to own header in namespace `matador::sql`
+- move `prepare_*` methods from `dialect` to `query_compiler`
+- add `session_insert_builder` and `session_update_builder` (returning multiple statements)
+- finish `attribued_definition` (also in `repository` class -> dependencies)
+- fix compile errors
+- finish fetch eager has-many/belongs-to relations
+- implement lazy loading
+- implement polymorphic class hierarchies
+- finish `schema` and `schema_repository` classes (move add/drop from `session` to `schema`)
+
+## book class
+```cpp
+class book : public matador::sql::aliasable_table<Book> {
+public:
+    using aliasable_table::as;
+
+    Book() : aliasable_table("book", "") {}
+    
+private:
+    friend class aliasable_table;
+
+    explicit Book(std::string alias)
+    : aliasable_table("book", std::move(alias)) {}
+
+public:
+    matador::sql::column id = create_column("id", *this);
+    matador::sql::column title = create_column("title", *this);
+    matador::sql::column year = create_column("year", *this);
+};
+```
+
+## aliasable_table
+```cpp
+class table {
+public:
+    using iterator = std::vector<column>::iterator;
+    using const_iterator = std::vector<column>::const_iterator;
+
+    explicit table(std::string name) : name_(std::move(name)) {}
+    table(std::string name, std::vector<column> columns)
+    : name_(std::move(name)), columns_(std::move(columns)) {}
+
+    void add_column(column column) {
+        column.table_ = shared_from_this();
+        columns_.emplace_back(std::move(column));
+    }
+
+    static const column& create_column(std::string name, table& t) {
+        column c{std::move(name)};
+        c.table_ = &t;
+        t.columns_.emplace_back(std::move(c));
+        return t.columns_.back();
+    }
+    operator const std::vector<column>&() const { return columns_; }
+    table as_table() const { return {name_, columns_}; }
+
+    iterator begin() { return columns_.begin(); }
+    iterator end() { return columns_.end(); }
+
+    [[nodiscard]] bool empty() const { return columns_.empty(); }
+    [[nodiscard]] size_t size() const { return columns_.size(); }
+
+    [[nodiscard]] const std::string& name() const { return name_; }
+    [[nodiscard]] const std::vector<column>& columns() const { return columns_; }
+private:
+    std::string name_;
+    std::vector<column> columns_;
+};
+
+template < typename Type >
+class aliasable_table : public table {
+public:
+    aliasable_table(std::string name, std::string alias)
+    : table(std::move(name))
+    , alias_(std::move(alias)) {}
+
+    Type as(std::string alias) { return Type{std::move(alias)}; }
+
+private:
+    std::string alias_;
+};
+```