query parts progress

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)
 {}
 }