query parts progress

src/sql/column_definition.cpp

@@ -1,5 +1,6 @@
 #include "matador/sql/column_definition.hpp"
 
+#include <ostream>
 #include <utility>
 
 namespace matador::sql {
@@ -74,6 +75,12 @@ std::string column_definition::str() const
   return visitor.result;
 }
 
+std::ostream& operator<<(std::ostream &out, const column_definition &col)
+{
+  out << col.str();
+  return out;
+}
+
 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};

src/sql/condition.cpp

@@ -9,7 +9,7 @@ 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);
+  return d.prepare_identifier(field_) + " " + operand + " " + d.next_placeholder(query.bind_vars);
 }
 
 condition<column, query_context>::condition(column col, basic_condition::operand_t op, query_context &q)
@@ -18,7 +18,7 @@ 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_) + " " + operand + " (");
   result += (")");
   return result;
 }

src/sql/connection.cpp

@@ -8,17 +8,16 @@
 
 namespace matador::sql {
 
-connection::connection(connection_info info, const std::shared_ptr<sql::schema> &repo)
+connection::connection(connection_info info)
 : connection_info_(std::move(info))
 , logger_(stdout, "SQL")
 , dialect_(backend_provider::instance().connection_dialect(connection_info_.type))
-, schema_(repo)
 {
   connection_.reset(backend_provider::instance().create_connection(connection_info_.type, connection_info_));
 }
 
-connection::connection(const std::string& dns, const std::shared_ptr<sql::schema> &repo)
-: connection(connection_info::parse(dns), repo)
+connection::connection(const std::string& dns)
+: connection(connection_info::parse(dns))
 {}
 
 connection::connection(const connection &x)
@@ -90,9 +89,9 @@ size_t connection::execute(const std::string &sql) const
   return connection_->execute(sql);
 }
 
-sql::query connection::query() const
+sql::query connection::query(const std::shared_ptr<sql::schema> &schema) const
 {
-  return sql::query(*const_cast<connection*>(this));
+  return sql::query(*const_cast<connection*>(this), schema);
 }
 
 query_result<record> connection::fetch(const query_context &q) const
@@ -135,9 +134,4 @@ const class dialect &connection::dialect() const
   return dialect_;
 }
 
-std::shared_ptr<schema> connection::schema() const
-{
-  return schema_;
-}
-
 }

src/sql/key_value_pair.cpp

@@ -1,8 +1,16 @@
+#include <utility>
+
 #include "matador/sql/key_value_pair.hpp"
 
 namespace matador::sql {
-key_value_pair::key_value_pair(const std::string &name, any_type value)
-: name_(name)
+
+key_value_pair::key_value_pair(std::string name, any_type value)
+: name_(std::move(name))
+, value_(std::move(value)) {
+}
+
+key_value_pair::key_value_pair(const column &col, any_type value)
+: name_(col.name)
 , value_(std::move(value)) {
 }
 

src/sql/query.cpp

@@ -3,43 +3,39 @@
 
 namespace matador::sql {
 
-query::query(connection &c)
-: connection_(c)
+query::query(connection &db, const std::shared_ptr<sql::schema> &schema)
+: connection_(db)
+, schema_(schema)
 {}
 
 query_create_intermediate query::create()
 {
-  return query_create_intermediate(connection_);
+  return query_create_intermediate(connection_, schema_);
 }
 
 query_drop_intermediate query::drop()
 {
-  return query_drop_intermediate{connection_};
+  return query_drop_intermediate{connection_, schema_};
 }
 
 query_select_intermediate query::select(std::initializer_list<column> columns)
 {
-  return {connection_, columns};
+  return {connection_, schema_, columns};
 }
 
 query_insert_intermediate query::insert()
 {
-  return query_insert_intermediate{connection_};
+  return query_insert_intermediate{connection_, schema_};
 }
 
-query_update_intermediate query::update(const std::string &table)
+query_update_intermediate query::update(const sql::table &table)
 {
-  return query_update_intermediate{connection_, table};
+  return query_update_intermediate{connection_, schema_, table};
 }
 
 query_delete_intermediate query::remove()
 {
-  return query_delete_intermediate{connection_};
-}
-
-const sql::schema& query::schema() const
-{
-  return *connection_.schema();
+  return query_delete_intermediate{connection_, schema_};
 }
 
 }

src/sql/query_builder.cpp

@@ -206,7 +206,7 @@ struct column_context
   std::vector<fk_context> foreign_contexts;
 };
 
