sascha
/
query
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity

added new query criteria class set

This commit is contained in:
Sascha Kühl 2025-10-20 13:20:56 +02:00
parent 009498fae1
commit 5d53addc60
22 changed files with 488 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
backends/postgres/test/CMakeLists.txt
View File

@ -3,7 +3,7 @@ CPMAddPackage("gh:catchorg/Catch2@3.7.1")
list(APPEND CMAKE_MODULE_PATH ${catch2_SOURCE_DIR}/extras)
#set(POSTGRES_CONNECTION_STRING "postgres://news:news@127.0.0.1:15432/matador")
set(POSTGRES_CONNECTION_STRING "postgres://test:test123!@127.0.0.1:15442/matador")
set(POSTGRES_CONNECTION_STRING "postgres://test:test123!@127.0.0.1:5432/matador")
configure_file(Connection.hpp.in ${PROJECT_BINARY_DIR}/backends/postgres/test/connection.hpp @ONLY IMMEDIATE)

13
include/matador/query/criteria.hpp Normal file
View File

@ -0,0 +1,13 @@
#ifndef CRITERIA_CRITERIA_HPP
#define CRITERIA_CRITERIA_HPP
#include "matador/query/criteria/between_criteria.hpp"
#include "matador/query/criteria/binary_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/criteria/criteria_operators.hpp"
#endif //CRITERIA_CRITERIA_HPP

20
include/matador/query/criteria/abstract_criteria.hpp Normal file
View File

@ -0,0 +1,20 @@
#ifndef CRITERIA_CRITERIA_NODE_HPP
#define CRITERIA_CRITERIA_NODE_HPP
#include <memory>
namespace matador::query {
class criteria_visitor;
class abstract_criteria {
public:
virtual ~abstract_criteria() = default;
virtual void accept(criteria_visitor& visitor) const = 0;
};
using criteria_ptr = std::unique_ptr<abstract_criteria>;
}
#endif //CRITERIA_CRITERIA_NODE_HPP

25
include/matador/query/criteria/between_criteria.hpp Normal file
View File

@ -0,0 +1,25 @@
#ifndef CRITERIA_BETWEEN_CRITERIA_NODE_HPP
#define CRITERIA_BETWEEN_CRITERIA_NODE_HPP
#include "matador/query/criteria/abstract_criteria.hpp"
#include "matador/sql/column.hpp"
#include "matador/utils/value.hpp"
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);
void accept(criteria_visitor& visitor) const override;
private:
sql::column column_;
utils::value min_;
utils::value max_;
};
}
#endif //CRITERIA_BETWEEN_CRITERIA_NODE_HPP

33
include/matador/query/criteria/binary_criteria.hpp Normal file
View File

@ -0,0 +1,33 @@
#ifndef CRITERIA_BINARY_CRITERIA_NODE_HPP
#define CRITERIA_BINARY_CRITERIA_NODE_HPP
#include "matador/query/criteria/abstract_criteria.hpp"
#include "matador/sql/column.hpp"
#include "matador/utils/value.hpp"
namespace matador::query {
enum class binary_operator {
EQUALS,
NOT_EQUALS,
GREATER_THAN,
GREATER_THAN_OR_EQUAL,
LESS_THAN,
LESS_THAN_OR_EQUAL,
};
class binary_criteria final : public abstract_criteria {
public:
binary_criteria() = delete;
binary_criteria( sql::column column, binary_operator operator_, utils::value value );
void accept( criteria_visitor& visitor ) const override;
private:
sql::column column_;
binary_operator operator_{};
utils::value value_;
};
}
#endif //CRITERIA_BINARY_CRITERIA_NODE_HPP

29
include/matador/query/criteria/collection_criteria.hpp Normal file
View File

@ -0,0 +1,29 @@
#ifndef CRITERIA_COLLECTION_CRITERIA_NODE_HPP
#define CRITERIA_COLLECTION_CRITERIA_NODE_HPP
#include "matador/query/criteria/abstract_criteria.hpp"
#include "matador/sql/column.hpp"
#include "matador/utils/value.hpp"
namespace matador::query {
enum class collection_operator {
IN,
OUT
};
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);
void accept(criteria_visitor& visitor) const override;
private:
sql::column column_;
collection_operator operator_;
std::vector<utils::value> values_;
};
}
#endif //CRITERIA_COLLECTION_CRITERIA_NODE_HPP

72
include/matador/query/criteria/criteria_operators.hpp Normal file
View File

