resolve has one progress

include/matador/sql/internal/object_resolver_producer.hpp

@@ -32,7 +32,7 @@ class joined_object_resolver_producer {
 public:
   virtual ~joined_object_resolver_producer() = default;
   virtual utils::result<query_context, utils::error> build_query(const dialect& d) = 0;
-  virtual std::shared_ptr<object::abstract_joined_resolver> produce(statement&& stmt) = 0;
+  virtual std::shared_ptr<object::abstract_type_resolver> produce(statement&& stmt) = 0;
 
   [[nodiscard]] const std::type_index& root_type() const;
   [[nodiscard]] const std::type_index& type() const;

include/matador/sql/internal/query_result_impl.hpp

@@ -130,16 +130,16 @@ void query_result_impl::on_belongs_to(const char*, Pointer& x, const utils::fore
 
 template <class PointerType>
 void query_result_impl::on_has_one(const char*, object::object_ptr<PointerType>& x, const char *join_column, const utils::foreign_attributes& attr) {
-  const auto resolver = resolver_->collection_resolver<PointerType>(result_type_, join_column);
+  const auto resolver = resolver_->joined_object_resolver<PointerType>(result_type_, join_column);
   if (attr.fetch() == utils::fetch_type::Lazy) {
-    x = object::object_ptr<PointerType>(std::make_shared<object::object_proxy<PointerType>>(resolver, id_reader_.read(x, column_index_++)));
+    x.reset(std::make_shared<object::object_proxy<PointerType>>(resolver, utils::identifier{}));
   } else {
     auto obj = std::make_shared<PointerType>();
     const auto ti = std::type_index(typeid(*x));
     type_stack_.push(ti);
     access::process(*this, *obj);
     type_stack_.pop();
-    x = object::object_ptr<PointerType>(std::make_shared<object::object_proxy<PointerType>>(resolver, obj));
+    x.reset(std::make_shared<object::object_proxy<PointerType>>(resolver, obj));
   }
 }
 

include/matador/sql/producer_resolver_factory.hpp

@@ -33,13 +33,13 @@ private:
 
 class producer_joined_object_resolver_factory : public object::joined_object_resolver_factory {
 public:
-  [[nodiscard]] std::shared_ptr<object::abstract_joined_resolver> acquire_joined_object_resolver(const std::type_index& root_type,
+  [[nodiscard]] std::shared_ptr<object::abstract_type_resolver> acquire_joined_object_resolver(const std::type_index& root_type,
                                                                                                  const std::type_index& element_type,
                                                                                                  const std::string& collection_name) const override;
-  void register_joined_object_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) override;
+  void register_joined_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver, const std::type_index& root_type, const std::string& join_column) override;
 
 private:
-  std::unordered_map<object::collection_composite_key, std::shared_ptr<object::abstract_joined_resolver>, object::collection_composite_key_hash> resolvers_;
+  std::unordered_map<object::collection_composite_key, std::shared_ptr<object::abstract_type_resolver>, object::collection_composite_key_hash> resolvers_;
 };
 }
 #endif //MATADOR_RESOLVER_FACTORY_HPP

include/matador/sql/resolver_service.hpp

@@ -17,18 +17,18 @@ public:
   }
 
   template<class Type>
-  std::shared_ptr<object::collection_resolver<Type>> joined_object_resolver(const std::type_index &root_type, const std::string &join_column) const {
+  std::shared_ptr<object::object_resolver<Type>> joined_object_resolver(const std::type_index &root_type, const std::string &join_column) const {
     return joined_object_resolver_factory_.resolver<Type>(root_type, join_column);
   }
 
   void register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver);
   void register_collection_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver);
-  void register_joined_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver);
+  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:
-  sql::producer_resolver_factory object_resolver_factory_;
-  sql::producer_collection_resolver_factory collection_resolver_factory_;
-  sql::producer_resolver_factory joined_object_resolver_factory_;
+  producer_resolver_factory object_resolver_factory_;
+  producer_collection_resolver_factory collection_resolver_factory_;
+  producer_joined_object_resolver_factory joined_object_resolver_factory_;
 };
 }
 #endif  // MATADOR_RESOLVER_SERVICE_HPP