progress on query compiler

demo/work.cpp

@@ -164,5 +164,106 @@ int main() {
       in( iPT.payload_id, query::query::select({ temp_id_col }).from( temporary ) )
     )
   .str( conn->dialect() );
+
+      // const QString statement = QString( "SELECT %5 FROM %1 "
+      //                                  "LEFT JOIN (SELECT %2, MAX(%3) AS lastSuccessfulLogin FROM %1 WHERE %4 = ? GROUP BY %2) ll "
+      //                                  "ON %1.%2 = ll.%2 "
+      //                                  "WHERE (lastSuccessfulLogin IS NULL OR %3 <= lastSuccessfulLogin) AND %3 < ?" )
+      //                         .arg( LoginHistory::staticSqlMetaInfo().tableName() )
+      //                         .arg( LoginHistory::staticSqlMetaInfo().columnName( LoginHistory::Attributes::userAttributeId() ) )
+      //                         .arg( LoginHistory::staticSqlMetaInfo().columnName( LoginHistory::Attributes::timestampAttributeId() ) )
+      //                         .arg( LoginHistory::staticSqlMetaInfo().columnName( LoginHistory::Attributes::failReasonSqlAttributeId() ) )
+      //                         .arg( LoginHistory::staticSqlMetaInfo().columnName( LoginHistory::Attributes::idAttributeId() ) );
+
+  const auto q = query::query::select({LOGIN_HISTORY.client, query::max(LOGIN_HISTORY.login_time).as( "lastSuccessfulLogin" ) } )
+    .from( LOGIN_HISTORY )
+    .where( LOGIN_HISTORY.fail_reason == _ )
+    .group_by( LOGIN_HISTORY.client );
+    // .as_table("ll");
+
+  const auto stmt3 = query::query::select({ LOGIN_HISTORY.client })
+    .from( LOGIN_HISTORY )
+    .join_left(q/*, "ll"*/ )
+    .on( LOGIN_HISTORY.client == "ll.client" )
+    .where( query::is_null("lastSuccessfulLogin") && LOGIN_HISTORY.login_time < "ll.lastSuccessfulLogin" )
+    .str( conn->dialect() );
+
+  std::cout << stmt1 << std::endl;
+  std::cout << stmt2 << std::endl;
+  std::cout << stmt3 << std::endl;
+
+  // const QString subQuery = QString( "SELECT MAX(%1) AS lastSuccessfulLogin, %3 FROM %2 "
+  //                                 "WHERE(%4 = ? OR %4 = ? OR %4 = ?) AND %3 = ? GROUP BY %3 " );
+  //
+  // const QString statement = QString( "SELECT MAX(t1.%1) AS LAST_FAILED_LOGIN FROM %2 t1 LEFT JOIN"
+  //                                    "(%0) t2 "
+  //                                    "ON t1.%3 = t2.%3 "
+  //                                    "WHERE(t2.lastSuccessfulLogin IS NULL OR t2.lastSuccessfulLogin < t1.%1) "
+  //                                    "AND (t1.%4 = ? OR t1.%4 = ?) "
+  //                                    "AND t1.%3 = ?" )
+  //                           .arg( subQuery )
+  //                           .arg( LoginHistory::staticSqlMetaInfo().columnName( LoginHistory::Attributes::timestampAttributeId() ) )
+  //                           .arg( LoginHistory::staticSqlMetaInfo().tableName() )
+  //                           .arg( columnFilterName )
+  //                           .arg( LoginHistory::staticSqlMetaInfo().columnName( LoginHistory::Attributes::failReasonSqlAttributeId() ) );
+  //
+  // QSqlQuery query( sqlDatabase() );
+  // if ( query.prepare( statement ) ) {
+  //   query.addBindValue( LoginHistory::FailReason::NoFailReason );
+  //   query.addBindValue( LoginHistory::FailReason::NoScenarioForUser );
+  //   query.addBindValue( LoginHistory::FailReason::UserLockedByAdmin );
+  //   query.addBindValue( columnFilterValue );
+  //   query.addBindValue( LoginHistory::FailReason::WrongPassword );
+  //   query.addBindValue( LoginHistory::FailReason::UnknownUserName );
+  //   query.addBindValue( columnFilterValue );
+
   return 0;
 }
+
+/*
+SELECT
+  "tasks"."payload", "payloads"."id"
+FROM
+  "public"."tasks", "public"."payloads"
+WHERE
+  "payloads"."id" = "tasks"."payload"
+
+SELECT
+  "iPT"."payload_id" FROM "public"."id_payloads" "iPT"
+LEFT JOIN
+  "public"."payloads" "pT"
+ON
+  "iPT"."id" = "pT"."id"
+WHERE ("pT"."id" IN (
+  SELECT
+    "jobs"."payload"
+  FROM
+    "public"."jobs"
+  WHERE
+    "jobs"."state" = $1
+  ) AND "iPT"."payload_id" IN (
+  SELECT
+    "ID"
+  FROM "public"."TempTable"
+  )
+)
+
+SELECT
+  "login_histories"."client"
+FROM
+  "public"."login_histories"
+LEFT JOIN (
+  SELECT
+    "login_histories"."client", MAX(login_time) AS lastSuccessfulLogin
+  FROM
+    "public"."login_histories"
+  WHERE
+    "login_histories"."fail_reason" = $1
+  GROUP BY
+    "login_histories"."client"
+  )
+ON
+  "login_histories"."client" = 'll.client'
+WHERE
+  ("lastSuccessfulLogin" IS NULL AND "login_histories"."login_time" < 'll.lastSuccessfulLogin')
+*/

demo/work/admin/LoginHistory.hpp

@@ -9,6 +9,8 @@
 
 #include "matador/object/object_ptr.hpp"
 
+#include "matador/query/meta_table_macro.hpp"
+
 #include "matador/utils/base_class.hpp"
 #include "matador/utils/enum_mapper.hpp"
 #include "matador/utils/foreign_attributes.hpp"
@@ -59,6 +61,9 @@ struct LoginHistory : core::Model {
         field::attribute( op, "login_time", login_time );
     }
 };
+
 }
 
+META_TABLE( login_histories, LOGIN_HISTORY, id, version, client, scenario, collection_center, login_name, fail_reason, login_time )
+
 #endif //LOGIN_HISTORY_HPP

demo/work/admin/User.hpp

@@ -7,6 +7,8 @@
 
 #include "matador/object/object_ptr.hpp"
 
+#include "matador/query/meta_table_macro.hpp"
+
 #include "matador/utils/base_class.hpp"
 #include "matador/utils/foreign_attributes.hpp"
 #include "matador/utils/types.hpp"
@@ -42,4 +44,7 @@ struct User : core::Model {
 };
 
 }
