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::entity_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 = builder_result
-    auto stmt = query::query::select(data.columns)
+      .release()
-      .from(*data.root_table)
-      .join_left(data.joins)
-      .where(std::move(data.where_clause))
-      .order_by({data.root_table, data.pk_column_name})
-      .asc()
       .prepare(exec);
 
     if (!stmt) {

include/matador/query/select_query_builder.hpp

@@ -21,11 +21,10 @@
 
 namespace matador::query {
 
-struct entity_query_data {
+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)
+  explicit select_query_builder(const basic_schema &scm)
-  : schema_(scm)
+  : schema_(scm){}
-  , executor_(exec){}
 
   template<class EntityType>
-  utils::result<entity_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);
@@ -260,11 +268,10 @@ private:
   std::stack<table_info> table_info_stack_{};
   std::unordered_map<std::string, table> processed_tables_{};
   const basic_schema &schema_;
-  entity_query_data entity_query_data_{};
+  select_query_data entity_query_data_{};
   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()));
   }
 }
 

source/orm/CMakeLists.txt

@@ -185,6 +185,7 @@ add_library(matador-orm STATIC
   sql/resolver_service.cpp
   sql/statement.cpp
   sql/statement_cache.cpp
+  ../../include/matador/query/insert_query_builder.hpp
 )
 
 target_include_directories(matador-orm

source/orm/orm/session.cpp

@@ -119,13 +119,4 @@ utils::result<sql::statement, utils::error> session::prepare(const sql::query_co
 std::string session::str(const sql::query_context& ctx) const {
   return ctx.sql;
 }
-
-query::fetchable_query session::build_select_query(query::entity_query_data &&data) {
-  return 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();
-}
 }

source/orm/query/select_query_builder.cpp

@@ -64,6 +64,10 @@ void select_query_builder::push(const std::string &column_name) {
   entity_query_data_.columns.emplace_back(&it->second, column_name, build_alias('c', ++column_index));
 }
 
+const select_query_data & select_query_builder::query_data() const {
+  return entity_query_data_;
+}
+
 std::string select_query_builder::build_alias(const char prefix, const unsigned int count) {
   char str[4];
   snprintf(str, 4, "%c%02d", prefix, count);

test/backends/SessionTest.cpp

@@ -284,22 +284,31 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with many-to-m
       return schema.create(db);
     } );
 
-  std::vector<std::unique_ptr<ingredient>> ingredients;
+  std::vector ingredients {
-  ingredients.push_back(std::make_unique<ingredient>(1, "Apple"));
+    object_ptr(std::make_shared<ingredient>(1, "Apple")),
-  ingredients.push_back(std::make_unique<ingredient>(2, "Strawberry"));
+    object_ptr(std::make_shared<ingredient>(2, "Strawberry")),
-  ingredients.push_back(std::make_unique<ingredient>(3, "Pineapple"));
+    object_ptr(std::make_shared<ingredient>(3, "Pineapple")),
-  ingredients.push_back(std::make_unique<ingredient>(4, "Sugar"));
+    object_ptr(std::make_shared<ingredient>(4, "Sugar")),
-  ingredients.push_back(std::make_unique<ingredient>(5, "Flour"));
+    object_ptr(std::make_shared<ingredient>(5, "Flour")),
-  ingredients.push_back(std::make_unique<ingredient>(6, "Butter"));
+    object_ptr(std::make_shared<ingredient>(6, "Butter")),
-  ingredients.push_back(std::make_unique<ingredient>(7, "Beans"));
+    object_ptr(std::make_shared<ingredient>(7, "Beans"))
+  };
 
   for (auto &i: ingredients) {
-    auto res = ses.insert(i.release());
+    auto res = ses.insert(i);
     REQUIRE(res.is_ok());
   }
 
-  std::vector<std::unique_ptr<recipe>> recipes;
+  std::vector recipes {
-  recipes.push_back(std::make_unique<recipe>(7, "Apple Crumble"));
+    object_ptr(std::make_shared<recipe>(1, "Apple Pie", std::vector{ingredients[0], ingredients[3], ingredients[4]})),
-  recipes.push_back(std::make_unique<recipe>(8, "Beans Chili"));
+    object_ptr(std::make_shared<recipe>(2, "Strawberry Cake", std::vector{ingredients[5], ingredients[6]})),
-  recipes.push_back(std::make_unique<recipe>(9, "Fruit Salad"));
+    object_ptr(std::make_shared<recipe>(3, "Pineapple Pie", std::vector{ingredients[0], ingredients[1], ingredients[2]}))
+  };
+
+  for (auto &r: recipes) {
+    auto res = ses.insert(r);
+    REQUIRE(res.is_ok());
+  }
+
+
 }