-std::string build_create_column(const column_definition &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_definition> &columns)
 {
@@ -219,18 +219,18 @@ query_builder &query_builder::table(const std::string &table, const std::vector<
 
   column_context context;
 
-  if (columns.size() < 2) {
-    for (const auto &col: columns) {
-      result.append(build_create_column(col, dialect_, context));
-    }
-  } else {
-    auto it = columns.begin();
-    result.append(build_create_column(*it++, dialect_, context));
-    for (; it != columns.end(); ++it) {
-      result.append(", ");
-      result.append(build_create_column(*it, dialect_, context));
-    }
-  }
+//  if (columns.size() < 2) {
+//    for (const auto &col: columns) {
+//      result.append(build_create_column(col, dialect_, context));
+//    }
+//  } else {
+//    auto it = columns.begin();
+//    result.append(build_create_column(*it++, dialect_, context));
+//    for (; it != columns.end(); ++it) {
+//      result.append(", ");
+//      result.append(build_create_column(*it, dialect_, context));
+//    }
+//  }
 
   if (!context.primary_keys.empty()) {
     result.append(", CONSTRAINT PK_" + table + " PRIMARY KEY (" + utils::join(context.primary_keys, ", ") + ")");
@@ -491,27 +491,27 @@ void query_builder::initialize(query_builder::command_t cmd, query_builder::stat
   query_parts_.clear();
 }
 
-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) {
-    result.append("(" + std::to_string(col.attributes().size()) + ")");
-  }
-  if (!col.is_nullable()) {
-    result.append(" NOT NULL");
-  }
-  if (is_constraint_set(col.attributes().options(), utils::constraints::UNIQUE)) {
-    result.append(" UNIQUE");
-  }
-  if (is_constraint_set(col.attributes().options(), utils::constraints::PRIMARY_KEY)) {
-    context.primary_keys.emplace_back(col.name());
-  }
-  if (is_constraint_set(col.attributes().options(), utils::constraints::FOREIGN_KEY)) {
-    context.foreign_contexts.push_back({col.name(), col.ref_table(), col.ref_column()});
-  }
-
-  return result;
-}
+//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) {
+//    result.append("(" + std::to_string(col.attributes().size()) + ")");
+//  }
+//  if (!col.is_nullable()) {
+//    result.append(" NOT NULL");
+//  }
+//  if (is_constraint_set(col.attributes().options(), utils::constraints::UNIQUE)) {
+//    result.append(" UNIQUE");
+//  }
+//  if (is_constraint_set(col.attributes().options(), utils::constraints::PRIMARY_KEY)) {
+//    context.primary_keys.emplace_back(col.name());
+//  }
+//  if (is_constraint_set(col.attributes().options(), utils::constraints::FOREIGN_KEY)) {
+//    context.foreign_contexts.push_back({col.name(), col.ref_table(), col.ref_column()});
+//  }
+//
+//  return result;
+//}
 
 column alias(const std::string &column, const std::string &as)
 {

src/sql/query_compiler.cpp

@@ -2,11 +2,14 @@
 #include "matador/sql/query_data.hpp"
 #include "matador/sql/column_definition.hpp"
 #include "matador/sql/dialect.hpp"
+#include "matador/sql/query_builder.hpp"
+
+#include "matador/utils/string.hpp"
 
 namespace matador::sql {
 
 query_compiler::query_compiler(const sql::dialect &d)
-  : dialect_(d)
+: dialect_(d)
 {}
 
 query_context query_compiler::compile(const query_data *data)
@@ -50,6 +53,7 @@ void query_compiler::visit(query_select_part &select_part)
 
 void query_compiler::visit(query_from_part &from_part)
 {
+  query_.table_name = from_part.table().name;
   if (dialect_.default_schema_name().empty()) {
     query_.sql += " " + dialect_.token_at(dialect::token_t::FROM) +
                   " " + dialect_.prepare_identifier(from_part.table().name) +
@@ -85,7 +89,7 @@ void query_compiler::visit(query_where_part &where_part)
 
 void query_compiler::visit(query_group_by_part &group_by_part)
 {
-
+  query_.sql += " " + dialect_.token_at(dialect::token_t::GROUP_BY) + " " + dialect_.prepare_identifier(group_by_part.column());
 }
 
 void query_compiler::visit(query_order_by_part &order_by_part)
@@ -96,27 +100,85 @@ void query_compiler::visit(query_order_by_part &order_by_part)
 
 void query_compiler::visit(query_order_by_asc_part &order_by_asc_part)
 {
-
+  query_.sql += " " + dialect_.token_at(dialect::token_t::ASC);
 }
 
 void query_compiler::visit(query_order_by_desc_part &order_by_desc_part)
 {
+  query_.sql += " " + dialect_.token_at(dialect::token_t::DESC);
+}
 
+void query_compiler::visit(query_offset_part &offset_part)
+{
+  query_.sql += " " + dialect_.token_at(dialect::token_t::OFFSET) + " " + std::to_string(offset_part.offset());
+}
+
+void query_compiler::visit(query_limit_part &limit_part)
+{
+  query_.sql += " " + dialect_.token_at(dialect::token_t::LIMIT) + " " + std::to_string(limit_part.limit());
 }
 
 void query_compiler::visit(query_insert_part &insert_part)
 {
+  query_.sql = dialect_.token_at(dialect::token_t::INSERT);
+}
 
+void query_compiler::visit(query_into_part &into_part)
+{
+  query_.table_name = into_part.table().name;
+  query_.sql += " " + dialect_.token_at(dialect::token_t::INTO) +
+                " " + dialect_.prepare_identifier(into_part.table().name);
+
+  std::string result{"("};
+  if (into_part.columns().size() < 2) {
+    for (const auto &col: into_part.columns()) {
+      result.append(dialect_.prepare_identifier(col.name));
+    }
+  } else {
+    auto it = into_part.columns().begin();
+    result.append(dialect_.prepare_identifier((it++)->name));
+    for (; it != into_part.columns().end(); ++it) {
+      result.append(", ");
+      result.append(dialect_.prepare_identifier(it->name));
+    }
+  }
+  result += (")");
+  query_.sql += " " + result;
 }
 
 void query_compiler::visit(query_values_part &values_part)
 {
+  query_.sql += " " + dialect_.token_at(dialect::token_t::VALUES);
 
+  detail::any_type_to_string_visitor value_to_string(dialect_, query_);
+
+  std::string result{"("};
+  if (values_part.values().size() < 2) {
+    for (auto val: values_part.values()) {
+      std::visit(value_to_string, val);
+      result.append(value_to_string.result);
+    }
+  } else {
+    auto it = values_part.values().begin();
+    auto val = *it++;
+    std::visit(value_to_string, val);
+    result.append(value_to_string.result);
+    for (; it != values_part.values().end(); ++it) {
+      result.append(", ");
+      val = *it;
+      std::visit(value_to_string, val);
+      result.append(value_to_string.result);
+    }
+  }
+  result += (")");
+
+  query_.sql += " " + result;
 }
 
 void query_compiler::visit(query_update_part &update_part)
 {
-
+  query_.table_name = update_part.table().name;
+  query_.sql = dialect_.token_at(dialect::token_t::UPDATE) + " " + dialect_.prepare_identifier(update_part.table().name);
 }
 
 void query_compiler::visit(query_delete_part &delete_part)
@@ -126,12 +188,122 @@ void query_compiler::visit(query_delete_part &delete_part)
 
 void query_compiler::visit(query_create_part &create_part)
 {
+  query_.sql = dialect_.token_at(dialect::token_t::CREATE);
+}
 
+struct fk_context
+{
+  std::string column;
+  std::string ref_table;
+  std::string ref_column;
+};
+
+struct column_context
+{
+  std::vector<std::string> primary_keys;
+  std::vector<fk_context> foreign_contexts;
+};
+
+  std::string build_create_column(const column_definition &col, const dialect &d, column_context &context);
+
+void query_compiler::visit(query_create_table_part &create_table_part)
+{
+  query_.sql += " " + dialect_.token_at(dialect::token_t::TABLE) + " " + dialect_.prepare_identifier(create_table_part.table().name) + " ";
+  query_.table_name = create_table_part.table().name;
+
+  std::string result = "(";
+
+  column_context context;
+
+  if (create_table_part.columns().size() < 2) {
+    for (const auto &col: create_table_part.columns()) {
+      result.append(build_create_column(col, dialect_, context));
+    }
+  } else {
+    auto it = create_table_part.columns().begin();
+    result.append(build_create_column(*it++, dialect_, context));
+    for (; it != create_table_part.columns().end(); ++it) {
+      result.append(", ");
+      result.append(build_create_column(*it, dialect_, context));
+    }
+  }
+
+  if (!context.primary_keys.empty()) {
+    result.append(", CONSTRAINT PK_" + create_table_part.table().name + " PRIMARY KEY (" + utils::join(context.primary_keys, ", ") + ")");
+  }
+  for (const auto &fk: context.foreign_contexts) {
+    result += ", CONSTRAINT FK_" + create_table_part.table().name;
+    result += "_" + fk.column;
+    result += " FOREIGN KEY (" + fk.column + ")";
+    result += " REFERENCES " + fk.ref_table + "(" + fk.ref_column + ")";
+  }
+
+  result += ")";
+  query_.sql += result;
 }
 
 void query_compiler::visit(query_drop_part &drop_part)
 {
+  query_.sql = dialect_.token_at(dialect::token_t::DROP);
+}
 
+void query_compiler::visit(query_set_part &set_part)
+{
+  query_.sql += " " + dialect_.token_at(dialect::token_t::SET) + " ";
+
+  detail::any_type_to_string_visitor value_to_string(dialect_, query_);
+  std::string result;
+  if (set_part.key_values().size() < 2) {
+    for (const auto &col: set_part.key_values()) {
+      result.append(dialect_.prepare_identifier(col.name()) + "=");
+      auto var = col.value();
+      std::visit(value_to_string, var);
+      result.append(value_to_string.result);
+    }
+  } else {
+    auto it = set_part.key_values().begin();
+    result.append(dialect_.prepare_identifier(it->name()) + "=");
+    auto var = (it++)->value();
+    std::visit(value_to_string, var);
+    result.append(value_to_string.result);
+    for (; it != set_part.key_values().end(); ++it) {
+      result.append(", ");
+      result.append(dialect_.prepare_identifier((*it).name()) + "=");
+      var = it->value();
+      std::visit(value_to_string, var);
+      result.append(value_to_string.result);
+    }
+  }
+
+  query_.sql += result;
+}
+
+void query_compiler::visit(query_drop_table_part &drop_table_part)
+{
+  query_.sql += " " + dialect_.token_at(dialect::token_t::TABLE) + " " + dialect_.prepare_identifier(drop_table_part.table().name);
+  query_.table_name = drop_table_part.table().name;
+}
+
+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) {
+    result.append("(" + std::to_string(col.attributes().size()) + ")");
+  }
+  if (!col.is_nullable()) {
+    result.append(" NOT NULL");
+  }
+  if (is_constraint_set(col.attributes().options(), utils::constraints::UNIQUE)) {
+    result.append(" UNIQUE");
+  }
+  if (is_constraint_set(col.attributes().options(), utils::constraints::PRIMARY_KEY)) {
+    context.primary_keys.emplace_back(col.name());
+  }
+  if (is_constraint_set(col.attributes().options(), utils::constraints::FOREIGN_KEY)) {
+    context.foreign_contexts.push_back({col.name(), col.ref_table(), col.ref_column()});
+  }
+
+  return result;
 }
 
 }

src/sql/query_intermediates.cpp

@@ -4,13 +4,9 @@
 #include "matador/sql/condition.hpp"
 
 namespace matador::sql {
-basic_query_intermediate::basic_query_intermediate(connection &db)
-: connection_(db) {}
-
-std::shared_ptr<schema> basic_query_intermediate::tables() const
-{
-  return connection_.schema();
-}
+basic_query_intermediate::basic_query_intermediate(connection &db, const std::shared_ptr<sql::schema> & schema)
+: connection_(db)
+, schema_(schema) {}
 
 query_result<record> query_select_finish::fetch_all()
 {
@@ -42,100 +38,95 @@ statement query_select_finish::prepare()
   return connection_.prepare(compiler.compile(&data_));
 }
 
-query_intermediate::query_intermediate(connection &db, query_data &data)
-: basic_query_intermediate(db), data_(data) {}
+query_intermediate::query_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema, query_data &data)
+: basic_query_intermediate(db, schema), data_(data) {}
 
 query_offset_intermediate query_order_direction_intermediate::offset(size_t offset)
 {
-  return {connection_, data_};
+  data_.parts.push_back(std::make_unique<query_offset_part>(offset));
+  return {connection_, schema_, data_};
 }
 
 query_limit_intermediate query_offset_intermediate::limit(size_t limit)
 {
-  return {connection_, data_};
+  data_.parts.push_back(std::make_unique<query_limit_part>(limit));
+  return {connection_, schema_, data_};
 }
 
 query_limit_intermediate query_order_direction_intermediate::limit(size_t limit)
 {
-  return {connection_, data_};
+  data_.parts.push_back(std::make_unique<query_limit_part>(limit));
+  return {connection_, schema_, data_};
 }
 
-query_order_by_intermediate query_group_by_intermediate::order_by(const std::string &name)
+query_order_by_intermediate query_group_by_intermediate::order_by(const column &col)
 {
-  return {connection_, data_};
-//  return {connection_, builder_.order_by(name)};
+  data_.parts.push_back(std::make_unique<query_order_by_part>(col));
+  return {connection_, schema_, data_};
 }
 
 query_order_direction_intermediate query_order_by_intermediate::asc()
 {
-  return {connection_, data_};
-//  return {connection_, builder_.asc()};
+  data_.parts.push_back(std::make_unique<query_order_by_asc_part>());
+  return {connection_, schema_, data_};
 }
 
 query_order_direction_intermediate query_order_by_intermediate::desc()
 {
-  return {connection_, data_};
-//  return {connection_, builder_.desc()};
+  data_.parts.push_back(std::make_unique<query_order_by_asc_part>());
+  return {connection_, schema_, data_};
 }
 
-query_group_by_intermediate query_from_intermediate::group_by(const std::string &name)
+query_group_by_intermediate query_from_intermediate::group_by(const column &col)
 {
-  return {connection_, data_};
-//  return {connection_, builder_.group_by(name)};
+  data_.parts.push_back(std::make_unique<query_group_by_part>(col));
+  return {connection_, schema_, data_};
 }
 
-query_order_by_intermediate query_from_intermediate::order_by(const std::string &name)
+query_order_by_intermediate query_from_intermediate::order_by(const column &col)
 {
-  return {connection_, data_};
-//  return {connection_, builder_.order_by(name)};
+  data_.parts.push_back(std::make_unique<query_order_by_part>(col));
+  return {connection_, schema_, data_};
 }
 
-query_group_by_intermediate query_where_intermediate::group_by(const std::string &name)
+query_group_by_intermediate query_where_intermediate::group_by(const column &col)
 {
-  return {connection_, data_};
-//  return {connection_, builder_.group_by(name)};
+  data_.parts.push_back(std::make_unique<query_group_by_part>(col));
+  return {connection_, schema_, data_};
 }
 
 query_order_by_intermediate query_where_intermediate::order_by(const column &col)
 {
   data_.parts.push_back(std::make_unique<query_order_by_part>(col));
-  return {connection_, data_};
-//  return {connection_, builder_.order_by(name)};
+  return {connection_, schema_, data_};
 }
 
-query_join_intermediate query_on_intermediate::join(const std::string &join_table_name, const std::string &as)
+query_join_intermediate query_on_intermediate::join_left(const table &t)
 {
-  return {connection_, data_};
-//  return {connection_, builder_.join(join_table_name, join_type_t::INNER, as)};
+  data_.parts.push_back(std::make_unique<query_join_part>(t));
+  return {connection_, schema_, data_};
 }
 
-query_group_by_intermediate query_on_intermediate::group_by(const std::string &name)
+query_group_by_intermediate query_on_intermediate::group_by(const column &col)
 {
-  return {connection_, data_};
-//  return {connection_, builder_.group_by(name)};
+  data_.parts.push_back(std::make_unique<query_group_by_part>(col));
+  return {connection_, schema_, data_};
 }
 
 query_order_by_intermediate query_on_intermediate::order_by(const column &col)
 {
   data_.parts.push_back(std::make_unique<query_order_by_part>(col));
-  return {connection_, data_};
-//  return {connection_, builder_.order_by(name)};
+  return {connection_, schema_, data_};
 }
 
 query_join_intermediate query_from_intermediate::join_left(const table &t)
 {
   data_.parts.push_back(std::make_unique<query_join_part>(t));
-  return {connection_, data_};
+  return {connection_, schema_, data_};
 }
 
-query_where_intermediate query_from_intermediate::where(const basic_condition &cond)
-{
-  return query_where_intermediate{connection_, data_};
-//  return query_where_intermediate{connection_, builder_.where(cond)};
-}
-
-query_select_intermediate::query_select_intermediate(connection &db, const std::vector<column>& columns)
-: query_start_intermediate(db)
+query_select_intermediate::query_select_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema, const std::vector<column>& columns)
+: query_start_intermediate(db, schema)
 {
   data_.parts.push_back(std::make_unique<query_select_part>(columns));
 }
@@ -143,20 +134,19 @@ query_select_intermediate::query_select_intermediate(connection &db, const std::
 query_from_intermediate query_select_intermediate::from(const table& t)
 {
   data_.parts.push_back(std::make_unique<query_from_part>(t));
-  return {connection_, data_};
-//  return {connection_, builder_.from(table, as)};
+  return {connection_, schema_, data_};
 }
 
-query_insert_intermediate::query_insert_intermediate(connection &s)
-: query_start_intermediate(s)
+query_insert_intermediate::query_insert_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema)
+: query_start_intermediate(db, schema)
 {
   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> column_names)
+query_into_intermediate query_insert_intermediate::into(const sql::table &table, std::initializer_list<column> column_names)
 {
-  return {connection_, data_};
-//  return {connection_, builder_.into(table, column_names)};
+  data_.parts.push_back(std::make_unique<query_into_part>(table, column_names));
+  return {connection_, schema_, data_};
 }
 
 size_t query_execute_finish::execute()
@@ -171,6 +161,12 @@ statement query_execute_finish::prepare()
   return connection_.prepare(compiler.compile(&data_));
 }
 
