added has_one eager functionality and tests

demo/sandbox.cpp

@@ -100,7 +100,7 @@ struct user {
         namespace field = access;
         field::primary_key( op, "id", id );
         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;
 
-  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};
 
   object::collection_proxy cp(cr, id);

include/matador/object/joined_collection_resolver_factory.hpp

@@ -14,7 +14,7 @@ public:
   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:
   template<class Type>
   [[nodiscard]] std::shared_ptr<collection_resolver<Type>> resolver(const std::type_index &root_type, const std::string &collection_name) const {

include/matador/query/basic_schema.hpp

@@ -6,9 +6,9 @@
 #include "matador/query/abstract_pk_generator.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/producer_resolver_factory.hpp"
+#include "matador/sql/producer_object_resolver_factory.hpp"
 
 #include <memory>
 #include <typeindex>
@@ -102,7 +102,7 @@ public:
   [[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<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;
 
 protected:
@@ -113,7 +113,7 @@ protected:
   object::repository repo_;
   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<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_;
 };
 }

include/matador/query/schema.hpp

@@ -5,7 +5,7 @@
 
 #include "matador/sql/query_context.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_object_resolver.hpp"
@@ -64,11 +64,11 @@ private:
 };
 
 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:
-  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)
   , table_(tab)
   , 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 {
     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})
       .from(table_)
@@ -89,7 +89,7 @@ public:
   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>();
 
-    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:
@@ -99,11 +99,11 @@ private:
 };
 
 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:
-  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)
   , table_(tab)
   , 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 {
     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})
       .from(table_)
@@ -122,7 +122,7 @@ public:
   }
 
   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:
@@ -177,7 +177,7 @@ public:
       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_,
       it->second.table(),
       it->second.node().info().primary_key_attribute()->name(),
@@ -193,7 +193,7 @@ public:
     if (it == schema_.end()) {
       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_,
       it->second.table(),
       "value",
@@ -210,7 +210,7 @@ public:
       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_,
       it->second.table(),
       inverse_join_column,
@@ -230,7 +230,7 @@ public:
     object::join_columns_collector collector;
     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_,
       it->second.table(),
       jc.join_column,

include/matador/query/select_query_builder.hpp

@@ -112,13 +112,67 @@ public:
   }
 
   template<class Pointer>
