query compiler progress

src/sql/column.cpp

@@ -1,129 +1,10 @@
 #include "matador/sql/column.hpp"
 
-#include <utility>
-
 namespace matador::sql {
 
-column::column(sql_function_t func, std::string name)
-  : name_(std::move(name)), type_(data_type_t::type_int), attributes_(utils::null_attributes), function_(func)
-{}
-
-column::column(const char *name, std::string alias)
-  : name_(name), attributes_(utils::null_attributes), alias_(std::move(alias))
-{}
-
-column::column(std::string name, std::string alias)
-  : name_(std::move(name)), attributes_(utils::null_attributes), alias_(std::move(alias))
-{}
-
-column::column(std::string name, data_type_t type, utils::field_attributes attr, null_option null_opt, size_t index)
-  : name_(std::move(name)), index_(index), type_(type), attributes_(attr), null_option_(null_opt)
-{}
-
-column::column(std::string name, data_type_t type, size_t index, std::string ref_table, std::string ref_column,
-               utils::field_attributes attr, null_option null_opt)
-  : name_(std::move(name))
-  , index_(index)
-  , type_(type)
-  , attributes_(attr)
-  , null_option_(null_opt)
-  , ref_table_(std::move(ref_table))
-  , ref_column_(std::move(ref_column))
-{}
-
-const std::string &column::name() const
+column operator ""_col(const char *name, size_t len)
 {
-  return name_;
+  return {{name, len}};
 }
 
-size_t column::index() const
-{
-  return index_;
-}
-
-const utils::field_attributes &column::attributes() const
-{
-  return attributes_;
-}
-
-bool column::is_nullable() const
-{
-  return null_option_ == null_option::NULLABLE;
-}
-
-data_type_t column::type() const
-{
-  return type_;
-}
-
-const std::string &column::alias() const
-{
-  return alias_;
-}
-
-const std::string &column::ref_table() const
-{
-  return ref_table_;
-}
-
-const std::string &column::ref_column() const
-{
-  return ref_column_;
-}
-
-void column::type(data_type_t type)
-{
-  type_ = type;
-}
-
-void column::alias(const std::string &as)
-{
-  alias_ = as;
-}
-
-std::string column::str() const
-{
-  any_type_to_visitor<std::string> visitor;
-  std::visit(visitor, const_cast<any_type &>(value_));
-  return visitor.result;
-}
-
-bool column::is_function() const
-{
-  return function_ != sql_function_t::NONE;
-}
-
-sql_function_t column::function() const
-{
-  return function_;
-}
-
-column operator "" _col(const char *name, size_t len)
-{
-  return {std::string(name, len)};
-}
-
-column make_column(const std::string &name, data_type_t type, utils::field_attributes attr, null_option null_opt)
-{
-  return {name, type, attr, null_opt};
-}
-
-template<>
-column make_column<std::string>(const std::string &name, utils::field_attributes attr, null_option null_opt)
-{
-  return make_column(name, data_type_traits<std::string>::builtin_type(attr.size()), attr, null_opt);
-}
-
-template<>
-column make_pk_column<std::string>(const std::string &name, size_t size)
-{
-  return make_column<std::string>(name, {size, utils::constraints::FOREIGN_KEY});
-}
-
-template<>
-[[maybe_unused]] column make_fk_column<std::string>(const std::string &name, size_t size, const std::string &ref_table,
-                                                    const std::string &ref_column)
-{
-  return {name, data_type_traits<std::string>::builtin_type(size), 0, ref_table, ref_column, {size, utils::constraints::FOREIGN_KEY}, null_option::NOT_NULL};
-}
 }

src/sql/column_definition.cpp

