added like and between operator

include/matador/condition/condition_node_visitor.hpp

@@ -4,6 +4,7 @@
 namespace matador::condition {
 class between_condition_node;
 class binary_condition_node;
+class like_condition_node;
 class logical_condition_node;
 class not_condition_node;
 class collection_condition_node;
@@ -15,6 +16,7 @@ public:
     virtual void visit(const between_condition_node &node) = 0;
     virtual void visit(const binary_condition_node &node) = 0;
     virtual void visit(const collection_condition_node &node) = 0;
+    virtual void visit(const like_condition_node &node) = 0;
     virtual void visit(const logical_condition_node &node) = 0;
     virtual void visit(const not_condition_node &node) = 0;
 };

include/matador/condition/condition_operators.hpp

@@ -61,5 +61,9 @@ condition_node_ptr out(const column &col, std::initializer_list<V> args) {
     return std::make_unique<collection_condition_node>(col, collection_operator::OUT, values);
 }
 
+condition_node_ptr between(const column &col, value min, value max);
+
+condition_node_ptr like(const column &col, const std::string &pattern);
+
 }
 #endif //CONDITION_CONDITION_OPERATORS_HPP

include/matador/condition/like_condition_node.hpp

@@ -0,0 +1,20 @@
+#ifndef CONDITION_LIKE_CONDITION_NODE_HPP
+#define CONDITION_LIKE_CONDITION_NODE_HPP
+
+#include "column.hpp"
+#include "condition_node.hpp"
+
+namespace matador::condition {
+class like_condition_node final : public condition_node {
+public:
+  like_condition_node() = delete;
+  like_condition_node(column column, std::string pattern);
+
+  void accept(condition_node_visitor &visitor) const override;
+
+private:
+  column column_;
+  std::string pattern_;
+};
+}
+#endif //CONDITION_LIKE_CONDITION_NODE_HPP

include/matador/condition/types.hpp

@@ -1,6 +1,7 @@
 #ifndef CONDITION_TYPES_HPP
 #define CONDITION_TYPES_HPP
 
+#include <cstdint>
 #include <variant>
 #include <string>
 #include <vector>

src/CMakeLists.txt

@@ -15,6 +15,8 @@ SET(SOURCE
     condition/logical_condition_node.cpp
         ../include/matador/condition/between_condition_node.hpp
         condition/between_condition_node.cpp
+  ../include/matador/condition/like_condition_node.hpp
+  condition/like_condition_node.cpp
 )
 
 add_library(matador-condition STATIC ${SOURCE})

src/condition/condition_operators.cpp

@@ -1,5 +1,7 @@
 #include "matador/condition/condition_operators.hpp"
 
+#include "matador/condition/between_condition_node.hpp"
+#include "matador/condition/like_condition_node.hpp"
 #include "matador/condition/logical_condition_node.hpp"
 #include "matador/condition/not_condition_node.hpp"
 
@@ -16,4 +18,11 @@ condition_node_ptr operator!(condition_node_ptr cond) {
     return std::make_unique<not_condition_node>(std::move(cond));
 }
 
-}
+condition_node_ptr between(const column &col, value min, value max) {
+    return std::make_unique<between_condition_node>(col, std::move(min), std::move(max));
+}
+
+condition_node_ptr like(const column &col, const std::string &pattern) {
+    return std::make_unique<like_condition_node>(col, pattern);
+}
+}

src/condition/like_condition_node.cpp

@@ -0,0 +1,13 @@
+#include "matador/condition/like_condition_node.hpp"
+
+#include "matador/condition/condition_node_visitor.hpp"
+
+namespace matador::condition {
+like_condition_node::like_condition_node(column column, std::string pattern)
+: column_(std::move(column))
+, pattern_(std::move(pattern)){}
+
+void like_condition_node::accept(condition_node_visitor &visitor) const {
+  visitor.visit(*this);
+}
+}

src/main.cpp

@@ -12,6 +12,8 @@ int main() {
     cond = "age"_col <= 7;
     cond = in("age"_col, {34, 35, 78});
     cond = out("age"_col, {34, 35, 78});
+    cond = between("age"_col, 34, 78);
+    cond = like("name"_col, "John");
 
 
     // "age"_col != 7 && in("age"_col,  {7,5,5,8});