test/models/recipe.hpp

@@ -9,6 +9,7 @@
 #include "matador/object/many_to_many_relation.hpp"
 
 #include <string>
+#include <utility>
 
 namespace matador::test {
 struct recipe;
@@ -39,10 +40,14 @@ struct recipe {
   object::collection<object::object_ptr<ingredient> > ingredients{};
 
   recipe() = default;
-
   recipe(const unsigned int id, std::string name)
   : id(id), name(std::move(name)) {
   }
+  recipe(const unsigned int id, std::string name, std::vector<object::object_ptr<ingredient>> ings)
+  : id(id)
+  , name(std::move(name))
+  , ingredients(std::move(ings)){
+  }
 
   template<class Operator>
   void process(Operator &op) {

test/orm/orm/SessionQueryBuilderTest.cpp

@@ -3,7 +3,6 @@
 
 #include "matador/sql/backend_provider.hpp"
 #include "matador/sql/connection.hpp"
-#include "matador/sql/connection_pool.hpp"
 #include "matador/sql/interface/connection_impl.hpp"
 
 #include "matador/query/criteria_evaluator.hpp"
@@ -37,53 +36,57 @@ TEST_CASE("Create sql query data for entity with eager has one", "[query][entity
   using namespace matador::test;
   backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
   connection db("noop://noop.db");
-  connection_pool pool("noop://noop.db", 4);
 
   schema scm;
   auto result = scm.attach<airplane>("airplanes")
     .and_then( [&scm] { return scm.attach<flight>("flights"); } );
   REQUIRE(result);
 
-  select_query_builder eqb(scm, db);
+  select_query_builder eqb(scm);
 
   const auto it = scm.find(typeid(flight));
   REQUIRE(it != scm.end());
   const auto* col = it->second.table()["id"];
   REQUIRE(col);
-  auto data = eqb.build<flight>(*col == _);
+  auto q = eqb.build<flight>(*col == _);
+  REQUIRE(q.is_ok());
 
-  REQUIRE(data.is_ok());
+  const auto sql = q->str(db);
-  REQUIRE(data->root_table->table_name() == "flights");
+  const std::string expected_sql = R"(SELECT "t01"."id", "t02"."id", "t02"."brand", "t02"."model", "t01"."pilot_name" FROM "flights" "t01" LEFT JOIN "airplanes" "t02" ON "t01"."airplane_id" = "t02"."id" WHERE "t01"."id" = ? ORDER BY "t01"."id" ASC)";
-  REQUIRE(data->joins.size() == 1);
+  REQUIRE(expected_sql == sql);
+
+  const auto& data = eqb.query_data();
+  REQUIRE(data.root_table->table_name() == "flights");
+  REQUIRE(data.joins.size() == 1);
   const auto flights = table("flights").as("t01");
   const auto airplanes = table("airplanes").as("t02");
   const std::vector<table_column> expected_columns {
-    { &flights, "id", "c01" },
+      { &flights, "id", "c01" },
-    { &airplanes, "id", "c02" },
+      { &airplanes, "id", "c02" },
-    { &airplanes, "brand", "c03" },
+      { &airplanes, "brand", "c03" },
-    { &airplanes, "model", "c04" },
+      { &airplanes, "model", "c04" },
-    { &flights, "pilot_name", "c05" },
+      { &flights, "pilot_name", "c05" },
-  };
+    };
-  REQUIRE(data->columns.size() == expected_columns.size());
+  REQUIRE(data.columns.size() == expected_columns.size());
   for (size_t i = 0; i != expected_columns.size(); ++i) {
-    REQUIRE(expected_columns[i].equals(data->columns[i]));
+    REQUIRE(expected_columns[i].equals(data.columns[i]));
   }
 
   std::vector<std::pair<std::string, std::string>> expected_join_data {
-    { "airplanes", R"("t01"."airplane_id" = "t02"."id")"}
+      { "airplanes", R"("t01"."airplane_id" = "t02"."id")"}
   };
 
   query_context qc;
   size_t index{0};
   criteria_evaluator evaluator(db.dialect(), qc);
-  for (const auto &[join_table, condition] : data->joins) {
+  for (const auto &[join_table, condition] : data.joins) {
     REQUIRE(join_table->table_name() == expected_join_data[index].first);
     REQUIRE(evaluator.evaluate(*condition) == expected_join_data[index].second);
     ++index;
   }
 
-  REQUIRE(data->where_clause.get());
+  REQUIRE(data.where_clause.get());
-  auto cond = evaluator.evaluate(*data->where_clause);
+  auto cond = evaluator.evaluate(*data.where_clause);
   REQUIRE(cond == R"("t01"."id" = ?)");
 }
 
@@ -91,24 +94,29 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent
   using namespace matador::test;
   backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
   connection db("noop://noop.db");
-  connection_pool pool("noop://noop.db", 4);
 
   schema scm;
   auto result = scm.attach<author>("authors")
     .and_then( [&scm] { return scm.attach<book>("books"); } );
   REQUIRE(result);
 
-  select_query_builder eqb(scm, db);
+  select_query_builder eqb(scm);
 
   const auto it = scm.find(typeid(book));
   REQUIRE(it != scm.end());
   const auto* col = it->second.table()["id"];
   REQUIRE(col);
-  auto data = eqb.build<book>(*col == _);
+  auto q = eqb.build<book>(*col == _);
 
-  REQUIRE(data.is_ok());
+  REQUIRE(q.is_ok());
-  REQUIRE(data->root_table->table_name() == "books");
+  const auto sql = q->str(db);
-  REQUIRE(data->joins.size() == 1);
+  const std::string expected_sql = R"(SELECT "t01"."id", "t01"."title", "t02"."id", "t02"."first_name", "t02"."last_name", "t02"."date_of_birth", "t02"."year_of_birth", "t02"."distinguished", "t01"."published_in" FROM "books" "t01" LEFT JOIN "authors" "t02" ON "t01"."author_id" = "t02"."id" WHERE "t01"."id" = ? ORDER BY "t01"."id" ASC)";
+  REQUIRE(expected_sql == sql);
+
+  const auto& data = eqb.query_data();
+
+  REQUIRE(data.root_table->table_name() == "books");
+  REQUIRE(data.joins.size() == 1);
   const auto books = table("books").as("t01");
   const auto authors = table("authors").as("t02");
   const std::vector<table_column> expected_columns {
@@ -122,9 +130,9 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent
     { &authors, "distinguished", "c08" },
     { &books, "published_in", "c09" }
   };
-  REQUIRE(data->columns.size() == expected_columns.size());
+  REQUIRE(data.columns.size() == expected_columns.size());
   for (size_t i = 0; i != expected_columns.size(); ++i) {
-    REQUIRE(expected_columns[i].equals(data->columns[i]));
+    REQUIRE(expected_columns[i].equals(data.columns[i]));
   }
 
   std::vector<std::pair<std::string, std::string>> expected_join_data {
@@ -134,33 +142,32 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent
   query_context qc;
   size_t index{0};
   criteria_evaluator evaluator(db.dialect(), qc);
-  for (const auto & [join_table, clause] : data->joins) {
+  for (const auto & [join_table, clause] : data.joins) {
     REQUIRE(join_table->table_name() == expected_join_data[index].first);
     REQUIRE(evaluator.evaluate(*clause) == expected_join_data[index].second);
     ++index;
   }
 
-  REQUIRE(data->where_clause.get());
+  REQUIRE(data.where_clause.get());
-  auto cond = evaluator.evaluate(*data->where_clause);
+  auto cond = evaluator.evaluate(*data.where_clause);
   REQUIRE(cond == R"("t01"."id" = ?)");
 
-  auto q = matador::query::query::select(data->columns)
+  auto qs = matador::query::query::select(data.columns)
-    .from(data->root_table->name());
+    .from(data.root_table->name());
 
-  for (auto &jd : data->joins) {
+  // for (auto &jd : data.joins) {
-    q.join_left(*jd.join_table)
+  //   qs.join_left(*jd.join_table)
-      .on(std::move(jd.condition));
+  //     .on(std::move(jd.condition));
-  }
+  // }
-  auto context = q
+  // auto context = qs
-    .where(std::move(data->where_clause))
+  //   .where(std::move(data.where_clause))
-    .str(db);
+  //   .str(db);
 }
 
 TEST_CASE("Create sql query data for entity with eager has many belongs to", "[query][entity][builder]") {
   using namespace matador::test;
   backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
   connection db("noop://noop.db");
-  connection_pool pool("noop://noop.db", 4);
 
   schema scm;
   auto result = scm.attach<product>("products")
@@ -170,17 +177,23 @@ TEST_CASE("Create sql query data for entity with eager has many belongs to", "[q
     .and_then( [&scm] { return scm.attach<order>("orders"); } );
   REQUIRE(result);
 
-  select_query_builder eqb(scm, db);
+  select_query_builder eqb(scm);
 
   const auto it = scm.find(typeid(order));
   REQUIRE(it != scm.end());
   const auto* col = it->second.table()["order_id"];
   REQUIRE(col);
-  auto data = eqb.build<order>(*col == _);
+  auto q = eqb.build<order>(*col == _);
 
-  REQUIRE(data.is_ok());
+  REQUIRE(q.is_ok());
-  REQUIRE(data->root_table->table_name() == "orders");
+  const auto sql = q->str(db);
-  REQUIRE(data->joins.size() == 1);
+  const std::string expected_sql = R"(SELECT "t01"."order_id", "t01"."order_date", "t01"."required_date", "t01"."shipped_date", "t01"."ship_via", "t01"."freight", "t01"."ship_name", "t01"."ship_address", "t01"."ship_city", "t01"."ship_region", "t01"."ship_postal_code", "t01"."ship_country", "t02"."order_details_id", "t02"."order_id", "t02"."product_id" FROM "orders" "t01" LEFT JOIN "order_details" "t02" ON "t01"."order_id" = "t02"."order_id" WHERE "t01"."order_id" = ? ORDER BY "t01"."order_id" ASC)";
+  REQUIRE(expected_sql == sql);
+
+  const auto& data = eqb.query_data();
+
+  REQUIRE(data.root_table->table_name() == "orders");
+  REQUIRE(data.joins.size() == 1);
   const auto orders = table("orders").as("t01");
   const auto order_details = table("order_details").as("t02");
   const std::vector<table_column> expected_columns = {
@@ -200,9 +213,9 @@ TEST_CASE("Create sql query data for entity with eager has many belongs to", "[q
     { &order_details, "order_id", "c14" },
     { &order_details, "product_id", "c15" }
   };
-  REQUIRE(data->columns.size() == expected_columns.size());
+  REQUIRE(data.columns.size() == expected_columns.size());
   for (size_t i = 0; i != expected_columns.size(); ++i) {
-    REQUIRE(expected_columns[i].equals(data->columns[i]));
+    REQUIRE(expected_columns[i].equals(data.columns[i]));
   }
 
   std::vector<std::pair<std::string, std::string>> expected_join_data {
@@ -212,39 +225,44 @@ TEST_CASE("Create sql query data for entity with eager has many belongs to", "[q
   query_context qc;
   size_t index{0};
   criteria_evaluator evaluator(db.dialect(), qc);
-  for (const auto &jd : data->joins) {
+  for (const auto &jd : data.joins) {
     REQUIRE(jd.join_table->table_name() == expected_join_data[index].first);
-    REQUIRE(evaluator.evaluate(*jd.condition) == expected_join_data[index].second);
+    // REQUIRE(evaluator.evaluate(*jd.condition) == expected_join_data[index].second);
     ++index;
   }
 
-  REQUIRE(data->where_clause.get());
+  // REQUIRE(data.where_clause.get());
-  auto cond = evaluator.evaluate(*data->where_clause);
+  // auto cond = evaluator.evaluate(*data.where_clause);
-  REQUIRE(cond == R"("t01"."order_id" = ?)");
+  // REQUIRE(cond == R"("t01"."order_id" = ?)");
 }
 
 TEST_CASE("Create sql query data for entity with eager many to many", "[query][entity][builder]") {
   using namespace matador::test;
   backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
   connection db("noop://noop.db");
-  connection_pool pool("noop://noop.db", 4);
 
   schema scm;
   auto result = scm.attach<recipe>("recipes")
     .and_then( [&scm] { return scm.attach<ingredient>("ingredients"); } );
   REQUIRE(result);
 
-  select_query_builder eqb(scm, db);
+  select_query_builder eqb(scm);
 
   const auto it = scm.find(typeid(ingredient));
   REQUIRE(it != scm.end());
   const auto* col = it->second.table()["id"];
   REQUIRE(col);
-  auto data = eqb.build<ingredient>(*col == _);
+  auto q = eqb.build<ingredient>(*col == _);
 
-  REQUIRE(data.is_ok());
+  REQUIRE(q.is_ok());
-  REQUIRE(data->root_table->table_name() == "ingredients");
+  const auto sql = q->str(db);
-  REQUIRE(data->joins.size() == 2);
+  const std::string expected_sql = R"(SELECT "t01"."id", "t01"."name", "t03"."id", "t03"."name" FROM "ingredients" "t01" LEFT JOIN "recipe_ingredients" "t02" ON "t01"."id" = "t02"."ingredient_id" LEFT JOIN "recipes" "t03" ON "t02"."recipe_id" = "t03"."id" WHERE "t01"."id" = ? ORDER BY "t01"."id" ASC)";
+  REQUIRE(expected_sql == sql);
+
+  const auto& data = eqb.query_data();
+
+  REQUIRE(data.root_table->table_name() == "ingredients");
+  REQUIRE(data.joins.size() == 2);
   const auto ingredients = table("ingredients").as("t01");
   const auto recipes = table("recipes").as("t03");
   const std::vector<table_column> expected_columns {
@@ -253,9 +271,9 @@ TEST_CASE("Create sql query data for entity with eager many to many", "[query][e
     { &recipes, "id", "c03" },
     { &recipes, "name", "c04" }
   };
-  REQUIRE(data->columns.size() == expected_columns.size());
+  REQUIRE(data.columns.size() == expected_columns.size());
   for (size_t i = 0; i != expected_columns.size(); ++i) {
-    REQUIRE(expected_columns[i].equals(data->columns[i]));
+    REQUIRE(expected_columns[i].equals(data.columns[i]));
   }
 
   std::vector<std::pair<std::string, std::string>> expected_join_data {
@@ -266,39 +284,44 @@ TEST_CASE("Create sql query data for entity with eager many to many", "[query][e
   query_context qc;
   size_t index{0};
   criteria_evaluator evaluator(db.dialect(), qc);
-  for (const auto &jd : data->joins) {
+  for (const auto &jd : data.joins) {
     REQUIRE(jd.join_table->table_name() == expected_join_data[index].first);
-    REQUIRE(evaluator.evaluate(*jd.condition) == expected_join_data[index].second);
+    // REQUIRE(evaluator.evaluate(*jd.condition) == expected_join_data[index].second);
     ++index;
   }
 
-  REQUIRE(data->where_clause.get());
+  // REQUIRE(data.where_clause.get());
-  auto cond = evaluator.evaluate(*data->where_clause);
+  // auto cond = evaluator.evaluate(*data.where_clause);
-  REQUIRE(cond == R"("t01"."id" = ?)");
+  // REQUIRE(cond == R"("t01"."id" = ?)");
 }
 
 TEST_CASE("Create sql query data for entity with eager many to many (inverse part)", "[query][entity][builder]") {
   using namespace matador::test;
   backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
   connection db("noop://noop.db");
-  connection_pool pool("noop://noop.db", 4);
 
   schema scm;
   auto result = scm.attach<student>("students")
     .and_then( [&scm] { return scm.attach<course>("courses"); } );
   REQUIRE(result);
 
-  select_query_builder eqb(scm, db);
+  select_query_builder eqb(scm);
 
   const auto it = scm.find(typeid(course));
   REQUIRE(it != scm.end());
   const auto* col = it->second.table()["id"];
   REQUIRE(col);
-  auto data = eqb.build<course>(*col == _);
+  auto q = eqb.build<course>(*col == _);
 
-  REQUIRE(data.is_ok());
+  REQUIRE(q.is_ok());
-  REQUIRE(data->root_table->table_name() == "courses");
+  const auto sql = q->str(db);
-  REQUIRE(data->joins.size() == 2);
+  const std::string expected_sql = R"(SELECT "t01"."id", "t01"."title", "t03"."id", "t03"."name" FROM "courses" "t01" LEFT JOIN "student_courses" "t02" ON "t01"."id" = "t02"."course_id" LEFT JOIN "students" "t03" ON "t02"."student_id" = "t03"."id" WHERE "t01"."id" = ? ORDER BY "t01"."id" ASC)";
+  REQUIRE(expected_sql == sql);
+
+  const auto& data = eqb.query_data();
+
+  REQUIRE(data.root_table->table_name() == "courses");
+  REQUIRE(data.joins.size() == 2);
   const auto courses = table("courses").as("t01");
   const auto students = table("students").as("t03");
   const std::vector<table_column> expected_columns {
@@ -307,9 +330,9 @@ TEST_CASE("Create sql query data for entity with eager many to many (inverse par
     { &students, "id", "c03" },
     { &students, "name", "c04" }
   };
-  REQUIRE(data->columns.size() == expected_columns.size());
+  REQUIRE(data.columns.size() == expected_columns.size());
   for (size_t i = 0; i != expected_columns.size(); ++i) {
-    REQUIRE(expected_columns[i].equals(data->columns[i]));
+    REQUIRE(expected_columns[i].equals(data.columns[i]));
   }
 
   std::vector<std::pair<std::string, std::string>> expected_join_data {
@@ -320,40 +343,45 @@ TEST_CASE("Create sql query data for entity with eager many to many (inverse par
   query_context qc;
   size_t index{0};
   criteria_evaluator evaluator(db.dialect(), qc);
-  for (const auto &jd : data->joins) {
+  for (const auto &jd : data.joins) {
     REQUIRE(jd.join_table->table_name() == expected_join_data[index].first);
-    REQUIRE(evaluator.evaluate(*jd.condition) == expected_join_data[index].second);
+    // REQUIRE(evaluator.evaluate(*jd.condition) == expected_join_data[index].second);
     ++index;
   }
 
-  REQUIRE(data->where_clause.get());
+  // REQUIRE(data.where_clause.get());
-  auto cond = evaluator.evaluate(*data->where_clause);
+  // auto cond = evaluator.evaluate(*data.where_clause);
-  REQUIRE(cond == R"("t01"."id" = ?)");
+  // REQUIRE(cond == R"("t01"."id" = ?)");
 }
 
 TEST_CASE("Test eager relationship", "[query][entity][builder]") {
   using namespace matador::test;
   backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
   connection db("noop://noop.db");
-  connection_pool pool("noop://noop.db", 4);
 
   schema scm;
   auto result = scm.attach<department>("departments")
     .and_then( [&scm] { return scm.attach<employee>("employees"); } );
   REQUIRE(result);
 
-  select_query_builder eqb(scm, db);
+  select_query_builder eqb(scm);
 
-  auto data = eqb.build<department>();
+  auto q = eqb.build<department>();
-  REQUIRE(data.is_ok());
+  REQUIRE(q.is_ok());
+  const auto sql = q->str(db);
+  const std::string expected_sql = R"(SELECT "t01"."id", "t01"."name", "t02"."id", "t02"."first_name", "t02"."last_name", "t02"."dep_id" FROM "departments" "t01" LEFT JOIN "employees" "t02" ON "t01"."id" = "t02"."dep_id" ORDER BY "t01"."id" ASC)";
+  REQUIRE(expected_sql == sql);
 
-  auto ctx = query::select(data->columns)
+  const auto& data = eqb.query_data();
-  .from(*data->root_table)
-  .join_left(data->joins)
-  .where(std::move(data->where_clause))
-  .order_by(table_column{data->root_table, data->pk_column_name})
-  .asc()
-  .str(db);
 
-  std::cout << ctx << std::endl;
+
+  // auto ctx = query::select(data.columns)
+  // .from(*data.root_table)
+  // .join_left(data.joins)
+  // .where(std::move(data.where_clause))
+  // .order_by(table_column{data.root_table, data.pk_column_name})
+  // .asc()
+  // .str(db);
+  //
+  // std::cout << ctx << std::endl;
 }