+std::string query_execute_finish::str() const
+{
+  query_compiler compiler(connection_.dialect());
+  return compiler.compile(&data_).sql;
+}
+
 query_execute_finish query_into_intermediate::values(std::initializer_list<any_type> values)
 {
   return this->values(std::vector<any_type>(values));
@@ -178,80 +174,68 @@ query_execute_finish query_into_intermediate::values(std::initializer_list<any_t
 
 query_execute_finish query_into_intermediate::values(const std::vector<any_type> &values)
 {
-  return {connection_, data_};
+  data_.parts.push_back(std::make_unique<query_values_part>(values));
+  return {connection_, schema_, data_};
 }
 
-query_create_intermediate::query_create_intermediate(connection &db)
-: query_start_intermediate(db) {
+query_create_intermediate::query_create_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema)
+: query_start_intermediate(db, schema) {
   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_definition> columns)
+query_execute_finish query_create_intermediate::table(const sql::table &table, std::initializer_list<column_definition> columns)
 {
-  return table(table_name, std::vector<column_definition>{columns});
+  return this->table(table, std::vector<column_definition>{columns});
 }
 
-query_execute_finish query_create_intermediate::table(const std::string &table_name, const std::vector<column_definition> &columns)
+query_execute_finish query_create_intermediate::table(const sql::table &table, const std::vector<column_definition> &columns)
 {
-  return {connection_, data_};
-//  return {connection_, builder_.table(table_name, columns)};
+  data_.parts.push_back(std::make_unique<query_create_table_part>(table, columns));
+  return {connection_, schema_, data_};
 }
 
-query_drop_intermediate::query_drop_intermediate(connection &s)
-: query_start_intermediate(s)
+query_drop_intermediate::query_drop_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema)
+: query_start_intermediate(db, schema)
 {
   data_.parts.push_back(std::make_unique<query_drop_part>());
 }
 
-query_execute_finish query_drop_intermediate::table(const std::string &table)
+query_execute_finish query_drop_intermediate::table(const sql::table &table)
 {
-  return {connection_, data_};
-//  return {connection_, builder_.table(table)};
+  data_.parts.push_back(std::make_unique<query_drop_table_part>(table));
+  return {connection_, schema_, data_};
 }
 
 query_execute_finish query_execute_where_intermediate::limit(int limit)
 {
-  return {connection_, data_};
+  return {connection_, schema_, data_};
 //  return {connection_, builder_.limit(limit)};
 }
 
-query_execute_where_intermediate query_set_intermediate::where(const basic_condition &cond)
+query_update_intermediate::query_update_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema, const sql::table& table)
+: query_start_intermediate(db, schema)
 {
-  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)
-{
-  data_.parts.push_back(std::make_unique<query_update_part>(table_name));
+  data_.parts.push_back(std::make_unique<query_update_part>(table));
 }
 
 query_set_intermediate query_update_intermediate::set(std::initializer_list<key_value_pair> columns)
 {
-  return {connection_, data_};
-//  return {connection_, builder_.set(columns)};
+  data_.parts.push_back(std::make_unique<query_set_part>(columns));
+  return {connection_, schema_, data_};
 }
 