+
+META_TABLE(users, USER, id, version, name, symbol, salt, password, lock_type, locked_at, lock_reason, role, user_directory)
+
 #endif //USER_HPP

include/matador/query/criteria.hpp

@@ -3,6 +3,7 @@
 
 #include "matador/query/criteria/between_criteria.hpp"
 #include "matador/query/criteria/binary_criteria.hpp"
+#include "matador/query/criteria/check_null_criteria.hpp"
 #include "matador/query/criteria/collection_criteria.hpp"
 #include "matador/query/criteria/like_criteria.hpp"
 #include "matador/query/criteria/logical_criteria.hpp"

include/matador/query/criteria/check_null_criteria.hpp

@@ -0,0 +1,26 @@
+#ifndef MATADOR_IS_NULL_CRITERIA_HPP
+#define MATADOR_IS_NULL_CRITERIA_HPP
+
+#include "matador/query/criteria/abstract_column_criteria.hpp"
+
+namespace matador::query {
+enum class check_null_operator {
+  IsNull,
+  IsNotNull,
+};
+
+class check_null_criteria final : public abstract_column_criteria {
+public:
+  check_null_criteria() = delete;
+  check_null_criteria(const table_column& col, check_null_operator op);
+
+  void accept(criteria_visitor& visitor) const override;
+
+  [[nodiscard]] check_null_operator operand() const;
+
+private:
+  check_null_operator operator_{};
+};
+
+}
+#endif  // MATADOR_IS_NULL_CRITERIA_HPP

include/matador/query/criteria/criteria_operators.hpp

@@ -104,5 +104,8 @@ criteria_ptr between(const table_column &col, utils::placeholder min, utils::pla
 
 criteria_ptr like(const table_column &col, const std::string &pattern);
 
+criteria_ptr is_null(const table_column &col);
+criteria_ptr is_not_null(const table_column &col);
+
 }
 #endif //CRITERIA_CRITERIA_OPERATORS_HPP

include/matador/query/criteria/criteria_visitor.hpp

@@ -5,6 +5,7 @@ namespace matador::query {
 class between_criteria;
 class binary_criteria;
 class binary_column_criteria;
+class check_null_criteria;
 class like_criteria;
 class logical_criteria;
 class not_criteria;
@@ -18,6 +19,7 @@ public:
     virtual void visit(const between_criteria &node) = 0;
     virtual void visit(const binary_criteria &node) = 0;
     virtual void visit(const binary_column_criteria &node) = 0;
+    virtual void visit(const check_null_criteria &node) = 0;
     virtual void visit(const collection_criteria &node) = 0;
     virtual void visit(const collection_query_criteria &node) = 0;
     virtual void visit(const like_criteria &node) = 0;

include/matador/query/criteria_evaluator.hpp

@@ -23,6 +23,7 @@ public:
   void visit(const between_criteria &node) override;
   void visit(const binary_criteria &node) override;
   void visit(const binary_column_criteria &node) override;
+  void visit(const check_null_criteria &node) override;
   void visit(const collection_criteria &node) override;
   void visit(const collection_query_criteria &node) override;
   void visit(const like_criteria &node) override;

include/matador/query/intermediates/query_from_intermediate.hpp

@@ -16,6 +16,7 @@ public:
   using fetchable_query::fetchable_query;
 
   query_join_intermediate join_left(const table &t);
+  query_join_intermediate join_left(const fetchable_query &q);
   query_from_intermediate join_left(join_data &data);
   query_from_intermediate join_left(std::vector<join_data> &data_vector);
 

include/matador/query/internal/query_parts.hpp

@@ -143,10 +143,10 @@ private:
   std::vector<table> tables_;
 };
 
-class query_join_part final : public query_part
+class query_join_table_part final : public query_part
 {
 public:
-  explicit query_join_part(class table tab);
+  explicit query_join_table_part(class table tab);
 
   [[nodiscard]] const class table& table() const;
 
@@ -157,6 +157,20 @@ private:
   class table table_;
 };
 