@@ -0,0 +1,100 @@
+#include "matador/sql/column_definition.hpp"
+
+#include <utility>
+
+namespace matador::sql {
+
+column_definition::column_definition(const char *name)
+  : name_(name), attributes_(utils::null_attributes)
+{}
+
+column_definition::column_definition(std::string name)
+  : name_(std::move(name)), attributes_(utils::null_attributes)
+{}
+
+column_definition::column_definition(std::string name, data_type_t type, utils::field_attributes attr, null_option null_opt, size_t index)
+  : name_(std::move(name)), index_(index), type_(type), attributes_(attr), null_option_(null_opt)
+{}
+
+column_definition::column_definition(std::string name, data_type_t type, size_t index, std::string ref_table, std::string ref_column,
+                                     utils::field_attributes attr, null_option null_opt)
+  : name_(std::move(name))
+  , index_(index)
+  , type_(type)
+  , attributes_(attr)
+  , null_option_(null_opt)
+  , ref_table_(std::move(ref_table))
+  , ref_column_(std::move(ref_column))
+{}
+
+const std::string &column_definition::name() const
+{
+  return name_;
+}
+
+size_t column_definition::index() const
+{
+  return index_;
+}
+
+const utils::field_attributes &column_definition::attributes() const
+{
+  return attributes_;
+}
+
+bool column_definition::is_nullable() const
+{
+  return null_option_ == null_option::NULLABLE;
+}
+
+data_type_t column_definition::type() const
+{
+  return type_;
+}
+
+const std::string &column_definition::ref_table() const
+{
+  return ref_table_;
+}
+
+const std::string &column_definition::ref_column() const
+{
+  return ref_column_;
+}
+
+void column_definition::type(data_type_t type)
+{
+  type_ = type;
+}
+
+std::string column_definition::str() const
+{
+  any_type_to_visitor<std::string> visitor;
+  std::visit(visitor, const_cast<any_type &>(value_));
+  return visitor.result;
+}
+
+column_definition make_column(const std::string &name, data_type_t type, utils::field_attributes attr, null_option null_opt)
+{
+  return {name, type, attr, null_opt};
+}
+
+template<>
+column_definition make_column<std::string>(const std::string &name, utils::field_attributes attr, null_option null_opt)
+{
+  return make_column(name, data_type_traits<std::string>::builtin_type(attr.size()), attr, null_opt);
+}
+
+template<>
+column_definition make_pk_column<std::string>(const std::string &name, size_t size)
+{
+  return make_column<std::string>(name, {size, utils::constraints::FOREIGN_KEY});
+}
+
+template<>
+[[maybe_unused]] column_definition make_fk_column<std::string>(const std::string &name, size_t size, const std::string &ref_table,
+                                                               const std::string &ref_column)
+{
+  return {name, data_type_traits<std::string>::builtin_type(size), 0, ref_table, ref_column, {size, utils::constraints::FOREIGN_KEY}, null_option::NOT_NULL};
+}
+}

src/sql/column_generator.cpp

