From b6cabbe3ed86bf0c370b934adcc36f73f6a45124 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sascha=20K=C3=BChl?= Date: Tue, 27 Jan 2026 08:14:05 +0100 Subject: [PATCH] collection resolver progress --- .../object/abstract_type_resolver_factory.hpp | 4 +- include/matador/object/collection_proxy.hpp | 13 ------ .../matador/object/collection_resolver.hpp | 13 ++++++ .../object/collection_resolver_factory.hpp | 10 ++++- include/matador/object/container_resolver.hpp | 23 ++++++++++ include/matador/object/object_resolver.hpp | 1 + .../object/object_resolver_factory.hpp | 17 +++----- include/matador/query/basic_schema.hpp | 2 +- .../query/query_container_resolver.hpp | 42 +++++++++++++++++++ include/matador/query/schema.hpp | 16 +++---- ...ducer.hpp => object_resolver_producer.hpp} | 6 +-- .../matador/sql/producer_resolver_factory.hpp | 6 +-- source/core/CMakeLists.txt | 1 + source/orm/CMakeLists.txt | 6 ++- source/orm/query/basic_schema.cpp | 2 +- source/orm/query/query_container_resolver.cpp | 14 +++++++ .../sql/internal/object_resolver_producer.cpp | 10 +++++ source/orm/sql/internal/resolver_producer.cpp | 10 ----- source/orm/sql/producer_resolver_factory.cpp | 4 +- 19 files changed, 143 insertions(+), 57 deletions(-) create mode 100644 include/matador/object/container_resolver.hpp create mode 100644 include/matador/query/query_container_resolver.hpp rename include/matador/sql/internal/{resolver_producer.hpp => object_resolver_producer.hpp} (67%) create mode 100644 source/orm/query/query_container_resolver.cpp create mode 100644 source/orm/sql/internal/object_resolver_producer.cpp delete mode 100644 source/orm/sql/internal/resolver_producer.cpp diff --git a/include/matador/object/abstract_type_resolver_factory.hpp b/include/matador/object/abstract_type_resolver_factory.hpp index cd65a47..6f36fc4 100644 --- a/include/matador/object/abstract_type_resolver_factory.hpp +++ b/include/matador/object/abstract_type_resolver_factory.hpp @@ -10,8 +10,8 @@ class abstract_type_resolver_factory { public: virtual ~abstract_type_resolver_factory() = default; - virtual std::shared_ptr acquire_resolver(const std::type_index &type) = 0; - virtual void register_resolver(std::shared_ptr &&resolver) = 0; + virtual std::shared_ptr acquire_object_resolver(const std::type_index &type) = 0; + virtual void register_object_resolver(std::shared_ptr &&resolver) = 0; }; } #endif //MATADOR_ABSTRACT_TYPE_RESOLVER_FACTORY_HPP \ No newline at end of file diff --git a/include/matador/object/collection_proxy.hpp b/include/matador/object/collection_proxy.hpp index 0384d4e..38e1a38 100644 --- a/include/matador/object/collection_proxy.hpp +++ b/include/matador/object/collection_proxy.hpp @@ -12,19 +12,6 @@ namespace matador::object { -class abstract_collection_resolver { -public: - virtual ~abstract_collection_resolver() = default; - - [[nodiscard]] const std::type_index& type() const { return type_; } - -protected: - explicit abstract_collection_resolver(const std::type_index& ti) : type_(ti) {} - -public: - const std::type_index type_; -}; - // template // class collection_resolver : public abstract_collection_resolver { diff --git a/include/matador/object/collection_resolver.hpp b/include/matador/object/collection_resolver.hpp index db76a59..169b905 100644 --- a/include/matador/object/collection_resolver.hpp +++ b/include/matador/object/collection_resolver.hpp @@ -8,6 +8,19 @@ #include namespace matador::object { +class abstract_collection_resolver { +public: + virtual ~abstract_collection_resolver() = default; + + [[nodiscard]] const std::type_index& type() const { return type_; } + +protected: + explicit abstract_collection_resolver(const std::type_index& ti) : type_(ti) {} + +public: + const std::type_index type_; +}; + template class collection_resolver : public abstract_type_resolver { public: diff --git a/include/matador/object/collection_resolver_factory.hpp b/include/matador/object/collection_resolver_factory.hpp index e01dca2..14d09f5 100644 --- a/include/matador/object/collection_resolver_factory.hpp +++ b/include/matador/object/collection_resolver_factory.hpp @@ -5,11 +5,19 @@ #include "matador/object/collection_resolver.hpp" namespace matador::object { +class abstract_collection_resolver_factory { +public: + virtual ~abstract_collection_resolver_factory() = default; + + virtual std::shared_ptr acquire_collection_resolver(const std::type_index &root_type, const std::type_index &element_type, const std::string &collection_name) = 0; + virtual void register_collection_resolver(std::shared_ptr &&resolver) = 0; +}; + class collection_resolver_factory : public abstract_type_resolver_factory { public: template std::shared_ptr> resolver() { - const auto res = acquire_resolver(typeid(std::vector>)); + const auto res = acquire_object_resolver(typeid(std::vector>)); if (!res) { return std::dynamic_pointer_cast>(res); } diff --git a/include/matador/object/container_resolver.hpp b/include/matador/object/container_resolver.hpp new file mode 100644 index 0000000..68b5aff --- /dev/null +++ b/include/matador/object/container_resolver.hpp @@ -0,0 +1,23 @@ +#ifndef MATADOR_CONTAINER_RESOLVER_HPP +#define MATADOR_CONTAINER_RESOLVER_HPP + +#include "matador/object/abstract_type_resolver.hpp" + +#include +#include + +namespace matador::utils { +class identifier; +} + +namespace matador::object { +template +class container_resolver : public abstract_type_resolver { +public: + container_resolver() : abstract_type_resolver(typeid(Type)) {} + + virtual std::shared_ptr> resolve(const utils::identifier& id) = 0; +}; +} + +#endif //MATADOR_CONTAINER_RESOLVER_HPP \ No newline at end of file diff --git a/include/matador/object/object_resolver.hpp b/include/matador/object/object_resolver.hpp index cbac7ad..11487c1 100644 --- a/include/matador/object/object_resolver.hpp +++ b/include/matador/object/object_resolver.hpp @@ -2,6 +2,7 @@ #define MATADOR_OBJECT_LOADER_HPP #include "matador/object/abstract_type_resolver.hpp" + #include namespace matador::utils { diff --git a/include/matador/object/object_resolver_factory.hpp b/include/matador/object/object_resolver_factory.hpp index be0f8e3..0e1e904 100644 --- a/include/matador/object/object_resolver_factory.hpp +++ b/include/matador/object/object_resolver_factory.hpp @@ -10,23 +10,18 @@ class object_resolver_factory : public abstract_type_resolver_factory { public: template std::shared_ptr> resolver() { - const auto res = acquire_resolver(std::type_index(typeid(Type))); + const auto res = acquire_object_resolver(std::type_index(typeid(Type))); if (!res) { return std::dynamic_pointer_cast>(res); } return std::dynamic_pointer_cast>(res); } - // - // template - // std::shared_ptr> collection_resolver(const std::string &name) { - // const auto res = acquire_collection_resolver(std::type_index(typeid(Type)), name); - // if (!res) { - // return std::dynamic_pointer_cast>(res); - // } - // - // return std::dynamic_pointer_cast>(res); - // } }; + +class object_resolver_service : public object_resolver_factory, public collection_resolver_factory { +public: +}; + } #endif //MATADOR_OBJECT_RESOLVER_FACTORY_HPP \ No newline at end of file diff --git a/include/matador/query/basic_schema.hpp b/include/matador/query/basic_schema.hpp index c38bcbc..dbe5549 100644 --- a/include/matador/query/basic_schema.hpp +++ b/include/matador/query/basic_schema.hpp @@ -58,7 +58,7 @@ protected: object::repository repo_; std::unordered_map schema_nodes_; - std::unordered_map> resolver_producers_; + std::unordered_map> resolver_producers_; }; } #endif //MATADOR_BASIC_SCHEMA_HPP \ No newline at end of file diff --git a/include/matador/query/query_container_resolver.hpp b/include/matador/query/query_container_resolver.hpp new file mode 100644 index 0000000..c9d74a1 --- /dev/null +++ b/include/matador/query/query_container_resolver.hpp @@ -0,0 +1,42 @@ +#ifndef MATADOR_QUERY_CONTAINER_RESOLVER_HPP +#define MATADOR_QUERY_CONTAINER_RESOLVER_HPP + +#include "matador/object/container_resolver.hpp" + +#include "matador/sql/internal/identifier_statement_binder.hpp" +#include "matador/sql/statement.hpp" + +#include "matador/query/table.hpp" +#include "matador/query/select_query_builder.hpp" + +namespace matador::sql { +class executor; +} + +namespace matador::query { +template +class query_container_resolver : public object::container_resolver { +public: + explicit query_container_resolver(const basic_schema &repo, sql::executor& exec, const table &tab, std::string pk_name) + : executor_(exec) + , schema_(repo) + , table_(tab) + , pk_name_(std::move(pk_name)) {} + + std::shared_ptr resolve(const utils::identifier &id) override; +protected: + sql::executor& executor_; + const basic_schema &schema_; + const table &table_; + std::string pk_name_; + std::type_index index{typeid(Type)}; +}; + +utils::result prepare_collection_statement(sql::executor& exec, entity_query_data &&data); + +template +std::shared_ptr query_container_resolver::resolve(const utils::identifier &id) { + +} +} +#endif //MATADOR_QUERY_CONTAINER_RESOLVER_HPP \ No newline at end of file diff --git a/include/matador/query/schema.hpp b/include/matador/query/schema.hpp index dcd0498..b4b7e63 100644 --- a/include/matador/query/schema.hpp +++ b/include/matador/query/schema.hpp @@ -4,7 +4,7 @@ #include "matador/object/observer.hpp" #include "matador/sql/query_context.hpp" -#include "matador/sql/internal/resolver_producer.hpp" +#include "matador/sql/internal/object_resolver_producer.hpp" #include "matador/query/query_object_resolver.hpp" #include "matador/query/basic_schema.hpp" @@ -18,11 +18,11 @@ class executor; namespace matador::query { template -class query_resolver_producer : public sql::resolver_producer { +class query_object_resolver_producer : public sql::object_resolver_producer { public: - query_resolver_producer() = default; - query_resolver_producer(const basic_schema& repo, const table& tab, std::string pk_name) - : resolver_producer(typeid(Type)) + query_object_resolver_producer() = default; + query_object_resolver_producer(const basic_schema& repo, const table& tab, std::string pk_name) + : object_resolver_producer(typeid(Type)) , repo_(repo) , table_(tab) , pk_name_(std::move(pk_name)) {} @@ -38,11 +38,11 @@ private: }; template -class query_collection_resolver_producer : public sql::resolver_producer { +class query_collection_resolver_producer : public sql::object_resolver_producer { public: query_collection_resolver_producer() = default; query_collection_resolver_producer(const basic_schema& repo, const table& tab, std::string pk_name) - : resolver_producer(typeid(Type)) + : object_resolver_producer(typeid(Type)) , repo_(repo) , table_(tab) , pk_name_(std::move(pk_name)) {} @@ -200,7 +200,7 @@ void schema_observer::on_attach(const object::repository_node &node, const const auto it = schema_.insert_table(typeid(Type), node); if (it->second.node().info().has_primary_key()) { - auto producer = std::make_unique>(schema_, it->second.table(), it->second.node().info().primary_key_attribute()->name()); + auto producer = std::make_unique>(schema_, it->second.table(), it->second.node().info().primary_key_attribute()->name()); schema_.resolver_producers_[typeid(Type)] = std::move(producer); } } diff --git a/include/matador/sql/internal/resolver_producer.hpp b/include/matador/sql/internal/object_resolver_producer.hpp similarity index 67% rename from include/matador/sql/internal/resolver_producer.hpp rename to include/matador/sql/internal/object_resolver_producer.hpp index 11bdbca..2208b8c 100644 --- a/include/matador/sql/internal/resolver_producer.hpp +++ b/include/matador/sql/internal/object_resolver_producer.hpp @@ -7,15 +7,15 @@ namespace matador::sql { class executor; -class resolver_producer { +class object_resolver_producer { public: - virtual ~resolver_producer() = default; + virtual ~object_resolver_producer() = default; virtual std::shared_ptr produce(executor &exec) = 0; [[nodiscard]] const std::type_index& type() const; protected: - explicit resolver_producer(const std::type_index &type); + explicit object_resolver_producer(const std::type_index &type); private: std::type_index type_; diff --git a/include/matador/sql/producer_resolver_factory.hpp b/include/matador/sql/producer_resolver_factory.hpp index a3de911..6c1ee2e 100644 --- a/include/matador/sql/producer_resolver_factory.hpp +++ b/include/matador/sql/producer_resolver_factory.hpp @@ -3,7 +3,7 @@ #include "matador/object/object_resolver_factory.hpp" -#include "matador/sql/internal/resolver_producer.hpp" +#include "matador/sql/internal/object_resolver_producer.hpp" #include @@ -13,8 +13,8 @@ class executor; class producer_resolver_factory : public object::object_resolver_factory { public: - std::shared_ptr acquire_resolver(const std::type_index &type) override; - void register_resolver(std::shared_ptr &&resolver) override; + std::shared_ptr acquire_object_resolver(const std::type_index &type) override; + void register_object_resolver(std::shared_ptr &&resolver) override; private: std::unordered_map> resolvers_; diff --git a/source/core/CMakeLists.txt b/source/core/CMakeLists.txt index 750b5f9..c5144d9 100644 --- a/source/core/CMakeLists.txt +++ b/source/core/CMakeLists.txt @@ -118,6 +118,7 @@ add_library(matador-core STATIC ../../include/matador/object/collection_resolver.hpp ../../include/matador/object/abstract_type_resolver.hpp ../../include/matador/object/abstract_type_resolver_factory.hpp + ../../include/matador/object/container_resolver.hpp ) target_link_libraries(matador-core ${CMAKE_DL_LIBS}) diff --git a/source/orm/CMakeLists.txt b/source/orm/CMakeLists.txt index b3363c7..0156551 100644 --- a/source/orm/CMakeLists.txt +++ b/source/orm/CMakeLists.txt @@ -86,7 +86,7 @@ add_library(matador-orm STATIC ../../include/matador/sql/internal/object_result_binder.hpp ../../include/matador/sql/internal/query_result_impl.hpp ../../include/matador/sql/internal/query_result_pk_resolver.hpp - ../../include/matador/sql/internal/resolver_producer.hpp + ../../include/matador/sql/internal/object_resolver_producer.hpp ../../include/matador/sql/internal/statement_object_resolver.hpp ../../include/matador/sql/producer_resolver_factory.hpp ../../include/matador/sql/query_context.hpp @@ -173,13 +173,15 @@ add_library(matador-orm STATIC sql/internal/identifier_statement_binder.cpp sql/internal/object_result_binder.cpp sql/internal/query_result_pk_resolver.cpp - sql/internal/resolver_producer.cpp + sql/internal/object_resolver_producer.cpp sql/object_parameter_binder.cpp sql/producer_resolver_factory.cpp sql/query_result.cpp sql/record.cpp sql/statement.cpp sql/statement_cache.cpp + ../../include/matador/query/query_container_resolver.hpp + query/query_container_resolver.cpp ) target_include_directories(matador-orm diff --git a/source/orm/query/basic_schema.cpp b/source/orm/query/basic_schema.cpp index c4385b8..8c8d66a 100644 --- a/source/orm/query/basic_schema.cpp +++ b/source/orm/query/basic_schema.cpp @@ -85,7 +85,7 @@ void basic_schema::initialize_executor(sql::executor &exec) const { auto factory = std::make_shared(); for (const auto &[key, producer] : resolver_producers_) { auto resolver = producer->produce(exec); - exec.resolver_factory()->register_resolver(std::move(resolver)); + exec.resolver_factory()->register_object_resolver(std::move(resolver)); } } diff --git a/source/orm/query/query_container_resolver.cpp b/source/orm/query/query_container_resolver.cpp new file mode 100644 index 0000000..3fb9424 --- /dev/null +++ b/source/orm/query/query_container_resolver.cpp @@ -0,0 +1,14 @@ +#include "matador/query/query_container_resolver.hpp" + +namespace matador::query { +utils::result prepare_collection_statement(sql::executor& exec, entity_query_data &&data) { + return query::query::select(data.columns) + .from(*data.root_table) + .join_left(data.joins) + .where(std::move(data.where_clause)) + .order_by({data.root_table, data.pk_column_name}) + .asc() + .prepare(exec); +} + +} \ No newline at end of file diff --git a/source/orm/sql/internal/object_resolver_producer.cpp b/source/orm/sql/internal/object_resolver_producer.cpp new file mode 100644 index 0000000..48bd4c4 --- /dev/null +++ b/source/orm/sql/internal/object_resolver_producer.cpp @@ -0,0 +1,10 @@ +#include "matador/sql/internal/object_resolver_producer.hpp" + +namespace matador::sql { +const std::type_index & object_resolver_producer::type() const { + return type_; +} + +object_resolver_producer::object_resolver_producer(const std::type_index &type) +: type_(type) {} +} diff --git a/source/orm/sql/internal/resolver_producer.cpp b/source/orm/sql/internal/resolver_producer.cpp deleted file mode 100644 index dd51d3a..0000000 --- a/source/orm/sql/internal/resolver_producer.cpp +++ /dev/null @@ -1,10 +0,0 @@ -#include "matador/sql/internal/resolver_producer.hpp" - -namespace matador::sql { -const std::type_index & resolver_producer::type() const { - return type_; -} - -resolver_producer::resolver_producer(const std::type_index &type) -: type_(type) {} -} diff --git a/source/orm/sql/producer_resolver_factory.cpp b/source/orm/sql/producer_resolver_factory.cpp index 22202b1..33c5abc 100644 --- a/source/orm/sql/producer_resolver_factory.cpp +++ b/source/orm/sql/producer_resolver_factory.cpp @@ -1,14 +1,14 @@ #include "matador/sql/producer_resolver_factory.hpp" namespace matador::sql { -std::shared_ptr producer_resolver_factory::acquire_resolver(const std::type_index &type) { +std::shared_ptr producer_resolver_factory::acquire_object_resolver(const std::type_index &type) { if (const auto it = resolvers_.find(type); it != resolvers_.end()) { return it->second; } return nullptr; } -void producer_resolver_factory::register_resolver(std::shared_ptr &&resolver) { +void producer_resolver_factory::register_object_resolver(std::shared_ptr &&resolver) { resolvers_[resolver->type()] = std::move(resolver); } }