removed condition classes, functions and operators

include/matador/orm/session.hpp

@@ -4,7 +4,7 @@
 #include "matador/orm/error_code.hpp"
 #include "matador/orm/session_query_builder.hpp"
 
-#include "matador/query/condition.hpp"
+#include "matador/query/criteria.hpp"
 #include "matador/query/query.hpp"
 
 #include "matador/sql/column_generator.hpp"

include/matador/orm/session_insert_builder.hpp

@@ -3,7 +3,7 @@
 
 #include "matador/orm/query_builder_exception.hpp"
 
-#include "matador/query/condition.hpp"
+#include "matador/query/criteria.hpp"
 #include "matador/query/query_intermediates.hpp"
 
 #include "matador/object/repository.hpp"
@@ -14,8 +14,8 @@
 namespace matador::orm {
 struct entity_insert_data {
   sql::table table;
-  std::vector<std::string> columns;
-  std::vector<utils::database_type> values;
+  std::vector<std::string> columns{};
+  std::vector<utils::database_type> values{};
 };
 
 enum class insert_build_error : std::uint8_t {

include/matador/orm/session_query_builder.hpp

@@ -3,7 +3,7 @@
 
 #include "matador/orm/query_builder_exception.hpp"
 
-#include "matador/query/condition.hpp"
+#include "matador/query/criteria.hpp"
 #include "matador/query/query.hpp"
 
 #include "matador/sql/executor.hpp"
@@ -27,7 +27,7 @@ struct entity_query_data {
   std::vector<sql::column> columns{};
   std::unordered_map<std::string, sql::statement> lazy_loading_statements{};
   std::vector<query::join_data> joins{};
-  std::unique_ptr<query::basic_condition> where_clause{};
+  query::criteria_ptr where_clause;
 };
 
 class session_query_builder final {
@@ -87,8 +87,9 @@ public:
     }
     entity_query_data_.pk_column_name = id;
     if (!pk_.is_null()) {
-      auto c = sql::column{table_info_stack_.top().table, id, ""};
-      auto co = std::make_unique<query::condition<sql::column, utils::placeholder>>(c, query::basic_condition::operand_type::EQUAL, utils::_);
+      const auto c = sql::column{table_info_stack_.top().table, id, ""};
+      using namespace matador::query;
+      auto co = c == utils::_;
       entity_query_data_.where_clause = std::move(co);
     }
   }
@@ -240,13 +241,13 @@ private:
     std::shared_ptr<sql::table> table;
   };
 
-  std::stack<table_info> table_info_stack_;
-  std::unordered_map<std::string, std::shared_ptr<sql::table>> processed_tables_;
+  std::stack<table_info> table_info_stack_{};
+  std::unordered_map<std::string, std::shared_ptr<sql::table>> processed_tables_{};
   const object::repository &schema_;
-  entity_query_data entity_query_data_;
+  entity_query_data entity_query_data_{};
   unsigned int column_index{0};
   unsigned int table_index{0};
-  object::join_columns_collector join_columns_collector_;
+  object::join_columns_collector join_columns_collector_{};
   sql::executor &executor_;
 };
 

include/matador/query/criteria/between_criteria.hpp

@@ -19,8 +19,8 @@ public:
     void accept(criteria_visitor& visitor) const override;
 
     [[nodiscard]] const sql::column& column() const;
-    [[nodiscard]] const criteria_value &min() const;
-    [[nodiscard]] const criteria_value &max() const;
+    [[nodiscard]] const criteria_value &minimum() const;
+    [[nodiscard]] const criteria_value &maximum() const;
 
 private:
     sql::column column_;

include/matador/query/criteria/binary_criteria.hpp

@@ -32,5 +32,22 @@ private:
     binary_operator operator_{};
     criteria_value value_;
 };
+
+class binary_column_criteria final : public abstract_criteria {
+public:
+    binary_column_criteria() = delete;
+    binary_column_criteria(sql::column left_column, binary_operator operand, sql::column right_column);
+
+    void accept(criteria_visitor& visitor) const override;
+
+    [[nodiscard]] const sql::column& left_column() const;
+    [[nodiscard]] binary_operator operand() const;
+    [[nodiscard]] const sql::column& right_column() const;
+
+private:
+    sql::column left_column_;
+    binary_operator operator_{};
+    sql::column right_column_;
+};
 }
 #endif //CRITERIA_BINARY_CRITERIA_NODE_HPP

include/matador/query/criteria/collection_criteria.hpp