-query_execute_where_intermediate query_delete_from_intermediate::where(const basic_condition &cond)
-{
-  return {connection_, data_};
-//  return {connection_, builder_.where(cond)};
-}
-
-query_delete_intermediate::query_delete_intermediate(connection &s)
-: query_start_intermediate(s)
+query_delete_intermediate::query_delete_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema)
+: query_start_intermediate(db, schema)
 {
   data_.parts.push_back(std::make_unique<query_delete_part>());
 }
 
-query_delete_from_intermediate query_delete_intermediate::from(const std::string &table)
+query_delete_from_intermediate query_delete_intermediate::from(const sql::table &table)
 {
-  return {connection_, data_};
-//  return {connection_, builder_.from(table)};
+  return {connection_, schema_, data_};
 }
 
-query_start_intermediate::query_start_intermediate(connection &db)
-: basic_query_intermediate(db)
+query_start_intermediate::query_start_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema)
+: basic_query_intermediate(db, schema)
 {}
 }

src/sql/query_parts.cpp

@@ -74,10 +74,16 @@ query_table_name_part::query_table_name_part(sql::dialect::token_t token, std::s
 : 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)
+query_group_by_part::query_group_by_part(sql::column col)
+: query_part(dialect::token_t::GROUP_BY)
+, column_(std::move(col))
 {}
 
