added more join_left methods to query_from_intermediate to write shorter fluent sql queries

include/matador/sql/entity_query_builder.hpp

@@ -57,14 +57,10 @@ public:
 private:
   join_columns join_columns_;
 };
-struct join_data
-{
-  table join_table;
-  std::unique_ptr<basic_condition> condition;
-};
 
 struct entity_query_data {
   std::string root_table_name;
+  std::string pk_column_;
   std::vector<column> columns;
   std::vector<join_data> joins;
   std::unique_ptr<basic_condition> where_clause;
@@ -142,6 +138,7 @@ public:
     push(id);
     if (is_root_entity() && pk_.is_integer()) {
       entity_query_data_.where_clause = make_condition(column{table_info_stack_.top().name, id, ""} == *pk_.as<V>());
+      entity_query_data_.pk_column_ = id;
     }
   }
 

include/matador/sql/query_intermediates.hpp

@@ -150,12 +150,21 @@ public:
 
 class query_join_intermediate;
 
-class query_on_intermediate : public query_select
+struct join_data
+{
+  table join_table;
+  std::unique_ptr<basic_condition> condition;
+};
+
+class query_from_intermediate : public query_select
 {
 public:
   using query_select::query_select;
 
   query_join_intermediate join_left(const table &t);
+  query_from_intermediate join_left(join_data &data);
+  query_from_intermediate join_left(std::vector<join_data> &data_vector);
+
   template<class Condition>
   query_where_intermediate where(const Condition &cond)
   {
@@ -172,6 +181,8 @@ private:
   query_where_intermediate where_clause(std::unique_ptr<basic_condition> &&cond);
 };
 
+using query_on_intermediate = query_from_intermediate;
+
 class query_join_intermediate : public query_intermediate
 {
 public:
@@ -191,28 +202,6 @@ private:
   query_on_intermediate on_clause(std::unique_ptr<basic_condition> &&cond);
 };
 
-class query_from_intermediate : public query_select
-{
-public:
-  using query_select::query_select;
-
-  query_join_intermediate join_left(const table &t);
-  template<class Condition>
-  query_where_intermediate where(const Condition &cond)
-  {
-    return where_clause(std::make_unique<Condition>(std::move(cond)));
-  }
-  query_where_intermediate where(std::unique_ptr<basic_condition> &&cond)
-  {
-    return where_clause(std::move(cond));
-  }
-  query_group_by_intermediate group_by(const column &col);
-  query_order_by_intermediate order_by(const column &col);
-
-private:
-  query_where_intermediate where_clause(std::unique_ptr<basic_condition> &&cond);
-};
-
 class query_start_intermediate : public basic_query_intermediate
 {
 public:

src/sql/query_intermediates.cpp

@@ -85,7 +85,9 @@ query_order_direction_intermediate query_order_by_intermediate::desc()
 
 query_where_intermediate query_from_intermediate::where_clause(std::unique_ptr<basic_condition> &&cond)
 {
-  data_->parts.push_back(std::make_unique<query_where_part>(std::move(cond)));
+  if (cond) {
+    data_->parts.push_back(std::make_unique<query_where_part>(std::move(cond)));
+  }
   return {connection_, schema_, data_};
 }
 
@@ -113,30 +115,6 @@ query_order_by_intermediate query_where_intermediate::order_by(const column &col
   return {connection_, schema_, data_};
 }
 
-query_join_intermediate query_on_intermediate::join_left(const table &t)
-{
-  data_->parts.push_back(std::make_unique<query_join_part>(t));
-  return {connection_, schema_, data_};
-}
-
-query_where_intermediate query_on_intermediate::where_clause(std::unique_ptr<basic_condition> &&cond)
-{
-  data_->parts.push_back(std::make_unique<query_where_part>(std::move(cond)));
-  return {connection_, schema_, data_};
-}
-
-query_group_by_intermediate query_on_intermediate::group_by(const column &col)
-{
-  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_, schema_, data_};
-}
-
 query_on_intermediate query_join_intermediate::on_clause(std::unique_ptr<basic_condition> &&cond)
 {
   data_->parts.push_back(std::make_unique<query_on_part>(std::move(cond)));
@@ -149,6 +127,22 @@ query_join_intermediate query_from_intermediate::join_left(const table &t)
   return {connection_, schema_, data_};
 }
 
+query_from_intermediate query_from_intermediate::join_left(join_data &data)
+{
+  data_->parts.push_back(std::make_unique<query_join_part>(data.join_table));
+  data_->parts.push_back(std::make_unique<query_on_part>(std::move(data.condition)));
+  return {connection_, schema_, data_};
+}
+
+query_from_intermediate query_from_intermediate::join_left(std::vector<join_data> &data_vector)
+{
+  for (auto &data : data_vector) {
+    data_->parts.push_back(std::make_unique<query_join_part>(data.join_table));
+    data_->parts.push_back(std::make_unique<query_on_part>(std::move(data.condition)));
+  }
+  return {connection_, schema_, data_};
+}
+
 query_select_intermediate::query_select_intermediate(connection &db, const sql::schema &schema, const std::vector<column>& columns)
 : query_start_intermediate(db, schema)
 {

src/sql/session.cpp

@@ -105,24 +105,13 @@ std::unique_ptr<query_result_impl> session::fetch(const std::string &sql) const
 
 query_select session::build_select_query(connection_ptr<connection> &conn, entity_query_data &&data) const
 {
-  auto q = conn->query(*schema_)
+  return 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;
-  }
+    .from(data.root_table_name)
+    .join_left(data.joins)
+    .where(std::move(data.where_clause))
+    .order_by({data.root_table_name, data.pk_column_})
+    .asc();
 }
+
 }

test/ResultTest.cpp

@@ -25,7 +25,12 @@ utils::result<float, math_error>plus(int x, int y) {
 }
 
 utils::result<float, std::string>error_to_string(math_error err) {
-  return utils::error(std::string("error"));
+  switch (err) {
+    case math_error::DIVISION_BY_ZERO:
+      return utils::error(std::string("division by zero error"));
+    default:
+      return utils::error(std::string("unknown error"));
+  }
 }
 
 }
@@ -76,7 +81,7 @@ TEST_CASE("Result tests", "[result]") {
   REQUIRE(!res2);
   REQUIRE(!res2.is_ok());
   REQUIRE(res2.is_error());
-  REQUIRE((res2.err() == "error"));
+  REQUIRE((res2.err() == "division by zero error"));
 
   res = test::divide(4, 2)
     .and_then([](const auto &val) { return test::multiply(val, 5); })