has one progress

source/core/CMakeLists.txt

@@ -13,7 +13,7 @@ add_library(matador-core STATIC
   ../../include/matador/net/reactor.hpp
   ../../include/matador/net/select_fd_sets.hpp
   ../../include/matador/net/socket_interrupter.hpp
-  ../../include/matador/object/abstract_collection_resolver.hpp
+  ../../include/matador/object/abstract_joined_resolver.hpp
   ../../include/matador/object/abstract_type_resolver.hpp
   ../../include/matador/object/abstract_type_resolver_factory.hpp
   ../../include/matador/object/attribute.hpp
@@ -92,7 +92,7 @@ add_library(matador-core STATIC
   logger/log_manager.cpp
   logger/logger.cpp
   logger/rotating_file_sink.cpp
-  object/abstract_collection_resolver.cpp
+  object/abstract_joined_resolver.cpp
   object/attribute.cpp
   object/basic_object_info.cpp
   object/basic_repository.cpp

source/core/object/abstract_collection_resolver.cpp

@@ -1,23 +0,0 @@
-#include "matador/object/abstract_collection_resolver.hpp"
-
-namespace matador::object {
-
-const std::type_index& abstract_collection_resolver::root_type() const {
-  return root_type_;
-}
-
-const std::type_index& abstract_collection_resolver::type() const {
-  return type_;
-}
-
-const std::string& abstract_collection_resolver::collection_name() const {
-  return collection_name_;
-}
-
-abstract_collection_resolver::abstract_collection_resolver(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::object

source/core/object/abstract_joined_resolver.cpp

@@ -0,0 +1,16 @@
+#include "matador/object/abstract_collection_resolver.hpp"
+
+namespace matador::object {
+const std::type_index& abstract_joined_resolver::root_type() const {
+  return root_type_;
+}
+
+const std::string& abstract_joined_resolver::collection_name() const {
+  return collection_name_;
+}
+
+abstract_joined_resolver::abstract_joined_resolver(const std::type_index& root_type, const std::type_index& type, std::string collection_name)
+: abstract_type_resolver(type)
+, root_type_(root_type)
+, collection_name_(std::move(collection_name)) {}
+}  // namespace matador::object

source/orm/query/basic_schema.cpp

@@ -145,6 +145,10 @@ const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::
   return collection_resolver_producers_;
 }
 
+const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::object_resolver_producer>, object::collection_composite_key_hash>& basic_schema::joined_object_resolver_producers() const {
+  return joined_object_resolver_producers_;
+}
+
 namespace detail {
 utils::result<void, utils::error> create_tables(const object::repository &repo, const sql::connection &conn) {
   for (const auto &node: repo) {

source/orm/query/session.cpp

@@ -93,6 +93,23 @@ session::session(session_context&& ctx, const basic_schema &scm)
     }
   }
 
+  for (const auto &pair : schema_.joined_object_resolver_producers()) {
+    auto res = pair.second->build_query(dialect_).and_then([this](sql::query_context&& query_ctx) -> result<sql::statement, error> {
+      query_ctx.resolver = resolver_service_;
+      return cache_.acquire(query_ctx);
+    }).and_then([&pair, this](sql::statement&& stmt) -> result<void, error> {
+      resolver_service_->register_collection_resolver(pair.second->produce(std::move(stmt), *resolver_service_));
+
+      return ok<void>();
+    }).or_else([](const auto &err) {
+      return failure(err);
+    });
+
+    if (!res) {
+      throw std::runtime_error(res.err().message());
+    }
+  }
+
   for (const auto &pair : schema_.collection_resolver_producers()) {
     auto res = pair.second->build_query(dialect_).and_then([this](sql::query_context&& query_ctx) -> result<sql::statement, error> {
       query_ctx.resolver = resolver_service_;

source/orm/sql/internal/object_resolver_producer.cpp

@@ -8,3 +8,20 @@ const std::type_index & object_resolver_producer::type() const {
 object_resolver_producer::object_resolver_producer(const std::type_index &type)
 : type_(type) {}
 }
+
+const std::type_index& matador::sql::joined_object_resolver_producer::root_type() const {
+  return root_type_;
+}
+
+const std::type_index& matador::sql::joined_object_resolver_producer::type() const {
+  return type_;
+}
+
+const std::string& matador::sql::joined_object_resolver_producer::collection_name() const {
+  return collection_name_;
+}
+
+matador::sql::joined_object_resolver_producer::joined_object_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)) {}

source/orm/sql/producer_resolver_factory.cpp

@@ -11,7 +11,7 @@ std::shared_ptr<object::abstract_type_resolver> producer_resolver_factory::acqui
 void producer_resolver_factory::register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) {
   resolvers_[resolver->type()] = std::move(resolver);
 }
-std::shared_ptr<object::abstract_collection_resolver>
+std::shared_ptr<object::abstract_joined_resolver>
 producer_collection_resolver_factory::acquire_collection_resolver(const std::type_index& root_type,
                                                                   const std::type_index& element_type,
                                                                   const std::string& collection_name) const {
@@ -21,7 +21,22 @@ producer_collection_resolver_factory::acquire_collection_resolver(const std::typ
   }
   return nullptr;
 }
-void producer_collection_resolver_factory::register_collection_resolver(std::shared_ptr<object::abstract_collection_resolver>&& resolver) {
+void producer_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()};
+  resolvers_[key] = std::move(resolver);
+}
+
+std::shared_ptr<object::abstract_joined_resolver> producer_joined_object_resolver_factory::acquire_joined_object_resolver(const std::type_index& root_type,
+                                                                                                                          const std::type_index& element_type,
+                                                                                                                          const std::string& collection_name) const {
+  const object::collection_composite_key key{root_type, element_type, collection_name};
+  if (const auto it = resolvers_.find(key); it != resolvers_.end()) {
+    return it->second;
+  }
+  return nullptr;
+}
+
+void producer_joined_object_resolver_factory::register_joined_object_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) {
   const object::collection_composite_key key{resolver->root_type(), resolver->type(), resolver->collection_name()};
   resolvers_[key] = std::move(resolver);
 }

source/orm/sql/resolver_service.cpp

@@ -4,7 +4,12 @@ namespace matador::sql {
 void resolver_service::register_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver) {
   object_resolver_factory_.register_object_resolver(std::move(resolver));
 }
-void resolver_service::register_collection_resolver(std::shared_ptr<object::abstract_collection_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));
 }
+
+void resolver_service::register_joined_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver) {
+  joined_object_resolver_factory_.register_object_resolver(std::move(resolver));
+}
 }  // namespace matador::query