+const sql::column &query_group_by_part::column() const
+{
+  return column_;
+}
+
 void query_group_by_part::accept(query_part_visitor &visitor)
 {
   visitor.visit(*this);
@@ -108,7 +114,7 @@ void query_order_by_asc_part::accept(query_part_visitor &visitor)
 }
 
 query_order_by_desc_part::query_order_by_desc_part()
-  : query_part(dialect::token_t::DESC)
+: query_part(dialect::token_t::DESC)
 {}
 
 void query_order_by_desc_part::accept(query_part_visitor &visitor)
@@ -116,6 +122,34 @@ void query_order_by_desc_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
+query_offset_part::query_offset_part(size_t offset)
+: query_part(dialect::token_t::OFFSET)
+, offset_(offset) {}
+
+size_t query_offset_part::offset() const
+{
+  return offset_;
+}
+
+void query_offset_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+query_limit_part::query_limit_part(size_t limit)
+: query_part(dialect::token_t::LIMIT)
+, limit_(limit) {}
+
+size_t query_limit_part::limit() const
+{
+  return limit_;
+}
+
+void query_limit_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
 query_insert_part::query_insert_part()
 : query_part(dialect::token_t::INSERT) {}
 
@@ -124,23 +158,68 @@ 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_into_part::query_into_part(sql::table t, std::vector<sql::column> columns)
+: query_part(dialect::token_t::INSERT)
+, table_(std::move(t))
+, columns_(std::move(columns)) {}
+
+const sql::table &query_into_part::table() const
+{
+  return table_;
+}
+
+const std::vector<column> &query_into_part::columns() const
+{
+  return columns_;
+}
+
+void query_into_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
+query_values_part::query_values_part(std::vector<any_type> values)
 : query_part(sql::dialect::token_t::VALUES)