@@ -9,13 +9,33 @@
 
 namespace matador::query {
 enum class collection_operator {
-    IN,
-    OUT
+  In,
+  Out
 };
 
+/**
+ * @brief Criteria class representing an IN condition
+ *
+ * This class represents a query IN condition and evaluates to
+ * this condition based on the current database d
+ *
+ * @code
+ * WHERE age IN (29,34,56)
+ * @endcode
+ */
 class collection_criteria final : public abstract_criteria {
 public:
     collection_criteria() = delete;
+    /**
+     * @brief Creates an IN condition
+     *
+     * Creates an IN or OUT criteria for the given sql::column and
+     * the given list of arguments.
+     *
+     * @param col Column for the IN condition
+     * @param operand_ Operator to use
+     * @param values List of values
+     */
     collection_criteria(sql::column col, collection_operator operand_, std::vector<criteria_value> values);
     collection_criteria(sql::column col, collection_operator operand_, std::initializer_list<criteria_value> values);
 

include/matador/query/criteria/criteria_operators.hpp

@@ -19,6 +19,8 @@ criteria_ptr operator==(const sql::column &col, Type val) {
     return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, utils::value(val));
 }
 
+criteria_ptr operator==(const sql::column &col_left, const sql::column &col_right);
+
 template<class Type>
 criteria_ptr operator!=(const sql::column &col, Type val) {
     return std::make_unique<binary_criteria>(col, binary_operator::NOT_EQUALS, utils::value(val));
@@ -63,7 +65,7 @@ criteria_ptr in(const sql::column &col, std::initializer_list<Type> args) {
     for ( auto &&arg : args ) {
         values.emplace_back(utils::value{std::move(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));
 }
 
 template <>
@@ -77,7 +79,7 @@ criteria_ptr out(const sql::column &col, std::initializer_list<Type> args) {
     for ( auto &&arg : args ) {
         values.emplace_back(utils::value{std::move(arg)});
     }
-    return std::make_unique<collection_criteria>(col, collection_operator::OUT, values);
+    return std::make_unique<collection_criteria>(col, collection_operator::Out, values);
 }
 
 template <>

include/matador/query/criteria/criteria_visitor.hpp

@@ -4,6 +4,7 @@
 namespace matador::query {
 class between_criteria;
 class binary_criteria;
+class binary_column_criteria;
 class like_criteria;
 class logical_criteria;
 class not_criteria;
@@ -16,6 +17,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 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

@@ -22,6 +22,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 collection_criteria &node) override;
   void visit(const collection_query_criteria &node) override;
   void visit(const like_criteria &node) override;

include/matador/query/intermediates/query_delete_from_intermediate.hpp

@@ -3,7 +3,7 @@
 
 #include "matador/query/intermediates/executable_query.hpp"
 
-#include "matador/query/basic_condition.hpp"
+#include "matador/query/criteria/abstract_criteria.hpp"
 
 #include "matador/query/intermediates/query_execute_where_intermediate.hpp"
 
@@ -14,14 +14,10 @@ class query_delete_from_intermediate : public executable_query
 public:
   using executable_query::executable_query;
 
-  template<class Condition>
-  query_execute_where_intermediate where(const Condition &cond)
-  {
-    return where_clause(std::make_unique<Condition>(std::move(cond)));
-  }
+  query_execute_where_intermediate where(std::unique_ptr<abstract_criteria> cond);
 
 private:
-  query_execute_where_intermediate where_clause(std::unique_ptr<basic_condition> &&cond);
+  query_execute_where_intermediate where_clause(std::unique_ptr<abstract_criteria> &&cond);
 };
 
 }

include/matador/query/intermediates/query_from_intermediate.hpp

@@ -19,20 +19,17 @@ public:
   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)
-  {
-    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));
-  }
+  // 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<abstract_criteria> &&cond);
   query_group_by_intermediate group_by(const sql::column &col);
   query_order_by_intermediate order_by(const sql::column &col);
 
 private:
-  query_where_intermediate where_clause(std::unique_ptr<basic_condition> &&cond);
+  query_where_intermediate where_clause(std::unique_ptr<abstract_criteria> &&cond);
 };
 
 }

include/matador/query/intermediates/query_join_intermediate.hpp

@@ -13,18 +13,15 @@ class query_join_intermediate : public query_intermediate
 public:
   using query_intermediate::query_intermediate;
 
