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

renamed collection resolver producer related classes

This commit is contained in:
sascha 2026-05-18 09:03:24 +02:00
parent bf99642af4
commit 820b5432b2
16 changed files with 74 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
demo/sandbox.cpp
View File

@ -100,7 +100,7 @@ struct user {
namespace field = access; namespace field = access;
field::primary_key( op, "id", id ); field::primary_key( op, "id", id );
field::attribute( op, "username", username, VarChar255 ); field::attribute( op, "username", username, VarChar255 );
field::has_one(op, "profile_id", profile, utils::CascadeNoneFetchLazy ); field::has_one(op, "profiles", profile, "profile_id", utils::CascadeNoneFetchLazy );
} }
}; };
@ -139,7 +139,7 @@ int main() {
sql::resolver_service rs; sql::resolver_service rs;
std::weak_ptr cr = rs.collection_resolver<object::object_ptr<names>>( typeid(person), "names" ); std::weak_ptr cr = rs.joined_collection_resolver<object::object_ptr<names>>( typeid(person), "names" );
utils::identifier id{1}; utils::identifier id{1};
object::collection_proxy cp(cr, id); object::collection_proxy cp(cr, id);

2
include/matador/object/collection_resolver_factory.hpp → include/matador/object/joined_collection_resolver_factory.hpp
View File

@ -14,7 +14,7 @@ public:
virtual void register_collection_resolver(std::shared_ptr<abstract_joined_resolver> &&resolver) = 0; virtual void register_collection_resolver(std::shared_ptr<abstract_joined_resolver> &&resolver) = 0;
}; };
class collection_resolver_factory : public abstract_collection_resolver_factory { class joined_collection_resolver_factory : public abstract_collection_resolver_factory {
public: public:
template<class Type> template<class Type>
[[nodiscard]] std::shared_ptr<collection_resolver<Type>> resolver(const std::type_index &root_type, const std::string &collection_name) const { [[nodiscard]] std::shared_ptr<collection_resolver<Type>> resolver(const std::type_index &root_type, const std::string &collection_name) const {

8
include/matador/query/basic_schema.hpp
View File

@ -6,9 +6,9 @@
#include "matador/query/abstract_pk_generator.hpp" #include "matador/query/abstract_pk_generator.hpp"
#include "matador/query/table.hpp" #include "matador/query/table.hpp"
#include "matador/sql/internal/collection_resolver_producer.hpp" #include "matador/sql/internal/joined_collection_resolver_producer.hpp"
#include "matador/sql/internal/object_resolver_producer.hpp" #include "matador/sql/internal/object_resolver_producer.hpp"
#include "matador/sql/producer_resolver_factory.hpp" #include "matador/sql/producer_object_resolver_factory.hpp"
#include <memory> #include <memory>
#include <typeindex> #include <typeindex>
@ -102,7 +102,7 @@ public:
[[nodiscard]] bool contains(const std::type_index &index) const; [[nodiscard]] bool contains(const std::type_index &index) const;
[[nodiscard]] const std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_producer>>& resolver_producers() const; [[nodiscard]] const std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_producer>>& resolver_producers() const;
[[nodiscard]] const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::collection_resolver_producer>, object::collection_composite_key_hash>& collection_resolver_producers() const; [[nodiscard]] const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::joined_collection_resolver_producer>, object::collection_composite_key_hash>& collection_resolver_producers() const;
[[nodiscard]] const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::joined_object_resolver_producer>, object::collection_composite_key_hash>& joined_object_resolver_producers() const; [[nodiscard]] const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::joined_object_resolver_producer>, object::collection_composite_key_hash>& joined_object_resolver_producers() const;
protected: protected:
@ -113,7 +113,7 @@ protected:
object::repository repo_; object::repository repo_;
std::unordered_map<std::type_index, schema_node> schema_nodes_; std::unordered_map<std::type_index, schema_node> schema_nodes_;
std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_producer>> resolver_producers_; std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_producer>> resolver_producers_;
std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::collection_resolver_producer>, object::collection_composite_key_hash> collection_resolver_producers_; std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::joined_collection_resolver_producer>, object::collection_composite_key_hash> collection_resolver_producers_;
std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::joined_object_resolver_producer>, object::collection_composite_key_hash> joined_object_resolver_producers_; std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::joined_object_resolver_producer>, object::collection_composite_key_hash> joined_object_resolver_producers_;
}; };
} }

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