-, values_(values) {}
+, values_(std::move(values)) {}
+
+const std::vector<any_type>& query_values_part::values() const
+{
+  return 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) {}
+query_update_part::query_update_part(sql::table table)
+: query_part(dialect::token_t::UPDATE)
+, table_(std::move(table)) {}
+
+const sql::table& query_update_part::table() const
+{
+  return table_;
+}
 
 void query_update_part::accept(query_part_visitor &visitor)
 {
   visitor.visit(*this);
 }
 
+query_set_part::query_set_part(const std::vector<sql::key_value_pair>& key_value_pairs)
+: query_part(sql::dialect::token_t::SET)
+, key_value_pairs_(key_value_pairs) {}
+
+const std::vector<sql::key_value_pair> &query_set_part::key_values() const
+{
+  return key_value_pairs_;
+}
+
+void query_set_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
 query_delete_part::query_delete_part()
 : query_part(sql::dialect::token_t::REMOVE) {}
 
@@ -157,6 +236,26 @@ 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<sql::column_definition> columns)
+: query_part(sql::dialect::token_t::TABLE)
+, table_(std::move(table))
+, columns_(std::move(columns)) {}
+
+const sql::table &query_create_table_part::table() const
+{
+  return table_;
+}
+
+const std::vector<sql::column_definition> &query_create_table_part::columns() const
+{
+  return columns_;
+}
+
+void query_create_table_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
 query_drop_part::query_drop_part()
 : query_part(sql::dialect::token_t::DROP) {}
 