@ -0,0 +1,72 @@
#ifndef CRITERIA_CRITERIA_OPERATORS_HPP
#define CRITERIA_CRITERIA_OPERATORS_HPP
#include "matador/query/criteria/binary_criteria.hpp"
#include "matador/query/criteria/collection_criteria.hpp"
#include "matador/sql/column.hpp"
#include "matador/utils/value.hpp"
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);
}
template<class Type>
criteria_ptr operator!=(const sql::column &col, Type val) {
return std::make_unique<binary_criteria>(col, binary_operator::NOT_EQUALS, 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);
}
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);
}
template<class Type>
criteria_ptr operator<(const sql::column &col, Type val) {
return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN, 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);
}
criteria_ptr operator&&(criteria_ptr left, criteria_ptr right);
criteria_ptr operator||(criteria_ptr left, criteria_ptr right);
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;
for ( auto &&arg : args ) {
values.emplace_back(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;
for ( auto &&arg : args ) {
values.emplace_back(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);
criteria_ptr like(const sql::column &col, const std::string &pattern);
}
#endif //CRITERIA_CRITERIA_OPERATORS_HPP

24
include/matador/query/criteria/criteria_visitor.hpp Normal file
View File

@ -0,0 +1,24 @@
#ifndef CRITERIA_CRITERIA_NODE_VISITOR_HPP
#define CRITERIA_CRITERIA_NODE_VISITOR_HPP
namespace matador::query {
class between_criteria;
class binary_criteria;
class like_criteria;
class logical_criteria;
class not_criteria;
class collection_criteria;
class criteria_visitor {
public:
virtual ~criteria_visitor() = default;
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 like_criteria &node) = 0;
virtual void visit(const logical_criteria &node) = 0;
virtual void visit(const not_criteria &node) = 0;
};
}
#endif //CRITERIA_CRITERIA_NODE_VISITOR_HPP

21
include/matador/query/criteria/like_criteria.hpp Normal file
View File

@ -0,0 +1,21 @@
#ifndef CRITERIA_LIKE_CRITERIA_NODE_HPP
#define CRITERIA_LIKE_CRITERIA_NODE_HPP
#include "matador/query/criteria/abstract_criteria.hpp"
#include "matador/sql/column.hpp"
namespace matador::query {
class like_criteria final : public abstract_criteria {
public:
like_criteria() = delete;
like_criteria(sql::column column, std::string pattern);
void accept(criteria_visitor &visitor) const override;
private:
sql::column column_;
std::string pattern_;
};
}
#endif //CRITERIA_LIKE_CRITERIA_NODE_HPP

25
include/matador/query/criteria/logical_criteria.hpp Normal file
View File

@ -0,0 +1,25 @@
#ifndef CRITERIA_LOGICAL_CRITERIA_NODE_HPP
#define CRITERIA_LOGICAL_CRITERIA_NODE_HPP
#include "matador/query/criteria/abstract_criteria.hpp"
namespace matador::query {
enum class logical_operator {
AND,
OR,
};
class logical_criteria final : public abstract_criteria {
public:
logical_criteria() = delete;
logical_criteria(criteria_ptr left, logical_operator op, criteria_ptr right);
void accept(criteria_visitor& visitor) const override;
private:
std::unique_ptr<abstract_criteria> left_criteria_;
logical_operator operand_;
std::unique_ptr<abstract_criteria> right_criteria_;
};
}
#endif //CRITERIA_LOGICAL_CRITERIA_NODE_HPP

18
include/matador/query/criteria/not_criteria.hpp Normal file
View File

@ -0,0 +1,18 @@
#ifndef CRITERIA_NOT_CRITERIA_NODE_HPP
#define CRITERIA_NOT_CRITERIA_NODE_HPP
#include "matador/query/criteria/abstract_criteria.hpp"
namespace matador::query {
class not_criteria final : public abstract_criteria {
public:
explicit not_criteria(criteria_ptr clause);
void accept(criteria_visitor& visitor) const override;
private:
criteria_ptr criteria_;
};
}
#endif //CRITERIA_NOT_CRITERIA_NODE_HPP

28
include/matador/query/criteria_evaluator.hpp Normal file
View File

@ -0,0 +1,28 @@
#ifndef MATADOR_CRITERIA_EVALUATOR_HPP
#define MATADOR_CRITERIA_EVALUATOR_HPP
#include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::sql {
class dialect;
struct query_context;
}
namespace matador::query {
class criteria_evaluator final : public criteria_visitor {
public:
criteria_evaluator(const sql::dialect &d, sql::query_context &query);
void visit(const between_criteria &node) override;
void visit(const binary_criteria &node) override;
void visit(const collection_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:
const sql::dialect &dialect_;
sql::query_context &query_;
};
}
#endif //MATADOR_CRITERIA_EVALUATOR_HPP

17
source/orm/CMakeLists.txt
View File

@ -6,6 +6,14 @@ add_library(matador-orm STATIC
../../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
../../include/matador/query/criteria.hpp
../../include/matador/query/criteria/criteria_operators.hpp
../../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
@ -78,6 +86,13 @@ add_library(matador-orm STATIC
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
query/criteria/criteria_operators.cpp
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
@ -136,6 +151,8 @@ add_library(matador-orm STATIC
sql/statement.cpp
sql/statement_cache.cpp
sql/table.cpp
../../include/matador/query/criteria_evaluator.hpp
query/criteria_evaluator.cpp
)
target_include_directories(matador-orm

15
source/orm/query/criteria/between_criteria.cpp Normal file
View File

@ -0,0 +1,15 @@
#include "matador/query/criteria/between_criteria.hpp"
#include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::query{
between_criteria::between_criteria(sql::column column, utils::value min, utils::value max )
: column_(std::move(column))
, min_(std::move(min))
, max_(std::move(max))
{}
void between_criteria::accept( criteria_visitor& visitor ) const {
visitor.visit(*this);
}
}

15
source/orm/query/criteria/binary_criteria.cpp Normal file
View File

@ -0,0 +1,15 @@
#include "matador/query/criteria/binary_criteria.hpp"
#include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::query {
binary_criteria::binary_criteria(sql::column column, const binary_operator operator_, utils::value value)
: column_(std::move(column))
, operator_(operator_)
, value_(std::move(value))
{}
void binary_criteria::accept( criteria_visitor& visitor ) const {
visitor.visit(*this);
}
}

21
source/orm/query/criteria/collection_criteria.cpp Normal file
View File

@ -0,0 +1,21 @@
#include "matador/query/criteria/collection_criteria.hpp"
#include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::query {
collection_criteria::collection_criteria(sql::column col, collection_operator operator_, std::vector<utils::value> values )
: column_(std::move(col))
, operator_(operator_)
, values_(std::move(values))
{}
collection_criteria::collection_criteria(sql::column col, const collection_operator operator_, const std::initializer_list<utils::value> values )
: column_(std::move(col))
, operator_(operator_)
, values_(values)
{}
void collection_criteria::accept( criteria_visitor& visitor ) const {
visitor.visit(*this);
}
}

28
source/orm/query/criteria/criteria_operators.cpp Normal file
View File

@ -0,0 +1,28 @@
#include "matador/query/criteria/criteria_operators.hpp"
#include "matador/query/criteria/between_criteria.hpp"
#include "matador/query/criteria/like_criteria.hpp"
#include "matador/query/criteria/logical_criteria.hpp"
#include "matador/query/criteria/not_criteria.hpp"
namespace matador::query {
criteria_ptr operator&&(criteria_ptr left, criteria_ptr right) {
return std::make_unique<logical_criteria>(std::move(left), logical_operator::AND, std::move(right));
}
criteria_ptr operator||(criteria_ptr left, criteria_ptr right) {
return std::make_unique<logical_criteria>(std::move(left), logical_operator::OR, std::move(right));
}
criteria_ptr operator!(criteria_ptr clause) {
return std::make_unique<not_criteria>(std::move(clause));
}
criteria_ptr between(const sql::column &col, utils::value min, utils::value max) {
return std::make_unique<between_criteria>(col, std::move(min), std::move(max));
}
criteria_ptr like(const sql::column &col, const std::string &pattern) {
return std::make_unique<like_criteria>(col, pattern);
}
}

13
source/orm/query/criteria/like_criteria.cpp Normal file
View File

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

15
source/orm/query/criteria/logical_criteria.cpp Normal file
View File

@ -0,0 +1,15 @@
#include "matador/query/criteria/logical_criteria.hpp"
#include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::query {
logical_criteria::logical_criteria(criteria_ptr left, const logical_operator op, criteria_ptr right)
: left_criteria_(std::move(left))
, operand_(op)
, right_criteria_(std::move(right))
{}
void logical_criteria::accept(criteria_visitor& visitor) const {
visitor.visit(*this);
}
}

13
source/orm/query/criteria/not_criteria.cpp Normal file
View File

@ -0,0 +1,13 @@
#include "matador/query/criteria/not_criteria.hpp"
#include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::query {
not_criteria::not_criteria(criteria_ptr clause)
: criteria_(std::move(clause))
{}
void not_criteria::accept(criteria_visitor& visitor) const {
visitor.visit(*this);
}
}

25
source/orm/query/criteria_evaluator.cpp Normal file
View File

@ -0,0 +1,25 @@
#include "matador/query/criteria_evaluator.hpp"
namespace matador::query {
criteria_evaluator::criteria_evaluator(const sql::dialect &d, sql::query_context &query)
: dialect_(d)
, query_(query) {}
void criteria_evaluator::visit(const between_criteria &node) {
}
void criteria_evaluator::visit(const binary_criteria &node) {
}
void criteria_evaluator::visit(const collection_criteria &node) {
}
void criteria_evaluator::visit(const like_criteria &node) {
}
void criteria_evaluator::visit(const logical_criteria &node) {
}
void criteria_evaluator::visit(const not_criteria &node) {
}
}

22
source/orm/sql/column.cpp
View File

@ -1,13 +1,25 @@
#include "matador/sql/column.hpp"
#include "matador/sql/table.hpp"
#include <stdexcept>
#include <utility>
#include "matador/sql/column.hpp"
#include "matador/sql/table.hpp"
namespace matador::sql {
column operator ""_col(const char *name, size_t len)
{
return column{{name, len}};
column operator ""_col(const char *name, size_t len) {
const std::string str(name, len);
const auto pos = str.find('.');
if (pos == std::string::npos) {
return column{str};
}
if (str.find('.', pos + 1) != std::string::npos) {
throw std::invalid_argument("Invalid column name: multiple dots found");
}
return column{str.substr(0, pos), str.substr(pos + 1)};
}
column::column(const char *name, const std::string& as)