@ -5,7 +5,7 @@
#include "matador/sql/query_context.hpp" #include "matador/sql/query_context.hpp"
#include "matador/sql/internal/object_resolver_producer.hpp" #include "matador/sql/internal/object_resolver_producer.hpp"
#include "matador/sql/internal/collection_resolver_producer.hpp" #include "matador/sql/internal/joined_collection_resolver_producer.hpp"
#include "matador/query/query_collection_resolver.hpp" #include "matador/query/query_collection_resolver.hpp"
#include "matador/query/query_object_resolver.hpp" #include "matador/query/query_object_resolver.hpp"
@ -64,11 +64,11 @@ private:
}; };
template<typename Type> template<typename Type>
class query_collection_resolver_producer : public sql::collection_resolver_producer { class query_joined_collection_resolver_producer : public sql::joined_collection_resolver_producer {
public: public:
query_collection_resolver_producer() = default; query_joined_collection_resolver_producer() = default;
query_collection_resolver_producer(const basic_schema& repo, const table& tab, std::string pk_name, const std::type_index& root_type, std::string join_column) query_joined_collection_resolver_producer(const basic_schema& repo, const table& tab, std::string pk_name, const std::type_index& root_type, std::string join_column)
: collection_resolver_producer(root_type, typeid(Type), std::move(join_column)) : joined_collection_resolver_producer(root_type, typeid(Type), std::move(join_column))
, repo_(repo) , repo_(repo)
, table_(tab) , table_(tab)
, pk_name_(std::move(pk_name)) , pk_name_(std::move(pk_name))
@ -76,7 +76,7 @@ public:
utils::result<sql::query_context, utils::error> build_query(const sql::dialect& d) override { utils::result<sql::query_context, utils::error> build_query(const sql::dialect& d) override {
const auto *pk_column = table_[pk_name_]; const auto *pk_column = table_[pk_name_];
const auto *join_column = table_[collection_name()]; const auto *join_column = table_[join_column_name()];
const auto stmt = select({*pk_column}) const auto stmt = select({*pk_column})
.from(table_) .from(table_)
@ -89,7 +89,7 @@ public:
std::shared_ptr<object::abstract_joined_resolver> produce(sql::statement&& stmt, const sql::resolver_service& rs) override { std::shared_ptr<object::abstract_joined_resolver> produce(sql::statement&& stmt, const sql::resolver_service& rs) override {
const auto object_resolver = rs.object_resolver<typename Type::value_type>(); const auto object_resolver = rs.object_resolver<typename Type::value_type>();
return std::make_shared<query_collection_resolver<Type>>(std::move(stmt), root_type(), collection_name(), object_resolver); return std::make_shared<query_collection_resolver<Type>>(std::move(stmt), root_type(), join_column_name(), object_resolver);
} }
private: private:
@ -99,11 +99,11 @@ private:
}; };
template<typename Type> template<typename Type>
class query_collection_primitive_resolver_producer : public sql::collection_resolver_producer { class query_joined_collection_primitive_resolver_producer : public sql::joined_collection_resolver_producer {
public: public:
query_collection_primitive_resolver_producer() = default; query_joined_collection_primitive_resolver_producer() = default;
query_collection_primitive_resolver_producer(const basic_schema& repo, const table& tab, std::string value_name, const std::type_index& root_type, std::string join_column) query_joined_collection_primitive_resolver_producer(const basic_schema& repo, const table& tab, std::string value_name, const std::type_index& root_type, std::string join_column)
: collection_resolver_producer(root_type, typeid(Type), std::move(join_column)) : joined_collection_resolver_producer(root_type, typeid(Type), std::move(join_column))
, repo_(repo) , repo_(repo)
, table_(tab) , table_(tab)
, value_name_(std::move(value_name)) , value_name_(std::move(value_name))
@ -111,7 +111,7 @@ public:
utils::result<sql::query_context, utils::error> build_query(const sql::dialect& d) override { utils::result<sql::query_context, utils::error> build_query(const sql::dialect& d) override {
const auto *value_column = table_[value_name_]; const auto *value_column = table_[value_name_];
const auto *join_column = table_[collection_name()]; const auto *join_column = table_[join_column_name()];
const auto stmt = select({*value_column}) const auto stmt = select({*value_column})
.from(table_) .from(table_)
@ -122,7 +122,7 @@ public:
} }
std::shared_ptr<object::abstract_joined_resolver> produce(sql::statement&& stmt, const sql::resolver_service& /*rs*/) override { std::shared_ptr<object::abstract_joined_resolver> produce(sql::statement&& stmt, const sql::resolver_service& /*rs*/) override {
return std::make_shared<query_collection_primitive_resolver<Type>>(std::move(stmt), root_type(), collection_name()/*, object_resolver*/); return std::make_shared<query_collection_primitive_resolver<Type>>(std::move(stmt), root_type(), join_column_name()/*, object_resolver*/);
} }
private: private:
@ -177,7 +177,7 @@ public:
throw query_builder_exception{error_code::MissingPrimaryKey, "Missing primary key"}; throw query_builder_exception{error_code::MissingPrimaryKey, "Missing primary key"};
} }
auto producer = std::make_unique<query_collection_resolver_producer<typename CollectionType::value_type>>( auto producer = std::make_unique<query_joined_collection_resolver_producer<typename CollectionType::value_type>>(
schema_, schema_,
it->second.table(), it->second.table(),
it->second.node().info().primary_key_attribute()->name(), it->second.node().info().primary_key_attribute()->name(),
@ -193,7 +193,7 @@ public:
if (it == schema_.end()) { if (it == schema_.end()) {
throw query_builder_exception{error_code::UnknownType, "Unknown type" + std::string{id}}; throw query_builder_exception{error_code::UnknownType, "Unknown type" + std::string{id}};
} }
auto producer = std::make_unique<query_collection_primitive_resolver_producer<typename CollectionType::value_type>>( auto producer = std::make_unique<query_joined_collection_primitive_resolver_producer<typename CollectionType::value_type>>(
schema_, schema_,
it->second.table(), it->second.table(),
"value", "value",
@ -210,7 +210,7 @@ public:
throw query_builder_exception{error_code::UnknownType, "Unknown type"}; throw query_builder_exception{error_code::UnknownType, "Unknown type"};
} }
auto producer = std::make_unique<query_collection_resolver_producer<typename CollectionType::value_type>>( auto producer = std::make_unique<query_joined_collection_resolver_producer<typename CollectionType::value_type>>(
schema_, schema_,
it->second.table(), it->second.table(),
inverse_join_column, inverse_join_column,
@ -230,7 +230,7 @@ public:
object::join_columns_collector collector; object::join_columns_collector collector;
const auto jc = collector.collect<typename CollectionType::value_type::value_type>(); const auto jc = collector.collect<typename CollectionType::value_type::value_type>();
auto producer = std::make_unique<query_collection_resolver_producer<typename CollectionType::value_type>>( auto producer = std::make_unique<query_joined_collection_resolver_producer<typename CollectionType::value_type>>(
schema_, schema_,
it->second.table(), it->second.table(),
jc.join_column, jc.join_column,

10
include/matador/sql/internal/collection_resolver_producer.hpp → include/matador/sql/internal/joined_collection_resolver_producer.hpp
View File

@ -14,23 +14,23 @@ namespace matador::sql {
class dialect; class dialect;
class statement; class statement;
class resolver_service; class resolver_service;
class collection_resolver_producer { class joined_collection_resolver_producer {
public: public:
virtual ~collection_resolver_producer() = default; virtual ~joined_collection_resolver_producer() = default;
virtual utils::result<query_context, utils::error> build_query(const dialect& d) = 0; virtual utils::result<query_context, utils::error> build_query(const dialect& d) = 0;
virtual std::shared_ptr<object::abstract_joined_resolver> produce(statement&& stmt, const resolver_service& rs) = 0; virtual std::shared_ptr<object::abstract_joined_resolver> produce(statement&& stmt, const resolver_service& rs) = 0;
[[nodiscard]] const std::type_index& root_type() const; [[nodiscard]] const std::type_index& root_type() const;
[[nodiscard]] const std::type_index& type() const; [[nodiscard]] const std::type_index& type() const;
[[nodiscard]] const std::string& collection_name() const; [[nodiscard]] const std::string& join_column_name() const;
protected: protected:
explicit collection_resolver_producer(const std::type_index &root_type, const std::type_index &type, std::string collection_name); explicit joined_collection_resolver_producer(const std::type_index &root_type, const std::type_index &type, std::string join_column_name);
private: private:
std::type_index root_type_; std::type_index root_type_;
std::type_index type_; std::type_index type_;
std::string collection_name_; std::string join_column_name_;
}; };
} }
#endif // MATADOR_COLLECTION_RESOLVER_PRODUCER_HPP #endif // MATADOR_COLLECTION_RESOLVER_PRODUCER_HPP

8
include/matador/sql/internal/query_result_impl.hpp
View File

@ -147,7 +147,7 @@ template <class CollectionType>
void query_result_impl::on_has_many(const char *, CollectionType &cont, const char *join_column, const utils::foreign_attributes &attr, std::enable_if_t<object::is_object_ptr<typename CollectionType::value_type>::value> *) { void query_result_impl::on_has_many(const char *, CollectionType &cont, const char *join_column, const utils::foreign_attributes &attr, std::enable_if_t<object::is_object_ptr<typename CollectionType::value_type>::value> *) {
using value_type = typename CollectionType::value_type::value_type; using value_type = typename CollectionType::value_type::value_type;
auto object_resolver = resolver_->object_resolver<value_type>(); auto object_resolver = resolver_->object_resolver<value_type>();
auto resolver = resolver_->collection_resolver<typename CollectionType::value_type>(result_type_, join_column); auto resolver = resolver_->joined_collection_resolver<typename CollectionType::value_type>(result_type_, join_column);
if (attr.fetch() == utils::fetch_type::Lazy) { if (attr.fetch() == utils::fetch_type::Lazy) {
cont.reset(std::make_shared<object::collection_proxy<typename CollectionType::value_type>>(resolver, current_pk_)); cont.reset(std::make_shared<object::collection_proxy<typename CollectionType::value_type>>(resolver, current_pk_));
@ -172,7 +172,7 @@ template <class CollectionType>
void query_result_impl::on_has_many(const char *id, CollectionType &cont, const char *join_column, const utils::foreign_attributes &attr, std::enable_if_t<!object::is_object_ptr<typename CollectionType::value_type>::value> *) { void query_result_impl::on_has_many(const char *id, CollectionType &cont, const char *join_column, const utils::foreign_attributes &attr, std::enable_if_t<!object::is_object_ptr<typename CollectionType::value_type>::value> *) {
using value_type = typename CollectionType::value_type; using value_type = typename CollectionType::value_type;
auto object_resolver = resolver_->object_resolver<value_type>(); auto object_resolver = resolver_->object_resolver<value_type>();
auto resolver = resolver_->collection_resolver<value_type>(result_type_, join_column); auto resolver = resolver_->joined_collection_resolver<value_type>(result_type_, join_column);
if (attr.fetch() == utils::fetch_type::Lazy) { if (attr.fetch() == utils::fetch_type::Lazy) {
cont.reset(std::make_shared<object::collection_proxy<value_type>>(resolver, current_pk_)); cont.reset(std::make_shared<object::collection_proxy<value_type>>(resolver, current_pk_));
@ -192,7 +192,7 @@ template <class CollectionType>
void query_result_impl::on_has_many_to_many(const char *id, CollectionType &cont, const char *join_column, const char *, const utils::foreign_attributes &attr) { void query_result_impl::on_has_many_to_many(const char *id, CollectionType &cont, const char *join_column, const char *, const utils::foreign_attributes &attr) {
using value_type = typename CollectionType::value_type::value_type; using value_type = typename CollectionType::value_type::value_type;
auto object_resolver = resolver_->object_resolver<value_type>(); auto object_resolver = resolver_->object_resolver<value_type>();
auto resolver = resolver_->collection_resolver<typename CollectionType::value_type>(result_type_, join_column); auto resolver = resolver_->joined_collection_resolver<typename CollectionType::value_type>(result_type_, join_column);
if (attr.fetch() == utils::fetch_type::Lazy) { if (attr.fetch() == utils::fetch_type::Lazy) {
cont.reset(std::make_shared<object::collection_proxy<typename CollectionType::value_type>>(resolver, current_pk_)); cont.reset(std::make_shared<object::collection_proxy<typename CollectionType::value_type>>(resolver, current_pk_));
} else { } else {
@ -220,7 +220,7 @@ void query_result_impl::on_has_many_to_many(const char *id, CollectionType &cont
const auto jc = collector.collect<typename CollectionType::value_type::value_type>(); const auto jc = collector.collect<typename CollectionType::value_type::value_type>();
auto object_resolver = resolver_->object_resolver<value_type>(); auto object_resolver = resolver_->object_resolver<value_type>();
auto resolver = resolver_->collection_resolver<typename CollectionType::value_type>(result_type_, jc.inverse_join_column); auto resolver = resolver_->joined_collection_resolver<typename CollectionType::value_type>(result_type_, jc.inverse_join_column);
if (attr.fetch() == utils::fetch_type::Lazy) { if (attr.fetch() == utils::fetch_type::Lazy) {
cont.reset(std::make_shared<object::collection_proxy<typename CollectionType::value_type>>(resolver, current_pk_)); cont.reset(std::make_shared<object::collection_proxy<typename CollectionType::value_type>>(resolver, current_pk_));
} else { } else {

6
include/matador/sql/producer_resolver_factory.hpp → include/matador/sql/producer_object_resolver_factory.hpp
View File

@ -5,13 +5,13 @@
#include "matador/object/abstract_joined_resolver.hpp" #include "matador/object/abstract_joined_resolver.hpp"
#include "matador/object/object_resolver_factory.hpp" #include "matador/object/object_resolver_factory.hpp"
#include "matador/object/collection_resolver_factory.hpp" #include "matador/object/joined_collection_resolver_factory.hpp"
#include "matador/object/collection_utils.hpp" #include "matador/object/collection_utils.hpp"
namespace matador::sql { namespace matador::sql {
class executor; class executor;
class producer_resolver_factory : public object::object_resolver_factory { class producer_object_resolver_factory : public object::object_resolver_factory {
public: public:
[[nodiscard]] std::shared_ptr<object::abstract_type_resolver> acquire_object_resolver(const std::type_index &type) const override; [[nodiscard]] std::shared_ptr<object::abstract_type_resolver> acquire_object_resolver(const std::type_index &type) const override;
void register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) override; void register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) override;
@ -20,7 +20,7 @@ private:
std::unordered_map<std::type_index, std::shared_ptr<object::abstract_type_resolver>> resolvers_; std::unordered_map<std::type_index, std::shared_ptr<object::abstract_type_resolver>> resolvers_;
}; };
class producer_collection_resolver_factory : public object::collection_resolver_factory { class producer_joined_collection_resolver_factory : public object::joined_collection_resolver_factory {
public: public:
[[nodiscard]] std::shared_ptr<object::abstract_joined_resolver> acquire_collection_resolver(const std::type_index& root_type, [[nodiscard]] std::shared_ptr<object::abstract_joined_resolver> acquire_collection_resolver(const std::type_index& root_type,
const std::type_index& element_type, const std::type_index& element_type,

10
include/matador/sql/resolver_service.hpp
View File

@ -1,7 +1,7 @@
#ifndef MATADOR_RESOLVER_SERVICE_HPP #ifndef MATADOR_RESOLVER_SERVICE_HPP
#define MATADOR_RESOLVER_SERVICE_HPP #define MATADOR_RESOLVER_SERVICE_HPP
#include "matador/sql/producer_resolver_factory.hpp" #include "matador/sql/producer_object_resolver_factory.hpp"
namespace matador::sql { namespace matador::sql {
class resolver_service { class resolver_service {
@ -12,8 +12,8 @@ public:
} }
template<class Type> template<class Type>
std::shared_ptr<object::collection_resolver<Type>> collection_resolver(const std::type_index &root_type, const std::string &collection_name) const { std::shared_ptr<object::collection_resolver<Type>> joined_collection_resolver(const std::type_index &root_type, const std::string &collection_name) const {
return collection_resolver_factory_.resolver<Type>(root_type, collection_name); return joined_collection_resolver_factory_.resolver<Type>(root_type, collection_name);
} }
template<class Type> template<class Type>
@ -26,8 +26,8 @@ public:
void register_joined_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver, const std::type_index& root_type, const std::string& join_column); void register_joined_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver, const std::type_index& root_type, const std::string& join_column);
private: private:
producer_resolver_factory object_resolver_factory_; producer_object_resolver_factory object_resolver_factory_;
producer_collection_resolver_factory collection_resolver_factory_; producer_joined_collection_resolver_factory joined_collection_resolver_factory_;
producer_joined_object_resolver_factory joined_object_resolver_factory_; producer_joined_object_resolver_factory joined_object_resolver_factory_;
}; };
} }

2
source/core/CMakeLists.txt
View File

@ -21,7 +21,7 @@ add_library(matador-core STATIC
../../include/matador/object/basic_repository.hpp ../../include/matador/object/basic_repository.hpp
../../include/matador/object/collection_proxy.hpp ../../include/matador/object/collection_proxy.hpp
../../include/matador/object/collection_resolver.hpp ../../include/matador/object/collection_resolver.hpp
../../include/matador/object/collection_resolver_factory.hpp ../../include/matador/object/joined_collection_resolver_factory.hpp
../../include/matador/object/collection_utils.hpp ../../include/matador/object/collection_utils.hpp
../../include/matador/object/error_code.hpp ../../include/matador/object/error_code.hpp
../../include/matador/object/foreign_node_completer.hpp ../../include/matador/object/foreign_node_completer.hpp

8
source/orm/CMakeLists.txt
View File

@ -104,7 +104,7 @@ add_library(matador-orm STATIC
../../include/matador/sql/interface/query_result_reader.hpp ../../include/matador/sql/interface/query_result_reader.hpp
../../include/matador/sql/interface/statement_impl.hpp ../../include/matador/sql/interface/statement_impl.hpp
../../include/matador/sql/interface/statement_proxy.hpp ../../include/matador/sql/interface/statement_proxy.hpp
../../include/matador/sql/internal/collection_resolver_producer.hpp ../../include/matador/sql/internal/joined_collection_resolver_producer.hpp
../../include/matador/sql/internal/identifier_reader.hpp ../../include/matador/sql/internal/identifier_reader.hpp
../../include/matador/sql/internal/identifier_statement_binder.hpp ../../include/matador/sql/internal/identifier_statement_binder.hpp
../../include/matador/sql/internal/object_resolver_producer.hpp ../../include/matador/sql/internal/object_resolver_producer.hpp
@ -113,7 +113,7 @@ add_library(matador-orm STATIC
../../include/matador/sql/internal/query_result_impl.hpp ../../include/matador/sql/internal/query_result_impl.hpp
../../include/matador/sql/internal/query_result_pk_resolver.hpp ../../include/matador/sql/internal/query_result_pk_resolver.hpp
../../include/matador/sql/internal/statement_object_resolver.hpp ../../include/matador/sql/internal/statement_object_resolver.hpp
../../include/matador/sql/producer_resolver_factory.hpp ../../include/matador/sql/producer_object_resolver_factory.hpp
../../include/matador/sql/query_context.hpp ../../include/matador/sql/query_context.hpp
../../include/matador/sql/query_result.hpp ../../include/matador/sql/query_result.hpp
../../include/matador/sql/record.hpp ../../include/matador/sql/record.hpp
@ -208,14 +208,14 @@ add_library(matador-orm STATIC
sql/interface/query_result_reader.cpp sql/interface/query_result_reader.cpp
sql/interface/statement_impl.cpp sql/interface/statement_impl.cpp
sql/interface/statement_proxy.cpp sql/interface/statement_proxy.cpp
sql/internal/collection_resolver_producer.cpp sql/internal/joined_collection_resolver_producer.cpp
sql/internal/identifier_reader.cpp sql/internal/identifier_reader.cpp
sql/internal/identifier_statement_binder.cpp sql/internal/identifier_statement_binder.cpp
sql/internal/object_resolver_producer.cpp sql/internal/object_resolver_producer.cpp
sql/internal/object_result_binder.cpp sql/internal/object_result_binder.cpp
sql/internal/query_result_pk_resolver.cpp sql/internal/query_result_pk_resolver.cpp
sql/object_parameter_binder.cpp sql/object_parameter_binder.cpp
sql/producer_resolver_factory.cpp sql/producer_object_resolver_factory.cpp
sql/query_result.cpp sql/query_result.cpp
sql/record.cpp sql/record.cpp
sql/resolver_service.cpp sql/resolver_service.cpp

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

@ -141,7 +141,7 @@ const std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_p
return resolver_producers_; return resolver_producers_;
} }
const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::collection_resolver_producer>, object::collection_composite_key_hash> & basic_schema::collection_resolver_producers() const { const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::joined_collection_resolver_producer>, object::collection_composite_key_hash> & basic_schema::collection_resolver_producers() const {
return collection_resolver_producers_; return collection_resolver_producers_;
} }

20
source/orm/sql/internal/collection_resolver_producer.cpp
View File

@ -1,20 +0,0 @@
#include "matador/sql/internal/collection_resolver_producer.hpp"
namespace matador::sql {
const std::type_index& collection_resolver_producer::root_type() const {
return root_type_;
}
const std::type_index& collection_resolver_producer::type() const {
return type_;
}
const std::string& collection_resolver_producer::collection_name() const {
return collection_name_;
}
collection_resolver_producer::collection_resolver_producer(const std::type_index& root_type,
const std::type_index& type,
std::string collection_name)
: root_type_(root_type), type_(type), collection_name_(std::move(collection_name)) {}
} // namespace matador::sql

20
source/orm/sql/internal/joined_collection_resolver_producer.cpp Normal file
View File

@ -0,0 +1,20 @@
#include "matador/sql/internal/joined_collection_resolver_producer.hpp"
namespace matador::sql {
const std::type_index& joined_collection_resolver_producer::root_type() const {
return root_type_;
}
const std::type_index& joined_collection_resolver_producer::type() const {
return type_;
}
const std::string& joined_collection_resolver_producer::join_column_name() const {
return join_column_name_;
}
joined_collection_resolver_producer::joined_collection_resolver_producer(const std::type_index& root_type,
const std::type_index& type,
std::string join_column_name)
: root_type_(root_type), type_(type), join_column_name_(std::move(join_column_name)) {}
} // namespace matador::sql

10
source/orm/sql/producer_resolver_factory.cpp → source/orm/sql/producer_object_resolver_factory.cpp
View File

@ -1,18 +1,18 @@
#include "matador/sql/producer_resolver_factory.hpp" #include "matador/sql/producer_object_resolver_factory.hpp"
namespace matador::sql { namespace matador::sql {
std::shared_ptr<object::abstract_type_resolver> producer_resolver_factory::acquire_object_resolver(const std::type_index &type) const { std::shared_ptr<object::abstract_type_resolver> producer_object_resolver_factory::acquire_object_resolver(const std::type_index &type) const {
if (const auto it = resolvers_.find(type); it != resolvers_.end()) { if (const auto it = resolvers_.find(type); it != resolvers_.end()) {
return it->second; return it->second;
} }
return nullptr; return nullptr;
} }
void producer_resolver_factory::register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) { void producer_object_resolver_factory::register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) {
resolvers_[resolver->type()] = std::move(resolver); resolvers_[resolver->type()] = std::move(resolver);
} }
std::shared_ptr<object::abstract_joined_resolver> std::shared_ptr<object::abstract_joined_resolver>
producer_collection_resolver_factory::acquire_collection_resolver(const std::type_index& root_type, producer_joined_collection_resolver_factory::acquire_collection_resolver(const std::type_index& root_type,
const std::type_index& element_type, const std::type_index& element_type,
const std::string& collection_name) const { const std::string& collection_name) const {
const object::collection_composite_key key{root_type, element_type, collection_name}; const object::collection_composite_key key{root_type, element_type, collection_name};
@ -21,7 +21,7 @@ producer_collection_resolver_factory::acquire_collection_resolver(const std::typ
} }
return nullptr; return nullptr;
} }
void producer_collection_resolver_factory::register_collection_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) { void producer_joined_collection_resolver_factory::register_collection_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) {
const object::collection_composite_key key{resolver->root_type(), resolver->type(), resolver->collection_name()}; const object::collection_composite_key key{resolver->root_type(), resolver->type(), resolver->collection_name()};
resolvers_[key] = std::move(resolver); resolvers_[key] = std::move(resolver);
} }

2
source/orm/sql/resolver_service.cpp
View File

@ -6,7 +6,7 @@ void resolver_service::register_object_resolver(std::shared_ptr<object::abstract
} }
void resolver_service::register_collection_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) { void resolver_service::register_collection_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) {
collection_resolver_factory_.register_collection_resolver(std::move(resolver)); joined_collection_resolver_factory_.register_collection_resolver(std::move(resolver));
} }
void resolver_service::register_joined_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver, const std::type_index& root_type, const std::string& join_column) { void resolver_service::register_joined_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver, const std::type_index& root_type, const std::string& join_column) {

3
test/backends/SessionInsertHasOne.cpp
View File

@ -31,7 +31,6 @@ TEST_CASE_METHOD(SessionFixture, "Test insert object with has_one relation", "[s
const auto user_result = ses.find<user_identity>(u->id); const auto user_result = ses.find<user_identity>(u->id);
REQUIRE(user_result.is_ok()); REQUIRE(user_result.is_ok());
// REQUIRE(user_result.value()->session->session_token == "session1");
us = user_result.value()->session; us = user_result.value()->session;
const auto token = us->session_token; REQUIRE(us->session_token == "session1");
} }