has one progress

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