removed condition classes, functions and operators

source/orm/CMakeLists.txt

@@ -5,7 +5,6 @@ add_library(matador-orm STATIC
   ../../include/matador/orm/session_insert_builder.hpp
   ../../include/matador/orm/session_query_builder.hpp
   ../../include/matador/query/attribute_string_writer.hpp
-  ../../include/matador/query/basic_condition.hpp
   ../../include/matador/query/criteria/abstract_criteria.hpp
   ../../include/matador/query/criteria/between_criteria.hpp
   ../../include/matador/query/criteria/collection_criteria.hpp
@@ -14,7 +13,6 @@ add_library(matador-orm STATIC
   ../../include/matador/query/criteria/criteria_visitor.hpp
   ../../include/matador/query/criteria/like_criteria.hpp
   ../../include/matador/query/criteria/logical_criteria.hpp
-  ../../include/matador/query/condition.hpp
   ../../include/matador/query/fk_value_extractor.hpp
   ../../include/matador/query/intermediates/executable_query.hpp
   ../../include/matador/query/intermediates/fetchable_query.hpp
@@ -85,7 +83,6 @@ add_library(matador-orm STATIC
   orm/session_insert_builder.cpp
   orm/session_query_builder.cpp
   query/attribute_string_writer.cpp
-  query/basic_condition.cpp
   query/criteria/between_criteria.cpp
   query/criteria/binary_criteria.cpp
   query/criteria/collection_criteria.cpp
@@ -93,7 +90,6 @@ add_library(matador-orm STATIC
   query/criteria/like_criteria.cpp
   query/criteria/logical_criteria.cpp
   query/criteria/not_criteria.cpp
-  query/condition.cpp
   query/intermediates/executable_query.cpp
   query/intermediates/fetchable_query.cpp
   query/intermediates/query_create_intermediate.cpp

source/orm/orm/session.cpp

@@ -1,10 +1,10 @@
 #include "matador/orm/session.hpp"
 
 #include "matador/sql/backend_provider.hpp"
+#include "matador/sql/dialect.hpp"
 
 #include "matador/query/query.hpp"
 
-#include <queue>
 #include <stdexcept>
 
 namespace matador::orm {

source/orm/orm/session_query_builder.cpp

@@ -30,7 +30,7 @@ void session_query_builder::append_join(const sql::column &left, const sql::colu
   using namespace matador::query;
   entity_query_data_.joins.push_back({
     {right.table_},
-    make_condition(left == right)
+    left == right
   });
 }
 }

source/orm/query/criteria/between_criteria.cpp

@@ -23,11 +23,11 @@ const sql::column & between_criteria::column() const {
   return column_;
 }
 
-const criteria_value &between_criteria::min() const {
+const criteria_value &between_criteria::minimum() const {
   return min_;
 }
 
-const criteria_value &between_criteria::max() const {
+const criteria_value &between_criteria::maximum() const {
   return max_;
 }
 }

source/orm/query/criteria/binary_criteria.cpp

@@ -24,4 +24,25 @@ binary_operator binary_criteria::operand() const {
 const criteria_value& binary_criteria::value() const {
   return value_;
 }
+
+binary_column_criteria::binary_column_criteria( sql::column left_column, binary_operator operand, sql::column right_column )
+: left_column_(std::move(left_column))
+, operator_(operand)
+, right_column_(std::move(right_column)){}
+
+void binary_column_criteria::accept(criteria_visitor& visitor) const {
+  visitor.visit(*this);
+}
+
+const sql::column& binary_column_criteria::left_column() const {
+  return left_column_;
+}
+
+binary_operator binary_column_criteria::operand() const {
+  return operator_;
+}
+
+const sql::column& binary_column_criteria::right_column() const {
+  return right_column_;
+}
 }

source/orm/query/criteria/criteria_operators.cpp

@@ -6,6 +6,10 @@
 #include "matador/query/criteria/not_criteria.hpp"
 
 namespace matador::query {
+criteria_ptr operator==( const sql::column& col_left, const sql::column& col_right ) {
+  return std::make_unique<binary_column_criteria>(col_left, binary_operator::EQUALS, col_right);
+}
+
 criteria_ptr operator==(const sql::column &col, utils::placeholder p) {
   return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, p);
 }
@@ -49,11 +53,11 @@ criteria_ptr in(const sql::column &col, const std::initializer_list<utils::place
   for ( auto &&arg : args ) {
     values.emplace_back(arg);
   }
-  return std::make_unique<collection_criteria>(col, collection_operator::IN, std::move(values));
+  return std::make_unique<collection_criteria>(col, collection_operator::In, std::move(values));
 }
 
 criteria_ptr in(const sql::column &col, sql::query_context &&ctx) {
-  return std::make_unique<collection_query_criteria>(col, collection_operator::IN, std::move(ctx));
+  return std::make_unique<collection_query_criteria>(col, collection_operator::In, std::move(ctx));
 }
 
 template <>
@@ -62,11 +66,11 @@ criteria_ptr out(const sql::column &col, const std::initializer_list<utils::plac
   for ( auto &&arg : args ) {
     values.emplace_back(arg);
   }
-  return std::make_unique<collection_criteria>(col, collection_operator::OUT, values);
+  return std::make_unique<collection_criteria>(col, collection_operator::Out, values);
 }
 
 criteria_ptr out(const sql::column &col, sql::query_context &&ctx) {
-  return std::make_unique<collection_query_criteria>(col, collection_operator::IN, std::move(ctx));
+  return std::make_unique<collection_query_criteria>(col, collection_operator::In, std::move(ctx));
 }
 
 criteria_ptr between(const sql::column &col, const int64_t min, const int64_t max) {

source/orm/query/criteria_evaluator.cpp

@@ -41,9 +41,9 @@ void criteria_evaluator::visit(const between_criteria &node) {
   query_.bind_vars.emplace_back(node.column().name);
   query_.bind_vars.emplace_back(node.column().name);
   clause_ += dialect_.prepare_identifier(node.column()) + " " + dialect_.token_at(sql::dialect_token::Between) + " ";
-  evaluate_value(node.min());
+  evaluate_value(node.minimum());
   clause_ += " " + dialect_.token_at(sql::dialect_token::And) + " ";
-  evaluate_value(node.max());
+  evaluate_value(node.maximum());
 }
 
 template<class... Ts> struct overload : Ts... { using Ts::operator()...; };
@@ -55,6 +55,10 @@ void criteria_evaluator::visit(const binary_criteria &node) {
   evaluate_value(node.value());
 }
 
+void criteria_evaluator::visit( const binary_column_criteria& node ) {
+  clause_ += dialect_.prepare_condition(node.left_column()) + " " + detail::BinaryOperatorEnum.to_string(node.operand()) + " " + dialect_.prepare_condition(node.right_column());
+}
+
 void criteria_evaluator::visit(const collection_criteria &node) {
   const auto count = node.values().size();
   for (size_t i = 0; i < count; ++i) {
@@ -62,7 +66,7 @@ void criteria_evaluator::visit(const collection_criteria &node) {
   }
 
   clause_ += dialect_.prepare_identifier(node.column()) +
-      (node.operand() == collection_operator::OUT ? " " + dialect_.token_at(sql::dialect_token::Not) + " " : " ") +
+      (node.operand() == collection_operator::Out ? " " + dialect_.token_at(sql::dialect_token::Not) + " " : " ") +
       dialect_.token_at(sql::dialect_token::In) + " (";
   if (node.values().size() < 2) {
     for (const auto &val: node.values()) {
@@ -81,7 +85,7 @@ void criteria_evaluator::visit(const collection_criteria &node) {
 
 void criteria_evaluator::visit(const collection_query_criteria &node) {
   clause_ += dialect_.prepare_identifier(node.column()) +
-      (node.operand() == collection_operator::OUT ? " " + dialect_.token_at(sql::dialect_token::Not) + " " : " ") +
+      (node.operand() == collection_operator::Out ? " " + dialect_.token_at(sql::dialect_token::Not) + " " : " ") +
       dialect_.token_at(sql::dialect_token::In) + " (" +node.context().sql + ")";
 }
 

source/orm/query/intermediates/query_delete_from_intermediate.cpp

@@ -4,10 +4,12 @@
 
 namespace matador::query {
 
-query_execute_where_intermediate query_delete_from_intermediate::where_clause(std::unique_ptr<basic_condition> &&cond)
-{
+query_execute_where_intermediate query_delete_from_intermediate::where_clause(std::unique_ptr<abstract_criteria> &&cond) {
   context_->parts.push_back(std::make_unique<internal::query_where_part>(std::move(cond)));
   return {context_};
 }
 
+query_execute_where_intermediate query_delete_from_intermediate::where( std::unique_ptr<abstract_criteria> cond ) {
+    return where_clause(std::move(cond));
+}
 }

source/orm/query/intermediates/query_from_intermediate.cpp

@@ -8,44 +8,42 @@
 
 namespace matador::query {
 
-query_join_intermediate query_from_intermediate::join_left(const sql::table &t)
-{
+query_join_intermediate query_from_intermediate::join_left(const sql::table &t) {
   context_->parts.push_back(std::make_unique<internal::query_join_part>(t));
   return {context_};
 }
 
-query_from_intermediate query_from_intermediate::join_left(join_data &data)
-{
+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_on_part>(std::move(data.condition)));
   return {context_};
 }
 
-query_from_intermediate query_from_intermediate::join_left(std::vector<join_data> &data_vector)
-{
-  for (auto &data : data_vector) {
-    context_->parts.push_back(std::make_unique<internal::query_join_part>(*data.join_table));
-    context_->parts.push_back(std::make_unique<internal::query_on_part>(std::move(data.condition)));
+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_on_part>(std::move(condition)));
   }
   return {context_};
 }
 
-query_where_intermediate query_from_intermediate::where_clause(std::unique_ptr<basic_condition> &&cond)
-{
+query_where_intermediate query_from_intermediate::where( std::unique_ptr<abstract_criteria>&& cond ) {
+    return where_clause(std::move(cond));
+}
+
+query_where_intermediate query_from_intermediate::where_clause(std::unique_ptr<abstract_criteria> &&cond) {
   if (cond) {
     context_->parts.push_back(std::make_unique<internal::query_where_part>(std::move(cond)));
   }
   return {context_};
 }
 
-query_group_by_intermediate query_from_intermediate::group_by(const sql::column &col)
-{
+query_group_by_intermediate query_from_intermediate::group_by(const sql::column &col) {
   context_->parts.push_back(std::make_unique<internal::query_group_by_part>(col));
   return {context_};
 }
 
-query_order_by_intermediate query_from_intermediate::order_by(const sql::column &col)
-{
+query_order_by_intermediate query_from_intermediate::order_by(const sql::column &col) {
   context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
   return {context_};
 }

source/orm/query/intermediates/query_join_intermediate.cpp

@@ -4,8 +4,11 @@
 
 namespace matador::query {
 
-query_on_intermediate query_join_intermediate::on_clause(std::unique_ptr<basic_condition> &&cond)
-{
+query_on_intermediate query_join_intermediate::on( std::unique_ptr<abstract_criteria>&& cond ) {
+    return on_clause(std::move(cond));
+}
+
+query_on_intermediate query_join_intermediate::on_clause(std::unique_ptr<abstract_criteria> &&cond) {
   context_->parts.push_back(std::make_unique<internal::query_on_part>(std::move(cond)));
   return {context_};
 }

source/orm/query/intermediates/query_set_intermediate.cpp

@@ -4,7 +4,7 @@
 
 namespace matador::query {
 
-query_execute_where_intermediate query_set_intermediate::where_clause(std::unique_ptr<basic_condition> &&cond)
+query_execute_where_intermediate query_set_intermediate::where_clause(std::unique_ptr<abstract_criteria> &&cond)
 {
   context_->parts.push_back(std::make_unique<internal::query_where_part>(std::move(cond)));
   return {context_};

source/orm/query/internal/query_parts.cpp

@@ -46,11 +46,11 @@ void query_join_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
-query_on_part::query_on_part(std::unique_ptr<basic_condition> &&cond)
+query_on_part::query_on_part(std::unique_ptr<abstract_criteria> &&cond)
 : query_part(sql::dialect_token::On)
 , condition_(std::move(cond)) {}
 
-const basic_condition &query_on_part::condition() const
+const abstract_criteria &query_on_part::condition() const
 {
   return *condition_;
 }
@@ -60,7 +60,7 @@ void query_on_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
-query_where_part::query_where_part(std::unique_ptr<basic_condition> &&cond)
+query_where_part::query_where_part(std::unique_ptr<abstract_criteria> &&cond)
 : query_part(sql::dialect_token::Where)
 , condition_(std::move(cond)) {}
 
@@ -69,7 +69,7 @@ void query_where_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
-const basic_condition &query_where_part::condition() const
+const abstract_criteria &query_where_part::condition() const
 {
   return *condition_;
 }

source/orm/query/query_compiler.cpp

@@ -2,6 +2,7 @@
 
 #include "matador/query/attribute_string_writer.hpp"
 #include "matador/query/query_data.hpp"
+#include "matador/query/criteria_evaluator.hpp"
 
 #include "matador/query/internal/basic_type_to_string_visitor.hpp"
 #include "matador/query/internal/query_parts.hpp"
@@ -16,7 +17,7 @@ namespace matador::query {
 
 sql::query_context query_compiler::compile(const query_data &data,
                                       const sql::dialect &d,
-                                      std::optional<std::reference_wrapper<const sql::connection_impl>> conn)
+                                      const std::optional<std::reference_wrapper<const sql::connection_impl>> conn)
 {
   data_ = &data;
   dialect_ = &d;
@@ -86,20 +87,19 @@ void query_compiler::visit(internal::query_join_part &join_part)
   query_.sql += " " + query_compiler::build_table_name(join_part.token(), *dialect_, join_part.table());
 }
 
-void query_compiler::visit(internal::query_on_part &on_part)
-{
+void query_compiler::visit(internal::query_on_part &on_part) {
+  criteria_evaluator evaluator(*dialect_, query_);
   query_.sql += " " + dialect_->token_at(sql::dialect_token::On) +
-                " " + on_part.condition().evaluate(*dialect_, query_);
+                " " + evaluator.evaluate(on_part.condition());
 }
 
-void query_compiler::visit(internal::query_where_part &where_part)
-{
+void query_compiler::visit(internal::query_where_part &where_part) {
+  criteria_evaluator evaluator(*dialect_, query_);
   query_.sql += " " + dialect_->token_at(sql::dialect_token::Where) +
-                " " + where_part.condition().evaluate(*dialect_, query_);
+                " " + evaluator.evaluate(where_part.condition());
 }
 
-void query_compiler::visit(internal::query_group_by_part &group_by_part)
-{
+void query_compiler::visit(internal::query_group_by_part &group_by_part) {
   query_.sql += " " + dialect_->token_at(sql::dialect_token::GroupBy) + " " + dialect_->prepare_identifier(group_by_part.column());
 }