some improvements to select_query_builder and started insert_query_builder

include/matador/orm/session.hpp

@@ -147,8 +147,6 @@ public:
 private:
   friend class query_select;
 
-  static query::fetchable_query build_select_query(query::select_query_data &&data);
-
 private:
   sql::connection_pool pool_;
   mutable sql::statement_cache cache_;
@@ -321,7 +319,7 @@ utils::result<object::object_ptr<Type>, utils::error> session::find(const Primar
     return utils::failure(make_error(error_code::NoPrimaryKey, "Type hasn't primary key."));
   }
 
-  query::select_query_builder eqb(schema_, *this);
+  query::select_query_builder eqb(schema_);
   const query::table_column c(&it->second.table(), info.primary_key_attribute()->name());
   using namespace matador::query;
   auto data = eqb.build<Type>(c == utils::_);
@@ -352,7 +350,7 @@ utils::result<sql::query_result<Type>, utils::error> session::find(query::criter
     return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
   }
 
-  query::select_query_builder eqb(schema_, *this);
+  query::select_query_builder eqb(schema_);
   auto data = eqb.build<Type>(std::move(clause));
   if (!data.is_ok()) {
     return utils::failure(make_error(error_code::FailedToBuildQuery,

include/matador/query/insert_query_builder.hpp

@@ -0,0 +1,47 @@
+#ifndef MATADOR_INSERT_QUERY_BUILDER_HPP
+#define MATADOR_INSERT_QUERY_BUILDER_HPP
+
+#include "matador/query/basic_schema.hpp"
+#include "matador/query/intermediates/executable_query.hpp"
+
+namespace matador::query {
+class insert_query_builder {
+public:
+  explicit insert_query_builder(const basic_schema &schema);
+
+  template<class EntityType>
+  utils::result<executable_query, utils::error> build(const object::object_ptr<EntityType> &ptr) {
+  }
+
+  template < class V >
+  void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
+    push(id);
+    if (!is_root_entity()) {
+      return;
+    }
+    entity_query_data_.pk_column_name = id;
+  }
+
+  void on_revision(const char *id, uint64_t &/*rev*/);
+
+  template<typename Type>
+  void on_attribute(const char *id, Type &, const utils::field_attributes &/*attr*/ = utils::null_attributes)
+  {
+    push(id);
+  }
+
+  template<class Pointer>
+  void on_belongs_to(const char *id, Pointer &obj, const utils::foreign_attributes &attr) {
+    on_foreign_object(id, obj, attr);
+  }
+
+  template<class Pointer>
+  void on_has_one(const char *id, Pointer &obj, const utils::foreign_attributes &attr) {
+    on_foreign_object(id, obj, attr);
+  }
+
+private:
+  const basic_schema &schema_;
+};
+}
+#endif //MATADOR_INSERT_QUERY_BUILDER_HPP

include/matador/query/schema.hpp

@@ -154,7 +154,7 @@ public:
     Type obj;
     access::process(pc, obj);
 
-    select_query_builder qb(repo_, exec);
+    select_query_builder qb(repo_);
     const auto *pk_column = table_[pk_name_];
     auto builder_result = qb.build<Type>(*pk_column == utils::_);
 
@@ -162,13 +162,8 @@ public:
       return nullptr;
     }
 
-    auto data = builder_result.release();
-    auto stmt = query::query::select(data.columns)
-      .from(*data.root_table)
-      .join_left(data.joins)
-      .where(std::move(data.where_clause))
-      .order_by({data.root_table, data.pk_column_name})
-      .asc()
+    auto stmt = builder_result
+      .release()
       .prepare(exec);
 
     if (!stmt) {

include/matador/query/select_query_builder.hpp

@@ -25,7 +25,6 @@ struct select_query_data {
   const table* root_table{nullptr};
   std::string pk_column_name{};
   std::vector<table_column> columns{};
-  std::unordered_map<std::string, sql::statement> lazy_loading_statements{};
   std::vector<join_data> joins{};
   criteria_ptr where_clause{};
 };
@@ -53,12 +52,11 @@ private:
 
 class select_query_builder final {
 public:
-  select_query_builder(const basic_schema &scm, sql::executor &exec)
-  : schema_(scm)
-  , executor_(exec){}
+  explicit select_query_builder(const basic_schema &scm)
+  : schema_(scm){}
 
   template<class EntityType>
-  utils::result<select_query_data, query_build_error> build(criteria_ptr clause = {}) {
+  utils::result<fetchable_query, query_build_error> build(criteria_ptr clause = {}) {
     const auto it = schema_.find(typeid(EntityType));
     if (it == schema_.end()) {
       return utils::failure(query_build_error::UnknownType);
@@ -75,7 +73,15 @@ public:
         clause->accept(transformer);
         entity_query_data_.where_clause = std::move(clause);
       }
-      return {utils::ok(std::move(entity_query_data_))};
+
+      fetchable_query q = query::query::select(entity_query_data_.columns)
+        .from(*entity_query_data_.root_table)
+        .join_left(entity_query_data_.joins)
+        .where(std::move(entity_query_data_.where_clause))
+        .order_by({entity_query_data_.root_table, entity_query_data_.pk_column_name})
+        .asc();
+
+      return {utils::ok(std::move(q))};
     } catch (const query_builder_exception &ex) {
       return {utils::failure(ex.error_type())};
     } catch (...) {
@@ -243,6 +249,8 @@ public:
     );
   }
 
+  const select_query_data &query_data() const;
+
 private:
   template<class Pointer>
   void on_foreign_object(const char *id, Pointer &, const utils::foreign_attributes &attr);
@@ -264,7 +272,6 @@ private:
   unsigned int column_index{0};
   unsigned int table_index{0};
   object::join_columns_collector join_columns_collector_{};
-  sql::executor &executor_;
 };
 
 template<class Pointer>
@@ -297,18 +304,6 @@ void select_query_builder::on_foreign_object(const char *id, Pointer &, const ut
     );
   } else {
     push(id);
-    using namespace matador::utils;
-    using namespace matador::query;
-    // create select query
-    auto result = query::query::select(generator::columns<typename Pointer::value_type>(schema_, foreign_table, generator::column_generator_options::ForceLazy))
-      .from(foreign_table)
-      .where(table_column(&foreign_table, info.primary_key_attribute()->name(), "") == _)
-      .prepare(executor_);
-    if (!result) {
-      throw query_builder_exception(query_build_error::QueryError, result.release_error());
-    }
-
-    entity_query_data_.lazy_loading_statements.emplace(id, std::move(result.release()));
   }
 }