@@ -165,4 +264,18 @@ void query_drop_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
+query_drop_table_part::query_drop_table_part(sql::table table)
+: query_part(sql::dialect::token_t::TABLE)
+, table_(std::move(table)) {}
+
+const sql::table &query_drop_table_part::table() const
+{
+  return table_;
+}
+
+void query_drop_table_part::accept(query_part_visitor &visitor)
+{
+  visitor.visit(*this);
+}
+
 }

src/sql/record.cpp

@@ -1,4 +1,5 @@
 #include "matador/sql/record.hpp"
+#include "matador/sql/column.hpp"
 
 #include <algorithm>
 #include <stdexcept>
@@ -60,12 +61,18 @@ const column_definition &record::primary_key() const
   return columns_[pk_index_];
 }
 
-const column_definition &record::at(const std::string &name) const
+const column_definition &record::at(const column &col) const
 {
-  auto ref = columns_by_name_.at(name).first;
-  return columns_by_name_.at(name).first;
+  auto ref = columns_by_name_.at(col.name).first;
+  return columns_by_name_.at(col.name).first;
 }
 
+//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_definition &record::at(size_t index) const
 {
   return columns_.at(index);

src/sql/schema.cpp

@@ -7,14 +7,17 @@ namespace matador::sql {
 
 void table_info::create(connection &conn) const
 {
-  conn.query().create().table(name, prototype.columns()).execute();
+//  conn.query().create().table(name, prototype.columns()).execute();
 }
 
 void table_info::drop(connection &conn) const
 {
-  conn.query().drop().table(name).execute();
+//  conn.query().drop().table(name).execute();
 }
 
+schema::schema(std::string name)
+: name_(std::move(name)) {}
+
 std::string schema::name() const
 {
   return name_;

src/sql/session.cpp

@@ -8,12 +8,13 @@ namespace matador::sql {
 
 session::session(connection_pool<connection> &pool)
 : pool_(pool)
-, dialect_(backend_provider::instance().connection_dialect(pool_.info().type)) {}
+, dialect_(backend_provider::instance().connection_dialect(pool_.info().type))
+, schema_(std::make_shared<sql::schema>(dialect_.default_schema_name())){}
 
 void session::create_schema()
 {
   auto c = pool_.acquire();
-  for (const auto &t : schema_) {
+  for (const auto &t : *schema_) {
     t.second.create(*c);
   }
 }
@@ -25,7 +26,7 @@ void session::drop_table(const std::string &table_name)
     throw std::logic_error("no database connection available");
   }
 
-  c->query().drop().table(table_name).execute();
+  c->query(schema_).drop().table(table_name).execute();
 }
 
 query_result<record> session::fetch(const query_context &q) const
@@ -90,7 +91,7 @@ bool session::table_exists(const std::string &table_name) const
 
 const schema& session::tables() const
 {
-  return schema_;
+  return *schema_;
 }
 
 const class dialect &session::dialect() const