added criteria_evaluator and extended all criteria classes with missing methods

include/matador/query/condition.hpp

@@ -420,7 +420,7 @@ condition<sql::column, std::initializer_list<V>> in(const sql::column &col, std:
  * @param q The query to be executes as sub select
  * @return The condition object
  */
-condition<sql::column, sql::query_context> in(const sql::column &col, sql::query_context &&q);
+condition<sql::column, sql::query_context> in_old(const sql::column &col, sql::query_context &&q);
 
 /**
  * @brief Creates a between condition.
@@ -450,7 +450,7 @@ condition<sql::column, std::pair<T, T>> between(const sql::column &col, T low, T
  * @param val The value to the like operator
  * @return The like condition object
  */
-condition<sql::column, std::string> like(const sql::column &col, const std::string &val);
+condition<sql::column, std::string> like_old(const sql::column &col, const std::string &val);
 
 /**
  * @brief Condition equality operator for a column and a value

include/matador/query/criteria/between_criteria.hpp

@@ -2,6 +2,7 @@
 #define CRITERIA_BETWEEN_CRITERIA_NODE_HPP
 
 #include "matador/query/criteria/abstract_criteria.hpp"
+#include "matador/query/criteria/criteria_utils.hpp"
 
 #include "matador/sql/column.hpp"
 
@@ -12,14 +13,19 @@ namespace matador::query {
 class between_criteria final : public abstract_criteria {
 public:
     between_criteria() = delete;
-    between_criteria(sql::column column, utils::value min, utils::value max);
+    between_criteria(sql::column column, int64_t min, int64_t max);
+    between_criteria(sql::column column, utils::placeholder min, utils::placeholder max);
 
     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;
+
 private:
     sql::column column_;
-    utils::value min_;
-    utils::value max_;
+    criteria_value min_;
+    criteria_value max_;
 };
 }
 #endif //CRITERIA_BETWEEN_CRITERIA_NODE_HPP

include/matador/query/criteria/binary_criteria.hpp

@@ -2,11 +2,10 @@
 #define CRITERIA_BINARY_CRITERIA_NODE_HPP
 
 #include "matador/query/criteria/abstract_criteria.hpp"
+#include "matador/query/criteria/criteria_utils.hpp"
 
 #include "matador/sql/column.hpp"
 
-#include "matador/utils/value.hpp"
-
 namespace matador::query {
 enum class binary_operator {
     EQUALS,
@@ -20,14 +19,18 @@ enum class binary_operator {
 class binary_criteria final : public abstract_criteria {
 public:
     binary_criteria() = delete;
-    binary_criteria( sql::column column, binary_operator operator_, utils::value value );
+    binary_criteria(sql::column column, binary_operator operand, criteria_value value);
 
     void accept( criteria_visitor& visitor ) const override;
 
+    [[nodiscard]] const sql::column& column() const;
+    [[nodiscard]] binary_operator operand() const;
+    [[nodiscard]] const criteria_value& value() const;
+
 private:
     sql::column column_;
     binary_operator operator_{};
-    utils::value value_;
+    criteria_value value_;
 };
 }
 #endif //CRITERIA_BINARY_CRITERIA_NODE_HPP

include/matador/query/criteria/collection_criteria.hpp

@@ -2,10 +2,10 @@
 #define CRITERIA_COLLECTION_CRITERIA_NODE_HPP
 
 #include "matador/query/criteria/abstract_criteria.hpp"
+#include "matador/query/criteria/criteria_utils.hpp"
 
 #include "matador/sql/column.hpp"
-
-#include "matador/utils/value.hpp"
+#include "matador/sql/query_context.hpp"
 
 namespace matador::query {
 enum class collection_operator {
@@ -16,14 +16,36 @@ enum class collection_operator {
 class collection_criteria final : public abstract_criteria {
 public:
     collection_criteria() = delete;
-    collection_criteria(sql::column col, collection_operator operator_, std::vector<utils::value> values);
-    collection_criteria(sql::column col, collection_operator operator_, std::initializer_list<utils::value> 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);
 
     void accept(criteria_visitor& visitor) const override;
+
+    [[nodiscard]] const sql::column& column() const;
+    [[nodiscard]] collection_operator operand() const;
+    [[nodiscard]] const std::vector<criteria_value>& values() const;
+
 private:
     sql::column column_;
-    collection_operator operator_;
-    std::vector<utils::value> values_;
+    collection_operator operand_;
+    std::vector<criteria_value> values_;
+};
+
+class collection_query_criteria final : public abstract_criteria {
+public:
+    collection_query_criteria() = delete;
+    collection_query_criteria(sql::column col, collection_operator operand_, sql::query_context ctx);
+
+    void accept(criteria_visitor& visitor) const override;
+
+    [[nodiscard]] const sql::column& column() const;
+    [[nodiscard]] collection_operator operand() const;
+    [[nodiscard]] const sql::query_context& context() const;
+
+private:
+    sql::column column_;
+    collection_operator operand_;
+    sql::query_context query_context_;
 };
 }
 #endif //CRITERIA_COLLECTION_CRITERIA_NODE_HPP

include/matador/query/criteria/criteria_operators.hpp

@@ -6,40 +6,51 @@
 
 #include "matador/sql/column.hpp"
 
+#include "matador/utils/placeholder.hpp"
 #include "matador/utils/value.hpp"
 
+namespace matador::sql {
+struct query_context;
+}
 namespace matador::query {
 
 template<class Type>
 criteria_ptr operator==(const sql::column &col, Type val) {
-    return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, val);
+    return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, utils::value(val));
 }
 
 template<class Type>
 criteria_ptr operator!=(const sql::column &col, Type val) {
-    return std::make_unique<binary_criteria>(col, binary_operator::NOT_EQUALS, val);
+    return std::make_unique<binary_criteria>(col, binary_operator::NOT_EQUALS, utils::value(val));
 }
 
 template<class Type>
 criteria_ptr operator>(const sql::column &col, Type val) {
-    return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN, val);
+    return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN, utils::value(val));
 }
 
 template<class Type>
 criteria_ptr operator>=(const sql::column &col, Type val) {
-    return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN_OR_EQUAL, val);
+    return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN_OR_EQUAL, utils::value(val));
 }
 
 template<class Type>
 criteria_ptr operator<(const sql::column &col, Type val) {
-    return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN, val);
+    return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN, utils::value(val));
 }
 
 template<class Type>
 criteria_ptr operator<=(const sql::column &col, Type val) {
-    return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN_OR_EQUAL, val);
+    return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN_OR_EQUAL, utils::value(val));
 }
 
+criteria_ptr operator==(const sql::column &col, utils::placeholder p);
+criteria_ptr operator!=(const sql::column &col, utils::placeholder p);
+criteria_ptr operator>(const sql::column &col, utils::placeholder p);
+criteria_ptr operator>=(const sql::column &col, utils::placeholder p);
+criteria_ptr operator<(const sql::column &col, utils::placeholder p);
+criteria_ptr operator<=(const sql::column &col, utils::placeholder p);
+
 criteria_ptr operator&&(criteria_ptr left, criteria_ptr right);
 
 criteria_ptr operator||(criteria_ptr left, criteria_ptr right);
@@ -48,23 +59,34 @@ criteria_ptr operator!(criteria_ptr clause);
 
 template < class Type >
 criteria_ptr in(const sql::column &col, std::initializer_list<Type> args) {
-    std::vector<utils::value> values;
+    std::vector<criteria_value> values;
     for ( auto &&arg : args ) {
-        values.emplace_back(std::move(arg));
+        values.emplace_back(utils::value{std::move(arg)});
     }
     return std::make_unique<collection_criteria>(col, collection_operator::IN, std::move(values));
 }
 
-template < class V >
-criteria_ptr out(const sql::column &col, std::initializer_list<V> args) {
-    std::vector<utils::value> values;
+template <>
+criteria_ptr in(const sql::column &col, std::initializer_list<utils::placeholder> args);
+
+criteria_ptr in(const sql::column &col, sql::query_context &&ctx);
+
+template < class Type >
+criteria_ptr out(const sql::column &col, std::initializer_list<Type> args) {
+    std::vector<criteria_value> values;
     for ( auto &&arg : args ) {
-        values.emplace_back(std::move(arg));
+        values.emplace_back(utils::value{std::move(arg)});
     }
     return std::make_unique<collection_criteria>(col, collection_operator::OUT, values);
 }
 
-criteria_ptr between(const sql::column &col, utils::value min, utils::value max);
+template <>
+criteria_ptr out(const sql::column &col, std::initializer_list<utils::placeholder> args);
+
+criteria_ptr out(const sql::column &col, sql::query_context &&ctx);
+
+criteria_ptr between(const sql::column &col, int64_t min, int64_t max);
+criteria_ptr between(const sql::column &col, utils::placeholder min, utils::placeholder max);
 
 criteria_ptr like(const sql::column &col, const std::string &pattern);
 

include/matador/query/criteria/criteria_utils.hpp

@@ -0,0 +1,11 @@
+#ifndef MATADOR_CRITERIA_UTILS_HPP
+#define MATADOR_CRITERIA_UTILS_HPP
+
+#include "matador/utils/placeholder.hpp"
+#include "matador/utils/value.hpp"
+
+namespace matador::query {
+using criteria_value = std::variant<utils::placeholder, utils::value>;
+}
+
+#endif //MATADOR_CRITERIA_UTILS_HPP

include/matador/query/criteria/criteria_visitor.hpp

@@ -8,6 +8,7 @@ class like_criteria;
 class logical_criteria;
 class not_criteria;
 class collection_criteria;
+class collection_query_criteria;
 
 class criteria_visitor {
 public:
@@ -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 collection_criteria &node) = 0;
+    virtual void visit(const collection_query_criteria &node) = 0;
     virtual void visit(const like_criteria &node) = 0;
     virtual void visit(const logical_criteria &node) = 0;
     virtual void visit(const not_criteria &node) = 0;

include/matador/query/criteria/like_criteria.hpp

@@ -13,6 +13,9 @@ public:
 
   void accept(criteria_visitor &visitor) const override;
 
+  [[nodiscard]] const sql::column& column() const;
+  [[nodiscard]] const std::string& pattern() const;
+
 private:
   sql::column column_;
   std::string pattern_;

include/matador/query/criteria/logical_criteria.hpp

@@ -16,6 +16,10 @@ public:
 
     void accept(criteria_visitor& visitor) const override;
 
+    [[nodiscard]] const criteria_ptr& left_clause() const;
+    [[nodiscard]] logical_operator operand() const;
+    [[nodiscard]] const criteria_ptr& right_clause() const;
+
 private:
     std::unique_ptr<abstract_criteria> left_criteria_;
     logical_operator operand_;

include/matador/query/criteria/not_criteria.hpp

@@ -6,12 +6,14 @@
 namespace matador::query {
 class not_criteria final : public abstract_criteria {
 public:
-    explicit not_criteria(criteria_ptr clause);
+  explicit not_criteria(criteria_ptr clause);
 
-    void accept(criteria_visitor& visitor) const override;
+  void accept(criteria_visitor& visitor) const override;
+
+  [[nodiscard]] const criteria_ptr& clause() const;
 
 private:
-    criteria_ptr criteria_;
+  criteria_ptr criteria_;
 };
 }
 

include/matador/query/criteria_evaluator.hpp

@@ -1,7 +1,11 @@
 #ifndef MATADOR_CRITERIA_EVALUATOR_HPP
 #define MATADOR_CRITERIA_EVALUATOR_HPP
 
+#include "matador/query/criteria/abstract_criteria.hpp"
 #include "matador/query/criteria/criteria_visitor.hpp"
+#include "matador/query/criteria/criteria_utils.hpp"
+
+#include <string>
 
 namespace matador::sql {
 class dialect;
@@ -13,16 +17,24 @@ namespace matador::query {
 class criteria_evaluator final : public criteria_visitor {
 public:
   criteria_evaluator(const sql::dialect &d, sql::query_context &query);
+
+  std::string evaluate(const abstract_criteria &node);
+
   void visit(const between_criteria &node) override;
   void visit(const binary_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;
   void visit(const logical_criteria &node) override;
   void visit(const not_criteria &node) override;
 
+private:
+  void evaluate_value(const criteria_value &value);
+
 private:
   const sql::dialect &dialect_;
   sql::query_context &query_;
+  std::string clause_;
 };
 }
 #endif //MATADOR_CRITERIA_EVALUATOR_HPP

include/matador/sql/dialect.hpp

@@ -13,6 +13,10 @@
 #include <unordered_map>
 #include <vector>
 
+namespace matador::utils {
+class value;
+}
+
 namespace matador::sql {
 
 class connection_impl;
@@ -53,6 +57,8 @@ public:
 
   [[nodiscard]] const std::string& to_string(bool val) const;
 
+  [[nodiscard]] std::string to_sql_string(const utils::value &val) const ;
+
   void bool_strings(const std::string &true_string, const std::string &false_string);
 
   /**
@@ -150,7 +156,10 @@ private:
     {dialect_token::WHERE,       "WHERE"},
     {dialect_token::AND,         "AND"},
     {dialect_token::OR,          "OR"},
+    {dialect_token::NOT,         "NOT"},
     {dialect_token::LIKE,        "LIKE"},
+    {dialect_token::BETWEEN,     "BETWEEN"},
+    {dialect_token::IN,          "IN"},
     {dialect_token::ORDER_BY,    "ORDER BY"},
     {dialect_token::GROUP_BY,    "GROUP BY"},
     {dialect_token::ASC,         "ASC"},
@@ -171,6 +180,8 @@ private:
     {dialect_token::STRING_QUOTE, "'"},
     {dialect_token::BEGIN_BINARY_DATA, "X'"},
     {dialect_token::END_BINARY_DATA, "'"},
+    {dialect_token::BEGIN_STRING_DATA, "'"},
+    {dialect_token::END_STRING_DATA, "'"},
     {dialect_token::NONE, ""}
   };
 

include/matador/sql/dialect_token.hpp

@@ -28,7 +28,10 @@ enum class dialect_token : uint8_t {
   WHERE_CLAUSE,
   AND,
   OR,
+  NOT,
   LIKE,
+  BETWEEN,
+  IN,
   ORDER_BY,
   GROUP_BY,
   ASC,
@@ -49,6 +52,8 @@ enum class dialect_token : uint8_t {
   STRING_QUOTE,
   BEGIN_BINARY_DATA,
   END_BINARY_DATA,
+  BEGIN_STRING_DATA,
+  END_STRING_DATA,
   NONE
 };
 }

include/matador/sql/interface/statement_impl.hpp

@@ -14,8 +14,7 @@ namespace matador::sql {
 
 class sql_error;
 
-class statement_impl
-{
+class statement_impl {
 protected:
   explicit statement_impl(query_context query, size_t start_bind_pos);