use result in entity_query_builder

src/sql/query_intermediates.cpp

@@ -8,13 +8,13 @@ basic_query_intermediate::basic_query_intermediate(connection &db, const sql::sc
 : connection_(db)
 , schema_(schema) {}
 
-query_result<record> query_select_finish::fetch_all()
+query_result<record> query_select::fetch_all()
 {
   query_compiler compiler(connection_.dialect());
   return connection_.fetch(compiler.compile(data_.get()));
 }
 
-std::optional<record> query_select_finish::fetch_one()
+std::optional<record> query_select::fetch_one()
 {
   query_compiler compiler(connection_.dialect());
   auto result = connection_.fetch(compiler.compile(data_.get()));
@@ -26,19 +26,19 @@ std::optional<record> query_select_finish::fetch_one()
   return *first.get();
 }
 
-query_context query_select_finish::build() const
+query_context query_select::build() const
 {
   query_compiler compiler(connection_.dialect());
   return compiler.compile(data_.get());
 }
 
-std::unique_ptr<query_result_impl> query_select_finish::fetch()
+std::unique_ptr<query_result_impl> query_select::fetch()
 {
   query_compiler compiler(connection_.dialect());
   return connection_.fetch(compiler.compile(data_.get()).sql);
 }
 
-statement query_select_finish::prepare()
+statement query_select::prepare()
 {
   query_compiler compiler(connection_.dialect());
   return connection_.prepare(compiler.compile(data_.get()));
@@ -184,30 +184,30 @@ query_into_intermediate query_insert_intermediate::into(const table &table)
   return {connection_, schema_, data_};
 }
 
-size_t query_execute_finish::execute()
+size_t query_execute::execute()
 {
   query_compiler compiler(connection_.dialect());
   return connection_.execute(compiler.compile(data_.get()).sql);
 }
 
-statement query_execute_finish::prepare()
+statement query_execute::prepare()
 {
   query_compiler compiler(connection_.dialect());
   return connection_.prepare(compiler.compile(data_.get()));
 }
 
-query_context query_execute_finish::build() const
+query_context query_execute::build() const
 {
   query_compiler compiler(connection_.dialect());
   return compiler.compile(data_.get());
 }
 
-query_execute_finish query_into_intermediate::values(std::initializer_list<any_type> values)
+query_execute query_into_intermediate::values(std::initializer_list<any_type> values)
 {
   return this->values(std::vector<any_type>(values));
 }
 
-query_execute_finish query_into_intermediate::values(std::vector<any_type> &&values)
+query_execute query_into_intermediate::values(std::vector<any_type> &&values)
 {
   data_->parts.push_back(std::make_unique<query_values_part>(std::move(values)));
   return {connection_, schema_, data_};
@@ -218,12 +218,12 @@ query_create_intermediate::query_create_intermediate(connection &db, const sql::
   data_->parts.push_back(std::make_unique<query_create_part>());
 }
 
-query_execute_finish query_create_intermediate::table(const sql::table &table, std::initializer_list<column_definition> columns)
+query_execute query_create_intermediate::table(const sql::table &table, std::initializer_list<column_definition> columns)
 {
   return this->table(table, std::vector<column_definition>{columns});
 }
 
-query_execute_finish query_create_intermediate::table(const sql::table &table, const std::vector<column_definition> &columns)
+query_execute query_create_intermediate::table(const sql::table &table, const std::vector<column_definition> &columns)
 {
   data_->parts.push_back(std::make_unique<query_create_table_part>(table, columns));
   return {connection_, schema_, data_};
@@ -235,7 +235,7 @@ query_drop_intermediate::query_drop_intermediate(connection &db, const sql::sche
   data_->parts.push_back(std::make_unique<query_drop_part>());
 }
 
-query_execute_finish query_drop_intermediate::table(const sql::table &table)
+query_execute query_drop_intermediate::table(const sql::table &table)
 {
   data_->parts.push_back(std::make_unique<query_drop_table_part>(table));
   return {connection_, schema_, data_};

src/sql/session.cpp

@@ -103,4 +103,26 @@ std::unique_ptr<query_result_impl> session::fetch(const std::string &sql) const
   return c->fetch(sql);
 }
 
+query_select session::build_select_query(connection_ptr<connection> &conn, entity_query_data &&data) const
+{
+  auto q = conn->query(*schema_)
+    .select(data.columns)
+    .from(data.root_table_name);
+
+  auto it = data.joins.begin();
+  if (it != data.joins.end()) {
+    auto qj = q.join_left(it->join_table).on(std::move(it->condition));
+    while (++it != data.joins.end()) {
+      qj.join_left(it->join_table).on(std::move(it->condition));
+    }
+    if (data.where_clause) {
+      return qj.where(std::move(data.where_clause));
+    }
+    return qj;
+  } else if (data.where_clause) {
+    return q.where(std::move(data.where_clause));
+  } else {
+    return q;
+  }
+}
 }