-  void on_belongs_to(const char *id, Pointer &obj, const utils::foreign_attributes &attr) {
+  void on_belongs_to(const char *id, Pointer &/*obj*/, const utils::foreign_attributes &attr) {
-    on_foreign_object(id, obj, attr, true);
+    const auto it = schema_.find(typeid(typename Pointer::value_type));
+    if (it == schema_.end()) {
+      throw query_builder_exception{error_code::UnknownType, "Unknown type"};
+    }
+    if (!it->second.node().info().has_primary_key()) {
+      throw query_builder_exception{error_code::MissingPrimaryKey, "Missing primary key"};
+    }
+
+    const auto& info = it->second.node().info();
+    auto foreign_table = it->second.table().as(build_alias('t', ++table_index));
+    if (attr.fetch() == utils::fetch_type::Eager) {
+
+      auto next = processed_tables_.find(info.name());
+      if (next != processed_tables_.end()) {
+        return;
+      }
+      table_info_stack_.push({info, std::move(foreign_table)});
+      next = processed_tables_.insert({info.name(), table_info_stack_.top().table}).first;
+      typename Pointer::value_type obj;
+      access::process(*this, obj);
+      table_info_stack_.pop();
+
+      append_join(
+        table_column{&table_info_stack_.top().table, id},
+        table_column{&next->second, info.primary_key_attribute()->name()}
+      );
+    } else {
+      push(id);
+    }
   }
 
   template<class Pointer>
-  void on_has_one(const char *id, Pointer &obj, const char * /*join_column*/, const utils::foreign_attributes &attr) {
+  void on_has_one(const char * /*id*/, Pointer &/*obj*/, const char * join_column, const utils::foreign_attributes &attr) {
-    on_foreign_object(id, obj, attr, false);
+    const auto it = schema_.find(typeid(typename Pointer::value_type));
+    if (it == schema_.end()) {
+      throw query_builder_exception{error_code::UnknownType, "Unknown type"};
+    }
+    if (!it->second.node().info().has_primary_key()) {
+      throw query_builder_exception{error_code::MissingPrimaryKey, "Missing primary key"};
+    }
+
+    const auto& info = it->second.node().info();
+    auto foreign_table = it->second.table().as(build_alias('t', ++table_index));
+    if (attr.fetch() == utils::fetch_type::Eager) {
+
+      auto next = processed_tables_.find(info.name());
+      if (next != processed_tables_.end()) {
+        return;
+      }
+      table_info_stack_.push({info, std::move(foreign_table)});
+      next = processed_tables_.insert({info.name(), table_info_stack_.top().table}).first;
+      typename Pointer::value_type obj;
+      access::process(*this, obj);
+      table_info_stack_.pop();
+
+      append_join(
+        table_column{&table_info_stack_.top().table, it->second.node().info().primary_key_attribute()->name()},
+        table_column{&next->second, join_column}
+      );
+    }
   }
 
   template<typename T>
@@ -257,8 +311,6 @@ public:
   [[nodiscard]] const select_query_data &query_data() const;
 
 private:
-  template<class Pointer>
-  void on_foreign_object(const char *id, Pointer &, const utils::foreign_attributes &attr, bool add_column_on_lazy);
   void push(const std::string &column_name);
   static std::string build_alias(char prefix, unsigned int count);
   [[nodiscard]] bool is_root_entity() const;
@@ -278,39 +330,5 @@ private:
   unsigned int table_index{0};
   object::join_columns_collector join_columns_collector_{};
 };
-
-template<class Pointer>
-void select_query_builder::on_foreign_object(const char *id, Pointer &, const utils::foreign_attributes &attr, const bool add_column_on_lazy) {
-  const auto it = schema_.find(typeid(typename Pointer::value_type));
-  if (it == schema_.end()) {
-    throw query_builder_exception{error_code::UnknownType, "Unknown type"};
-  }
-  if (!it->second.node().info().has_primary_key()) {
-    throw query_builder_exception{error_code::MissingPrimaryKey, "Missing primary key"};
-  }
-
-  const auto& info = it->second.node().info();
-  auto foreign_table = it->second.table().as(build_alias('t', ++table_index));
-  if (attr.fetch() == utils::fetch_type::Eager) {
-
-    auto next = processed_tables_.find(info.name());
-    if (next != processed_tables_.end()) {
-      return;
-    }
-    table_info_stack_.push({info, std::move(foreign_table)});
-    next = processed_tables_.insert({info.name(), table_info_stack_.top().table}).first;
-    typename Pointer::value_type obj;
-    access::process(*this, obj);
-    table_info_stack_.pop();
-
-    append_join(
-      table_column{&table_info_stack_.top().table, id},
-      table_column{&next->second, info.primary_key_attribute()->name()}
-    );
-  } else if (add_column_on_lazy) {
-    push(id);
-  }
-}
-
 }
 #endif //QUERY_ENTITY_QUERY_BUILDER_HPP

include/matador/sql/internal/joined_collection_resolver_producer.hpp

