removed condition classes, functions and operators
This commit is contained in:
Sascha Kühl
parent
f29f642e72
commit
6fa56b2019
|
|
@ -1,66 +0,0 @@
|
||||||
#ifndef QUERY_BASIC_CONDITION_HPP
|
|
||||||
#define QUERY_BASIC_CONDITION_HPP
|
|
||||||
|
|
||||||
#include "matador/sql/column.hpp"
|
|
||||||
|
|
||||||
#include <unordered_map>
|
|
||||||
#include <cstdint>
|
|
||||||
#include <string>
|
|
||||||
|
|
||||||
namespace matador::sql {
|
|
||||||
class dialect;
|
|
||||||
struct query_context;
|
|
||||||
}
|
|
||||||
|
|
||||||
namespace matador::query {
|
|
||||||
|
|
||||||
class basic_condition
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
basic_condition() = default;
|
|
||||||
virtual ~basic_condition() = default;
|
|
||||||
|
|
||||||
enum class operand_type : uint8_t
|
|
||||||
{
|
|
||||||
EQUAL = 0,
|
|
||||||
NOT_EQUAL,
|
|
||||||
LESS,
|
|
||||||
LESS_EQUAL,
|
|
||||||
GREATER,
|
|
||||||
GREATER_EQUAL,
|
|
||||||
OR,
|
|
||||||
AND,
|
|
||||||
NOT,
|
|
||||||
IN_LIST,
|
|
||||||
LIKE
|
|
||||||
};
|
|
||||||
|
|
||||||
virtual std::string evaluate(const sql::dialect &dialect, sql::query_context &query) const = 0;
|
|
||||||
|
|
||||||
static std::unordered_map<operand_type, std::string> operands;
|
|
||||||
};
|
|
||||||
|
|
||||||
class basic_column_condition : public basic_condition
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
sql::column field_;
|
|
||||||
std::string operand;
|
|
||||||
|
|
||||||
basic_column_condition(sql::column fld, operand_type op);
|
|
||||||
};
|
|
||||||
|
|
||||||
class basic_in_condition : public basic_condition
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
sql::column field_;
|
|
||||||
|
|
||||||
explicit basic_in_condition(sql::column fld);
|
|
||||||
|
|
||||||
[[nodiscard]] virtual size_t size() const = 0;
|
|
||||||
};
|
|
||||||
|
|
||||||
/// @endcond
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif //QUERY_BASIC_CONDITION_HPP
|
|
||||||
|
|
@ -1,635 +0,0 @@
|
||||||
#ifndef QUERY_CONDITION_HPP
|
|
||||||
#define QUERY_CONDITION_HPP
|
|
||||||
|
|
||||||
#include "matador/query/basic_condition.hpp"
|
|
||||||
|
|
||||||
#include "matador/sql/dialect.hpp"
|
|
||||||
#include "matador/sql/query_context.hpp"
|
|
||||||
|
|
||||||
#include "matador/utils/placeholder.hpp"
|
|
||||||
|
|
||||||
#include <memory>
|
|
||||||
#include <utility>
|
|
||||||
|
|
||||||
namespace matador::query {
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @class condition
|
|
||||||
* @brief Represents a sql query condition
|
|
||||||
*
|
|
||||||
* @tparam L Left hand operator type
|
|
||||||
* @tparam R Right hand operator type
|
|
||||||
* This class represents a condition part
|
|
||||||
* of a sql query or update statement.
|
|
||||||
* Each compare method returns a reference to
|
|
||||||
* the condition itself. That way one can
|
|
||||||
* concatenate conditions together.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/// @cond MATADOR_DEV
|
|
||||||
|
|
||||||
template<class L, class R, class Enabled = void>
|
|
||||||
class condition;
|
|
||||||
|
|
||||||
template<>
|
|
||||||
class condition<sql::column, utils::placeholder, std::enable_if_t<true>> final : public basic_column_condition
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
condition(const sql::column &fld, operand_type op, const utils::placeholder &val);
|
|
||||||
|
|
||||||
utils::placeholder value;
|
|
||||||
|
|
||||||
std::string evaluate(const sql::dialect &d, sql::query_context &query) const override;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
class condition<sql::column, T, std::enable_if_t<
|
|
||||||
std::is_scalar_v<T> &&
|
|
||||||
!std::is_same_v<std::string, T> &&
|
|
||||||
!std::is_same_v<const char*, T>>> final : public basic_column_condition
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
condition(const sql::column &fld, const operand_type op, T val)
|
|
||||||
: basic_column_condition(fld, op)
|
|
||||||
, value(val)
|
|
||||||
{ }
|
|
||||||
|
|
||||||
T value;
|
|
||||||
|
|
||||||
std::string evaluate(const sql::dialect &d, sql::query_context &query) const override
|
|
||||||
{
|
|
||||||
query.bind_vars.emplace_back(field_.name);
|
|
||||||
return d.prepare_condition(field_) + " " + operand + " " + std::to_string(value);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
class condition<sql::column, T, std::enable_if_t<
|
|
||||||
std::is_same_v<std::string, T> ||
|
|
||||||
std::is_same_v<const char*, T>>>final : public basic_column_condition
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
condition(const sql::column &fld, const operand_type op, T val)
|
|
||||||
: basic_column_condition(fld, op)
|
|
||||||
,value(val)
|
|
||||||
{ }
|
|
||||||
|
|
||||||
T value;
|
|
||||||
|
|
||||||
std::string evaluate(const sql::dialect &d, sql::query_context &query) const override
|
|
||||||
{
|
|
||||||
query.bind_vars.emplace_back(field_.name);
|
|
||||||
return d.prepare_identifier(field_) + " " + operand + " '" + value + "'";
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
class condition<T, sql::column, std::enable_if_t<
|
|
||||||
std::is_scalar_v<T> &&
|
|
||||||
!std::is_same_v<std::string, T> &&
|
|
||||||
!std::is_same_v<const char*, T>>> final : public basic_column_condition
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
condition(T val, const operand_type op, const sql::column &fld)
|
|
||||||
: basic_column_condition(fld, op)
|
|
||||||
, value(val)
|
|
||||||
{ }
|
|
||||||
|
|
||||||
T value;
|
|
||||||
|
|
||||||
std::string evaluate(const sql::dialect &d, sql::query_context &query) const override
|
|
||||||
{
|
|
||||||
return std::to_string(value) + " " + operand + " " + d.prepare_identifier(field_);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
class condition<T, sql::column, std::enable_if_t<
|
|
||||||
std::is_same_v<std::string, T> ||
|
|
||||||
std::is_same_v<const char*, T>>> final : public basic_column_condition
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
condition(T val, const operand_type op, const sql::column &fld)
|
|
||||||
: basic_column_condition(fld, op)
|
|
||||||
, value(val)
|
|
||||||
{ }
|
|
||||||
|
|
||||||
T value;
|
|
||||||
|
|
||||||
std::string evaluate(const sql::dialect &d, sql::query_context &query) const override
|
|
||||||
{
|
|
||||||
return "'" + std::to_string(value) + "' " + operand + " " + d.prepare_identifier(field_);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
/// @endcond
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Condition class representing an IN condition
|
|
||||||
*
|
|
||||||
* This class represents an query IN condition and evaluates to
|
|
||||||
* this condition based on the current database d
|
|
||||||
*
|
|
||||||
* @code
|
|
||||||
* WHERE age IN (29,34,56)
|
|
||||||
* @endcode
|
|
||||||
*/
|
|
||||||
template < class V >
|
|
||||||
class condition<sql::column, std::initializer_list<V>> final : public basic_in_condition {
|
|
||||||
public:
|
|
||||||
/**
|
|
||||||
* @brief Creates an IN condition
|
|
||||||
*
|
|
||||||
* Creates an IN condition for the given sql::column and
|
|
||||||
* the given list of arguments.
|
|
||||||
*
|
|
||||||
* @param col Column for the IN condition
|
|
||||||
* @param args List of arguments
|
|
||||||
*/
|
|
||||||
condition(const sql::column &col, const std::initializer_list<V> &args)
|
|
||||||
: basic_in_condition(col), args_(args) {}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Evaluates the condition
|
|
||||||
*
|
|
||||||
* Evaluates the condition to a part of the
|
|
||||||
* query string based on the given compile type
|
|
||||||
*
|
|
||||||
* @param d The d used to evaluate
|
|
||||||
* @param query Query to evaluate
|
|
||||||
* @return A condition IN part of the query
|
|
||||||
*/
|
|
||||||
std::string evaluate(const sql::dialect &d, sql::query_context &query) const override {
|
|
||||||
auto count = size();
|
|
||||||
for (size_t i = 0; i < count; ++i) {
|
|
||||||
query.bind_vars.emplace_back(field_.name);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string result = d.prepare_identifier(field_) + " IN (";
|
|
||||||
if (args_.size() < 2) {
|
|
||||||
for (const auto &val : args_) {
|
|
||||||
result.append(std::to_string(val));
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
auto it = args_.begin();
|
|
||||||
result.append(std::to_string(*it++));
|
|
||||||
for(; it != args_.end(); ++it) {
|
|
||||||
result.append(", " + std::to_string(*it));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
result += ")";
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Returns the number of arguments in the list
|
|
||||||
* @return The number of arguments in the list
|
|
||||||
*/
|
|
||||||
[[nodiscard]] size_t size() const override {
|
|
||||||
return args_.size();
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
std::vector<V> args_;
|
|
||||||
};
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Condition 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 (select age_value from table)
|
|
||||||
* @endcode
|
|
||||||
*/
|
|
||||||
template <>
|
|
||||||
class condition<sql::column, sql::query_context> final : public basic_column_condition
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
/**
|
|
||||||
* @brief Create a query IN condition
|
|
||||||
*
|
|
||||||
* Create an IN condition where the argument values come from
|
|
||||||
* the given query. To evaluate the query a sql d must be
|
|
||||||
* given.
|
|
||||||
*
|
|
||||||
* @param col Column for the IN condition
|
|
||||||
* @param op Operand of the condition
|
|
||||||
* @param q The query to be evaluated to the IN arguments
|
|
||||||
*/
|
|
||||||
condition(sql::column col, operand_type op, sql::query_context &q);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Evaluates the condition
|
|
||||||
*
|
|
||||||
* Evaluates the condition to a part of the
|
|
||||||
* query string based on the given compile type
|
|
||||||
*
|
|
||||||
* @param d The d used to evaluate
|
|
||||||
* @param query Query to evaluate
|
|
||||||
* @return A condition IN part of the query
|
|
||||||
*/
|
|
||||||
std::string evaluate(const sql::dialect &d, sql::query_context &query) const override;
|
|
||||||
|
|
||||||
private:
|
|
||||||
sql::query_context &query_;
|
|
||||||
};
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Between condition.
|
|
||||||
*
|
|
||||||
* The condition represents a between where clause
|
|
||||||
* part.
|
|
||||||
*
|
|
||||||
* @tparam T The type of the boundary values
|
|
||||||
*/
|
|
||||||
template < class T >
|
|
||||||
class condition<sql::column, std::pair<T, T>> final : public basic_condition {
|
|
||||||
public:
|
|
||||||
/**
|
|
||||||
* @brief Create a new between condition
|
|
||||||
*
|
|
||||||
* @param col The column for the range check
|
|
||||||
* @param range The boundary values defining the range
|
|
||||||
*/
|
|
||||||
condition(sql::column col, const std::pair<T, T> &range)
|
|
||||||
: field_(std::move(col)), range_(range) {}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Evaluates the condition
|
|
||||||
*
|
|
||||||
* Evaluates the condition to a between part
|
|
||||||
* based on the given compile type
|
|
||||||
*
|
|
||||||
* @param d The d used to evaluate
|
|
||||||
* @param query Query to evaluate
|
|
||||||
* @return A condition BETWEEN part of the query
|
|
||||||
*/
|
|
||||||
std::string evaluate(const sql::dialect &d, sql::query_context &query) const override {
|
|
||||||
query.bind_vars.emplace_back(field_.name);
|
|
||||||
query.bind_vars.emplace_back(field_.name);
|
|
||||||
return d.prepare_identifier(field_) + " BETWEEN " + std::to_string(range_.first) + " AND " + std::to_string(range_.second);
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
sql::column field_;
|
|
||||||
std::pair<T, T> range_;
|
|
||||||
};
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Logical binary condition
|
|
||||||
*
|
|
||||||
* This class represents a logical binary condition
|
|
||||||
* - AND
|
|
||||||
* - OR
|
|
||||||
*
|
|
||||||
* @tparam L1 The left hand type of the left operator
|
|
||||||
* @tparam R1 The right hand type of the left operator
|
|
||||||
* @tparam L2 The left hand type of the right operator
|
|
||||||
* @tparam R2 The right hand type of the right operator
|
|
||||||
*/
|
|
||||||
template<class L1, class R1, class L2, class R2>
|
|
||||||
class condition<condition<L1, R1>, condition<L2, R2>> final : public basic_condition
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
/**
|
|
||||||
* @brief Create a binary logical condition
|
|
||||||
* @param l Left hand operator of the condition
|
|
||||||
* @param r right hand operator of the condition
|
|
||||||
* @param op The operand (AND or OR)
|
|
||||||
*/
|
|
||||||
condition(condition<L1, R1> &&l, condition<L2, R2> &&r, const operand_type op)
|
|
||||||
: left(std::move(l)), right(std::move(r)), operand(op) { }
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Evaluates the condition
|
|
||||||
*
|
|
||||||
* @param d The d used to evaluate
|
|
||||||
* @param query Query to evaluate
|
|
||||||
* @return The evaluated string based on the compile type
|
|
||||||
*/
|
|
||||||
std::string evaluate(const sql::dialect &d, sql::query_context &query) const override
|
|
||||||
{
|
|
||||||
// ensure the numbering order for host vars
|
|
||||||
auto cl = left.evaluate(d, query);
|
|
||||||
auto cr = right.evaluate(d, query);
|
|
||||||
if (operand == operand_type::AND) {
|
|
||||||
return "(" + cl + " " + operands[operand] + " " + cr + ")";
|
|
||||||
} else {
|
|
||||||
return cl + " " + operands[operand] + " " + cr;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
condition<L1, R1> left;
|
|
||||||
condition<L2, R2> right;
|
|
||||||
basic_condition::operand_type operand;
|
|
||||||
};
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Logical unary condition
|
|
||||||
*
|
|
||||||
* This class represents a logical unary NOT condition
|
|
||||||
*
|
|
||||||
* @tparam L Left hand type of the condition to be negated
|
|
||||||
* @tparam R Right hand type of the condition to be negated
|
|
||||||
*/
|
|
||||||
template<class L, class R>
|
|
||||||
class condition<condition<L, R>, void> final : public basic_condition
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
/**
|
|
||||||
* @brief Create a logical unary condition
|
|
||||||
* @param c The condition to be negated
|
|
||||||
*/
|
|
||||||
condition(const condition<L, R> &c) // NOLINT(*-explicit-constructor)
|
|
||||||
: cond(c), operand(operands[operand_type::NOT]) { }
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Evaluates the condition
|
|
||||||
*
|
|
||||||
* @param d The d used to evaluate
|
|
||||||
* @param query The context of the query
|
|
||||||
* @return The evaluated string based on the compile type
|
|
||||||
*/
|
|
||||||
std::string evaluate(const sql::dialect &d, sql::query_context &query) const override
|
|
||||||
{
|
|
||||||
return operand + " (" + cond.evaluate(d, query) + ")";
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
condition<L, R> cond;
|
|
||||||
std::string operand;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
class condition<sql::column, sql::column> final : public basic_column_condition
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
condition(const sql::column &a, const operand_type op, sql::column b)
|
|
||||||
: basic_column_condition(a, op)
|
|
||||||
, other_column_(std::move(b)) {}
|
|
||||||
/**
|
|
||||||
* @brief Evaluates the condition
|
|
||||||
*
|
|
||||||
* @param d The d used to evaluate
|
|
||||||
* @param query The context of the query
|
|
||||||
* @return The evaluated string based on the compile type
|
|
||||||
*/
|
|
||||||
std::string evaluate(const sql::dialect &d, sql::query_context &query) const override;
|
|
||||||
|
|
||||||
private:
|
|
||||||
sql::column other_column_;
|
|
||||||
};
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @file condition.hpp
|
|
||||||
* @brief Contains functions to create query conditions
|
|
||||||
*
|
|
||||||
* This file contains some functions to create
|
|
||||||
* query conditions. These functions wrap the
|
|
||||||
* constructing of a concrete condition and allows
|
|
||||||
* expression like condition programming.
|
|
||||||
*
|
|
||||||
* @code
|
|
||||||
* cond1 == cond2
|
|
||||||
* cond1 < cond2
|
|
||||||
* cond2 != cond1 && cond3 < cond4
|
|
||||||
* @endcode
|
|
||||||
*/
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Creates an IN condition for a given column and a list of values
|
|
||||||
*
|
|
||||||
* @tparam V The type of the list arguments
|
|
||||||
* @param col The column to compare
|
|
||||||
* @param args The list of values
|
|
||||||
* @return The condition object
|
|
||||||
*/
|
|
||||||
template < class V >
|
|
||||||
condition<sql::column, std::initializer_list<V>> in(const sql::column &col, std::initializer_list<V> args)
|
|
||||||
{
|
|
||||||
return condition<sql::column, std::initializer_list<V>>(col, args);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Creates an IN condition for a given column and a query to be executed
|
|
||||||
*
|
|
||||||
* @param col The column to compare
|
|
||||||
* @param q The query to be executes as sub select
|
|
||||||
* @return The condition object
|
|
||||||
*/
|
|
||||||
condition<sql::column, sql::query_context> in_old(const sql::column &col, sql::query_context &&q);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Creates a between condition.
|
|
||||||
*
|
|
||||||
* Creates a between condition for the given column with
|
|
||||||
* the given range consisting of a low and high value
|
|
||||||
*
|
|
||||||
* @tparam T The type of the column and range
|
|
||||||
* @param col The column for the between condition
|
|
||||||
* @param low The low value of the range
|
|
||||||
* @param high The high value of the range
|
|
||||||
* @return The condition object
|
|
||||||
*/
|
|
||||||
template<class T>
|
|
||||||
condition<sql::column, std::pair<T, T>> between(const sql::column &col, T low, T high)
|
|
||||||
{
|
|
||||||
return condition<sql::column, std::pair<T, T>>(col, std::make_pair(low, high));
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Creates a like condition
|
|
||||||
*
|
|
||||||
* Creates a like condition for the given column
|
|
||||||
* and the given value string.
|
|
||||||
*
|
|
||||||
* @param col The column for the like condition
|
|
||||||
* @param val The value to the like operator
|
|
||||||
* @return The like condition object
|
|
||||||
*/
|
|
||||||
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
|
|
||||||
*
|
|
||||||
* Creates a condition object of a column and a value
|
|
||||||
* checked on equality.
|
|
||||||
*
|
|
||||||
* @tparam T The type of the value
|
|
||||||
* @param col The column object
|
|
||||||
* @param val The value to compare with
|
|
||||||
* @return The condition object representing the equality operation
|
|
||||||
*/
|
|
||||||
template<class T>
|
|
||||||
condition<sql::column, T> operator==(const sql::column &col, T val)
|
|
||||||
{
|
|
||||||
return condition<sql::column, T>(col, basic_condition::operand_type::EQUAL, val);
|
|
||||||
}
|
|
||||||
|
|
||||||
condition<sql::column, sql::column> operator==(const sql::column &a, const sql::column &b);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Condition equality method for a column and a query
|
|
||||||
*
|
|
||||||
* Creates a condition object of a column and a query
|
|
||||||
* checked on equality.
|
|
||||||
*
|
|
||||||
* @param col The column object
|
|
||||||
* @param q The query to compare with
|
|
||||||
* @return The condition object representing the equality operation
|
|
||||||
*/
|
|
||||||
condition<sql::column, sql::query_context> equals(const sql::column &col, sql::query_context &q);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Condition inequality operator for a column and a value
|
|
||||||
*
|
|
||||||
* Creates a condition object of a column and a value
|
|
||||||
* checked on inequality.
|
|
||||||
*
|
|
||||||
* @tparam T The type of the value
|
|
||||||
* @param col The column object
|
|
||||||
* @param val The value to compare with
|
|
||||||
* @return The condition object representing the inequality operation
|
|
||||||
*/
|
|
||||||
template<class T>
|
|
||||||
condition<sql::column, T> operator!=(const sql::column &col, T val)
|
|
||||||
{
|
|
||||||
return condition<sql::column, T>(col, basic_condition::operand_type::NOT_EQUAL, val);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Condition less operator for a column and a value
|
|
||||||
*
|
|
||||||
* Creates a condition object checking if the value of the given column
|
|
||||||
* is less than the given value.
|
|
||||||
*
|
|
||||||
* @tparam T The type of the value
|
|
||||||
* @param col The column object
|
|
||||||
* @param val The value to compare with
|
|
||||||
* @return The condition object representing the less operation
|
|
||||||
*/
|
|
||||||
template<class T>
|
|
||||||
condition<sql::column, T> operator<(const sql::column &col, T val)
|
|
||||||
{
|
|
||||||
return condition<sql::column, T>(col, basic_condition::operand_type::LESS, val);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Condition less or equal operator for a column and a value
|
|
||||||
*
|
|
||||||
* Creates a condition object checking if the value of the given column
|
|
||||||
* is less or equal than the given value.
|
|
||||||
*
|
|
||||||
* @tparam T The type of the value
|
|
||||||
* @param col The column object
|
|
||||||
* @param val The value to compare with
|
|
||||||
* @return The condition object representing the less or equal operation
|
|
||||||
*/
|
|
||||||
template<class T>
|
|
||||||
condition<sql::column, T> operator<=(const sql::column &col, T val)
|
|
||||||
{
|
|
||||||
return condition<sql::column, T>(col, basic_condition::operand_type::LESS_EQUAL, val);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Condition greater operator for a column and a value
|
|
||||||
*
|
|
||||||
* Creates a condition object checking if the value of the given column
|
|
||||||
* is greater than the given value.
|
|
||||||
*
|
|
||||||
* @tparam T The type of the value
|
|
||||||
* @param col The column object
|
|
||||||
* @param val The value to compare with
|
|
||||||
* @return The condition object representing the greater operation
|
|
||||||
*/
|
|
||||||
template<class T>
|
|
||||||
condition<sql::column, T> operator>(const sql::column &col, T val)
|
|
||||||
{
|
|
||||||
return condition<sql::column, T>(col, basic_condition::operand_type::GREATER, val);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Condition greater or equal operator for a column and a value
|
|
||||||
*
|
|
||||||
* Creates a condition object checking if the value of the given column
|
|
||||||
* is greater or equal than the given value.
|
|
||||||
*
|
|
||||||
* @tparam T The type of the value
|
|
||||||
* @param col The column object
|
|
||||||
* @param val The value to compare with
|
|
||||||
* @return The condition object representing the greater or equal operation
|
|
||||||
*/
|
|
||||||
template<class T>
|
|
||||||
condition<sql::column, T> operator>=(const sql::column &col, T val)
|
|
||||||
{
|
|
||||||
return condition<sql::column, T>(col, basic_condition::operand_type::GREATER_EQUAL, val);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief AND operation condition consisting of a left and right hand condition
|
|
||||||
*
|
|
||||||
* @tparam L1 Left hand type of left hand condition
|
|
||||||
* @tparam R1 Right hand type of left hand condition
|
|
||||||
* @tparam L2 Left hand type of right hand condition
|
|
||||||
* @tparam R2 Right hand type of right hand condition
|
|
||||||
* @param l Left hand condition
|
|
||||||
* @param r Right hand condition
|
|
||||||
* @return An condition object representing the AND operation
|
|
||||||
*/
|
|
||||||
template<class L1, class R1, class L2, class R2>
|
|
||||||
condition<condition<L1, R1>, condition<L2, R2>> operator&&(condition<L1, R1> l, condition<L2, R2> r)
|
|
||||||
{
|
|
||||||
return condition<condition<L1, R1>, condition<L2, R2>>(std::move(l), std::move(r), basic_condition::operand_type::AND);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief OR operation condition consisting of a left and right hand condition
|
|
||||||
*
|
|
||||||
* @tparam L1 Left hand type of left hand condition
|
|
||||||
* @tparam R1 Right hand type of left hand condition
|
|
||||||
* @tparam L2 Left hand type of right hand condition
|
|
||||||
* @tparam R2 Right hand type of right hand condition
|
|
||||||
* @param l Left hand condition
|
|
||||||
* @param r Right hand condition
|
|
||||||
* @return An condition object representing the OR operation
|
|
||||||
*/
|
|
||||||
template<class L1, class R1, class L2, class R2>
|
|
||||||
condition<condition<L1, R1>, condition<L2, R2>> operator||(condition<L1, R1> l, condition<L2, R2> r)
|
|
||||||
{
|
|
||||||
return condition<condition<L1, R1>, condition<L2, R2>>(std::move(l), std::move(r), basic_condition::operand_type::OR);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Negates a given condition.
|
|
||||||
*
|
|
||||||
* @tparam L The left hand type of the condition
|
|
||||||
* @tparam R The right hand type of the condition
|
|
||||||
* @param c The condition to negated
|
|
||||||
* @return An condition object representing the NOT operation
|
|
||||||
*/
|
|
||||||
template<class L, class R>
|
|
||||||
condition<condition<L, R>, void> operator!(condition<L, R> c)
|
|
||||||
{
|
|
||||||
return condition<condition<L, R>, void>(std::move(c));
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Creates a unique condition from a given condition object
|
|
||||||
*
|
|
||||||
* @tparam L The left hand type of the condition
|
|
||||||
* @tparam R The right hand type of the condition
|
|
||||||
* @param cond The condition to be copied
|
|
||||||
* @return A unique condition pointer representing the given condition
|
|
||||||
*/
|
|
||||||
template<class L, class R>
|
|
||||||
std::unique_ptr<basic_condition> make_condition(const condition<L, R> &cond)
|
|
||||||
{
|
|
||||||
return std::make_unique<condition<L, R>>(cond);
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif //QUERY_CONDITION_HPP
|
|
||||||
|
|
@ -1,26 +0,0 @@
|
||||||
#include "matador/query/basic_condition.hpp"
|
|
||||||
|
|
||||||
namespace matador::query {
|
|
||||||
|
|
||||||
std::unordered_map<basic_condition::operand_type, std::string> basic_condition::operands{
|
|
||||||
{operand_type::EQUAL, "="},
|
|
||||||
{operand_type::NOT_EQUAL, "<>"},
|
|
||||||
{operand_type::LESS, "<"},
|
|
||||||
{operand_type::LESS_EQUAL, "<="},
|
|
||||||
{operand_type::GREATER, ">"},
|
|
||||||
{operand_type::GREATER_EQUAL, ">="},
|
|
||||||
{operand_type::OR, "OR"},
|
|
||||||
{operand_type::AND, "AND"},
|
|
||||||
{operand_type::NOT, "NOT"},
|
|
||||||
{operand_type::IN_LIST, "IN"},
|
|
||||||
{operand_type::LIKE, "LIKE"}
|
|
||||||
};
|
|
||||||
|
|
||||||
basic_column_condition::basic_column_condition(sql::column fld, const operand_type op)
|
|
||||||
: field_(std::move(fld)), operand(operands[op])
|
|
||||||
{ }
|
|
||||||
|
|
||||||
basic_in_condition::basic_in_condition(sql::column fld)
|
|
||||||
: field_(std::move(fld))
|
|
||||||
{ }
|
|
||||||
}
|
|
||||||
|
|
@ -1,44 +0,0 @@
|
||||||
#include "matador/query/condition.hpp"
|
|
||||||
|
|
||||||
namespace matador::query {
|
|
||||||
|
|
||||||
condition<sql::column, utils::placeholder>::condition(const sql::column &fld, const operand_type op, const utils::placeholder &val)
|
|
||||||
: basic_column_condition(fld, op), value(val)
|
|
||||||
{}
|
|
||||||
|
|
||||||
std::string condition<sql::column, utils::placeholder>::evaluate(const sql::dialect &d, sql::query_context &query) const
|
|
||||||
{
|
|
||||||
query.bind_vars.emplace_back(field_.name);
|
|
||||||
return d.prepare_identifier(field_) + " " + operand + " " + d.next_placeholder(query.bind_vars);
|
|
||||||
}
|
|
||||||
|
|
||||||
condition<sql::column, sql::query_context>::condition(sql::column col, const operand_type op, sql::query_context &q)
|
|
||||||
: basic_column_condition(std::move(col), op), query_(q)
|
|
||||||
{}
|
|
||||||
|
|
||||||
std::string condition<sql::column, sql::query_context>::evaluate(const sql::dialect &d, sql::query_context &/*query*/) const
|
|
||||||
{
|
|
||||||
std::string result(d.prepare_identifier(field_) + " " + operand + " (");
|
|
||||||
result += query_.sql;
|
|
||||||
result += ")";
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string condition<sql::column, sql::column>::evaluate(const sql::dialect &d, sql::query_context &/*query*/) const {
|
|
||||||
return d.prepare_condition(field_) + " " + operand + " " + d.prepare_condition(other_column_);
|
|
||||||
}
|
|
||||||
|
|
||||||
condition<sql::column, sql::query_context> in_old(const sql::column &col, sql::query_context &&q)
|
|
||||||
{
|
|
||||||
return {col, basic_condition::operand_type::IN_LIST, q};
|
|
||||||
}
|
|
||||||
|
|
||||||
condition<sql::column, std::string> like_old(const sql::column &col, const std::string &val) {
|
|
||||||
return { col, basic_condition::operand_type::LIKE, val };
|
|
||||||
}
|
|
||||||
|
|
||||||
condition<sql::column, sql::column> operator==(const sql::column &a, const sql::column &b)
|
|
||||||
{
|
|
||||||
return {a, basic_condition::operand_type::EQUAL, b};
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,112 +0,0 @@
|
||||||
#include <catch2/catch_test_macros.hpp>
|
|
||||||
|
|
||||||
#include "matador/query/condition.hpp"
|
|
||||||
|
|
||||||
#include "matador/sql/dialect_builder.hpp"
|
|
||||||
|
|
||||||
using namespace matador::sql;
|
|
||||||
using namespace matador::query;
|
|
||||||
|
|
||||||
class ConditionFixture {
|
|
||||||
protected:
|
|
||||||
dialect dlc = dialect_builder::builder()
|
|
||||||
.create()
|
|
||||||
.build();
|
|
||||||
query_context ctx;
|
|
||||||
};
|
|
||||||
|
|
||||||
TEST_CASE_METHOD(ConditionFixture, "Test column user defined literal", "[column][literal]") {
|
|
||||||
const auto col = "name"_col;
|
|
||||||
|
|
||||||
REQUIRE(col.name == "name");
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST_CASE_METHOD(ConditionFixture, "Test logical condition", "[condition][logical]") {
|
|
||||||
const auto name_col = "name"_col;
|
|
||||||
|
|
||||||
REQUIRE(name_col.name == "name");
|
|
||||||
|
|
||||||
auto cond1 = name_col != "george";
|
|
||||||
|
|
||||||
auto clause = cond1.evaluate(dlc, ctx);
|
|
||||||
REQUIRE(clause == "\"name\" <> 'george'");
|
|
||||||
|
|
||||||
auto cond2 = "age"_col != 9;
|
|
||||||
clause = cond2.evaluate(dlc, ctx);
|
|
||||||
REQUIRE(clause == "\"age\" <> 9");
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST_CASE_METHOD(ConditionFixture, "Test and condition", "[condition][bin][and]") {
|
|
||||||
const auto name_col = "name"_col;
|
|
||||||
|
|
||||||
REQUIRE(name_col.name == "name");
|
|
||||||
|
|
||||||
const auto cond = name_col == "Hans" && name_col == "Dieter";
|
|
||||||
|
|
||||||
auto clause = cond.evaluate(dlc, ctx);
|
|
||||||
REQUIRE(clause == "(\"name\" = 'Hans' AND \"name\" = 'Dieter')");
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST_CASE_METHOD(ConditionFixture, "Test or condition", "[condition][bin][or]") {
|
|
||||||
const auto name_col = "name"_col;
|
|
||||||
|
|
||||||
REQUIRE(name_col.name == "name");
|
|
||||||
|
|
||||||
const auto cond = name_col == "Hans" || name_col == "Dieter";
|
|
||||||
|
|
||||||
auto clause = cond.evaluate(dlc, ctx);
|
|
||||||
REQUIRE(clause == "\"name\" = 'Hans' OR \"name\" = 'Dieter'");
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST_CASE_METHOD(ConditionFixture, "Test not condition", "[condition][not]") {
|
|
||||||
const auto name_col = "name"_col;
|
|
||||||
|
|
||||||
REQUIRE(name_col.name == "name");
|
|
||||||
|
|
||||||
const auto cond = !(name_col != "Hans");
|
|
||||||
|
|
||||||
auto clause = cond.evaluate(dlc, ctx);
|
|
||||||
REQUIRE(clause == "NOT (\"name\" <> 'Hans')");
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST_CASE_METHOD(ConditionFixture, "Test in condition", "[condition][in]") {
|
|
||||||
const auto age_col = "age"_col;
|
|
||||||
|
|
||||||
REQUIRE(age_col.name == "age");
|
|
||||||
auto cond = age_col != 7 && in(age_col, {7,5,5,8});
|
|
||||||
|
|
||||||
auto clause = cond.evaluate(dlc, ctx);
|
|
||||||
REQUIRE(clause == "(\"age\" <> 7 AND \"age\" IN (7, 5, 5, 8))");
|
|
||||||
|
|
||||||
cond = age_col != 7 && in(age_col, {7});
|
|
||||||
clause = cond.evaluate(dlc, ctx);
|
|
||||||
REQUIRE(clause == "(\"age\" <> 7 AND \"age\" IN (7))");
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST_CASE_METHOD(ConditionFixture, "Test in query condition", "[condition][in query]") {
|
|
||||||
const auto age_col = "age"_col;
|
|
||||||
const auto name_col = "name"_col;
|
|
||||||
|
|
||||||
query_context sub_ctx;
|
|
||||||
sub_ctx.sql = R"(SELECT "name" FROM "test")";
|
|
||||||
|
|
||||||
auto cond = age_col != 7 && in_old(name_col, std::move(sub_ctx));
|
|
||||||
auto clause = cond.evaluate(dlc, ctx);
|
|
||||||
REQUIRE(clause == "(\"age\" <> 7 AND \"name\" IN (SELECT \"name\" FROM \"test\"))");
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST_CASE_METHOD(ConditionFixture, "Test between condition", "[condition][between]") {
|
|
||||||
const auto age_col = "age"_col;
|
|
||||||
|
|
||||||
auto cond = age_col != 7 && between(age_col, 21, 30);
|
|
||||||
auto clause = cond.evaluate(dlc, ctx);
|
|
||||||
REQUIRE(clause == "(\"age\" <> 7 AND \"age\" BETWEEN 21 AND 30)");
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST_CASE_METHOD(ConditionFixture, "Test like condition", "[condition][like]") {
|
|
||||||
const auto name_col = "name"_col;
|
|
||||||
|
|
||||||
auto cond = like_old(name_col, "%er%");
|
|
||||||
auto clause = cond.evaluate(dlc, ctx);
|
|
||||||
REQUIRE(clause == "\"name\" LIKE '%er%'");
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue