startet with connection query intermediates

src/sql/condition.cpp

@@ -0,0 +1,26 @@
+#include "matador/sql/condition.hpp"
+
+namespace matador::sql {
+
+condition<column, placeholder, std::enable_if<true>::type>::condition(const column &fld, basic_condition::operand_t op, const placeholder &val)
+: basic_column_condition(fld, op)
+, value(val)
+{ }
+
+std::string condition<column, placeholder, std::enable_if<true>::type>::evaluate(dialect &d) const {
+  d.add_host_var(field_.name());
+  return d.prepare_identifier(field_.name()) + " " + operand + " " + d.next_placeholder();
+}
+
+condition<column, query>::condition(column col, basic_condition::operand_t op, query &q)
+: basic_column_condition(std::move(col), op)
+, query_(q)
+{}
+
+std::string condition<column, query>::evaluate(dialect &d) const {
+  std::string result(d.prepare_identifier(field_.name()) + " " + operand + " (");
+  result += (")");
+  return result;
+}
+
+}

src/sql/connection.cpp

@@ -0,0 +1,13 @@
+#include "matador/sql/connection.hpp"
+
+namespace matador::sql {
+
+
+connection::connection()
+: query_(dialect_) {}
+
+result connection::execute(const std::string &sql) {
+  return {sql};
+}
+
+}

src/sql/connection_intermediates.cpp

@@ -0,0 +1,60 @@
+#include "matador/sql/connection_intermediates.hpp"
+#include "matador/sql/connection.hpp"
+#include "matador/sql/query_builder.hpp"
+
+namespace matador::sql {
+
+result query_finish::fetch_all()
+{
+  return db.execute(query.compile());
+}
+
+result query_finish::fetch_one()
+{
+  return db.execute(query.compile());
+}
+
+result query_finish::fetch_value()
+{
+  return db.execute(query.compile());
+}
+
+query_intermediate::query_intermediate(connection &db, query_builder &query)
+: db(db), query(query) {}
+
+query_order_direction_intermediate query_order_by_intermediate::asc()
+{
+  return {db, query.asc()};
+}
+
+query_order_direction_intermediate query_order_by_intermediate::desc()
+{
+  return {db, query.desc()};
+}
+
+query_group_by_intermediate query_from_intermediate::group_by(const std::string &name)
+{
+  return {db, query.group_by(name)};
+}
+
+query_order_by_intermediate query_from_intermediate::order_by(const std::string &name)
+{
+  return {db, query.order_by(name)};
+}
+
+query_where_intermediate query_from_intermediate::where(const basic_condition &cond)
+{
+  return query_where_intermediate{db, query.where(cond)};
+}
+
+query_from_intermediate query_select_intermediate::from(const std::string &table, const std::string &as)
+{
+  return {db, query.from(table, as)};
+}
+
+query_select_intermediate connection::select(std::initializer_list<std::string> column_names)
+{
+  return query_select_intermediate{*this, query_.select(column_names)};
+}
+
+}

src/sql/dialect.cpp

@@ -62,11 +62,6 @@ std::string dialect::next_placeholder() const
   return "?";
 }
 
-dialect::compile_type_t dialect::compile_type() const
-{
-  return compile_type_;
-}
-
 void dialect::add_host_var(const std::string &host_var)
 {
   host_vars_.emplace_back(host_var);

src/sql/query_builder.cpp

@@ -32,13 +32,14 @@ query_builder::query_state_transition_map query_builder::transitions_{
   {state_t::QUERY_DELETE, {state_t::QUERY_FROM}},
   {state_t::QUERY_TABLE_CREATE, {state_t::QUERY_FINISH}},
   {state_t::QUERY_TABLE_DROP, {state_t::QUERY_FINISH}},
-  {state_t::QUERY_FROM, {state_t::QUERY_WHERE, state_t::QUERY_ORDER_BY, state_t::QUERY_GROUP_BY, state_t::QUERY_FINISH}},
+  {state_t::QUERY_FROM, {state_t::QUERY_OFFSET, state_t::QUERY_LIMIT, state_t::QUERY_WHERE, state_t::QUERY_ORDER_BY, state_t::QUERY_GROUP_BY, state_t::QUERY_FINISH}},
   {state_t::QUERY_SET, {state_t::QUERY_WHERE, state_t::QUERY_FINISH}},
   {state_t::QUERY_INTO, {state_t::QUERY_VALUES}},
-  {state_t::QUERY_WHERE, {state_t::QUERY_ORDER_BY, state_t::QUERY_GROUP_BY, state_t::QUERY_LIMIT, state_t::QUERY_FINISH}},
+  {state_t::QUERY_WHERE, {state_t::QUERY_ORDER_BY, state_t::QUERY_GROUP_BY, state_t::QUERY_OFFSET, state_t::QUERY_LIMIT, state_t::QUERY_FINISH}},
   {state_t::QUERY_ORDER_BY, {state_t::QUERY_ORDER_DIRECTION}},
-  {state_t::QUERY_ORDER_DIRECTION, {state_t::QUERY_LIMIT, state_t::QUERY_FINISH}},
+  {state_t::QUERY_ORDER_DIRECTION, {state_t::QUERY_OFFSET, state_t::QUERY_LIMIT, state_t::QUERY_FINISH}},
   {state_t::QUERY_GROUP_BY, {state_t::QUERY_FINISH}},
+  {state_t::QUERY_OFFSET, {state_t::QUERY_LIMIT}},
   {state_t::QUERY_LIMIT, {state_t::QUERY_FINISH}},
   {state_t::QUERY_VALUES, {state_t::QUERY_FINISH}},
   {state_t::QUERY_FINISH, {}},
@@ -60,6 +61,7 @@ query_builder::query_state_to_string_map query_builder::state_strings_ {
   { state_t::QUERY_WHERE, "where" },
   { state_t::QUERY_ORDER_BY, "order_by" },
   { state_t::QUERY_GROUP_BY, "group_by" },
+  { state_t::QUERY_OFFSET, "offset" },
   { state_t::QUERY_LIMIT, "limit" },
   { state_t::QUERY_FINISH, "finish" },
 };
@@ -78,7 +80,7 @@ query_builder::query_builder(const dialect &d)
 : dialect_(d)
 , value_to_string_(d) {}
 
-query_builder query_builder::create() {
+query_builder& query_builder::create() {
   initialize(command_t::CREATE, state_t::QUERY_CREATE);
 
   query_parts_.emplace_back(dialect_.token_at(dialect::token_t::CREATE));
@@ -86,7 +88,7 @@ query_builder query_builder::create() {
   return *this;
 }
 
-query_builder query_builder::drop() {
+query_builder& query_builder::drop() {
   initialize(command_t::DROP, state_t::QUERY_DROP);
 
   query_parts_.emplace_back(dialect_.token_at(dialect::token_t::DROP));
@@ -94,7 +96,7 @@ query_builder query_builder::drop() {
   return *this;
 }
 
-query_builder query_builder::select(std::initializer_list<std::string> column_names) {
+query_builder& query_builder::select(std::initializer_list<std::string> column_names) {
     initialize(command_t::SELECT, state_t::QUERY_SELECT);
 
     query_parts_.emplace_back(dialect_.token_at(dialect::token_t::SELECT) + " ");
@@ -107,7 +109,7 @@ query_builder query_builder::select(std::initializer_list<std::string> column_na
     } else {
         auto it = column_names.begin();
         result.append(dialect_.prepare_identifier(*it++));
-        for (it; it != column_names.end(); ++it) {
+        for (; it != column_names.end(); ++it) {
             result.append(", ");
             result.append(dialect_.prepare_identifier(*it));
         }
@@ -117,7 +119,7 @@ query_builder query_builder::select(std::initializer_list<std::string> column_na
     return *this;
 }
 
-query_builder query_builder::insert() {
+query_builder& query_builder::insert() {
   initialize(command_t::INSERT, state_t::QUERY_INSERT);
 
   query_parts_.emplace_back(dialect_.token_at(dialect::token_t::INSERT));
@@ -125,7 +127,7 @@ query_builder query_builder::insert() {
   return *this;
 }
 
-query_builder query_builder::update(const std::string &table) {
+query_builder& query_builder::update(const std::string &table) {
   initialize(command_t::UPDATE, state_t::QUERY_UPDATE);
 
   query_parts_.emplace_back(dialect_.token_at(dialect::token_t::UPDATE) + " " + dialect_.prepare_identifier(table));
@@ -133,7 +135,7 @@ query_builder query_builder::update(const std::string &table) {
   return *this;
 }
 
-query_builder query_builder::remove() {
+query_builder& query_builder::remove() {
   initialize(command_t::REMOVE, state_t::QUERY_DELETE);
 
   query_parts_.emplace_back(dialect_.token_at(dialect::token_t::REMOVE));
@@ -141,7 +143,7 @@ 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> columns) {
   transition_to(state_t::QUERY_TABLE_CREATE);
 
   query_parts_.emplace_back(" " + dialect_.token_at(dialect::token_t::TABLE) + " " + dialect_.prepare_identifier(table) + " ");
@@ -155,7 +157,7 @@ query_builder &query_builder::table(const std::string &table, std::initializer_l
   } else {
       auto it = columns.begin();
       result.append(build_create_column(*it++, dialect_));
-      for (it; it != columns.end(); ++it) {
+      for (; it != columns.end(); ++it) {
           result.append(", ");
           result.append(build_create_column(*it, dialect_));
       }
@@ -166,7 +168,7 @@ query_builder &query_builder::table(const std::string &table, std::initializer_l
   return *this;
 }
 
-query_builder &query_builder::table(const std::string &table) {
+query_builder& query_builder::table(const std::string &table) {
   transition_to(state_t::QUERY_TABLE_DROP);
 
   query_parts_.emplace_back(" " + dialect_.token_at(dialect::token_t::TABLE) + " " + dialect_.prepare_identifier(table));
@@ -174,7 +176,7 @@ query_builder &query_builder::table(const std::string &table) {
   return *this;
 }
 
-query_builder &query_builder::into(const std::string &table, std::initializer_list<std::string> column_names) {
+query_builder& query_builder::into(const std::string &table, std::initializer_list<std::string> column_names) {
   transition_to(state_t::QUERY_INTO);
 
   query_parts_.emplace_back(" " + dialect_.token_at(dialect::token_t::INTO) + " " + dialect_.prepare_identifier(table) + " ");
@@ -187,7 +189,7 @@ query_builder &query_builder::into(const std::string &table, std::initializer_li
   } else {
     auto it = column_names.begin();
     result.append(dialect_.prepare_identifier(*it++));
-    for (it; it != column_names.end(); ++it) {
+    for (; it != column_names.end(); ++it) {
       result.append(", ");
       result.append(dialect_.prepare_identifier(*it));
     }
@@ -198,7 +200,7 @@ query_builder &query_builder::into(const std::string &table, std::initializer_li
   return *this;
 }
 
-query_builder &query_builder::values(std::initializer_list<any_type> values) {
+query_builder& query_builder::values(std::initializer_list<any_type> values) {
   transition_to(state_t::QUERY_VALUES);
 
   query_parts_.emplace_back(" " + dialect_.token_at(dialect::token_t::VALUES) + " ");
@@ -227,7 +229,7 @@ query_builder &query_builder::values(std::initializer_list<any_type> values) {
   return *this;
 }
 
-query_builder &query_builder::from(const std::string &table, const std::string &as) {
+query_builder& query_builder::from(const std::string &table, const std::string &as) {
   transition_to(state_t::QUERY_FROM);
 
   query_parts_.emplace_back(" " + dialect_.token_at(dialect::token_t::FROM) + " " + dialect_.prepare_identifier(table) + (as.empty() ? "" : " " + as));
@@ -235,7 +237,17 @@ query_builder &query_builder::from(const std::string &table, const std::string &
   return *this;
 }
 
-query_builder &query_builder::set(std::initializer_list<key_value_pair> key_values) {
+query_builder &query_builder::join(const std::string &table, join_type_t)
+{
+  return *this;
+}
+
+query_builder &query_builder::on(const std::string &column, const std::string &join_column)
+{
+  return *this;
+}
+
+query_builder& query_builder::set(std::initializer_list<key_value_pair> key_values) {
   transition_to(state_t::QUERY_SET);
 
   query_parts_.emplace_back(" " + dialect_.token_at(dialect::token_t::SET) + " ");
@@ -267,7 +279,7 @@ query_builder &query_builder::set(std::initializer_list<key_value_pair> key_valu
   return *this;
 }
 
-query_builder &query_builder::where(const basic_condition &cond) {
+query_builder& query_builder::where(const basic_condition &cond) {
   transition_to(state_t::QUERY_WHERE);
 
   query_parts_.emplace_back(" " + dialect_.token_at(dialect::token_t::WHERE) + " ");
@@ -276,6 +288,53 @@ query_builder &query_builder::where(const basic_condition &cond) {
   return *this;
 }
 
+query_builder& query_builder::order_by(const std::string& column) {
+    transition_to(state_t::QUERY_ORDER_BY);
+
+    query_parts_.emplace_back(" " + dialect_.token_at(dialect::token_t::ORDER_BY) + " " + dialect_.prepare_identifier(column));
+
+    return *this;
+}
+
+query_builder& query_builder::group_by(const std::string& column) {
+    transition_to(state_t::QUERY_GROUP_BY);
+
+    query_parts_.emplace_back(" " + dialect_.token_at(dialect::token_t::GROUP_BY) + " " + dialect_.prepare_identifier(column));
+
+    return *this;
+}
+
+query_builder& query_builder::asc() {
+    transition_to(state_t::QUERY_ORDER_DIRECTION);
+
+    query_parts_.emplace_back(" " + dialect_.token_at(dialect::token_t::ASC));
+
+    return *this;
+}
+
+query_builder& query_builder::desc() {
+    transition_to(state_t::QUERY_ORDER_DIRECTION);
+
+    query_parts_.emplace_back(" " + dialect_.token_at(dialect::token_t::DESC));
+
+    return *this;
+}
+
+query_builder& query_builder::offset( size_t count ) {
+    transition_to(state_t::QUERY_OFFSET);
+
+    query_parts_.emplace_back(" " + dialect_.token_at(dialect::token_t::OFFSET) + " " + std::to_string(count));
+
+    return *this;
+}
+
+query_builder& query_builder::limit( size_t count ) {
+    transition_to(state_t::QUERY_LIMIT);
+
+    query_parts_.emplace_back( " " + dialect_.token_at(dialect::token_t::LIMIT) + " " + std::to_string( count));
+
+    return *this;
+}
 
 std::string query_builder::compile() {
   std::string result;