@@ -14,23 +14,23 @@ namespace matador::sql {
 class dialect;
 class statement;
 class resolver_service;
-class collection_resolver_producer {
+class joined_collection_resolver_producer {
 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 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& type() const;
-  [[nodiscard]] const std::string& collection_name() const;
+  [[nodiscard]] const std::string& join_column_name() const;
 
 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:
   std::type_index root_type_;
   std::type_index type_;
-  std::string collection_name_;
+  std::string join_column_name_;
 };
 }
 #endif  // MATADOR_COLLECTION_RESOLVER_PRODUCER_HPP

include/matador/sql/internal/query_result_impl.hpp

@@ -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> *) {
   using value_type = typename CollectionType::value_type::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) {
     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> *) {
   using value_type = typename CollectionType::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) {
     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) {
   using value_type = typename CollectionType::value_type::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) {
     cont.reset(std::make_shared<object::collection_proxy<typename CollectionType::value_type>>(resolver, current_pk_));
   } 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>();
 
   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) {
     cont.reset(std::make_shared<object::collection_proxy<typename CollectionType::value_type>>(resolver, current_pk_));
   } else {

include/matador/sql/producer_object_resolver_factory.hpp

@@ -5,13 +5,13 @@
 
 #include "matador/object/abstract_joined_resolver.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"
 
 namespace matador::sql {
 class executor;
 
-class producer_resolver_factory : public object::object_resolver_factory {
+class producer_object_resolver_factory : public object::object_resolver_factory {
 public:
   [[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;
@@ -20,7 +20,7 @@ private:
   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:
   [[nodiscard]] std::shared_ptr<object::abstract_joined_resolver> acquire_collection_resolver(const std::type_index& root_type,
                                                                                                   const std::type_index& element_type,

include/matador/sql/resolver_service.hpp

@@ -1,7 +1,7 @@
 #ifndef 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 {
 class resolver_service {
@@ -12,8 +12,8 @@ public:
   }
 
   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>
@@ -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);
 
 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_;
 };
 }

source/core/CMakeLists.txt

@@ -21,7 +21,7 @@ add_library(matador-core STATIC
   ../../include/matador/object/basic_repository.hpp
   ../../include/matador/object/collection_proxy.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/error_code.hpp
   ../../include/matador/object/foreign_node_completer.hpp

source/orm/CMakeLists.txt

@@ -104,7 +104,7 @@ add_library(matador-orm STATIC
   ../../include/matador/sql/interface/query_result_reader.hpp
   ../../include/matador/sql/interface/statement_impl.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_statement_binder.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_pk_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_result.hpp
   ../../include/matador/sql/record.hpp
@@ -208,14 +208,14 @@ add_library(matador-orm STATIC
   sql/interface/query_result_reader.cpp
   sql/interface/statement_impl.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_statement_binder.cpp
   sql/internal/object_resolver_producer.cpp
   sql/internal/object_result_binder.cpp
   sql/internal/query_result_pk_resolver.cpp
   sql/object_parameter_binder.cpp
-  sql/producer_resolver_factory.cpp
+  sql/producer_object_resolver_factory.cpp
   sql/query_result.cpp
   sql/record.cpp
   sql/resolver_service.cpp

source/orm/query/basic_schema.cpp

@@ -141,7 +141,7 @@ const std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_p
   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_;
 }
 

source/orm/sql/internal/collection_resolver_producer.cpp

@@ -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

source/orm/sql/internal/joined_collection_resolver_producer.cpp

@@ -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

source/orm/sql/producer_object_resolver_factory.cpp

@@ -1,18 +1,18 @@
-#include "matador/sql/producer_resolver_factory.hpp"
+#include "matador/sql/producer_object_resolver_factory.hpp"
 
 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()) {
     return it->second;
   }
   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);
 }
 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::string& collection_name) const {
   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;
 }
-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()};
   resolvers_[key] = std::move(resolver);
 }

source/orm/sql/resolver_service.cpp

@@ -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) {
-  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) {

test/backends/SessionInsertHasOne.cpp

@@ -7,12 +7,13 @@
 #include "matador/query/session.hpp"
 
 #include "models/user.hpp"
+#include "models/country.hpp"
 
 using namespace matador::test;
 using namespace matador::query;
 using namespace matador::object;
 
-TEST_CASE_METHOD(SessionFixture, "Test insert object with has_one relation", "[session][insert][has_one]") {
+TEST_CASE_METHOD(SessionFixture, "Test insert object with has_one relation lazy", "[session][insert][has_one][lazy]") {
   const auto result = schema.attach<user_identity>("users")
     .and_then( [this] { return schema.attach<user_session_identity>("user_sessions"); } )
     .and_then([this] { return schema.create(db); } );
@@ -31,7 +32,29 @@ TEST_CASE_METHOD(SessionFixture, "Test insert object with has_one relation", "[s
 
   const auto user_result = ses.find<user_identity>(u->id);
   REQUIRE(user_result.is_ok());
-  // REQUIRE(user_result.value()->session->session_token == "session1");
   us = user_result.value()->session;
-  const auto token = us->session_token;
+  REQUIRE(us->session_token == "session1");
+}
+
+TEST_CASE_METHOD(SessionFixture, "Test insert object with has_one relation eager", "[session][insert][has_one][eager]") {
+  const auto result = schema.attach<country_identity>("countries")
+    .and_then( [this] { return schema.attach<capital_identity>("capitals"); } )
+    .and_then([this] { return schema.create(db); } );
+  REQUIRE(result.is_ok());
+
+  session ses({bus, connection::dns, 4}, schema);
+
+  const auto ger = make_object<country_identity>("Germany");
+  auto ger_cap = make_object<capital_identity>("Berlin", ger);
+
+  REQUIRE(ger.is_transient());
+  REQUIRE(ger_cap.is_transient());
+  REQUIRE(ses.insert(ger_cap).is_ok());
+  REQUIRE(ger_cap.is_persistent());
+  REQUIRE(ger.is_persistent());
+
+  const auto ger_result = ses.find<country_identity>(ger->id);
+  REQUIRE(ger_result.is_ok());
+  ger_cap = ger_result.value()->capital;
+  REQUIRE(ger_cap->name == "Berlin");
 }

test/models/country.hpp

@@ -0,0 +1,72 @@
+#ifndef MATADOR_COUNTRY_HPP
+#define MATADOR_COUNTRY_HPP
+
+#include "matador/utils/access.hpp"
+
+#include "matador/object/object_ptr.hpp"
+
+#include <string>
+
+namespace matador::test {
+template<const utils::primary_key_attribute &PkAttribute>
+struct capital_pk_generator;
+
+template<const utils::primary_key_attribute &PkAttribute>
+struct country_pk_generator {
+  unsigned int id{};
+  std::string name;
+  object::object_ptr<capital_pk_generator<PkAttribute>> capital;
+
+  country_pk_generator() = default;
+  explicit country_pk_generator(std::string name)
+  : name(std::move(name)) {}
+  country_pk_generator(const unsigned int id, std::string name)
+  : id(id)
+  , name(std::move(name)) {}
+
+  template<class Operator>
+  void process(Operator &op) {
+    namespace field = matador::access;
+    using namespace matador::utils;
+    field::primary_key(op, "id", id, PkAttribute);
+    field::attribute(op, "name", name, UniqueVarChar255);
+    field::has_one(op, "capital", capital, "country_id", CascadeAllFetchEager);
+  }
+};
+
+template<const utils::primary_key_attribute &PkAttribute>
+struct capital_pk_generator {
+  unsigned int id{};
+  std::string name;
+  object::object_ptr<country_pk_generator<PkAttribute>> country;
+
+  capital_pk_generator() = default;
+  capital_pk_generator(std::string name, object::object_ptr<country_pk_generator<PkAttribute>> country)
+  : name(std::move(name))
+  , country(std::move(country)) {}
+  capital_pk_generator(const unsigned int id, std::string name, object::object_ptr<country_pk_generator<PkAttribute>> country)
+  : id(id)
+  , name(std::move(name))
+  , country(std::move(country)) {}
+
+  template<class Operator>
+  void process(Operator &op) {
+    namespace field = matador::access;
+    using namespace matador::utils;
+    field::primary_key(op, "id", id, PkAttribute);
+    field::attribute(op, "name", name, VarChar255);
+    field::belongs_to(op, "country_id", country, CascadeAllFetchLazy);
+  }
+};
+
+using country = country_pk_generator<utils::Manual>;
+using country_identity = country_pk_generator<utils::Identity>;
+using country_sequence = country_pk_generator<utils::Sequence>;
+using country_table = country_pk_generator<utils::Table>;
+using capital = capital_pk_generator<utils::Manual>;
+using capital_identity = capital_pk_generator<utils::Identity>;
+using capital_sequence = capital_pk_generator<utils::Sequence>;
+using capital_table = capital_pk_generator<utils::Table>;
+}
+
+#endif //MATADOR_COUNTRY_HPP

test/models/order_details.hpp

@@ -3,6 +3,7 @@
 
 #include "product.hpp"
 
+#include "matador/object/collection.hpp"
 #include "matador/object/object_ptr.hpp"
 
 #include "matador/utils/foreign_attributes.hpp"
@@ -13,14 +14,14 @@ struct order;
 struct order_details {
   unsigned int order_details_id;
   object::object_ptr<order> order_;
-  object::object_ptr<product> product_;
+  object::collection<object::object_ptr<product>> products_;
 
   template<class Operator>
   void process(Operator &op) {
     namespace field = matador::access;
     field::primary_key(op, "order_details_id", order_details_id);
     field::belongs_to(op, "order_id", order_, utils::CascadeNoneFetchLazy);
-    field::has_one(op, "product_id", product_, utils::CascadeNoneFetchLazy);
+    field::has_many(op, "order_products", products_, "product_id", utils::CascadeNoneFetchLazy);
   }
 };
 }

test/orm/query/ColumnGeneratorTest.cpp

@@ -1,17 +1,9 @@
 #include <catch2/catch_test_macros.hpp>
 
-#include "matador/sql/backend_provider.hpp"
-#include "matador/sql/connection_pool.hpp"
-#include "matador/sql/interface/connection_impl.hpp"
-
 #include "matador/query/generator.hpp"
 #include "matador/query/table.hpp"
 #include "matador/query/schema.hpp"
 
-#include "matador/object/repository.hpp"
-
-#include "../backend/test_backend_service.hpp"
-
 #include "../test/models/product.hpp"
 #include "../test/models/order.hpp"
 #include "../test/models/book.hpp"
@@ -23,8 +15,6 @@ using namespace matador::sql;
 
 TEST_CASE("Generate columns from object", "[column][generator]") {
   using namespace matador::test;
-  backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
-  connection_pool pool("noop://noop.db", 4);
 
   schema s;
   auto result = s.attach<product>("product");
@@ -53,8 +43,6 @@ TEST_CASE("Generate columns from object", "[column][generator]") {
 
 TEST_CASE("Generate columns for object with has many relation", "[column][generator][relation]") {
   using namespace matador::test;
-  backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
-  connection_pool pool("noop://noop.db", 4);
 
   schema s;
   auto result = s.attach<supplier>("supplier")
@@ -82,8 +70,7 @@ TEST_CASE("Generate columns for object with has many relation", "[column][genera
     { &order_table, "ship_postal_code", "c11" },
     { &order_table, "ship_country", "c12" },
     { &order_details_table, "order_details_id", "c13" },
-    { &order_details_table, "order_id", "c14" },
+    { &order_details_table, "order_id", "c14" }
-    { &order_details_table, "product_id", "c15" }
   };
   REQUIRE(!columns.empty());
   REQUIRE(columns.size() == expected_columns.size());
@@ -96,8 +83,6 @@ TEST_CASE("Generate columns for object with has many relation", "[column][genera
 
 TEST_CASE("Generate columns for object with eager foreign key relation", "[column][generator][eager]") {
   using namespace matador::test;
-  backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
-  connection_pool pool("noop://noop.db", 4);
 
   schema s;
   auto result = s.attach<book>("books")

test/orm/query/SessionQueryBuilderTest.cpp

@@ -24,6 +24,7 @@
 #include "../../models/order.hpp"
 #include "../../models/student.hpp"
 #include "../../models/user.hpp"
+#include "../../models/country.hpp"
 #include "../../models/model_metas.hpp"
 
 using namespace matador::object;
@@ -188,7 +189,7 @@ TEST_CASE("Create sql query data for entity with eager has many belongs to", "[q
 
   REQUIRE(q.is_ok());
   const auto sql = q->str(db);
-  const std::string expected_sql = R"(SELECT "t01"."order_id", "t01"."order_date", "t01"."required_date", "t01"."shipped_date", "t01"."ship_via", "t01"."freight", "t01"."ship_name", "t01"."ship_address", "t01"."ship_city", "t01"."ship_region", "t01"."ship_postal_code", "t01"."ship_country", "t02"."order_details_id", "t02"."order_id", "t02"."product_id" FROM "orders" "t01" LEFT JOIN "order_details" "t02" ON "t01"."order_id" = "t02"."order_id" WHERE "t01"."order_id" = ? ORDER BY "t01"."order_id" ASC)";
+  const std::string expected_sql = R"(SELECT "t01"."order_id", "t01"."order_date", "t01"."required_date", "t01"."shipped_date", "t01"."ship_via", "t01"."freight", "t01"."ship_name", "t01"."ship_address", "t01"."ship_city", "t01"."ship_region", "t01"."ship_postal_code", "t01"."ship_country", "t02"."order_details_id", "t02"."order_id" FROM "orders" "t01" LEFT JOIN "order_details" "t02" ON "t01"."order_id" = "t02"."order_id" WHERE "t01"."order_id" = ? ORDER BY "t01"."order_id" ASC)";
   REQUIRE(expected_sql == sql);
 
   const auto& data = eqb.query_data();
@@ -211,8 +212,7 @@ TEST_CASE("Create sql query data for entity with eager has many belongs to", "[q
     { &orders, "ship_postal_code", "c11" },
     { &orders, "ship_country", "c12" },
     { &order_details, "order_details_id", "c13" },
-    { &order_details, "order_id", "c14" },
+    { &order_details, "order_id", "c14" }
-    { &order_details, "product_id", "c15" }
   };
   REQUIRE(data.columns.size() == expected_columns.size());
   for (size_t i = 0; i != expected_columns.size(); ++i) {
@@ -387,7 +387,7 @@ TEST_CASE("Test eager relationship", "[query][entity][builder]") {
   // std::cout << ctx << std::endl;
 }
 
-TEST_CASE("Test has one relationship", "[query][entity][builder][has_one]") {
+TEST_CASE("Test has one lazy relationship", "[query][entity][builder][has_one][lazy]") {
   using namespace matador::test;
   backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
   connection db("noop://noop.db");
@@ -402,5 +402,27 @@ TEST_CASE("Test has one relationship", "[query][entity][builder][has_one]") {
   auto q = eqb.build<user>();
   REQUIRE(q.is_ok());
   const auto sql = q->str(db);
+  const std::string expected_sql = R"(SELECT "t01"."id", "t01"."name", "t01"."password" FROM "users" "t01" ORDER BY "t01"."id" ASC)";
 
+  REQUIRE(expected_sql == sql);
+}
+
+TEST_CASE("Test has one eager relationship", "[query][entity][builder][has_one][eager]") {
+  using namespace matador::test;
+  backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
+  connection db("noop://noop.db");
+
+  schema scm;
+  auto result = scm.attach<country>("countries")
+    .and_then( [&scm] { return scm.attach<capital>("capitals"); } );
+  REQUIRE(result);
+
+  select_query_builder eqb(scm);
+
+  auto q = eqb.build<country>();
+  REQUIRE(q.is_ok());
+  const auto sql = q->str(db);
+  const std::string expected_sql = R"(SELECT "t01"."id", "t01"."name", "t02"."id", "t02"."name", "t02"."country_id" FROM "countries" "t01" LEFT JOIN "capitals" "t02" ON "t01"."id" = "t02"."country_id" ORDER BY "t01"."id" ASC)";
+
+  REQUIRE(expected_sql == sql);
 }