-  template<class Condition>
-  query_on_intermediate on(const Condition &cond)
-  {
-    return on_clause(std::make_unique<Condition>(std::move(cond)));
-  }
-  query_on_intermediate on(std::unique_ptr<basic_condition> &&cond)
-  {
-    return on_clause(std::move(cond));
-  }
+  // template<class Condition>
+  // query_on_intermediate on(const Condition &cond)
+  // {
+  //   return on_clause(std::make_unique<Condition>(std::move(cond)));
+  // }
+  query_on_intermediate on(std::unique_ptr<abstract_criteria> &&cond);
 
 private:
-  query_on_intermediate on_clause(std::unique_ptr<basic_condition> &&cond);
+  query_on_intermediate on_clause(std::unique_ptr<abstract_criteria> &&cond);
 };
 
 }

include/matador/query/intermediates/query_set_intermediate.hpp

@@ -3,7 +3,7 @@
 
 #include "matador/query/intermediates/executable_query.hpp"
 
-#include "matador/query/basic_condition.hpp"
+#include "matador/query/criteria/abstract_criteria.hpp"
 
 #include "matador/query/intermediates/query_execute_where_intermediate.hpp"
 
@@ -14,14 +14,12 @@ class query_set_intermediate : public executable_query
 public:
   using executable_query::executable_query;
 
-  template<class Condition>
-  query_execute_where_intermediate where(const Condition &cond)
-  {
-    return where_clause(std::make_unique<Condition>(std::move(cond)));
+  query_execute_where_intermediate where(std::unique_ptr<abstract_criteria> cond) {
+    return where_clause(std::move(cond));
   }
 
 private:
-  query_execute_where_intermediate where_clause(std::unique_ptr<basic_condition> &&cond);
+  query_execute_where_intermediate where_clause(std::unique_ptr<abstract_criteria> &&cond);
 };
 
 }

include/matador/query/internal/query_parts.hpp

@@ -2,7 +2,7 @@
 #define QUERY_QUERY_PARTS_HPP
 
 #include "matador/query/query_part_visitor.hpp"
-#include "matador/query/basic_condition.hpp"
+#include "matador/query/criteria.hpp"
 
 #include "matador/query/internal/key_value_pair.hpp"
 #include "matador/query/query_part.hpp"
@@ -70,15 +70,15 @@ public:
   explicit query_on_part(const Condition &cond)
     : query_part(sql::dialect_token::On)
     , condition_(new Condition(cond)) {}
-  explicit query_on_part(std::unique_ptr<basic_condition> &&cond);
+  explicit query_on_part(std::unique_ptr<abstract_criteria> &&cond);
 
-  [[nodiscard]] const basic_condition& condition() const;
+  [[nodiscard]] const abstract_criteria& condition() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
 
 private:
-  std::unique_ptr<basic_condition> condition_;
+  std::unique_ptr<abstract_criteria> condition_;
 };
 
 class query_where_part final : public query_part
@@ -88,15 +88,15 @@ public:
   explicit query_where_part(const Condition &cond)
   : query_part(sql::dialect_token::Where)
   , condition_(new Condition(cond)) {}
-  explicit query_where_part(std::unique_ptr<basic_condition> &&cond);
+  explicit query_where_part(std::unique_ptr<abstract_criteria> &&cond);
 
-  [[nodiscard]] const basic_condition& condition() const;
+  [[nodiscard]] const abstract_criteria& condition() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
 
 private:
-  std::unique_ptr<basic_condition> condition_;
+  std::unique_ptr<abstract_criteria> condition_;
 };
 
 class query_table_name_part : public query_part

include/matador/query/join_data.hpp

@@ -1,7 +1,7 @@
 #ifndef JOIN_DATA_HPP
 #define JOIN_DATA_HPP
 
-#include "matador/query/basic_condition.hpp"
+#include "matador/query/criteria/abstract_criteria.hpp"
 
 #include "matador/sql/table.hpp"
 
@@ -9,10 +9,9 @@
 
 namespace matador::query {
 
-struct join_data
-{
+struct join_data {
   std::shared_ptr<sql::table> join_table;
-  std::unique_ptr<basic_condition> condition;
+  std::unique_ptr<abstract_criteria> condition;
 };
 
 }

include/matador/query/query_compiler.hpp

@@ -26,8 +26,8 @@ class query_compiler final : public query_part_visitor
 {
 public:
   sql::query_context compile(const query_data &data,
-                        const sql::dialect &d,
-                        std::optional<std::reference_wrapper<const sql::connection_impl>> conn);
+                             const sql::dialect &d,
+                             std::optional<std::reference_wrapper<const sql::connection_impl>> conn);
 
 protected:
   void visit(internal::query_select_part &select_part) override;