@@ -3,7 +3,7 @@
 
 namespace matador::sql {
 
-column_generator::column_generator(std::vector<column> &columns, const schema &repo)
+column_generator::column_generator(std::vector<column_definition> &columns, const schema &repo)
 : columns_(columns)
 , repo_(repo)
 {}

src/sql/column_name_generator.cpp

@@ -2,7 +2,7 @@
 
 namespace matador::sql {
 
-column_name_generator::column_name_generator(std::vector<column_info> &column_infos,
+column_name_generator::column_name_generator(std::vector<column> &column_infos,
                                              const sql::schema &ts,
                                              const std::string &table_name)
 : column_infos_(column_infos)
@@ -25,7 +25,7 @@ void column_name_generator::push(const std::string &column_name)
 {
   char str[4];
   snprintf(str, 4, "c%02d", ++column_index);
-  column_infos_.emplace_back(column_info{table_name_stack_.top(), column_name, str});
+  column_infos_.emplace_back(table_name_stack_.top(), column_name, str);
 }
 
 }

src/sql/condition.cpp

@@ -8,8 +8,8 @@ condition<column, placeholder, std::enable_if<true>::type>::condition(const colu
 
 std::string condition<column, placeholder, std::enable_if<true>::type>::evaluate(dialect &d, query_context &query) const
 {
-  query.bind_vars.emplace_back(field_.name());
-  return d.prepare_identifier(field_.name()) + " " + operand + " " + d.next_placeholder(query.bind_vars);
+  query.bind_vars.emplace_back(field_.name);
+  return d.prepare_identifier(field_.name) + " " + operand + " " + d.next_placeholder(query.bind_vars);
 }
 
 condition<column, query_context>::condition(column col, basic_condition::operand_t op, query_context &q)
@@ -18,9 +18,13 @@ condition<column, query_context>::condition(column col, basic_condition::operand
 
 std::string condition<column, query_context>::evaluate(dialect &d, query_context &query) const
 {
-  std::string result(d.prepare_identifier(field_.name()) + " " + operand + " (");
+  std::string result(d.prepare_identifier(field_.name) + " " + operand + " (");
   result += (")");
   return result;
 }
 
+condition<column, column> operator==(const column &a, const column &b)
+{
+  return {a, basic_condition::operand_t::EQUAL, b};
+}
 }

src/sql/connection.cpp

@@ -8,7 +8,7 @@
 
 namespace matador::sql {
 
-connection::connection(connection_info info, const std::shared_ptr<schema> &repo)
+connection::connection(connection_info info, const std::shared_ptr<sql::schema> &repo)
 : connection_info_(std::move(info))
 , logger_(stdout, "SQL")
 , dialect_(backend_provider::instance().connection_dialect(connection_info_.type))
@@ -17,7 +17,7 @@ connection::connection(connection_info info, const std::shared_ptr<schema> &repo
   connection_.reset(backend_provider::instance().create_connection(connection_info_.type, connection_info_));
 }
 
-connection::connection(const std::string& dns, const std::shared_ptr<schema> &repo)
+connection::connection(const std::string& dns, const std::shared_ptr<sql::schema> &repo)
 : connection(connection_info::parse(dns), repo)
 {}
 
@@ -69,36 +69,6 @@ const connection_info &connection::info() const
   return connection_info_;
 }
 
-query_create_intermediate connection::create()
-{
-  return query_create_intermediate(*this);
-}
-
-query_drop_intermediate connection::drop()
-{
-  return query_drop_intermediate{*this};
-}
-
-query_select_intermediate connection::select(std::initializer_list<column> columns)
-{
-  return {*this, columns};
-}
-
-query_insert_intermediate connection::insert()
-{
-  return query_insert_intermediate{*this};
-}
-
-query_update_intermediate connection::update(const std::string &table)
-{
-  return query_update_intermediate{*this, table};
-}
-
-query_delete_intermediate connection::remove()
-{
-  return query_delete_intermediate{*this};
-}
-
 record connection::describe(const std::string &table_name) const
 {
   return std::move(connection_->describe(table_name));
@@ -120,15 +90,20 @@ size_t connection::execute(const std::string &sql) const
   return connection_->execute(sql);
 }
 
+sql::query connection::query() const
+{
+  return sql::query(*const_cast<connection*>(this));
+}
+
 query_result<record> connection::fetch(const query_context &q) const
 {
   if (q.prototype.empty() || q.prototype.unknown()) {
     const auto table_prototype = describe(q.table_name);
     for (auto &col : q.prototype) {
       if (const auto rit = table_prototype.find(col.name()); col.type() == data_type_t::type_unknown && rit != table_prototype.end()) {
-        const_cast<column&>(col).type(rit->type());
+        const_cast<column_definition&>(col).type(rit->type());
       }
-    }
+     }
   }
 //  auto it = prototypes_.find(q.table_name);
 //  if (it == prototypes_.end()) {
@@ -160,7 +135,7 @@ const class dialect &connection::dialect() const
   return dialect_;
 }
 
-std::shared_ptr<schema> connection::tables() const
+std::shared_ptr<schema> connection::schema() const
 {
   return schema_;
 }

src/sql/dialect.cpp

@@ -1,5 +1,5 @@
 #include "matador/sql/dialect.hpp"
-#include "matador/sql/column.hpp"
+#include "matador/sql/column_definition.hpp"
 
 #include "matador/utils/string.hpp"
 
@@ -19,12 +19,12 @@ std::string dialect::prepare_identifier(const column &col) const
 {
   std::string result;
   if (!col.is_function()) {
-    result = prepare_identifier_string(col.name());
+    result = prepare_identifier_string(col.name);
   } else {
-    result = sql_func_map_.at(col.function()) + "(" + col.name() + ")";
+    result = sql_func_map_.at(col.function_) + "(" + col.name + ")";
   }
-  if (!col.alias().empty()) {
-    result += " AS " + col.alias();
+  if (!col.alias.empty()) {
+    result += " AS " + col.alias;
   }
   return result;
 }

src/sql/query.cpp

@@ -0,0 +1,45 @@
+#include "matador/sql/query.hpp"
+#include "matador/sql/connection.hpp"
+
+namespace matador::sql {
+
+query::query(connection &c)
+: connection_(c)
+{}
+
+query_create_intermediate query::create()
+{
+  return query_create_intermediate(connection_);
+}
+
+query_drop_intermediate query::drop()
+{
+  return query_drop_intermediate{connection_};
+}
+
+query_select_intermediate query::select(std::initializer_list<column> columns)
+{
+  return {connection_, columns};
+}
+
+query_insert_intermediate query::insert()
+{
+  return query_insert_intermediate{connection_};
+}
+
+query_update_intermediate query::update(const std::string &table)
+{
+  return query_update_intermediate{connection_, table};
+}
+
+query_delete_intermediate query::remove()
+{
+  return query_delete_intermediate{connection_};
+}
+
+const sql::schema& query::schema() const
+{
+  return *connection_.schema();
+}
+
+}

src/sql/query_builder.cpp

@@ -1,5 +1,6 @@
 #include "matador/sql/query_builder.hpp"
 #include "matador/sql/column_name_generator.hpp"
+#include "matador/sql/column.hpp"
 #include "matador/sql/dialect.hpp"
 
 #include "matador/utils/string.hpp"
@@ -139,19 +140,19 @@ query_builder &query_builder::select(const std::vector<column> &columns)
   if (columns.size() < 2) {
     for (const auto &col: columns) {
       result.append(dialect_.prepare_identifier(col));
-      query_.result_vars.emplace_back(col.name());
-      query_.prototype.append(col);
+      query_.result_vars.emplace_back(col.name);
+      query_.prototype.append(column_definition{col.name});
     }
   } else {
     auto it = columns.begin();
     result.append(dialect_.prepare_identifier(*it));
-    query_.result_vars.emplace_back(it->name());
-    query_.prototype.append(column{*it++});
+    query_.result_vars.emplace_back(it->name);
+    query_.prototype.append(column_definition{(*it++).name});
     for (; it != columns.end(); ++it) {
       result.append(", ");
       result.append(dialect_.prepare_identifier(*it));
-      query_.result_vars.emplace_back(it->name());
-      query_.prototype.append(column{*it});
+      query_.result_vars.emplace_back(it->name);
+      query_.prototype.append(column_definition{(*it).name});
     }
   }
 
@@ -187,9 +188,9 @@ query_builder &query_builder::remove()
   return *this;
 }
 
-query_builder &query_builder::table(const std::string &table, std::initializer_list<column> columns)
+query_builder &query_builder::table(const std::string &table, std::initializer_list<column_definition> columns)
 {
-  return this->table(table, std::vector<column>{columns});
+  return this->table(table, std::vector<column_definition>{columns});
 }
 
 struct fk_context
@@ -205,9 +206,9 @@ struct column_context
   std::vector<fk_context> foreign_contexts;
 };
 
-std::string build_create_column(const column &col, const dialect &d, column_context &context);
+std::string build_create_column(const column_definition &col, const dialect &d, column_context &context);
 
-query_builder &query_builder::table(const std::string &table, const std::vector<column> &columns)
+query_builder &query_builder::table(const std::string &table, const std::vector<column_definition> &columns)
 {
   transition_to(state_t::QUERY_TABLE_CREATE);
 
@@ -256,12 +257,12 @@ query_builder &query_builder::table(const std::string &table)
   return *this;
 }
 
-query_builder &query_builder::into(const std::string &table, std::initializer_list<column_info> column_names)
+query_builder &query_builder::into(const std::string &table, std::initializer_list<column> column_names)
 {
-  return into(table, std::vector<column_info>{column_names});
+  return into(table, std::vector<column>{column_names});
 }
 
-query_builder &query_builder::into(const std::string &table, const std::vector<column_info> &column_names)
+query_builder &query_builder::into(const std::string &table, const std::vector<column> &column_names)
 {
   transition_to(state_t::QUERY_INTO);
 
@@ -490,7 +491,7 @@ void query_builder::initialize(query_builder::command_t cmd, query_builder::stat
   query_parts_.clear();
 }
 
-std::string build_create_column(const column &col, const dialect &d, column_context &context)
+std::string build_create_column(const column_definition &col, const dialect &d, column_context &context)
 {
   std::string result = d.prepare_identifier(col.name()) + " " + d.data_type_at(col.type());
   if (col.attributes().size() > 0) {
@@ -514,12 +515,12 @@ std::string build_create_column(const column &col, const dialect &d, column_cont
 
 column alias(const std::string &column, const std::string &as)
 {
-  return {column, as};
+  return {"", column, as};
 }
 
 column alias(column &&col, const std::string &as)
 {
-  col.alias(as);
+  col.as(as);
   return std::move(col);
 }
 

src/sql/query_compiler.cpp

@@ -0,0 +1,105 @@
+#include "matador/sql/query_compiler.hpp"
+#include "matador/sql/query_data.hpp"
+#include "matador/sql/column_definition.hpp"
+#include "matador/sql/dialect.hpp"
+
+namespace matador::sql {
+
+query_compiler::query_compiler(const sql::dialect &d)
+  : dialect_(d)
+{}
+
+query_context query_compiler::compile(const query_data *data)
+{
+  for (const auto &part : data->parts) {
+    part->accept(*this);
+  }
+
+  return query_;
+}
+
+void query_compiler::visit(query_select_part &select_part)
+{
+  std::string result;
+  const auto &columns = select_part.columns();
+  if (columns.size() < 2) {
+    for (const auto &col: columns) {
+      result.append(dialect_.prepare_identifier(col));
+      query_.result_vars.emplace_back(col.name);
+      query_.prototype.append(column_definition{col.name});
+    }
+  } else {
+    auto it = columns.begin();
+    result.append(dialect_.prepare_identifier(*it));
+    query_.result_vars.emplace_back(it->name);
+    query_.prototype.append(column_definition{(*it++).name});
+    for (; it != columns.end(); ++it) {
+      result.append(", ");
+      result.append(dialect_.prepare_identifier(*it));
+      query_.result_vars.emplace_back(it->name);
+      query_.prototype.append(column_definition{(*it).name});
+    }
+  }
+}
+
+void query_compiler::visit(query_from_part &from_part)
+{
+
+}
+
+void query_compiler::visit(query_where_part &where_part)
+{
+
+}
+
+void query_compiler::visit(query_group_by_part &group_by_part)
+{
+
+}
+
+void query_compiler::visit(query_order_by_part &order_by_part)
+{
+
+}
+
+void query_compiler::visit(query_order_by_asc_part &order_by_asc_part)
+{
+
+}
+
+void query_compiler::visit(query_order_by_desc_part &order_by_desc_part)
+{
+
+}
+
+void query_compiler::visit(query_insert_part &insert_part)
+{
+
+}
+
+void query_compiler::visit(query_values_part &values_part)
+{
+
+}
+
+void query_compiler::visit(query_update_part &update_part)
+{
+
+}
+
+void query_compiler::visit(query_delete_part &delete_part)
+{
+
+}
+
+void query_compiler::visit(query_create_part &create_part)
+{
+
+}
+
+void query_compiler::visit(query_drop_part &drop_part)
+{
+
+}
+
+}

src/sql/query_intermediates.cpp

@@ -1,5 +1,6 @@
 #include "matador/sql/query_intermediates.hpp"
 #include "matador/sql/session.hpp"
+#include "matador/sql/query_compiler.hpp"
 
 namespace matador::sql {
 basic_query_intermediate::basic_query_intermediate(connection &db)
@@ -7,219 +8,252 @@ basic_query_intermediate::basic_query_intermediate(connection &db)
 
 std::shared_ptr<schema> basic_query_intermediate::tables() const
 {
-  return connection_.tables();
+  return connection_.schema();
 }
 
 query_result<record> query_select_finish::fetch_all()
 {
-  return connection_.fetch(builder_.compile());
+  query_compiler compiler(connection_.dialect());
+  return connection_.fetch(compiler.compile(&data_));
 }
 
 record query_select_finish::fetch_one()
 {
-  return *connection_.fetch(builder_.compile()).begin().get();
+  query_compiler compiler(connection_.dialect());
+  return *connection_.fetch(compiler.compile(&data_)).begin().get();
 }
 
 std::unique_ptr<query_result_impl> query_select_finish::fetch()
 {
-  return connection_.fetch(builder_.compile().sql);
+  query_compiler compiler(connection_.dialect());
+  return connection_.fetch(compiler.compile(&data_).sql);
 }
 
 statement query_select_finish::prepare()
 {
-  return connection_.prepare(builder_.compile());
+  query_compiler compiler(connection_.dialect());
+  return connection_.prepare(compiler.compile(&data_));
 }
 
-query_intermediate::query_intermediate(connection &db, query_builder &query)
-: basic_query_intermediate(db), builder_(query) {}
+query_intermediate::query_intermediate(connection &db, query_data &data)
+: basic_query_intermediate(db), data_(data) {}
 
 query_offset_intermediate query_order_direction_intermediate::offset(size_t offset)
 {
-  return {connection_, builder_};
+  return {connection_, data_};
 }
 
 query_limit_intermediate query_offset_intermediate::limit(size_t limit)
 {
-  return {connection_, builder_};
+  return {connection_, data_};
 }
 
 query_limit_intermediate query_order_direction_intermediate::limit(size_t limit)
 {
-  return {connection_, builder_};
+  return {connection_, data_};
 }
 
 query_order_by_intermediate query_group_by_intermediate::order_by(const std::string &name)
 {
-  return {connection_, builder_.order_by(name)};
+  return {connection_, data_};
+//  return {connection_, builder_.order_by(name)};
 }
 
 query_order_direction_intermediate query_order_by_intermediate::asc()
 {
-  return {connection_, builder_.asc()};
+  return {connection_, data_};
+//  return {connection_, builder_.asc()};
 }
 
 query_order_direction_intermediate query_order_by_intermediate::desc()
 {
-  return {connection_, builder_.desc()};
+  return {connection_, data_};
+//  return {connection_, builder_.desc()};
 }
 
 query_group_by_intermediate query_from_intermediate::group_by(const std::string &name)
 {
-  return {connection_, builder_.group_by(name)};
+  return {connection_, data_};
+//  return {connection_, builder_.group_by(name)};
 }
 
 query_order_by_intermediate query_from_intermediate::order_by(const std::string &name)
 {
-  return {connection_, builder_.order_by(name)};
+  return {connection_, data_};
+//  return {connection_, builder_.order_by(name)};
 }
 
 query_group_by_intermediate query_where_intermediate::group_by(const std::string &name)
 {
-  return {connection_, builder_.group_by(name)};
+  return {connection_, data_};
+//  return {connection_, builder_.group_by(name)};
 }
 
 query_order_by_intermediate query_where_intermediate::order_by(const std::string &name)
 {
-  return {connection_, builder_.order_by(name)};
+  return {connection_, data_};
+//  return {connection_, builder_.order_by(name)};
 }
 
 query_join_intermediate query_on_intermediate::join(const std::string &join_table_name, const std::string &as)
 {
-  return {connection_, builder_.join(join_table_name, join_type_t::INNER, as)};
+  return {connection_, data_};
+//  return {connection_, builder_.join(join_table_name, join_type_t::INNER, as)};
 }
 
 query_where_intermediate query_on_intermediate::where(const basic_condition &cond)
 {
-  return {connection_, builder_.where(cond)};
+  return {connection_, data_};
+//  return {connection_, builder_.where(cond)};
 }
 
 query_group_by_intermediate query_on_intermediate::group_by(const std::string &name)
 {
-  return {connection_, builder_.group_by(name)};
+  return {connection_, data_};
+//  return {connection_, builder_.group_by(name)};
 }
 
 query_order_by_intermediate query_on_intermediate::order_by(const std::string &name)
 {
-  return {connection_, builder_.order_by(name)};
+  return {connection_, data_};
+//  return {connection_, builder_.order_by(name)};
 }
 
-query_on_intermediate query_join_intermediate::on(const std::string &column, const std::string &join_column)
+query_on_intermediate query_join_intermediate::on(const basic_condition &cond)
 {
-  return {connection_, builder_.on(column, join_column)};
+  return {connection_, data_};
+//  return {connection_, builder_.on(column, join_column)};
 }
 
-query_join_intermediate query_from_intermediate::join(const std::string &join_table_name, const std::string &as)
+query_join_intermediate query_from_intermediate::join_left(const std::string &join_table_name, const std::string &as)
 {
-  return {connection_, builder_.join(join_table_name, join_type_t::INNER, as)};
+  return {connection_, data_};
+//  return {connection_, builder_.join(join_table_name, join_type_t::INNER, as)};
 }
 
 query_where_intermediate query_from_intermediate::where(const basic_condition &cond)
 {
-  return query_where_intermediate{connection_, builder_.where(cond)};
+  return query_where_intermediate{connection_, data_};
+//  return query_where_intermediate{connection_, builder_.where(cond)};
 }
 
-query_select_intermediate::query_select_intermediate(connection &s, const std::vector<column>& columns)
-: query_start_intermediate(s)
+query_select_intermediate::query_select_intermediate(connection &db, const std::vector<column>& columns)
+: query_start_intermediate(db)
 {
-  builder_.select(columns);
+  data_.parts.push_back(std::make_unique<query_select_part>(columns));
 }
 
 query_from_intermediate query_select_intermediate::from(const std::string &table, const std::string &as)
 {
-  return {connection_, builder_.from(table, as)};
+  return {connection_, data_};
+//  return {connection_, builder_.from(table, as)};
 }
 
 query_insert_intermediate::query_insert_intermediate(connection &s)
 : query_start_intermediate(s)
 {
-  builder_.insert();
+  data_.parts.push_back(std::make_unique<query_insert_part>());
 }
 
-query_into_intermediate query_insert_intermediate::into(const std::string &table, std::initializer_list<column_info> column_names)
+query_into_intermediate query_insert_intermediate::into(const std::string &table, std::initializer_list<column> column_names)
 {
-  return {connection_, builder_.into(table, column_names)};
+  return {connection_, data_};
+//  return {connection_, builder_.into(table, column_names)};
 }
 
 size_t query_execute_finish::execute()
 {
-  return connection_.execute(builder_.compile().sql);
+  query_compiler compiler(connection_.dialect());
+  return connection_.execute(compiler.compile(&data_).sql);
 }
 
 statement query_execute_finish::prepare()
 {
-  return connection_.prepare(builder_.compile());
+  query_compiler compiler(connection_.dialect());
+  return connection_.prepare(compiler.compile(&data_));
 }
 
 query_execute_finish query_into_intermediate::values(std::initializer_list<any_type> values)
 {
-  return {connection_, builder_.values(values)};
+  return this->values(std::vector<any_type>(values));
+}
+
+query_execute_finish query_into_intermediate::values(const std::vector<any_type> &values)
+{
+  return {connection_, data_};
 }
 
 query_create_intermediate::query_create_intermediate(connection &db)
 : query_start_intermediate(db) {
-  builder_.create();
+  data_.parts.push_back(std::make_unique<query_create_part>());
 }
 
-query_execute_finish query_create_intermediate::table(const std::string &table_name, std::initializer_list<column> columns)
+query_execute_finish query_create_intermediate::table(const std::string &table_name, std::initializer_list<column_definition> columns)
 {
-  return table(table_name, std::vector<column>{columns});
+  return table(table_name, std::vector<column_definition>{columns});
 }
 
-query_execute_finish query_create_intermediate::table(const std::string &table_name, const std::vector<column> &columns)
+query_execute_finish query_create_intermediate::table(const std::string &table_name, const std::vector<column_definition> &columns)
 {
-  return {connection_, builder_.table(table_name, columns)};
+  return {connection_, data_};
+//  return {connection_, builder_.table(table_name, columns)};
 }
 
 query_drop_intermediate::query_drop_intermediate(connection &s)
 : query_start_intermediate(s)
 {
-  builder_.drop();
+  data_.parts.push_back(std::make_unique<query_drop_part>());
 }
 
 query_execute_finish query_drop_intermediate::table(const std::string &table)
 {
-  return {connection_, builder_.table(table)};
+  return {connection_, data_};
+//  return {connection_, builder_.table(table)};
 }
 
 query_execute_finish query_execute_where_intermediate::limit(int limit)
 {
-  return {connection_, builder_.limit(limit)};
+  return {connection_, data_};
+//  return {connection_, builder_.limit(limit)};
 }
 
 query_execute_where_intermediate query_set_intermediate::where(const basic_condition &cond)
 {
-  return {connection_, builder_.where(cond)};
+  return {connection_, data_};
+//  return {connection_, builder_.where(cond)};
 }
 
 query_update_intermediate::query_update_intermediate(connection &s, const std::string& table_name)
 : query_start_intermediate(s)
 {
-  builder_.update(table_name);
+  data_.parts.push_back(std::make_unique<query_update_part>(table_name));
 }
 
 query_set_intermediate query_update_intermediate::set(std::initializer_list<key_value_pair> columns)
 {
-  return {connection_, builder_.set(columns)};
+  return {connection_, data_};
+//  return {connection_, builder_.set(columns)};
 }
 
 query_execute_where_intermediate query_delete_from_intermediate::where(const basic_condition &cond)
 {
-  return {connection_, builder_.where(cond)};
+  return {connection_, data_};
+//  return {connection_, builder_.where(cond)};
 }
 
 query_delete_intermediate::query_delete_intermediate(connection &s)
 : query_start_intermediate(s)
 {
-  builder_.remove();
+  data_.parts.push_back(std::make_unique<query_delete_part>());
 }
 
 query_delete_from_intermediate query_delete_intermediate::from(const std::string &table)
 {
-  return {connection_, builder_.from(table)};
+  return {connection_, data_};
+//  return {connection_, builder_.from(table)};
 }
 
-query_start_intermediate::query_start_intermediate(connection &s)
-: basic_query_intermediate(s)
-, builder_(s.dialect())
+query_start_intermediate::query_start_intermediate(connection &db)
+: basic_query_intermediate(db)
 {}
 }

src/sql/query_parts.cpp

@@ -0,0 +1,131 @@
+#include "matador/sql/query_parts.hpp"
+#include "matador/sql/basic_condition.hpp"
+
+namespace matador::sql {
+
+query_part::query_part(sql::dialect::token_t token)
+  : token_(token) {}
+
+query_select_part::query_select_part(std::vector<column> columns)
+  : query_part(sql::dialect::token_t::SELECT)
+  , columns_(std::move(columns)) {}
+
+void query_select_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+const std::vector<column>& query_select_part::columns() const
+{
+  return columns_;
+}
+
+query_from_part::query_from_part(std::string table_name)
+  : query_part(sql::dialect::token_t::FROM)
+  , table_(std::move(table_name)) {}
+
+query_from_part::query_from_part(std::string table_name, std::string as)
+  : query_part(sql::dialect::token_t::FROM)
+  , table_(std::move(table_name))
+  , alias_(std::move(as)) {}
+
+void query_from_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+void query_where_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+query_table_name_part::query_table_name_part(sql::dialect::token_t token, std::string table_name)
+: query_part(token)
+, table_name_(std::move(table_name)) {}
+
+query_group_by_part::query_group_by_part(const std::string &table_name)
+: query_table_name_part(dialect::token_t::GROUP_BY, table_name)
+{}
+
+void query_group_by_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+query_order_by_part::query_order_by_part(const std::string &table_name)
+: query_table_name_part(dialect::token_t::ORDER_BY, table_name)
+{}
+
+void query_order_by_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+query_order_by_asc_part::query_order_by_asc_part()
+: query_part(dialect::token_t::ASC)
+{}
+
+void query_order_by_asc_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+query_order_by_desc_part::query_order_by_desc_part()
+  : query_part(dialect::token_t::DESC)
+{}
+
+void query_order_by_desc_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+query_insert_part::query_insert_part()
+: query_part(dialect::token_t::INSERT) {}
+
+void query_insert_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+query_values_part::query_values_part(std::initializer_list<any_type> values)
+: query_part(sql::dialect::token_t::VALUES)
+, values_(values) {}
+
+void query_values_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+query_update_part::query_update_part(const std::string &table_name)
+: query_table_name_part(dialect::token_t::UPDATE, table_name) {}
+
+void query_update_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+query_delete_part::query_delete_part()
+: query_part(sql::dialect::token_t::REMOVE) {}
+
+void query_delete_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+query_create_part::query_create_part()
+: query_part(sql::dialect::token_t::CREATE) {}
+
+void query_create_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+query_drop_part::query_drop_part()
+: query_part(sql::dialect::token_t::DROP) {}
+
+void query_drop_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+}

src/sql/record.cpp

@@ -5,13 +5,13 @@
 
 namespace matador::sql {
 
-record::record(std::initializer_list<column> columns)
+record::record(std::initializer_list<column_definition> columns)
 : columns_(columns)
 {
   init();
 }
 
-record::record(const std::vector<column> &columns)
+record::record(const std::vector<column_definition> &columns)
 : columns_(columns)
 {
   init();
@@ -41,7 +41,7 @@ record &record::operator=(const record &x)
   return *this;
 }
 
-const std::vector<column> &record::columns() const
+const std::vector<column_definition> &record::columns() const
 {
   return columns_;
 }
@@ -51,7 +51,7 @@ bool record::has_primary_key() const
   return pk_index_ > -1;
 }
 
-const column &record::primary_key() const
+const column_definition &record::primary_key() const
 {
   if (!has_primary_key()) {
     throw std::logic_error("record has no primary key");
@@ -60,13 +60,13 @@ const column &record::primary_key() const
   return columns_[pk_index_];
 }
 
-const column &record::at(const std::string &name) const
+const column_definition &record::at(const std::string &name) const
 {
   auto ref = columns_by_name_.at(name).first;
   return columns_by_name_.at(name).first;
 }
 
-const column &record::at(size_t index) const
+const column_definition &record::at(size_t index) const
 {
   return columns_.at(index);
 }
@@ -82,7 +82,7 @@ record::const_iterator record::find(const std::string &column_name) const {
   return it != columns_by_name_.end() ? columns_.begin() + it->second.second : columns_.end();
 }
 
-void record::append(column col)
+void record::append(column_definition col)
 {
   auto &ref = columns_.emplace_back(std::move(col));
   add_to_map(ref, columns_.size()-1);
@@ -149,7 +149,7 @@ void record::init()
   }
 }
 
-void record::add_to_map(column &col, size_t index)
+void record::add_to_map(column_definition &col, size_t index)
 {
   columns_by_name_.emplace(col.name(), column_index_pair {std::ref(col), index});
   if (utils::is_constraint_set(col.attributes().options(), utils::constraints::PRIMARY_KEY)) {

src/sql/schema.cpp

@@ -7,12 +7,17 @@ namespace matador::sql {
 
 void table_info::create(connection &conn) const
 {
-  conn.create().table(name, prototype.columns()).execute();
+  conn.query().create().table(name, prototype.columns()).execute();
 }
 
 void table_info::drop(connection &conn) const
 {
-  conn.drop().table(name).execute();
+  conn.query().drop().table(name).execute();
+}
+
+std::string schema::name() const
+{
+  return name_;
 }
 
 const table_info& schema::attach(const std::type_index ti, const table_info& table)
@@ -71,4 +76,5 @@ bool schema::empty() const
 {
   return repository_.empty();
 }
+
 }

src/sql/session.cpp

@@ -25,7 +25,7 @@ void session::drop_table(const std::string &table_name)
     throw std::logic_error("no database connection available");
   }
 
-  c->drop().table(table_name).execute();
+  c->query().drop().table(table_name).execute();
 }
 
 query_result<record> session::fetch(const query_context &q) const
@@ -41,7 +41,7 @@ query_result<record> session::fetch(const query_context &q) const
   // adjust columns from given query
   for (auto &col : q.prototype) {
     if (const auto rit = it->second.find(col.name()); col.type() == data_type_t::type_unknown && rit != it->second.end()) {
-      const_cast<column&>(col).type(rit->type());
+      const_cast<column_definition&>(col).type(rit->type());
     }
   }
   auto res = c->fetch(q.sql);