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

observer progress, added to schema and added schema_observer class

This commit is contained in:
Sascha Kühl 2025-12-19 15:56:36 +01:00
parent 5e2d2ddde5
commit d104222fdd
16 changed files with 205 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
include/matador/object/foreign_node_completer.hpp
View File

@ -12,24 +12,32 @@
#include "matador/logger/log_manager.hpp"
#include <stack>
#include "repository.hpp"
#include <vector>
namespace matador::object {
template<typename NodeType, template<typename> typename... Observers>
class completer {
public:
template<typename Type>
void foo(Observers<NodeType>&&... observers) {
(std::unique_ptr<Observers<Type>>(new Observers(std::forward<Observers>(observers))), ...);
}
};
/**
* Processes the given node and ensures
* that all foreign nodes needed by the given node
* relations are attached in schema.
*/
template<typename NodeType>
template<typename NodeType, template<typename> typename ...Observers>
class foreign_node_completer final {
private:
using node_ptr = std::shared_ptr<repository_node>;
public:
static void complete(const std::shared_ptr<repository_node> &node) {
static void complete(const std::shared_ptr<repository_node> &node, Observers<NodeType>... observers) {
internal::shadow_repository shadow(node->repo_);
foreign_node_completer completer(shadow);
foreign_node_completer completer(shadow, observers...);
completer.complete_node(node);
}
@ -60,18 +68,20 @@ public:
}
template<class CollectionType>
void on_has_many_to_many(const char *id,
CollectionType &collection,
const char *join_column,
const char *inverse_join_column,
const utils::foreign_attributes &attr);
static void on_has_many_to_many(const char * /*id*/,
CollectionType &/*collection*/,
const char * /*join_column*/,
const char * /*inverse_join_column*/,
const utils::foreign_attributes &/*attr*/) {}
template<class CollectionType>
void on_has_many_to_many(const char *id, CollectionType &collection, const utils::foreign_attributes &attr);
static void on_has_many_to_many(const char * /*id*/, CollectionType &/*collection*/, const utils::foreign_attributes &/*attr*/) {}
private:
explicit foreign_node_completer(internal::shadow_repository &shadow)
explicit foreign_node_completer(internal::shadow_repository &shadow, Observers<NodeType>... observers)
: repo_(shadow)
, log_(logger::create_logger("node_completer")) {}
, log_(logger::create_logger("node_completer")) {
// observers_.emplace_back(observers...);
}
void complete_node(const std::shared_ptr<repository_node> &node) {
nodes_.push(node);
@ -160,7 +170,7 @@ private:
const endpoint_ptr &other_endpoint);
private:
template<typename Type>
template<typename Type, template<typename> typename ...OtherObservers>
friend class foreign_node_completer;
private:
@ -168,69 +178,41 @@ private:
internal::shadow_repository &repo_;
logger::logger log_;
join_columns_collector join_columns_collector_{};
// const std::vector<Observers<NodeType>...> observers_;
};
template<typename NodeType>
template<typename NodeType, template<typename> typename ...Observers>
template<class ForeignPointerType>
void foreign_node_completer<NodeType>::on_belongs_to(const char * /*id*/, ForeignPointerType &, const utils::foreign_attributes &) {
void foreign_node_completer<NodeType, Observers...>::on_belongs_to(const char * /*id*/, ForeignPointerType &, const utils::foreign_attributes &) {
attach_node<typename ForeignPointerType::value_type>();
}
template<typename NodeType>
template<typename NodeType, template<typename> typename ...Observers>
template<class ForeignPointerType>
void foreign_node_completer<NodeType>::on_has_one(const char *, ForeignPointerType &, const utils::foreign_attributes &) {
void foreign_node_completer<NodeType, Observers...>::on_has_one(const char *, ForeignPointerType &, const utils::foreign_attributes &) {
attach_node<typename ForeignPointerType::value_type>();
}
template<typename NodeType>
template<typename NodeType, template<typename> typename ...Observers>
template<class CollectionType>
void foreign_node_completer<NodeType>::on_has_many(const char * /*id*/,
void foreign_node_completer<NodeType, Observers...>::on_has_many(const char * /*id*/,
CollectionType &, const char * /*join_column*/,
const utils::foreign_attributes & /*attr*/,
std::enable_if_t<is_object_ptr<typename CollectionType::value_type>::value> *) {
attach_node<typename CollectionType::value_type::value_type>();
}
template<typename NodeType>
template<class CollectionType>
void foreign_node_completer<NodeType>::on_has_many_to_many(const char * /*id*/,
CollectionType & /*collection*/,
const char * /*join_column*/,
const char * /*inverse_join_column*/,
const utils::foreign_attributes & /*attr*/) {
// if (!repo_.expecting_relation_node(id)) {
// repo_.expect_relation_node(id, typeid(typename CollectionType::value_type::value_type));
// } else {
// attach_relation_node<typename CollectionType::value_type::value_type>(id, join_column, inverse_join_column);
// repo_.remove_expected_relation_node(id);
// }
}
template<typename NodeType>
template<class CollectionType>
void foreign_node_completer<NodeType>::on_has_many_to_many(const char * /*id*/,
CollectionType & /*collection*/,
const utils::foreign_attributes & /*attr*/) {
// if (!repo_.expecting_relation_node(id)) {
// repo_.expect_relation_node(id, typeid(typename CollectionType::value_type::value_type));
// } else {
// const auto join_columns = join_columns_collector_.collect<typename CollectionType::value_type::value_type>();
// attach_relation_node<typename CollectionType::value_type::value_type>(id, join_columns.join_column, join_columns.inverse_join_column);
// repo_.remove_expected_relation_node(id);
// }
}
template<typename NodeType>
void foreign_node_completer<NodeType>::register_relation_endpoints(const endpoint_ptr &endpoint,
template<typename NodeType, template<typename> typename ...Observers>
void foreign_node_completer<NodeType, Observers...>::register_relation_endpoints(const endpoint_ptr &endpoint,
const endpoint_ptr &other_endpoint) {
endpoint->node_->info_->register_relation_endpoint(other_endpoint->node_->type_index(), endpoint);
other_endpoint->node_->info_->register_relation_endpoint(endpoint->node_->type_index(), other_endpoint);
link_relation_endpoints(endpoint, other_endpoint);
}
template<typename NodeType>
void foreign_node_completer<NodeType>::link_relation_endpoints(const endpoint_ptr &endpoint, const endpoint_ptr &other_endpoint) {
template<typename NodeType, template<typename> typename ...Observers>
void foreign_node_completer<NodeType, Observers...>::link_relation_endpoints(const endpoint_ptr &endpoint, const endpoint_ptr &other_endpoint) {
endpoint->link_foreign_endpoint(other_endpoint);
other_endpoint->link_foreign_endpoint(endpoint);
}

2
include/matador/object/relation_endpoint.hpp
View File

@ -43,7 +43,7 @@ public:
private:
template<typename Type>
friend class relation_completer;
template<typename Type>
template<typename Type, template<typename> typename ...Observers>
friend class foreign_node_completer;
std::string field_name_;

4
include/matador/object/repository.hpp
View File

@ -67,8 +67,6 @@ public:
return utils::failure(result.err());
}
node->on_attach();
foreign_node_completer<Type>::complete(node);
relation_completer<Type>::complete(node);
} else if (!has_node(name)) {
@ -200,7 +198,7 @@ private:
private:
friend class internal::shadow_repository;
friend class repository_node;
template < typename NodeType >
template < typename NodeType, template<typename> typename ...Observers >
friend class foreign_node_completer;
friend class object_generator;

2
include/matador/object/repository_node.hpp
View File

@ -80,7 +80,7 @@ private:
friend class repository;
template<typename Type>
friend class relation_completer;
template < typename NodeType >
template < typename NodeType, template<typename> typename ...Observers >
friend class foreign_node_completer;
friend class const_repository_node_iterator;

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

@ -5,6 +5,7 @@
#include "matador/query/criteria.hpp"
#include "matador/query/query.hpp"
#include "matador/query/schema.hpp"
#include "matador/sql/executor.hpp"
#include "matador/sql/statement.hpp"
@ -33,7 +34,7 @@ struct entity_query_data {
class criteria_transformer final : public query::criteria_visitor {
public:
criteria_transformer(const object::repository &repo, const std::unordered_map<std::string, std::shared_ptr<query::table>>& tables_by_name);
criteria_transformer(const query::schema &repo, const std::unordered_map<std::string, std::shared_ptr<query::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;
@ -47,19 +48,19 @@ private:
void update_criteria_column(const query::abstract_column_criteria& node) const;
private:
const object::repository &repo_;
const query::schema &repo_;
const std::unordered_map<std::string, std::shared_ptr<query::table>>& tables_by_name_;
};
class session_query_builder final {
public:
session_query_builder(const object::repository &scm, sql::executor &exec)
session_query_builder(const query::schema &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>();
const auto info = schema_.repo().info<EntityType>();
if (!info) {
return utils::failure(query_build_error::UnknownType);
}
@ -114,7 +115,7 @@ public:
template<class ContainerType>
void on_has_many(const char * /*id*/, ContainerType &, const char *join_column, const utils::foreign_attributes &attr) {
if (attr.fetch() == utils::fetch_type::Eager) {
const auto result = schema_.basic_info(typeid(typename ContainerType::value_type::value_type));
const auto result = schema_.repo().basic_info(typeid(typename ContainerType::value_type::value_type));
if (!result) {
throw query_builder_exception{query_build_error::UnknownType};
}
@ -146,7 +147,7 @@ public:
if (attr.fetch() != utils::fetch_type::Eager) {
return;
}
const auto result = schema_.basic_info(typeid(typename ContainerType::value_type::value_type));
const auto result = schema_.repo().basic_info(typeid(typename ContainerType::value_type::value_type));
if (!result) {
throw query_builder_exception{query_build_error::UnknownType};
}
@ -186,7 +187,7 @@ public:
if (attr.fetch() != utils::fetch_type::Eager) {
return;
}
const auto result = schema_.basic_info(typeid(typename ContainerType::value_type::value_type));
const auto result = schema_.repo().basic_info(typeid(typename ContainerType::value_type::value_type));
if (!result) {
throw query_builder_exception{query_build_error::UnknownType};
}
@ -239,7 +240,7 @@ private:
std::stack<table_info> table_info_stack_{};
std::unordered_map<std::string, std::shared_ptr<query::table>> processed_tables_{};
const object::repository &schema_;
const query::schema &schema_;
entity_query_data entity_query_data_{};
unsigned int column_index{0};
unsigned int table_index{0};
@ -249,7 +250,7 @@ private:
template<class Pointer>
void session_query_builder::on_foreign_object(const char *id, Pointer &, const utils::foreign_attributes &attr) {
const auto info = schema_.info<typename Pointer::value_type>();
const auto info = schema_.repo().info<typename Pointer::value_type>();
if (!info) {
throw query_builder_exception{query_build_error::UnknownType};
}

11
include/matador/query/column.hpp
View File

@ -16,10 +16,13 @@ class table;
// ReSharper disable CppNonExplicitConvertingConstructor
class column {
public:
column(const char *name, const std::string& as = ""); // NOLINT(*-explicit-constructor)
column(std::string name, std::string as = ""); // NOLINT(*-explicit-constructor)
column(const char *name); // NOLINT(*-explicit-constructor)
column(std::string name); // NOLINT(*-explicit-constructor)
column(std::string name, std::string alias);
column(sql::sql_function_t func, std::string name);
column(const class table* tab, std::string name, std::string as = "");
column(const class table* tab, std::string name);
column(const class table* tab, std::string name, std::string alias);
column(const class table* tab, std::string name, utils::basic_type type, const utils::field_attributes& attributes);
[[nodiscard]] bool equals(const column &x) const;
@ -45,6 +48,8 @@ private:
static query::table* default_table();
private:
friend class table;
const query::table* table_{nullptr};
std::string name_;
std::string alias_;

19
include/matador/query/generator.hpp
View File

@ -6,12 +6,11 @@
#include <matador/utils/field_attributes.hpp>
#include <matador/utils/foreign_attributes.hpp>
#include "matador/object/repository.hpp"
#include "matador/query/fk_value_extractor.hpp"
#include "matador/query/internal/column_value_pair.hpp"
#include "matador/query/table.hpp"
#include "matador/query/schema.hpp"
#include <vector>
@ -48,7 +47,7 @@ class column_generator {
public:
explicit column_generator(const std::string &table_name = "",
column_generator_options options = default_column_generator_options);
explicit column_generator(const object::repository &repo,
explicit column_generator(const schema &repo,
const std::string &table_name = "",
column_generator_options options = default_column_generator_options);
@ -94,7 +93,7 @@ public:
if (!repo_) {
return;
}
const auto info = repo_->get().info<typename ContainerType::value_type::value_type>();
const auto info = repo_->get().repo().info<typename ContainerType::value_type::value_type>();
if (!info) {
return;
}
@ -130,7 +129,7 @@ private:
if (!repo_) {
return;
}
const auto info = repo_->get().info<typename Pointer::value_type>();
const auto info = repo_->get().repo().info<typename Pointer::value_type>();
if (!info) {
return;
}
@ -148,7 +147,7 @@ private:
void push(const std::string &column_name);
private:
std::optional<std::reference_wrapper<const object::repository>> repo_;
std::optional<std::reference_wrapper<const schema>> repo_;
std::vector<column> result_;
std::stack<std::shared_ptr<table>> table_stack_;
std::unordered_set<std::string> seen_tables;
@ -296,7 +295,7 @@ std::vector<internal::column_value_pair> column_value_pairs() {
}
template<typename Type>
std::vector<column> columns(const object::repository &repo,
std::vector<column> columns(const schema &repo,
const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
column_generator generator(repo, table_name, options);
@ -304,10 +303,10 @@ std::vector<column> columns(const object::repository &repo,
}
template<typename Type>
std::vector<column> columns(const object::repository &repo,
std::vector<column> columns(const schema &repo,
const column_generator_options options) {
std::string table_name;
if (const auto result = repo.info<Type>()) {
if (const auto result = repo.repo().info<Type>()) {
table_name = result.value().get().name();
}
column_generator generator(repo, table_name, options);
@ -316,7 +315,7 @@ std::vector<column> columns(const object::repository &repo,
template<typename Type>
std::vector<column> columns(const Type &obj,
const object::repository &repo,
const schema &repo,
const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
column_generator generator(repo, table_name, options);

62
include/matador/query/schema.hpp
View File

@ -1,6 +1,7 @@
#ifndef MATADOR_SCHEMA_HPP
#define MATADOR_SCHEMA_HPP
#include "matador/object/observer.hpp"
#include "matador/object/repository.hpp"
#include "matador/sql/query_context.hpp"
@ -28,19 +29,39 @@ private:
std::unordered_map<std::string, schema> schema_map_;
};
template<typename Type>
class schema_observer final : public object::observer<Type> {
public:
explicit schema_observer(schema& s)
: schema_(s) {}
void on_attach(object::repository_node &node, const Type &prototype) override;
void on_detach(object::repository_node &node, const Type &prototype) override;
void on_insert(Type &obj) override;
void on_update(Type &obj) override;
void on_delete(Type &obj) override;
private:
schema& schema_;
};
class schema final {
public:
explicit schema(sql::connection_pool &pool);
schema(sql::connection_pool &pool, const std::string &name);
template<typename Type, template <typename> class ObserverType>
[[nodiscard]] utils::result<void, utils::error> attach(const std::string &name, const std::string &parent = "", std::initializer_list<ObserverType<Type>*> observer = {}) {
return repo_.attach<Type>(name, parent, observer);
template<typename Type, typename... Observers>
[[nodiscard]] utils::result<void, utils::error> attach(const std::string &name, Observers&&... observers) {
return repo_.attach<Type>(name, schema_observer<Type>{*this}, std::forward<Observers>(observers)...);
}
template<typename Type, typename SuperType, template <typename> class ObserverType>
[[nodiscard]] utils::result<void, utils::error> attach(const std::string &name, std::initializer_list<ObserverType<Type>*> observer = {}) {
return repo_.attach<Type, SuperType>(name, observer);
template<typename Type, typename... Observers>
[[nodiscard]] utils::result<void, utils::error> attach(const std::string &name, const std::string &parent, Observers&&... observers) {
return repo_.attach<Type>(name, parent, schema_observer<Type>{*this}, std::forward<Observers>(observers)...);
}
template<typename Type, typename SuperType, typename... Observers>
[[nodiscard]] utils::result<void, utils::error> attach(const std::string &name, Observers&&... observers) {
return repo_.attach<Type, SuperType>(name, schema_observer<Type>{*this}, std::forward<Observers>(observers)...);
}
[[nodiscard]] utils::result<void, utils::error> create() const;
@ -53,13 +74,20 @@ public:
[[nodiscard]] utils::result<std::vector<object::attribute>, utils::error> describe_table(const std::string &table_name) const;
[[nodiscard]] utils::result<bool, utils::error> table_exists(const std::string &table_name) const;
private:
[[nodiscard]] sql::query_context build_add_constraint_context( const object::repository_node& node, const object::restriction& cons ) const;
[[nodiscard]] sql::query_context build_drop_constraint_context( const object::repository_node& node, const object::restriction& cons ) const;
const object::repository &repo() const { return repo_; }
private:
[[nodiscard]] sql::query_context build_add_constraint_context( const object::repository_node& node, const object::restriction& cons ) const;
[[nodiscard]] sql::query_context build_drop_constraint_context( const object::repository_node& node, const object::restriction& cons ) const;
void insert_table(const std::type_index& ti, const object::repository_node &node);
private:
template<typename Type>
friend class schema_observer;
object::repository repo_;
std::unordered_map<std::type_index, table> table_map_;
std::unordered_map<std::type_index, table> tables_;
sql::connection_pool &pool_;
};
@ -72,6 +100,18 @@ utils::result<void, utils::error> schema::drop_table() {
return utils::failure(info.err());
}
template <typename Type>
void schema_observer<Type>::on_attach(object::repository_node &node, const Type &prototype) {
schema_.insert_table(typeid(Type), node);
}
template <typename Type>
void schema_observer<Type>::on_detach(object::repository_node &node, const Type &prototype) {}
template <typename Type>
void schema_observer<Type>::on_insert(Type &obj) {}
template <typename Type>
void schema_observer<Type>::on_update(Type &obj) {}
template <typename Type>
void schema_observer<Type>::on_delete(Type &obj) {}
} // namespace matador::query
#endif //MATADOR_SCHEMA_HPP

4
source/core/object/repository.cpp
View File

@ -22,6 +22,8 @@ utils::result<void, utils::error> repository::detach(const node_ptr &node) {
remove_node(node);
node->on_detach();
return utils::ok<void>();
}
@ -126,6 +128,8 @@ utils::result<repository::node_ptr, utils::error> repository::attach_node(const
nodes_by_name_.insert({node->name(), node});
nodes_by_type_.insert({node->type_index(), node});
node->on_attach();
return utils::ok(node);
}

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

@ -3,7 +3,7 @@
#include <iostream>
namespace matador::orm {
criteria_transformer::criteria_transformer(const object::repository& repo, const std::unordered_map<std::string, std::shared_ptr<query::table>>& tables_by_name)
criteria_transformer::criteria_transformer(const query::schema& repo, const std::unordered_map<std::string, std::shared_ptr<query::table>>& tables_by_name)
: repo_(repo)
, tables_by_name_(tables_by_name) {}

27
source/orm/query/column.cpp
View File

@ -21,25 +21,38 @@ column operator ""_col(const char *name, const size_t len) {
return column{new table(str.substr(0, pos)), str.substr(pos + 1)};
}
column::column(const char *name, const std::string& as)
: column(std::string(name), as)
column::column(const char *name)
: column(std::string(name))
{}
column::column(std::string name, std::string as)
column::column(std::string name)
: table_(default_table())
, name_(std::move(name)) {}
column::column(std::string name, std::string alias)
: table_(default_table())
, name_(std::move(name))
, alias_(std::move(as)) {}
, alias_(std::move(alias)) {}
column::column(const sql::sql_function_t func, std::string name)
: table_(default_table())
, name_(std::move(name))
, function_(func) {}
column::column(const class table* tab, std::string name, std::string as)
column::column(const class table* tab, std::string name)
: table_(tab)
, name_(std::move(name)) {}
column::column(const class query::table* tab, std::string name, std::string alias)
: table_(tab)
, name_(std::move(name))
, alias_(std::move(as)) {
}
, alias_(std::move(alias)) {}
column::column(const class query::table* tab, std::string name,
const utils::basic_type type,
const utils::field_attributes& attributes)
: table_(tab)
, name_(std::move(name))
, type_(type)
, attributes_(attributes) {}
bool column::equals(const column &x) const {
return *table_ == *x.table_ &&

2
source/orm/query/generator.cpp
View File

@ -6,7 +6,7 @@ column_generator::column_generator(const std::string& table_name, const column_g
table_stack_.push(table_name.empty() ? std::make_shared<table>() : std::make_shared<table>(table_name));
}
column_generator::column_generator(const object::repository& repo, const std::string& table_name, const column_generator_options options)
column_generator::column_generator(const schema& repo, const std::string& table_name, const column_generator_options options)
: repo_(std::cref(repo))
, options_(options) {
table_stack_.push(table_name.empty() ? std::make_shared<table>() : std::make_shared<table>(table_name));

18
source/orm/query/schema.cpp
View File

@ -2,6 +2,8 @@
#include "matador/query/query.hpp"
#include "matador/object/repository_node.hpp"
#include "matador/sql/backend_provider.hpp"
#include "matador/sql/connection_pool.hpp"
#include "matador/sql/dialect.hpp"
@ -196,9 +198,17 @@ sql::query_context schema::build_add_constraint_context( const object::repositor
}
sql::query_context schema::build_drop_constraint_context( const object::repository_node& node, const object::restriction& cons ) const {
return query::query::alter()
.table(node.name())
.drop_constraint(cons)
.compile(*pool_.acquire());
return query::query::alter()
.table(node.name())
.drop_constraint(cons)
.compile(*pool_.acquire());
}
void schema::insert_table(const std::type_index& ti, const object::repository_node& node) {
std::vector<column> columns;
for (const auto &attr : node.info().attributes()) {
columns.emplace_back(nullptr, attr.name(), attr.type(), attr.attributes());
}
std::ignore = tables_.insert({ti, table(node.name(), "", columns)}).first;
}
} // namespace matador::query

6
source/orm/query/table.cpp
View File

@ -18,7 +18,11 @@ table::table(std::string name, std::string as)
table::table( std::string name, std::string as, const std::vector<query::column>& columns )
: name_(std::move(name))
, alias_(std::move(as))
, columns_(columns) {}
, columns_(columns) {
for (auto& col : columns_) {
col.table_ = this;
}
}
bool table::operator==( const table& x ) const {
return name_ == x.name_;

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

@ -3,11 +3,14 @@
#include "matador/sql/backend_provider.hpp"
#include "matador/sql/connection.hpp"
#include "matador/sql/connection_pool.hpp"
#include "matador/sql/interface/connection_impl.hpp"
#include "matador/query/criteria_evaluator.hpp"
#include "matador/query/query.hpp"
#include "matador/query/column.hpp"
#include "matador/query/table.hpp"
#include "matador/query/schema.hpp"
#include "matador/orm/session_query_builder.hpp"
@ -34,7 +37,9 @@ TEST_CASE("Create sql query data for entity with eager has one", "[query][entity
using namespace matador::test;
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection db("noop://noop.db");
repository scm("noop");
connection_pool pool("noop://noop.db", 4);
schema scm(pool);
auto result = scm.attach<airplane>("airplanes")
.and_then( [&scm] { return scm.attach<flight>("flights"); } );
REQUIRE(result);
@ -82,7 +87,9 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent
using namespace matador::test;
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection db("noop://noop.db");
repository scm("noop");
connection_pool pool("noop://noop.db", 4);
schema scm(pool);
auto result = scm.attach<author>("authors")
.and_then( [&scm] { return scm.attach<book>("books"); } );
REQUIRE(result);
@ -145,7 +152,9 @@ TEST_CASE("Create sql query data for entity with eager has many belongs to", "[q
using namespace matador::test;
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection db("noop://noop.db");
repository scm("noop");
connection_pool pool("noop://noop.db", 4);
schema scm(pool);
auto result = scm.attach<product>("products")
.and_then( [&scm] { return scm.attach<order_details>("order_details"); } )
.and_then( [&scm] { return scm.attach<supplier>("suppliers"); } )
@ -206,10 +215,12 @@ TEST_CASE("Create sql query data for entity with eager many to many", "[query][e
using namespace matador::test;
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection db("noop://noop.db");
repository scm("noop");
connection_pool pool("noop://noop.db", 4);
schema scm(pool);
auto result = scm.attach<recipe>("recipes")
.and_then( [&scm] { return scm.attach<ingredient>("ingredients"); } );
// .and_then( [&scm] { return scm.attach<recipe_ingredient>("recipe_ingredients"); } );
REQUIRE(result);
session_query_builder eqb(scm, db);
@ -254,10 +265,12 @@ TEST_CASE("Create sql query data for entity with eager many to many (inverse par
using namespace matador::test;
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection db("noop://noop.db");
repository scm("noop");
connection_pool pool("noop://noop.db", 4);
schema scm(pool);
auto result = scm.attach<student>("students")
.and_then( [&scm] { return scm.attach<course>("courses"); } );
// .and_then( [&scm] { return scm.attach<student_course>("student_courses"); } );
REQUIRE(result);
session_query_builder eqb(scm, db);
@ -302,9 +315,12 @@ TEST_CASE("Test eager relationship", "[session][eager]") {
using namespace matador::test;
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection db("noop://noop.db");
repository scm("noop");
connection_pool pool("noop://noop.db", 4);
schema scm(pool);
auto result = scm.attach<department>("departments")
.and_then( [&scm] { return scm.attach<employee>("employees"); } );
REQUIRE(result);
session_query_builder eqb(scm, db);

23
test/orm/sql/ColumnGeneratorTest.cpp
View File

@ -1,10 +1,17 @@
#include <catch2/catch_test_macros.hpp>
#include "matador/sql/backend_provider.hpp"
#include "matador/sql/connection_pool.hpp"
#include "matador/sql/interface/connection_impl.hpp"
#include "matador/query/generator.hpp"
#include "matador/query/table.hpp"
#include "matador/query/schema.hpp"
#include "matador/object/repository.hpp"
#include "../backend/test_backend_service.hpp"
#include "../test/models/product.hpp"
#include "../test/models/order.hpp"
#include "../test/models/book.hpp"
@ -12,10 +19,14 @@
using namespace matador::query;
using namespace matador::object;
using namespace matador::sql;
TEST_CASE("Generate columns from object", "[column][generator]") {
using namespace matador::test;
repository s("main");
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection_pool pool("noop://noop.db", 4);
schema s(pool);
auto result = s.attach<product>("product");
REQUIRE( result );
@ -42,7 +53,10 @@ TEST_CASE("Generate columns from object", "[column][generator]") {
TEST_CASE("Generate columns for object with has many relation", "[column][generator][relation]") {
using namespace matador::test;
repository s("main");
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection_pool pool("noop://noop.db", 4);
schema s(pool);
auto result = s.attach<supplier>("supplier")
.and_then( [&s] { return s.attach<category>("categories"); } )
.and_then( [&s] { return s.attach<order_details>("order_details"); } )
@ -82,7 +96,10 @@ TEST_CASE("Generate columns for object with has many relation", "[column][genera
TEST_CASE("Generate columns for object with eager foreign key relation", "[column][generator][eager]") {
using namespace matador::test;
repository s("main");
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection_pool pool("noop://noop.db", 4);
schema s(pool);
auto result = s.attach<book>("books")
.and_then( [&s] { return s.attach<author>("authors"); } );
REQUIRE(result);