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

Compare commits

base: sascha:5632746eb6e1c0399985e364cfb3f8ff4acef1de
Branches Tags
sascha:main
sascha:feature/matador-ng
..
compare: sascha:44c50cf2af45749f2cac730076c25b2c91b4c009
Branches Tags
sascha:feature/matador-ng
sascha:main

No commits in common. "5632746eb6e1c0399985e364cfb3f8ff4acef1de" and "44c50cf2af45749f2cac730076c25b2c91b4c009" have entirely different histories.
5632746eb6 ... 44c50cf2af

25 changed files with 210 additions and 340 deletions
Show Stats Expand all files Collapse all files

1
include/matador/orm/error_code.hpp
View File

@ -10,7 +10,6 @@ enum class error_code : uint8_t {
Ok = 0,
NoConnectionAvailable,
UnknownType,
NoPrimaryKey,
FailedToBuildQuery,
FailedToFindObject,
Failed

7
include/matador/orm/schema.hpp
View File

@ -3,10 +3,6 @@
#include "matador/object/repository.hpp"
namespace matador::sql {
class connection_pool;
}
namespace matador::orm {
class schema {
@ -23,9 +19,6 @@ public:
return repo_.attach<Type, SuperType>(name);
}
utils::result<void, utils::error> create(sql::connection_pool &pool) const;
utils::result<void, utils::error> drop() const;
private:
object::repository repo_;
};

42
include/matador/orm/session.hpp
View File

@ -121,7 +121,9 @@ public:
template<typename Type, typename PrimaryKeyType>
utils::result<object::object_ptr<Type>, utils::error> find(const PrimaryKeyType &pk);
template<typename Type>
utils::result<sql::query_result<Type>, utils::error> find(query::criteria_ptr clause = {});
utils::result<sql::query_result<Type>, utils::error> find();
// template<typename Type, typename Condition>
// utils::result<sql::query_result<Type>, utils::error> find(const Condition &cond);
template<typename Type>
utils::result<void, utils::error> drop_table();
@ -294,18 +296,11 @@ utils::result<object::object_ptr<Type>, utils::error> session::find(const Primar
if (!info) {
return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
}
if (!info.value().get().definition().has_primary_key()) {
return utils::failure(make_error(error_code::NoPrimaryKey, "Type hasn't primary key."));
}
const auto& type_info = info.value().get();
session_query_builder eqb(*schema_, *this);
const sql::column col(sql::table{type_info.reference_column()->table_name()}, type_info.reference_column()->name());
using namespace matador::query;
auto data = eqb.build<Type>(col == utils::_);
auto data = eqb.build<Type>(pk);
if (!data.is_ok()) {
return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + type_info.name() + "."));
return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + info->get().name() + "."));
}
auto res = build_select_query(data.release()).prepare(*this);
@ -315,20 +310,20 @@ utils::result<object::object_ptr<Type>, utils::error> session::find(const Primar
}
auto stmt_result = res->bind(0, const_cast<PrimaryKeyType&>(pk)).template fetch_one<Type>();
if (stmt_result && !stmt_result.value()) {
return utils::failure(make_error(error_code::FailedToFindObject, "Failed to find object of type " + type_info.name() + " with primary key " + std::to_string(pk) + "."));
return utils::failure(make_error(error_code::FailedToFindObject, "Failed to find object of type " + info->get().name() + " with primary key " + std::to_string(pk) + "."));
}
return utils::ok(object::object_ptr<Type>{ stmt_result->release() });
}
template<typename Type>
utils::result<sql::query_result<Type>, utils::error> session::find(query::criteria_ptr clause) {
utils::result<sql::query_result<Type>, utils::error> session::find() {
auto info = schema_->info<Type>();
if (!info) {
return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
}
session_query_builder eqb(*schema_, *this);
auto data = eqb.build<Type>(std::move(clause));
auto data = eqb.build<Type>();
if (!data.is_ok()) {
return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + info->get().name() + "."));
}
@ -341,6 +336,27 @@ utils::result<sql::query_result<Type>, utils::error> session::find(query::criter
return result->template fetch<Type>();
}
// template<typename Type, typename Condition>
// utils::result<sql::query_result<Type>, utils::error> session::find(const Condition &cond) {
// auto info = schema_->info<Type>();
// if (!info) {
// return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
// }
//
// session_query_builder eqb(*schema_, *this);
// auto data = eqb.build<Type>();
// if (!data.is_ok()) {
// return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + info->get().name() + "."));
// }
//
// auto result = build_select_query(data.release()).prepare(*this);
// if (!result.is_ok()) {
// return utils::failure(result.err());
// }
//
// return result->template fetch<Type>();
// }
//
template<typename Type>
utils::result<void, utils::error> session::drop_table() {
auto info = schema_->info<Type>();

62
include/matador/orm/session_query_builder.hpp
View File

@ -11,7 +11,6 @@
#include "matador/object/join_columns_collector.hpp"
#include "matador/object/repository.hpp"
#include "matador/query/criteria/criteria_visitor.hpp"
#include "matador/utils/primary_key_attribute.hpp"
#include "matador/utils/result.hpp"
@ -31,49 +30,46 @@ struct entity_query_data {
query::criteria_ptr where_clause;
};
class criteria_transformer final : public query::criteria_visitor {
public:
criteria_transformer(const object::repository &repo, const std::unordered_map<std::string, std::shared_ptr<sql::table>>& tables_by_name);
void visit( const query::between_criteria& node ) override;
void visit( const query::binary_criteria& node ) override;
void visit( const query::binary_column_criteria& node ) override;
void visit( const query::collection_criteria& node ) override;
void visit( const query::collection_query_criteria& node ) override;
void visit( const query::like_criteria& node ) override;
void visit( const query::logical_criteria& node ) override;
void visit( const query::not_criteria& node ) override;
private:
void update_criteria_column(const query::abstract_column_criteria& node) const;
private:
const object::repository &repo_;
const std::unordered_map<std::string, std::shared_ptr<sql::table>>& tables_by_name_;
};
class session_query_builder final {
public:
session_query_builder(const object::repository &scm, sql::executor &exec)
: schema_(scm)
, executor_(exec){}
template<class EntityType>
utils::result<entity_query_data, query_build_error> build(query::criteria_ptr clause = {}) {
const auto info = schema_.info<EntityType>();
template<class EntityType, typename PrimaryKeyType>
utils::result<entity_query_data, query_build_error> build(const PrimaryKeyType &pk) {
auto info = schema_.info<EntityType>();
if (!info) {
return utils::failure(query_build_error::UnknownType);
}
pk_ = pk;
table_info_stack_.push({info.value(), std::make_shared<sql::table>(info.value().get().name(), build_alias('t', ++table_index))});
entity_query_data_ = { table_info_stack_.top().table };
processed_tables_.insert({info->get().name(), entity_query_data_.root_table});
try {
access::process(*this, info->get().prototype());
if (clause) {
criteria_transformer transformer{schema_, processed_tables_};
clause->accept(transformer);
entity_query_data_.where_clause = std::move(clause);
return {utils::ok(std::move(entity_query_data_))};
} catch (const query_builder_exception &ex) {
return {utils::failure(ex.error_type())};
} catch (...) {
return {utils::failure(query_build_error::UnexpectedError)};
}
}
template<class EntityType>
utils::result<entity_query_data, query_build_error> build() {
const auto info = schema_.info<EntityType>();
if (!info) {
return utils::failure(query_build_error::UnknownType);
}
pk_ = nullptr;
table_info_stack_.push({info.value(), std::make_shared<sql::table>(info.value().get().name(), build_alias('t', ++table_index))});
entity_query_data_ = { table_info_stack_.top().table };
processed_tables_.insert({info->get().name(), entity_query_data_.root_table});
try {
access::process(*this, info->get().prototype());
return {utils::ok(std::move(entity_query_data_))};
} catch (const query_builder_exception &ex) {
return {utils::failure(ex.error_type())};
@ -83,12 +79,19 @@ public:
}
template < class V >
void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes)
{
push(id);
if (!is_root_entity()) {
return;
}
entity_query_data_.pk_column_name = id;
if (!pk_.is_null()) {
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);
}
}
void on_revision(const char *id, uint64_t &/*rev*/);
@ -232,6 +235,7 @@ private:
void append_join(const sql::column &left, const sql::column &right);
private:
utils::value pk_;
struct table_info {
std::reference_wrapper<const object::basic_object_info> info;
std::shared_ptr<sql::table> table;

22
include/matador/query/criteria/abstract_column_criteria.hpp
View File

@ -1,22 +0,0 @@
#ifndef MATADOR_ABSTRACT_COLUMN_CRITERIA_HPP
#define MATADOR_ABSTRACT_COLUMN_CRITERIA_HPP
#include "matador/query/criteria/abstract_criteria.hpp"
#include "matador/sql/column.hpp"
namespace matador::query {
class abstract_column_criteria : public abstract_criteria {
public:
abstract_column_criteria() = delete;
explicit abstract_column_criteria(sql::column column);
[[nodiscard]] const sql::column& column() const;
protected:
sql::column column_;
};
}
#endif //MATADOR_ABSTRACT_COLUMN_CRITERIA_HPP

8
include/matador/query/criteria/between_criteria.hpp
View File

@ -1,14 +1,16 @@
#ifndef CRITERIA_BETWEEN_CRITERIA_NODE_HPP
#define CRITERIA_BETWEEN_CRITERIA_NODE_HPP
#include "matador/query/criteria/abstract_column_criteria.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 {
class between_criteria final : public abstract_column_criteria {
class between_criteria final : public abstract_criteria {
public:
between_criteria() = delete;
between_criteria(sql::column column, int64_t min, int64_t max);
@ -16,10 +18,12 @@ public:
void accept(criteria_visitor& visitor) const override;
[[nodiscard]] const sql::column& column() const;
[[nodiscard]] const criteria_value &minimum() const;
[[nodiscard]] const criteria_value &maximum() const;
private:
sql::column column_;
criteria_value min_;
criteria_value max_;
};

6
include/matador/query/criteria/binary_criteria.hpp
View File

@ -1,7 +1,7 @@
#ifndef CRITERIA_BINARY_CRITERIA_NODE_HPP
#define CRITERIA_BINARY_CRITERIA_NODE_HPP
#include "matador/query/criteria/abstract_column_criteria.hpp"
#include "matador/query/criteria/abstract_criteria.hpp"
#include "matador/query/criteria/criteria_utils.hpp"
#include "matador/sql/column.hpp"
@ -16,17 +16,19 @@ enum class binary_operator {
LESS_THAN_OR_EQUAL,
};
class binary_criteria final : public abstract_column_criteria {
class binary_criteria final : public abstract_criteria {
public:
binary_criteria() = delete;
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_{};
criteria_value value_;
};

10
include/matador/query/criteria/collection_criteria.hpp
View File

@ -1,7 +1,7 @@
#ifndef CRITERIA_COLLECTION_CRITERIA_NODE_HPP
#define CRITERIA_COLLECTION_CRITERIA_NODE_HPP
#include "matador/query/criteria/abstract_column_criteria.hpp"
#include "matador/query/criteria/abstract_criteria.hpp"
#include "matador/query/criteria/criteria_utils.hpp"
#include "matador/sql/column.hpp"
@ -23,7 +23,7 @@ enum class collection_operator {
* WHERE age IN (29,34,56)
* @endcode
*/
class collection_criteria final : public abstract_column_criteria {
class collection_criteria final : public abstract_criteria {
public:
collection_criteria() = delete;
/**
@ -41,25 +41,29 @@ public:
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 operand_;
std::vector<criteria_value> values_;
};
class collection_query_criteria final : public abstract_column_criteria {
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_;
};

9
include/matador/query/criteria/criteria_operators.hpp
View File

@ -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));
@ -44,13 +46,6 @@ criteria_ptr operator<=(const sql::column &col, Type val) {
return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN_OR_EQUAL, utils::value(val));
}
criteria_ptr operator==(const sql::column &col_left, const sql::column &col_right);
criteria_ptr operator!=(const sql::column &col_left, const sql::column &col_right);
criteria_ptr operator>(const sql::column &col_left, const sql::column &col_right);
criteria_ptr operator>=(const sql::column &col_left, const sql::column &col_right);
criteria_ptr operator<(const sql::column &col_left, const sql::column &col_right);
criteria_ptr operator<=(const sql::column &col_left, const sql::column &col_right);
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);

6
include/matador/query/criteria/like_criteria.hpp
View File

@ -1,21 +1,23 @@
#ifndef CRITERIA_LIKE_CRITERIA_NODE_HPP
#define CRITERIA_LIKE_CRITERIA_NODE_HPP
#include "matador/query/criteria/abstract_column_criteria.hpp"
#include "matador/query/criteria/abstract_criteria.hpp"
#include "matador/sql/column.hpp"
namespace matador::query {
class like_criteria final : public abstract_column_criteria {
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;
[[nodiscard]] const sql::column& column() const;
[[nodiscard]] const std::string& pattern() const;
private:
sql::column column_;
std::string pattern_;
};
}

4
include/matador/query/criteria/logical_criteria.hpp
View File

@ -21,9 +21,9 @@ public:
[[nodiscard]] const criteria_ptr& right_clause() const;
private:
criteria_ptr left_criteria_;
std::unique_ptr<abstract_criteria> left_criteria_;
logical_operator operand_;
criteria_ptr right_criteria_;
std::unique_ptr<abstract_criteria> right_criteria_;
};
}
#endif //CRITERIA_LOGICAL_CRITERIA_NODE_HPP

5
include/matador/sql/column.hpp
View File

@ -31,12 +31,11 @@ struct column {
[[nodiscard]] const std::string& column_name() const;
[[nodiscard]] std::string full_name() const;
[[nodiscard]] const std::string& alias_name() const;
[[nodiscard]] bool is_function() const;
[[nodiscard]] bool has_alias() const;
[[nodiscard]] std::shared_ptr<sql::table> table() const;
std::shared_ptr<sql::table> table_;
std::shared_ptr<table> table_;
using table_ref = std::reference_wrapper<const table>;
std::string name;
std::string alias;
sql_function_t function_{sql_function_t::NONE};

2
source/orm/CMakeLists.txt
View File

@ -150,8 +150,6 @@ add_library(matador-orm STATIC
../../include/matador/query/criteria_evaluator.hpp
query/criteria_evaluator.cpp
../../include/matador/query/criteria/criteria_utils.hpp
../../include/matador/query/criteria/abstract_column_criteria.hpp
query/criteria/abstract_column_criteria.cpp
)
target_include_directories(matador-orm

2
source/orm/orm/error_code.cpp
View File

@ -14,8 +14,6 @@ std::string orm_category_impl::message(const int ev) const {
return "No connection available";
case error_code::UnknownType:
return "Unknown type";
case error_code::NoPrimaryKey:
return "No primary key";
case error_code::FailedToBuildQuery:
return "Failed to build query";
case error_code::FailedToFindObject:

64
source/orm/orm/schema.cpp
View File

@ -1,70 +1,6 @@
#include "matador/orm/schema.hpp"
#include "matador/query/query.hpp"
#include "matador/sql/connection_pool.hpp"
namespace matador::orm {
schema::schema( const std::string& name )
: repo_(name){}
}
matador::utils::result<void, matador::utils::error> matador::orm::schema::create(sql::connection_pool &pool) const {
// Step 1: Build dependency graph
// std::unordered_map<std::string, std::vector<std::string> > dependency_graph;
// std::unordered_map<std::string, std::pair<int,object::repository::node_ptr>> in_degree;
//
// for (const auto &node: repo_) {
// for (auto it = node->info().endpoint_begin(); it != node->info().endpoint_end(); ++it) {
// dependency_graph[node->name()].push_back(it->second->node().name());
//
// if (const auto dit = in_degree.find(it->second->node().name()); dit == in_degree.end()) {
// in_degree[it->second->node().name()] = std::make_pair(1, it->second->node_ptr());
// } else {
// in_degree[it->second->node().name()].first++;
// }
// }
//
// // Ensure the current node exists in the graph representation
// if (in_degree.find(node->name()) == in_degree.end()) {
// in_degree[node->name()] = std::make_pair(0, node);
// }
// }
//
// for (const auto &it : dependency_graph) {
// std::cout << "Dependency graph " << it.first << std::endl;
// for (const auto &neighbor: it.second) {
// std::cout << " " << neighbor << std::endl;
// }
// std::cout << std::endl;
// }
std::vector<std::string> fk_sql_commands;
auto c = pool.acquire();
for (const auto &node: repo_) {
auto ctx = query::query::create()
.table(node->name(), node->info().definition().columns())
.compile(*c);
for ( const auto& [sql, command] : ctx.additional_commands ) {
fk_sql_commands.push_back( sql );
}
std::cout << ctx.sql << std::endl;
if (auto result = c->execute(ctx.sql); !result) {
return utils::failure(result.err());
}
}
// execute additional commands (e.g. ALTER TABLE ADD FK)
for (const auto &sql: fk_sql_commands) {
std::cout << sql << std::endl;
if (auto result = c->execute(sql); !result) {
return utils::failure(result.err());
}
}
return utils::ok<void>();
}
matador::utils::result<void, matador::utils::error> matador::orm::schema::drop() const {
return utils::ok<void>();
}

44
source/orm/orm/session_query_builder.cpp
View File

@ -3,50 +3,6 @@
#include <iostream>
namespace matador::orm {
criteria_transformer::criteria_transformer(const object::repository& repo, const std::unordered_map<std::string, std::shared_ptr<sql::table>>& tables_by_name)
: repo_(repo)
, tables_by_name_(tables_by_name) {}
void criteria_transformer::visit( const query::between_criteria& node ) {
update_criteria_column(node);
}
void criteria_transformer::visit( const query::binary_criteria& node ) {
update_criteria_column(node);
}
void criteria_transformer::visit( const query::binary_column_criteria& node ) {}
void criteria_transformer::visit( const query::collection_criteria& node ) {
update_criteria_column(node);
}
void criteria_transformer::visit( const query::collection_query_criteria& node ) {
update_criteria_column(node);
}
void criteria_transformer::visit( const query::like_criteria& node ) {
update_criteria_column(node);
}
void criteria_transformer::visit( const query::logical_criteria& node ) {
node.left_clause()->accept(*this);
node.right_clause()->accept(*this);
}
void criteria_transformer::visit( const query::not_criteria& node ) {
node.clause()->accept(*this);
}
void criteria_transformer::update_criteria_column(const query::abstract_column_criteria& node) const {
const auto it = tables_by_name_.find(node.column().table()->name);
if (it == tables_by_name_.end()) {
return;
}
const_cast<sql::column&>(node.column()).table_ = it->second;
}
void session_query_builder::on_revision(const char *id, uint64_t &/*rev*/) {
push(id);
}

10
source/orm/query/criteria/abstract_column_criteria.cpp
View File

@ -1,10 +0,0 @@
#include "matador/query/criteria/abstract_column_criteria.hpp"
namespace matador::query {
abstract_column_criteria::abstract_column_criteria(sql::column column)
: column_(std::move(column)) {}
const sql::column& abstract_column_criteria::column() const {
return column_;
}
}

8
source/orm/query/criteria/between_criteria.cpp
View File

@ -4,13 +4,13 @@
namespace matador::query{
between_criteria::between_criteria(sql::column column, const int64_t min, const int64_t max)
: abstract_column_criteria(std::move(column))
: column_(std::move(column))
, min_(utils::value{min})
, max_(utils::value{max})
{}
between_criteria::between_criteria(sql::column column, utils::placeholder min, utils::placeholder max)
: abstract_column_criteria(std::move(column))
: column_(std::move(column))
, min_(min)
, max_(max)
{}
@ -19,6 +19,10 @@ void between_criteria::accept( criteria_visitor& visitor ) const {
visitor.visit(*this);
}
const sql::column & between_criteria::column() const {
return column_;
}
const criteria_value &between_criteria::minimum() const {
return min_;
}

6
source/orm/query/criteria/binary_criteria.cpp
View File

@ -4,7 +4,7 @@
namespace matador::query {
binary_criteria::binary_criteria(sql::column column, const binary_operator operand, criteria_value value)
: abstract_column_criteria(std::move(column))
: column_(std::move(column))
, operator_(operand)
, value_(std::move(value))
{}
@ -13,6 +13,10 @@ void binary_criteria::accept( criteria_visitor& visitor ) const {
visitor.visit(*this);
}
const sql::column & binary_criteria::column() const {
return column_;
}
binary_operator binary_criteria::operand() const {
return operator_;
}

14
source/orm/query/criteria/collection_criteria.cpp
View File

@ -4,13 +4,13 @@
namespace matador::query {
collection_criteria::collection_criteria(sql::column col, const collection_operator operand_, std::vector<criteria_value> values )
: abstract_column_criteria(std::move(col))
: column_(std::move(col))
, operand_(operand_)
, values_(std::move(values))
{}
collection_criteria::collection_criteria(sql::column col, const collection_operator operand_, const std::initializer_list<criteria_value> values )
: abstract_column_criteria(std::move(col))
: column_(std::move(col))
, operand_(operand_)
, values_(values)
{}
@ -19,6 +19,10 @@ void collection_criteria::accept(criteria_visitor& visitor) const {
visitor.visit(*this);
}
const sql::column & collection_criteria::column() const {
return column_;
}
collection_operator collection_criteria::operand() const {
return operand_;
}
@ -28,7 +32,7 @@ const std::vector<criteria_value>& collection_criteria::values() const {
}
collection_query_criteria::collection_query_criteria(sql::column col, collection_operator operand_, sql::query_context ctx)
: abstract_column_criteria(std::move(col))
: column_(std::move(col))
, operand_(operand_)
, query_context_(std::move(ctx)){
}
@ -37,6 +41,10 @@ void collection_query_criteria::accept(criteria_visitor &visitor) const {
visitor.visit(*this);
}
const sql::column & collection_query_criteria::column() const {
return column_;
}
collection_operator collection_query_criteria::operand() const {
return operand_;
}

29
source/orm/query/criteria/criteria_operators.cpp
View File

@ -6,6 +6,10 @@
#include "matador/query/criteria/not_criteria.hpp"
namespace matador::query {
criteria_ptr operator==( const sql::column& col_left, const sql::column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::EQUALS, col_right);
}
criteria_ptr operator==(const sql::column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, p);
}
@ -20,6 +24,7 @@ criteria_ptr operator>(const sql::column &col, utils::placeholder p) {
criteria_ptr operator>=(const sql::column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN_OR_EQUAL, p);
}
criteria_ptr operator<(const sql::column &col, utils::placeholder p) {
@ -30,30 +35,6 @@ criteria_ptr operator<=(const sql::column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN_OR_EQUAL, p);
}
criteria_ptr operator==( const sql::column& col_left, const sql::column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::EQUALS, col_right);
}
criteria_ptr operator!=( const sql::column& col_left, const sql::column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::NOT_EQUALS, col_right);
}
criteria_ptr operator>( const sql::column& col_left, const sql::column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::GREATER_THAN, col_right);
}
criteria_ptr operator>=( const sql::column& col_left, const sql::column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::GREATER_THAN_OR_EQUAL, col_right);
}
criteria_ptr operator<( const sql::column& col_left, const sql::column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::LESS_THAN, col_right);
}
criteria_ptr operator<=( const sql::column& col_left, const sql::column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::LESS_THAN_OR_EQUAL, col_right);
}
criteria_ptr operator&&(criteria_ptr left, criteria_ptr right) {
return std::make_unique<logical_criteria>(std::move(left), logical_operator::AND, std::move(right));
}

6
source/orm/query/criteria/like_criteria.cpp
View File

@ -4,13 +4,17 @@
namespace matador::query {
like_criteria::like_criteria(sql::column column, std::string pattern)
: abstract_column_criteria(std::move(column))
: column_(std::move(column))
, pattern_(std::move(pattern)){}
void like_criteria::accept(criteria_visitor &visitor) const {
visitor.visit(*this);
}
const sql::column & like_criteria::column() const {
return column_;
}
const std::string & like_criteria::pattern() const {
return pattern_;
}

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

@ -36,27 +36,29 @@ column::column(const sql_function_t func, std::string name)
, name(std::move(name))
, function_(func) {}
column::column(const sql::table& tab, std::string name, std::string as)
: table_(std::make_shared<sql::table>(tab))
column::column(const table& tab, std::string name, std::string as)
: table_(std::make_shared<table>(tab))
, name(std::move(name))
, alias(std::move(as)) {
table_->columns.push_back(*this);
}
column::column(const std::shared_ptr<sql::table>& t, std::string name, std::string as)
column::column(const std::shared_ptr<table>& t, std::string name, std::string as)
: table_(t)
, name(std::move(name))
, alias(std::move(as)) {
}
bool column::equals(const column &x) const {
bool column::equals(const column &x) const
{
return *table_ == *x.table_ &&
name == x.name &&
alias == x.alias &&
function_ == x.function_;
}
column &column::as(std::string a) {
column &column::as(std::string a)
{
alias = std::move(a);
return *this;
}
@ -72,11 +74,8 @@ std::string column::full_name() const {
return name;
}
const std::string& column::alias_name() const {
return alias;
}
bool column::is_function() const {
bool column::is_function() const
{
return function_ != sql_function_t::NONE;
}
@ -84,7 +83,4 @@ bool column::has_alias() const {
return !alias.empty();
}
std::shared_ptr<table> column::table() const {
return table_;
}
}

17
test/orm/orm/SessionQueryBuilderTest.cpp
View File

@ -26,7 +26,6 @@
using namespace matador::object;
using namespace matador::orm;
using namespace matador::query;
using namespace matador::utils;
using namespace matador::sql;
using namespace matador::test;
@ -41,7 +40,7 @@ TEST_CASE("Create sql query data for entity with eager has one", "[query][entity
session_query_builder eqb(scm, db);
auto data = eqb.build<flight>("flights.id"_col == _);
auto data = eqb.build<flight>(17U);
REQUIRE(data.is_ok());
REQUIRE(data->root_table->name == "flights");
@ -87,7 +86,7 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent
session_query_builder eqb(scm, db);
auto data = eqb.build<book>("books.id"_col == _);
auto data = eqb.build<book>(17);
REQUIRE(data.is_ok());
REQUIRE(data->root_table->name == "books");
@ -115,9 +114,9 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent
query_context qc;
size_t index{0};
criteria_evaluator evaluator(db.dialect(), qc);
for (const auto & [join_table, clause] : data->joins) {
REQUIRE(join_table->name == expected_join_data[index].first);
REQUIRE(evaluator.evaluate(*clause) == expected_join_data[index].second);
for (const auto &jd : data->joins) {
REQUIRE(jd.join_table->name == expected_join_data[index].first);
REQUIRE(evaluator.evaluate(*jd.condition) == expected_join_data[index].second);
++index;
}
@ -151,7 +150,7 @@ TEST_CASE("Create sql query data for entity with eager has many belongs to", "[q
session_query_builder eqb(scm, db);
auto data = eqb.build<order>("orders.order_id"_col == _);
auto data = eqb.build<order>(17);
REQUIRE(data.is_ok());
REQUIRE(data->root_table->name == "orders");
@ -207,7 +206,7 @@ TEST_CASE("Create sql query data for entity with eager many to many", "[query][e
session_query_builder eqb(scm, db);
auto data = eqb.build<ingredient>("ingredients.id"_col == _);
auto data = eqb.build<ingredient>(17);
REQUIRE(data.is_ok());
REQUIRE(data->root_table->name == "ingredients");
@ -253,7 +252,7 @@ TEST_CASE("Create sql query data for entity with eager many to many (inverse par
session_query_builder eqb(scm, db);
auto data = eqb.build<course>("courses.id"_col == _);
auto data = eqb.build<course>(17);
REQUIRE(data.is_ok());
REQUIRE(data->root_table->name == "courses");

140
test/orm/sql/StatementCacheTest.cpp
View File

@ -222,76 +222,76 @@ TEST_CASE("Test statement reuse avoids reprepare", "[statement][cache][prepare]"
auto stmt2 = result.value();
}
// TEST_CASE("Multithreaded stress test", "[statement][cache][stress]") {
// backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
//
// constexpr int thread_count = 16;
// constexpr int iterations = 1000;
// constexpr int sql_pool_size = 10;
//
// std::vector<std::string> sqls;
// for (int i = 0; i < sql_pool_size; ++i) {
// sqls.push_back("SELECT " + std::to_string(i));
// }
//
// connection_pool pool("noop://noop.db", 4);
// message_bus bus;
// statement_cache cache(bus, pool, 5);
// RecordingObserver observer(bus);
// MetricsObserver metrics(bus);
//
// auto start_time = std::chrono::steady_clock::now();
//
// std::atomic_int lock_failed_count{0};
// std::atomic_int exec_failed_count{0};
//
// auto worker = [&](const int tid) {
// std::mt19937 rng(tid);
// std::uniform_int_distribution dist(0, sql_pool_size - 1);
//
// for (int i = 0; i < iterations; ++i) {
// const auto& sql = sqls[dist(rng)];
// if (const auto result = cache.acquire({sql}); !result) {
// FAIL("Failed to acquire statement");
// } else {
// if (const auto exec_result = result->execute(); !exec_result) {
// if (exec_result.err().ec() == error_code::STATEMENT_LOCKED) {
// ++lock_failed_count;
// } else {
// ++exec_failed_count;
// }
// }
// }
// }
// };
//
// std::vector<std::thread> threads;
// for (int i = 0; i < thread_count; ++i) {
// threads.emplace_back(worker, i);
// }
//
// for (auto& t : threads) {
// t.join();
// }
//
// auto end_time = std::chrono::steady_clock::now();
// auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
//
// std::cout << "[Performance] Executed " << (thread_count * iterations) << " statements in " << duration.count() << " ms (lock failed: " << lock_failed_count << ", execute failed: " << exec_failed_count << ")\n";
//
// std::cout << "Average lock wait time: " << metrics.get_average_lock_wait_time().count() << "ms\n";
// std::cout << "Total lock wait time: " << metrics.get_total_lock_wait_time().count() << "ms\n";
// std::cout << "Average execution time: " << metrics.get_average_execution_time().count() << "ms\n";
// std::cout << "Total execution time: " << metrics.get_total_execution_time().count() << "ms\n";
// std::cout << "Number of lock failures: " << metrics.get_lock_failure_count() << "\n";
//
// // Some events should be generated
// int accessed = 0;
// while (auto e = observer.poll()) {
// if (e->is<statement_accessed_event>()) accessed++;
// }
// REQUIRE(accessed > 0);
// }
TEST_CASE("Multithreaded stress test", "[statement][cache][stress]") {
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
constexpr int thread_count = 16;
constexpr int iterations = 1000;
constexpr int sql_pool_size = 10;
std::vector<std::string> sqls;
for (int i = 0; i < sql_pool_size; ++i) {
sqls.push_back("SELECT " + std::to_string(i));
}
connection_pool pool("noop://noop.db", 4);
message_bus bus;
statement_cache cache(bus, pool, 5);
RecordingObserver observer(bus);
MetricsObserver metrics(bus);
auto start_time = std::chrono::steady_clock::now();
std::atomic_int lock_failed_count{0};
std::atomic_int exec_failed_count{0};
auto worker = [&](const int tid) {
std::mt19937 rng(tid);
std::uniform_int_distribution dist(0, sql_pool_size - 1);
for (int i = 0; i < iterations; ++i) {
const auto& sql = sqls[dist(rng)];
if (const auto result = cache.acquire({sql}); !result) {
FAIL("Failed to acquire statement");
} else {
if (const auto exec_result = result->execute(); !exec_result) {
if (exec_result.err().ec() == error_code::STATEMENT_LOCKED) {
++lock_failed_count;
} else {
++exec_failed_count;
}
}
}
}
};
std::vector<std::thread> threads;
for (int i = 0; i < thread_count; ++i) {
threads.emplace_back(worker, i);
}
for (auto& t : threads) {
t.join();
}
auto end_time = std::chrono::steady_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
std::cout << "[Performance] Executed " << (thread_count * iterations) << " statements in " << duration.count() << " ms (lock failed: " << lock_failed_count << ", execute failed: " << exec_failed_count << ")\n";
std::cout << "Average lock wait time: " << metrics.get_average_lock_wait_time().count() << "ms\n";
std::cout << "Total lock wait time: " << metrics.get_total_lock_wait_time().count() << "ms\n";
std::cout << "Average execution time: " << metrics.get_average_execution_time().count() << "ms\n";
std::cout << "Total execution time: " << metrics.get_total_execution_time().count() << "ms\n";
std::cout << "Number of lock failures: " << metrics.get_lock_failure_count() << "\n";
// Some events should be generated
int accessed = 0;
while (auto e = observer.poll()) {
if (e->is<statement_accessed_event>()) accessed++;
}
REQUIRE(accessed > 0);
}
TEST_CASE("Race condition simulation with mixed access", "[statement_cache][race]") {
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());