add missing sql execute statements in connection

src/sql/connection.cpp

@@ -6,8 +6,43 @@ namespace matador::sql {
 connection::connection()
 : query_(dialect_) {}
 
-result connection::execute(const std::string &sql) {
+query_create_intermediate connection::create()
+{
+  return query_create_intermediate{*this, query_.create()};
+}
+
+query_drop_intermediate connection::drop()
+{
+  return query_drop_intermediate{*this, query_.drop()};
+}
+
+query_select_intermediate connection::select(std::initializer_list<std::string> column_names)
+{
+  return query_select_intermediate{*this, query_.select(column_names)};
+}
+
+query_insert_intermediate connection::insert()
+{
+  return query_insert_intermediate{*this, query_.insert()};
+}
+
+query_update_intermediate connection::update(const std::string &table)
+{
+  return query_update_intermediate{*this, query_.update(table)};
+}
+
+query_delete_intermediate connection::remove()
+{
+  return query_delete_intermediate{*this, query_.remove()};
+}
+
+result connection::fetch(const std::string &sql)
+{
   return {sql};
 }
 
+std::pair<size_t, std::string> connection::execute(const std::string &sql)
+{
+  return {0, sql};
+}
 }

src/sql/connection_intermediates.cpp

@@ -3,58 +3,146 @@
 #include "matador/sql/query_builder.hpp"
 
 namespace matador::sql {
-
-result query_finish::fetch_all()
+connection &query_intermediate::db()
 {
-  return db.execute(query.compile());
+  return db_;
 }
 
-result query_finish::fetch_one()
+query_builder &query_intermediate::query()
 {
-  return db.execute(query.compile());
+  return query_;
 }
 
-result query_finish::fetch_value()
+result query_select_finish::fetch_all()
 {
-  return db.execute(query.compile());
+  return db().fetch(query().compile());
+}
+
+result query_select_finish::fetch_one()
+{
+  return db().fetch(query().compile());
+}
+
+result query_select_finish::fetch_value()
+{
+  return db().fetch(query().compile());
 }
 
 query_intermediate::query_intermediate(connection &db, query_builder &query)
-: db(db), query(query) {}
+: db_(db), query_(query) {}
+
+query_offset_intermediate query_order_direction_intermediate::offset(size_t offset)
+{
+  return {db(), query()};
+}
+
+query_limit_intermediate query_offset_intermediate::limit(size_t limit)
+{
+  return {db(), query()};
+}
+
+query_limit_intermediate query_order_direction_intermediate::limit(size_t limit)
+{
+  return {db(), query()};
+}
+
+query_order_by_intermediate query_group_by_intermediate::order_by(const std::string &name)
+{
+  return {db(), query().order_by(name)};
+}
 
 query_order_direction_intermediate query_order_by_intermediate::asc()
 {
-  return {db, query.asc()};
+  return {db(), query().asc()};
 }
 
 query_order_direction_intermediate query_order_by_intermediate::desc()
 {
-  return {db, query.desc()};
+  return {db(), query().desc()};
 }
 
 query_group_by_intermediate query_from_intermediate::group_by(const std::string &name)
 {
-  return {db, query.group_by(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)};
+  return {db(), query().order_by(name)};
+}
+
+query_group_by_intermediate query_where_intermediate::group_by(const std::string &name)
+{
+  return {db(), query().group_by(name)};
+}
+
+query_order_by_intermediate query_where_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)};
+  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)};
+  return {db(), query().from(table, as)};
 }
 
-query_select_intermediate connection::select(std::initializer_list<std::string> column_names)
+query_into_intermediate query_insert_intermediate::into(const std::string &table, std::initializer_list<std::string> column_names)
 {
-  return query_select_intermediate{*this, query_.select(column_names)};
+  return {db(), query().into(table, column_names)};
 }
 
+std::pair<size_t, std::string> query_execute_finish::execute()
+{
+  return db().execute(query().compile());
+}
+
+query_execute_finish query_into_intermediate::values(std::initializer_list<any_type> values)
+{
+  return {db(), query().values(values)};
+}
+
+void query_create_drop_finish::execute()
+{
+  db().execute(query().compile());
+}
+
+query_create_drop_finish query_create_intermediate::table(const std::string &table, std::initializer_list<column> columns)
+{
+  return {db(), query().table(table, columns)};
+}
+
+query_create_drop_finish query_drop_intermediate::table(const std::string &table)
+{
+  return {db(), query().table(table)};
+}
+
+query_execute_finish query_execute_where_intermediate::limit(int limit)
+{
+  return {db(), query().limit(limit)};
+}
+
+query_execute_where_intermediate query_set_intermediate::where(const basic_condition &cond)
+{
+  return {db(), query().where(cond)};
+}
+
+query_set_intermediate query_update_intermediate::set(std::initializer_list<key_value_pair> columns)
+{
+  return {db(), query().set(columns)};
+}
+
+query_execute_where_intermediate query_delete_from_intermediate::where(const basic_condition &cond)
+{
+  return {db(), query().where(cond)};
+}
+
+query_delete_from_intermediate query_delete_intermediate::from(const std::string &table, const std::string &as)
+{
+  return {db(), query().from(table, as)};
+}
 }

src/sql/query_builder.cpp

@@ -38,7 +38,7 @@ query_builder::query_state_transition_map query_builder::transitions_{
   {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_OFFSET, state_t::QUERY_LIMIT, state_t::QUERY_FINISH}},
-  {state_t::QUERY_GROUP_BY, {state_t::QUERY_FINISH}},
+  {state_t::QUERY_GROUP_BY, {state_t::QUERY_ORDER_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}},