+class query_join_query_part final : public query_part
+{
+public:
+  explicit query_join_query_part(fetchable_query q);
+
+  [[nodiscard]] const fetchable_query& query() const;
+
+private:
+  void accept(query_part_visitor &visitor) override;
+
+private:
+  fetchable_query query_;
+};
+
 class query_on_part final : public query_part
 {
 public:

include/matador/query/internal/string_builder_utils.hpp

@@ -0,0 +1,14 @@
+#ifndef MATADOR_STRING_BUILDER_UTILS_HPP
+#define MATADOR_STRING_BUILDER_UTILS_HPP
+
+#include <string>
+
+namespace matador::sql {
+class dialect;
+}
+
+namespace matador::query {
+void prepare_identifier_string_append(std::string& out, std::string_view col, const sql::dialect &d);
+}
+
+#endif  // MATADOR_STRING_BUILDER_UTILS_HPP

include/matador/query/meta_table_macro.hpp

@@ -3,7 +3,6 @@
 
 #include "matador/utils/macro_map.hpp"
 
-#include "matador/query/table_column.hpp"
 #include "matador/query/table.hpp"
 
 #define FIELD(FIELD_NAME) const matador::query::table_column& FIELD_NAME;

include/matador/query/query.hpp

@@ -10,10 +10,12 @@ class connection;
 }
 namespace matador::query {
 class schema;
-table_column alias(const std::string &column, const std::string &as);
-table_column alias(table_column &&col, const std::string &as);
 table_column count(const std::string &column);
 table_column count_all();
+table_column sum(const std::string &column);
+table_column avg(const std::string &column);
+table_column maximum(const std::string &column);
+table_column minimum(const std::string &column);
 
 class query
 {

include/matador/query/query_builder.hpp

@@ -37,6 +37,7 @@ public:
     void visit( const binary_criteria& node ) override;
     void visit( const binary_column_criteria& node ) override;
     void visit( const collection_criteria& node ) override;
+    void visit( const check_null_criteria& node ) override;
     void visit( const collection_query_criteria& node ) override;
     void visit( const like_criteria& node ) override;
     void visit( const logical_criteria& node ) override;

include/matador/query/query_compiler.hpp

@@ -47,7 +47,8 @@ protected:
 protected:
   void visit(internal::query_select_part &part) override;
   void visit(internal::query_from_part &part) override;
-  void visit(internal::query_join_part &part) override;
+  void visit(internal::query_join_table_part &part) override;
+  void visit(internal::query_join_query_part &part) override;
   void visit(internal::query_on_part &part) override;
   void visit(internal::query_where_part &part) override;
   void visit(internal::query_group_by_part &part) override;

include/matador/query/query_part_visitor.hpp

@@ -15,7 +15,8 @@ class query_add_foreign_key_reference_part;
 class query_add_primary_key_constraint_part;
 class query_select_part;
 class query_from_part;
-class query_join_part;
+class query_join_table_part;
+class query_join_query_part;
 class query_on_part;
 class query_where_part;
 class query_group_by_part;
@@ -57,7 +58,8 @@ public:
 
   virtual void visit(internal::query_select_part &part) = 0;
   virtual void visit(internal::query_from_part &part) = 0;
-  virtual void visit(internal::query_join_part &part) = 0;
+  virtual void visit(internal::query_join_table_part &part) = 0;
+  virtual void visit(internal::query_join_query_part &part) = 0;
   virtual void visit(internal::query_on_part &part) = 0;
   virtual void visit(internal::query_where_part &part) = 0;
   virtual void visit(internal::query_group_by_part &part) = 0;

include/matador/query/table_column.hpp

@@ -16,13 +16,19 @@ class table;
 class table_column {
 public:
   table_column(const char *name); // NOLINT(*-explicit-constructor)
-  table_column(std::string name); // NOLINT(*-explicit-constructor)
-  table_column(std::string name, std::string alias);
-  table_column(sql::sql_function_t func, std::string name);
-  table_column(const class table* tab, std::string name);
-  table_column(const class table* tab, std::string name, std::string alias);
-  table_column(const class table* tab, std::string name, utils::basic_type type, const utils::field_attributes& attributes);
-  table_column(const class table*, std::string name, std::string alias, utils::basic_type type, const utils::field_attributes& attributes, sql::sql_function_t func = sql::sql_function_t::None);
+  table_column(const std::string& name); // NOLINT(*-explicit-constructor)
+  table_column(const std::string& name, const std::string& alias);
+  table_column(sql::sql_function_t func, const std::string& name);
+  table_column(const class table* tab, const std::string& name);
+  table_column(const class table* tab, const std::string& name,
+               const std::string& alias);
+  table_column(const class table* tab, const std::string& name, utils::basic_type type, const utils::field_attributes& attributes);
+  table_column(const class table*,
+               const std::string& name,
+               const std::string& alias,
+               utils::basic_type type,
+               const utils::field_attributes& attributes,
+               sql::sql_function_t func = sql::sql_function_t::None);
   table_column& operator=(const table_column& other);
   table_column(const table_column& other) = default;
   table_column(table_column&& other) noexcept = default;
@@ -30,10 +36,11 @@ public:
 
   [[nodiscard]] bool equals(const table_column &x) const;
 
-  table_column as(std::string a);
+  [[nodiscard]] table_column as(const std::string& alias) const;
 
   [[nodiscard]] const std::string& name() const;
-  [[nodiscard]] std::string canonical_name() const;
+  [[nodiscard]] const std::string& column_name() const;
+  [[nodiscard]] const std::string& canonical_name() const;
   [[nodiscard]] const std::string& alias() const;
   [[nodiscard]] utils::basic_type type() const;
   [[nodiscard]] utils::field_attributes attributes() const;
@@ -49,11 +56,15 @@ public:
   // ReSharper disable once CppNonExplicitConversionOperator
   operator const std::string&() const; // NOLINT(*-explicit-constructor)
 
+private:
+  static std::string build_column_name(const class table *tab, const std::string& name);
+
 private:
   friend class table;
 
   const class table* table_{nullptr};
   std::string name_;
+  std::string column_name_;
   std::string alias_;
   utils::basic_type type_{utils::basic_type::Unknown};
   utils::field_attributes attributes_{};

include/matador/sql/dialect.hpp

@@ -53,7 +53,6 @@ public:
    * @return The prepared string
    */
   [[nodiscard]] std::string prepare_identifier_string(const std::string &col) const;
-  [[nodiscard]] std::string table_name(const std::string &table, const std::string &schema_name) const;
 
   [[nodiscard]] const std::string& to_string(bool val) const;
 
@@ -152,6 +151,8 @@ public:
   [[nodiscard]] const std::string& in() const;
   [[nodiscard]] const std::string& insert() const;
   [[nodiscard]] const std::string& into() const;
+  [[nodiscard]] const std::string& is_null() const;
+  [[nodiscard]] const std::string& is_not_null() const;
   [[nodiscard]] const std::string& join() const;
   [[nodiscard]] const std::string& like() const;
   [[nodiscard]] const std::string& limit() const;
@@ -218,6 +219,8 @@ private:
     {dialect_token::In,          "IN"},
     {dialect_token::Insert,      "INSERT"},
     {dialect_token::Into,        "INTO"},
+    {dialect_token::IsNull,      "IS NULL"},
+    {dialect_token::IsNotNull,   "IS NOT NULL"},
     {dialect_token::Join,        "LEFT JOIN"},
     {dialect_token::Like,        "LIKE"},
     {dialect_token::Limit,       "LIMIT"},

include/matador/sql/dialect_token.hpp

@@ -35,6 +35,8 @@ enum class dialect_token : uint8_t {
   In,
   Insert,
   Into,
+  IsNull,
+  IsNotNull,
   Join,
   Like,
   Limit,

source/orm/CMakeLists.txt

@@ -8,6 +8,7 @@ add_library(matador-orm STATIC
   ../../include/matador/query/criteria/abstract_column_criteria.hpp
   ../../include/matador/query/criteria/abstract_criteria.hpp
   ../../include/matador/query/criteria/between_criteria.hpp
+  ../../include/matador/query/criteria/check_null_criteria.hpp
   ../../include/matador/query/criteria/collection_criteria.hpp
   ../../include/matador/query/criteria/criteria_operators.hpp
   ../../include/matador/query/criteria/criteria_utils.hpp
@@ -47,6 +48,7 @@ add_library(matador-orm STATIC
   ../../include/matador/query/internal/basic_type_to_string_visitor.hpp
   ../../include/matador/query/internal/column_value_pair.hpp
   ../../include/matador/query/internal/query_parts.hpp
+  ../../include/matador/query/internal/string_builder_utils.hpp
   ../../include/matador/query/join_data.hpp
   ../../include/matador/query/key_value_generator.hpp
   ../../include/matador/query/meta_table_macro.hpp
@@ -102,6 +104,7 @@ add_library(matador-orm STATIC
   query/criteria/abstract_column_criteria.cpp
   query/criteria/between_criteria.cpp
   query/criteria/binary_criteria.cpp
+  query/criteria/check_null_criteria.cpp
   query/criteria/collection_criteria.cpp
   query/criteria/criteria_operators.cpp
   query/criteria/like_criteria.cpp
@@ -140,6 +143,7 @@ add_library(matador-orm STATIC
   query/internal/column_value_pair.cpp
   query/internal/query_parts.cpp
   query/internal/query_result_impl.cpp
+  query/internal/string_builder_utils.cpp
   query/key_value_generator.cpp
   query/query.cpp
   query/query_builder.cpp

source/orm/query/criteria/check_null_criteria.cpp

@@ -0,0 +1,16 @@
+#include "matador/query/criteria/check_null_criteria.hpp"
+
+#include "matador/query/criteria/criteria_visitor.hpp"
+
+namespace matador::query {
+check_null_criteria::check_null_criteria(const table_column& col, const check_null_operator op)
+: abstract_column_criteria(col)
+, operator_{op} {}
+
+void check_null_criteria::accept(criteria_visitor& visitor) const {
+  visitor.visit(*this);
+}
+check_null_operator check_null_criteria::operand() const {
+  return operator_;
+}
+}  // namespace matador::query

source/orm/query/criteria/criteria_operators.cpp

@@ -1,6 +1,7 @@
 #include "matador/query/criteria/criteria_operators.hpp"
 
 #include "matador/query/criteria/between_criteria.hpp"
+#include "matador/query/criteria/check_null_criteria.hpp"
 #include "matador/query/criteria/like_criteria.hpp"
 #include "matador/query/criteria/logical_criteria.hpp"
 #include "matador/query/criteria/not_criteria.hpp"
@@ -118,4 +119,11 @@ criteria_ptr between(const table_column &col, utils::placeholder min, utils::pla
 criteria_ptr like(const table_column &col, const std::string &pattern) {
   return std::make_unique<like_criteria>(col, pattern);
 }
+
+criteria_ptr is_null(const table_column &col) {
+  return std::make_unique<check_null_criteria>(col, check_null_operator::IsNull);
 }
+criteria_ptr is_not_null(const table_column &col) {
+  return std::make_unique<check_null_criteria>(col, check_null_operator::IsNotNull);
+}
+}  // namespace matador::query

source/orm/query/criteria_evaluator.cpp

@@ -1,18 +1,17 @@
 #include "matador/query/criteria_evaluator.hpp"
 
-#include "matador/query/query_utils.hpp"
 #include "matador/query/criteria/between_criteria.hpp"
 #include "matador/query/criteria/binary_criteria.hpp"
+#include "matador/query/criteria/check_null_criteria.hpp"
 #include "matador/query/criteria/collection_criteria.hpp"
 #include "matador/query/criteria/like_criteria.hpp"
 #include "matador/query/criteria/logical_criteria.hpp"
 #include "matador/query/criteria/not_criteria.hpp"
-
+#include "matador/query/query_utils.hpp"
 #include "matador/sql/dialect.hpp"
 #include "matador/sql/query_context.hpp"
-
-#include "matador/utils/value.hpp"
 #include "matador/utils/enum_mapper.hpp"
+#include "matador/utils/value.hpp"
 
 namespace matador::query {
 namespace detail {
@@ -41,7 +40,7 @@ std::string criteria_evaluator::evaluate(const abstract_criteria &node) {
 void criteria_evaluator::visit(const between_criteria &node) {
   query_.bind_vars.emplace_back(node.col().name());
   query_.bind_vars.emplace_back(node.col().name());
-  clause_ += prepare_identifier(dialect_, node.col()) + " " + dialect_.token_at(sql::dialect_token::Between) + " ";
+  clause_ += prepare_identifier(dialect_, node.col()) + " " + dialect_.between() + " ";
   evaluate_value(node.minimum());
   clause_ += " " + dialect_.token_at(sql::dialect_token::And) + " ";
   evaluate_value(node.maximum());
@@ -61,6 +60,14 @@ void criteria_evaluator::visit( const binary_column_criteria& node ) {
   clause_ += prepare_criteria(dialect_, node.left_column()) + " " + detail::BinaryOperatorEnum.to_string(node.operand()) + " " + prepare_criteria(dialect_, node.right_column());
 }
 
+void criteria_evaluator::visit(const check_null_criteria &node) {
+  clause_ += prepare_identifier(dialect_, node.col()) + " ";
+  if (node.operand() == check_null_operator::IsNull)
+    clause_ += dialect_.is_null();
+  else
+    clause_ += dialect_.is_not_null();
+}
+
 void criteria_evaluator::visit(const collection_criteria &node) {
   const auto count = node.values().size();
   for (size_t i = 0; i < count; ++i) {
@@ -87,12 +94,12 @@ void criteria_evaluator::visit(const collection_criteria &node) {
 
 void criteria_evaluator::visit(const collection_query_criteria &node) {
   clause_ += prepare_identifier(dialect_, node.col()) +
-      (node.operand() == collection_operator::Out ? " " + dialect_.token_at(sql::dialect_token::Not) + " " : " ") +
-      dialect_.token_at(sql::dialect_token::In) + " (" + node.query().str( dialect_ ) + ")";
+      (node.operand() == collection_operator::Out ? " " + dialect_.not_() + " " : " ") +
+      dialect_.in() + " (" + node.query().str( dialect_ ) + ")";
 }
 
 void criteria_evaluator::visit(const like_criteria &node) {
-  clause_ += prepare_criteria(dialect_, node.col()) + " " + dialect_.token_at(sql::dialect_token::Like) +
+  clause_ += prepare_criteria(dialect_, node.col()) + " " + dialect_.like() +
       " " + dialect_.token_at(sql::dialect_token::BeginStringData) + node.pattern() + dialect_.token_at(
         sql::dialect_token::EndStringData);
 }

source/orm/query/intermediates/query_from_intermediate.cpp

@@ -10,19 +10,24 @@
 namespace matador::query {
 
 query_join_intermediate query_from_intermediate::join_left(const table &t) {
-  context_->parts.push_back(std::make_unique<internal::query_join_part>(t));
+  context_->parts.push_back(std::make_unique<internal::query_join_table_part>(t));
+  return {context_};
+}
+
+query_join_intermediate query_from_intermediate::join_left(const fetchable_query &q) {
+  context_->parts.push_back(std::make_unique<internal::query_join_query_part>(q));
   return {context_};
 }
 
 query_from_intermediate query_from_intermediate::join_left(join_data &data) {
-  context_->parts.push_back(std::make_unique<internal::query_join_part>(*data.join_table));
+  context_->parts.push_back(std::make_unique<internal::query_join_table_part>(*data.join_table));
   context_->parts.push_back(std::make_unique<internal::query_on_part>(std::move(data.condition)));
   return {context_};
 }
 
 query_from_intermediate query_from_intermediate::join_left(std::vector<join_data> &data_vector) {
   for (auto &[join_table, condition] : data_vector) {
-    context_->parts.push_back(std::make_unique<internal::query_join_part>(*join_table));
+    context_->parts.push_back(std::make_unique<internal::query_join_table_part>(*join_table));
     context_->parts.push_back(std::make_unique<internal::query_on_part>(std::move(condition)));
   }
   return {context_};

source/orm/query/internal/query_parts.cpp

@@ -147,16 +147,29 @@ void query_from_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-query_join_part::query_join_part(class table tab)
+query_join_table_part::query_join_table_part(class table tab)
 : query_part(sql::dialect_token::Join)
 , table_(std::move(tab)) {
 }
 
-const table &query_join_part::table() const {
+const table &query_join_table_part::table() const {
   return table_;
 }
 
-void query_join_part::accept(query_part_visitor &visitor) {
+void query_join_table_part::accept(query_part_visitor &visitor) {
+  visitor.visit(*this);
+}
+
+query_join_query_part::query_join_query_part(fetchable_query q)
+: query_part(sql::dialect_token::Join)
+, query_(std::move(q))
+{}
+
+const fetchable_query &query_join_query_part::query() const {
+  return query_;
+}
+
+void query_join_query_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 

source/orm/query/internal/string_builder_utils.cpp

@@ -0,0 +1,40 @@
+#include "matador/query/internal/string_builder_utils.hpp"
+
+#include "matador/sql/dialect.hpp"
+
+namespace matador::query {
+void prepare_identifier_string_append(std::string& out, const std::string_view col, const sql::dialect &d) {
+  bool first_part = true;
+
+  const char sq = d.start_quote()[0];
+  const char eq = d.end_quote()[0];
+
+  std::size_t i = 0;
+  while (true) {
+    const std::size_t start = i;
+
+    // find end of part
+    while (i < col.size() && col[i] != '.') {
+      ++i;
+    }
+    const std::size_t end = i; // [start, end) is the part
+
+    if (!first_part) {
+      out.push_back('.');
+    }
+    first_part = false;
+
+    // quote_identifier(part) + escape_quotes_in_identifier(part), but streaming:
+    out.push_back(sq);
+    for (std::size_t j = start; j < end; ++j) {
+      const char c = col[j];
+      if (c == eq) out.push_back(eq); // escape " as ""
+      out.push_back(c);
+    }
+    out.push_back(eq);
+
+    if (i >= col.size()) break; // done
+    ++i; // skip '.'
+  }
+}
+}

source/orm/query/query.cpp

@@ -2,15 +2,6 @@
 
 namespace matador::query {
 
-table_column alias(const std::string &column, const std::string &as) {
-  return {column, as};
-}
-
-table_column alias(table_column &&col, const std::string &as) {
-  col.as(as);
-  return col;
-}
-
 table_column count(const std::string &column) {
   return {sql::sql_function_t::Count, column};
 }
@@ -18,6 +9,18 @@ table_column count(const std::string &column) {
 table_column count_all() {
   return count("*");
 }
+table_column sum(const std::string& column) {
+  return {sql::sql_function_t::Sum, column};
+}
+table_column avg(const std::string& column) {
+  return {sql::sql_function_t::Avg, column};
+}
+table_column maximum(const std::string& column) {
+  return {sql::sql_function_t::Max, column};
+}
+table_column minimum(const std::string& column) {
+  return {sql::sql_function_t::Min, column};
+}
 
 query_create_intermediate query::create()
 {

source/orm/query/query_builder.cpp

@@ -15,6 +15,10 @@ void criteria_transformer::visit( const binary_criteria& node ) {
 
 void criteria_transformer::visit( const binary_column_criteria& /*node*/ ) {}
 
+void criteria_transformer::visit(const check_null_criteria& node) {
+  update_criteria_column(node);
+}
+
 void criteria_transformer::visit( const collection_criteria& node ) {
   update_criteria_column(node);
 }

source/orm/query/query_compiler.cpp

@@ -8,14 +8,13 @@
 #include "matador/query/table_column.hpp"
 
 #include "matador/query/internal/basic_type_to_string_visitor.hpp"
+#include "matador/query/internal/string_builder_utils.hpp"
 #include "matador/query/internal/query_parts.hpp"
 
 #include "matador/sql/query_context.hpp"
 #include "matador/sql/connection.hpp"
 #include "matador/sql/dialect.hpp"
 
-#include "matador/utils/string.hpp"
-
 namespace matador::query {
 
 sql::query_context query_compiler::compile(const query_data &data,
@@ -39,10 +38,10 @@ sql::query_context query_compiler::compile(const query_data &data,
 
 std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const query_data &data, const table_column &col) {
   if (col.is_function()) {
-    ctx.prototype.emplace_back(col.has_alias() ? col.alias() : col.canonical_name());
+    ctx.prototype.emplace_back(col.name());
     ctx.prototype.back().change_type(utils::basic_type::Int32);
   } else {
-    ctx.prototype.emplace_back(col.canonical_name());
+    ctx.prototype.emplace_back(col.name());
   }
 
 
@@ -69,54 +68,23 @@ void query_compiler::visit(internal::query_add_key_constraint_part& part) {
   query_.sql += " " + dialect_->add_constraint() + " " + part.name();
 }
 
+void build_columns(std::string &out, const std::vector<table_column> &cols, const sql::dialect &d);
+
 void query_compiler::visit(internal::query_add_foreign_key_constraint_part& part) {
   query_.sql += " " + dialect_->token_at(part.token()) + " (";
-
-  if (part.columns().size() < 2) {
-    for (const auto &col: part.columns()) {
-      query_.sql += dialect_->prepare_identifier_string(col.name());
-    }
-  } else {
-    auto it = part.columns().begin();
-    query_.sql += dialect_->prepare_identifier_string(it->name());
-    for (; it != part.columns().end(); ++it) {
-        query_.sql += ", " + dialect_->prepare_identifier_string(it->name());
-    }
-  }
+  build_columns(query_.sql, part.columns(), *dialect_);
   query_.sql += ")";
 }
 
 void query_compiler::visit(internal::query_add_primary_key_constraint_part& part) {
   query_.sql += " " + dialect_->primary_key() + " (";
-
-    if (part.columns().size() < 2) {
-        for (const auto &col: part.columns()) {
-            query_.sql += dialect_->prepare_identifier_string(col.name());
-        }
-    } else {
-        auto it = part.columns().begin();
-        query_.sql += dialect_->prepare_identifier_string(it->name());
-        for (; it != part.columns().end(); ++it) {
-            query_.sql += ", " + dialect_->prepare_identifier_string(it->name());
-        }
-    }
+  build_columns(query_.sql, part.columns(), *dialect_);
   query_.sql += ")";
 }
 
 void query_compiler::visit(internal::query_add_foreign_key_reference_part& part) {
   query_.sql += " " + dialect_->token_at(part.token()) + " " + part.table().name() + " (";
-
-  if (part.columns().size() < 2) {
-    for (const auto &col: part.columns()) {
-      query_.sql += dialect_->prepare_identifier_string(col.name());
-    }
-  } else {
-    auto it = part.columns().begin();
-    query_.sql += dialect_->prepare_identifier_string(it->name());
-    for (; it != part.columns().end(); ++it) {
-      query_.sql += ", " + dialect_->prepare_identifier_string(it->name());
-    }
-  }
+  build_columns(query_.sql, part.columns(), *dialect_);
   query_.sql += ")";
 }
 
@@ -174,10 +142,14 @@ void query_compiler::visit(internal::query_from_part &part) {
   }
 }
 
-void query_compiler::visit(internal::query_join_part &part) {
+void query_compiler::visit(internal::query_join_table_part &part) {
   query_.sql += " " + build_table_name(part.token(), *dialect_, part.table());
 }
 
+void query_compiler::visit(internal::query_join_query_part &part) {
+  query_.sql += " " + dialect_->join() + " (" + part.query().str(*dialect_) + ")";
+}
+
 void query_compiler::visit(internal::query_on_part &part) {
   criteria_evaluator evaluator(*dialect_, query_);
   query_.sql += " " + dialect_->on() +
@@ -194,7 +166,7 @@ void query_compiler::visit(internal::query_group_by_part &part) {
   query_.sql += " " + dialect_->group_by() + " ";
   if (part.columns().size() < 2) {
     for (const auto &col: part.columns()) {
-      query_.sql.append(dialect_->prepare_identifier_string(col.canonical_name()));
+      query_.sql.append(dialect_->prepare_identifier_string(col.name()));
     }
   } else {
     auto it = part.columns().begin();
@@ -246,23 +218,10 @@ void query_compiler::visit(internal::query_insert_part &/*insert_part*/) {
 void query_compiler::visit(internal::query_into_part &part) {
   query_.table_name = part.table().name();
   query_.sql += " " + dialect_->into() +
-                " " + dialect_->prepare_identifier_string(part.table().name());
+                " " + dialect_->prepare_identifier_string(part.table().name()) + " (";
 
-  std::string result{"("};
-  if (part.columns().size() < 2) {
-    for (const auto &col: part.columns()) {
-      result.append(dialect_->prepare_identifier_string(col.name()));
-    }
-  } else {
-    auto it = part.columns().begin();
-    result.append(dialect_->prepare_identifier_string((it++)->name()));
-    for (; it != part.columns().end(); ++it) {
-      result.append(", ");
-      result.append(dialect_->prepare_identifier_string(it->name()));
-    }
-  }
-  result += (")");
-  query_.sql += " " + result;
+  build_columns(query_.sql, part.columns(), *dialect_);
+  query_.sql += ")"/* + result*/;
 }
 
 struct value_visitor {
@@ -337,7 +296,7 @@ void query_compiler::visit(internal::query_create_part &/*create_part*/)
   query_.sql = dialect_->create();
 }
 
-std::string build_create_column(const table_column &col, const sql::dialect &d);
+void build_create_column(std::string &out, const table_column &col, const sql::dialect &d);
 std::string build_constraint(const table_constraint &cons, const sql::dialect &d);
 
 void query_compiler::visit(internal::query_create_table_part &part)
@@ -349,22 +308,14 @@ void query_compiler::visit(internal::query_create_table_part &part)
 }
 
 void query_compiler::visit(internal::query_create_table_columns_part& part) {
-  std::string result;
-
-  if (part.columns().size() < 2) {
-    for (const auto &col: part.columns()) {
-      result.append(build_create_column(col, *dialect_));
+  bool first = true;
+  for (const auto& col : part.columns()) {
+    if (!first) {
+      query_.sql.append(", ");
     }
-  } else {
-    auto it = part.columns().begin();
-    result.append(build_create_column(*it++, *dialect_));
-    for (; it != part.columns().end(); ++it) {
-      result.append(", ");
-      result.append(build_create_column(*it, *dialect_));
+    build_create_column(query_.sql, col, *dialect_);
+    first = false;
   }
-  }
-
-  query_.sql += result;
 }
 
 void query_compiler::visit(internal::query_create_table_constraints_part& part) {
@@ -421,22 +372,31 @@ void query_compiler::visit(internal::query_drop_table_part &part) {
   query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name);
 }
 
-std::string build_create_column(const table_column &col, const sql::dialect &d) {
-  std::string result = d.prepare_identifier_string(col.name()) + " " + d.data_type_at(col.type());
+void build_create_column(std::string &out, const table_column &col, const sql::dialect &d) {
+  prepare_identifier_string_append(out, col.canonical_name(), d);
+  out += " " + d.data_type_at(col.type());
   if (col.attributes().size() > 0) {
-    result.append("(" + std::to_string(col.attributes().size()) + ")");
+    out.append("(" + std::to_string(col.attributes().size()) + ")");
   }
   if (!col.is_nullable()) {
-    result.append(" ").append(d.not_null());
+    out.append(" ").append(d.not_null());
   }
   if (is_constraint_set(col.attributes().options(), utils::constraints::Unique)) {
-    result.append(" ").append(d.unique());
+    out.append(" ").append(d.unique());
   }
   if (is_constraint_set(col.attributes().options(), utils::constraints::PrimaryKey)) {
-    result.append(" ").append(d.primary_key());
+    out.append(" ").append(d.primary_key());
+  }
+}
+void build_columns(std::string &out, const std::vector<table_column> &cols,  const sql::dialect &d) {
+  bool first = true;
+  for (const auto& col : cols) {
+    if (!first) {
+      out.append(", ");
+    }
+    prepare_identifier_string_append(out, col.name(), d);
+    first = false;
   }
-
-  return result;
 }
 
 std::string build_constraint(const table_constraint& cons, const sql::dialect& d) {

source/orm/query/query_utils.cpp

@@ -1,31 +1,23 @@
 #include "matador/query/query_utils.hpp"
 
 #include "matador/query/table.hpp"
+#include "matador/query/internal/string_builder_utils.hpp"
 
 namespace matador::query {
 std::string prepare_identifier(const sql::dialect& d, const table_column& col) {
   std::string result;
   if (!col.is_function()) {
-    if (col.table()) {
-      result = d.prepare_identifier_string(col.table()->name()) + ".";
-    }
-    result += d.prepare_identifier_string(col.name());
+    prepare_identifier_string_append(result, col.name(), d);
   } else {
     result = d.sql_function_at(col.function()) + "(" + col.name() + ")";
   }
-  if (!col.alias().empty()) {
-    result += " AS " + col.alias();
-  }
   return result;
 }
 
 std::string prepare_criteria(const sql::dialect& d, const table_column& col) {
   std::string result;
   if (!col.is_function()) {
-    if (col.table()) {
-      result = d.prepare_identifier_string(col.table()->name()) + ".";
-    }
-    result += d.prepare_identifier_string(col.name());
+    prepare_identifier_string_append(result, col.name(), d);
   } else {
     result = d.sql_function_at(col.function()) + "(" + col.name() + ")";
   }

source/orm/query/table.cpp

@@ -91,7 +91,7 @@ const table_column* table::operator[](const std::string &column_name) const {
 
 const table_column * table::column_by_name(const table &tab, const std::string &column_name) {
   for (const auto &col : tab.columns_) {
-    if (col.name() == column_name) {
+    if (col.column_name() == column_name) {
       return &col;
     }
   }

source/orm/query/table_column.cpp

@@ -25,42 +25,39 @@ table_column::table_column(const char *name)
 : table_column(std::string(name))
 {}
 
-table_column::table_column(std::string name)
-: name_(std::move(name)) {}
-table_column::table_column(std::string name, std::string alias)
-: name_(std::move(name))
-, alias_(std::move(alias)) {}
+table_column::table_column(const std::string& name)
+: table_column(name, name) {}
 
-table_column::table_column(const sql::sql_function_t func, std::string name)
-: name_(std::move(name))
-, function_(func) {}
+table_column::table_column(const std::string& name, const std::string& alias)
+: table_column(nullptr, name, alias, utils::basic_type::Unknown, {}, sql::sql_function_t::None)
+{}
 
-table_column::table_column(const class table* tab, std::string name)
-: table_(tab)
-, name_(std::move(name)) {}
+table_column::table_column(const sql::sql_function_t func, const std::string& name)
+: table_column(nullptr, name, name, utils::basic_type::Unknown, {}, func)
+{}
+
+table_column::table_column(const class table* tab, const std::string& name)
+: table_column(tab, name, name, utils::basic_type::Unknown, {}, sql::sql_function_t::None)
+{}
+
+table_column::table_column(const class table* tab, const std::string& name, const std::string& alias)
+: table_column(tab, name, alias, utils::basic_type::Unknown, {}, sql::sql_function_t::None)
+{}
+
+table_column::table_column(const class table* tab, const std::string& name, const utils::basic_type type, const utils::field_attributes& attributes)
+: table_column(tab, name, name, type, attributes, sql::sql_function_t::None)
+{}
 
-table_column::table_column(const class table* tab, std::string name, std::string alias)
-: table_(tab)
-, name_(std::move(name))
-, alias_(std::move(alias)) {}
 table_column::table_column(const class table* tab,
-               std::string name,
+                           const std::string& name,
+                           const std::string& alias,
                            const utils::basic_type type,
-               const utils::field_attributes& attributes)
-: table_(tab)
-, name_(std::move(name))
-, type_(type)
-, attributes_(attributes) {}
-
-table_column::table_column(const class table* tab,
-               std::string name,
-               std::string alias,
-               utils::basic_type type,
                            const utils::field_attributes &attributes,
                            const sql::sql_function_t func)
 : table_(tab)
-, name_(std::move(name))
-, alias_(std::move(alias))
+, name_(build_column_name(table_, name))
+, column_name_(name)
+, alias_(alias)
 , type_(type)
 , attributes_(attributes)
 , function_(func) {}
@@ -71,6 +68,7 @@ table_column & table_column::operator=(const table_column &other) {
   }
   table_ = other.table_;
   name_ = other.name_;
+  column_name_ = other.column_name_;
   alias_ = other.alias_;
   type_ = other.type_;
   attributes_ = other.attributes_;
@@ -82,6 +80,7 @@ bool table_column::equals(const table_column &x) const {
   if (table_ != nullptr && x.table_ != nullptr) {
     return *table_ == *x.table_ &&
            name_ == x.name_ &&
+           column_name_ == x.column_name_ &&
            alias_ == x.alias_ &&
            function_ == x.function_;
   }
@@ -91,17 +90,20 @@ bool table_column::equals(const table_column &x) const {
        function_ == x.function_;
 }
 
-table_column table_column::as(std::string a) {
-  alias_ = std::move(a);
-  return {table_, name_, alias_, type_, attributes_, function_};
+table_column table_column::as(const std::string& alias) const {
+  return {table_, column_name_, alias, type_, attributes_, function_};
 }
 
 const std::string& table_column::name() const {
-  return name_;
+  return has_alias() ? alias_ : name_;
 }
 
-std::string table_column::canonical_name() const {
-  return table_ ? table_->name() + "." + name_ : name_;
+const std::string& table_column::column_name() const {
+  return column_name_;
+}
+
+const std::string& table_column::canonical_name() const {
+  return name_;
 }
 
 const std::string& table_column::alias() const {
@@ -129,7 +131,7 @@ sql::sql_function_t table_column::function() const {
 }
 
 bool table_column::has_alias() const {
-  return !alias_.empty();
+  return alias_ != column_name_;
 }
 
 const class table* table_column::table() const {
@@ -138,9 +140,14 @@ const class table* table_column::table() const {
 
 void table_column::table(const query::table* tab) {
   table_ = tab;
+  name_ = build_column_name(table_, column_name_);
 }
 
 table_column::operator const std::string&() const {
-  return name_;
+  return name();
 }
+
+std::string table_column::build_column_name(const class query::table* tab, const std::string& name) {
+  return tab ? tab->name() + "." + name : name;
 }
+}  // namespace matador::query

source/orm/sql/dialect.cpp

@@ -18,16 +18,6 @@ const std::string &dialect::sql_function_at(const sql_function_t func) const {
   return sql_func_map_.at(func);
 }
 
-std::string dialect::table_name(const std::string &table, const std::string &schema_name) const {
-  if (schema_name.empty() && default_schema_name_.empty()) {
-    return prepare_identifier_string(table);
-  }
-  if (schema_name.empty()) {
-    return prepare_identifier_string(default_schema_name_) + "." + prepare_identifier_string(table);
-  }
-  return prepare_identifier_string(schema_name) + "." + prepare_identifier_string(table);
-}
-
 const std::string &dialect::to_string(const bool val) const {
   return bool_strings_[static_cast<int>(val)];
 }
@@ -89,7 +79,7 @@ dialect::escape_identifier_t dialect::identifier_escape_type() const {
   return identifier_escape_type_;
 }
 
-void dialect::identifier_escape_type(escape_identifier_t escape_identifier) {
+void dialect::identifier_escape_type(const escape_identifier_t escape_identifier) {
   identifier_escape_type_ = escape_identifier;
 }
 
@@ -221,6 +211,14 @@ const std::string &dialect::into() const {
   return token_at(dialect_token::Into);
 }
 
+const std::string &dialect::is_null() const {
+  return token_at(dialect_token::IsNull);
+}
+
+const std::string &dialect::is_not_null() const {
+  return token_at(dialect_token::IsNotNull);
+}
+
 const std::string &dialect::join() const {
   return token_at(dialect_token::Join);
 }

test/models/model_metas.hpp

@@ -15,5 +15,7 @@ META_TABLE(departments, DEPARTMENT, id, name)
 META_TABLE(employees, EMPLOYEE, id, first_name, last_name, dep_id)
 META_TABLE(authors, AUTHOR, id, first_name, last_name, date_of_birth, year_of_birth, distinguished)
 META_TABLE(books, BOOK, id, title, author_id, published_in)
+META_TABLE(orders, ORDER, order_id, order_date, required_date, shipped_date, ship_via, freight, ship_name, ship_address, ship_city, ship_region, ship_postal_code, ship_country)
+META_TABLE(courses, COURSE, id, title)
 
 #endif //MATADOR_MODEL_METAS_HPP

test/orm/orm/SessionQueryBuilderTest.cpp

@@ -24,12 +24,14 @@
 #include "../../models/recipe.hpp"
 #include "../../models/order.hpp"
 #include "../../models/student.hpp"
+#include "../../models/model_metas.hpp"
 
 using namespace matador::object;
 using namespace matador::query;
 using namespace matador::utils;
 using namespace matador::sql;
 using namespace matador::test;
+  using namespace matador::query::meta;
 
 TEST_CASE("Create sql query data for entity with eager has one", "[query][entity][builder]") {
   using namespace matador::test;
@@ -46,7 +48,7 @@ TEST_CASE("Create sql query data for entity with eager has one", "[query][entity
 
   const auto it = scm.find(typeid(flight));
   REQUIRE(it != scm.end());
-  const auto* col = it->second.table()["id"];
+  const auto* col = it->second.table()[FLIGHT.id];
   REQUIRE(col);
   auto data = eqb.build<flight>(*col == _);
 
@@ -100,7 +102,7 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent
 
   const auto it = scm.find(typeid(book));
   REQUIRE(it != scm.end());
-  const auto* col = it->second.table()["id"];
+  const auto* col = it->second.table()[BOOK.id];
   REQUIRE(col);
   auto data = eqb.build<book>(*col == _);
 
@@ -172,7 +174,7 @@ TEST_CASE("Create sql query data for entity with eager has many belongs to", "[q
 
   const auto it = scm.find(typeid(order));
   REQUIRE(it != scm.end());
-  const auto* col = it->second.table()["order_id"];
+  const auto* col = it->second.table()[ORDER.order_id];
   REQUIRE(col);
   auto data = eqb.build<order>(*col == _);
 
@@ -236,7 +238,7 @@ TEST_CASE("Create sql query data for entity with eager many to many", "[query][e
 
   const auto it = scm.find(typeid(ingredient));
   REQUIRE(it != scm.end());
-  const auto* col = it->second.table()["id"];
+  const auto* col = it->second.table()[INGREDIENT.id];
   REQUIRE(col);
   auto data = eqb.build<ingredient>(*col == _);
 
@@ -290,7 +292,7 @@ TEST_CASE("Create sql query data for entity with eager many to many (inverse par
 
   const auto it = scm.find(typeid(course));
   REQUIRE(it != scm.end());
-  const auto* col = it->second.table()["id"];
+  const auto* col = it->second.table()[COURSE.id];
   REQUIRE(col);
   auto data = eqb.build<course>(*col == _);
 

test/orm/query/ColumnGeneratorTest.cpp

@@ -47,7 +47,7 @@ TEST_CASE("Generate columns from object", "[column][generator]") {
   REQUIRE(columns.size() == expected_columns.size());
 
   for (size_t i = 0; i != expected_columns.size(); ++i) {
-    REQUIRE(expected_columns[i] == columns[i].name());
+    REQUIRE(expected_columns[i] == columns[i].column_name());
   }
 }
 

test/orm/query/CriteriaTests.cpp

@@ -2,9 +2,9 @@
 
 #include "matador/query/criteria.hpp"
 #include "matador/query/criteria_evaluator.hpp"
+#include "matador/query/query.hpp"
 
 #include "matador/sql/dialect_builder.hpp"
-#include "matador/sql/query_context.hpp"
 
 #include "matador/utils/placeholder.hpp"
 
@@ -79,7 +79,9 @@ TEST_CASE_METHOD(CriteriaFixture, "Test in query criteria", "[criteria][in query
   query_context sub_ctx;
   sub_ctx.sql = R"(SELECT "name" FROM "test")";
 
-  auto clause = age_col != 7 && in(name_col,  std::move(sub_ctx));
+  auto q = query::select({name_col}).from("test");
+
+  auto clause = age_col != 7 && in(name_col, std::move(q));
 }
 TEST_CASE_METHOD(CriteriaFixture, "Test out criteria", "[criteria][out]") {
   const auto age_col = "age"_col;
@@ -88,12 +90,12 @@ TEST_CASE_METHOD(CriteriaFixture, "Test out criteria", "[criteria][out]") {
   criteria_evaluator evaluator(dlc, ctx);
   auto str = evaluator.evaluate(*clause);
 
-  REQUIRE(str == "(\"age\" <> 7 AND \"age\" NOT IN (7, 5, 5, 8))");
+  REQUIRE(str == R"(("age" <> 7 AND "age" NOT IN (7, 5, 5, 8)))");
 
   clause = age_col != 7 && out(age_col,  {_, _, _});
   str = evaluator.evaluate(*clause);
 
-  REQUIRE(str == "(\"age\" <> 7 AND \"age\" NOT IN (?, ?, ?))");
+  REQUIRE(str == R"(("age" <> 7 AND "age" NOT IN (?, ?, ?)))");
 }
 
 TEST_CASE_METHOD(CriteriaFixture, "Test between criteria", "[criteria][between]") {
@@ -103,12 +105,12 @@ TEST_CASE_METHOD(CriteriaFixture, "Test between criteria", "[criteria][between]"
   criteria_evaluator evaluator(dlc, ctx);
   auto str = evaluator.evaluate(*clause);
 
-  REQUIRE(str == "(\"age\" <> 7 OR \"age\" BETWEEN 21 AND 30)");
+  REQUIRE(str == R"(("age" <> 7 OR "age" BETWEEN 21 AND 30))");
 
   clause = age_col != 7 || between(age_col, _, _);
   str = evaluator.evaluate(*clause);
 
-  REQUIRE(str == "(\"age\" <> 7 OR \"age\" BETWEEN ? AND ?)");
+  REQUIRE(str == R"(("age" <> 7 OR "age" BETWEEN ? AND ?))");
 }
 
 TEST_CASE_METHOD(CriteriaFixture, "Test like criteria", "[criteria][like]") {

test/orm/query/SchemaTest.cpp

@@ -7,7 +7,7 @@
 using namespace matador::query;
 using namespace matador::test;
 
-TEST_CASE("Test schema with belongs-to to has-many relation" "[schema][relation][belongs_to]") {
+TEST_CASE("Test schema with belongs-to to has-many relation" "[schema][relation][belongsto]") {
   schema repo;
   auto result = repo.attach<package>("packages")
     .and_then( [&repo] { return repo.attach<shipment>("shipments"); } );