collection resolver progress

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<abstract_type_resolver> acquire_resolver(const std::type_index &type) = 0;
+  virtual std::shared_ptr<abstract_type_resolver> acquire_object_resolver(const std::type_index &type) = 0;
-  virtual void register_resolver(std::shared_ptr<abstract_type_resolver> &&resolver) = 0;
+  virtual void register_object_resolver(std::shared_ptr<abstract_type_resolver> &&resolver) = 0;
 };
 }
 #endif //MATADOR_ABSTRACT_TYPE_RESOLVER_FACTORY_HPP

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<typename Type>
 // class collection_resolver : public abstract_collection_resolver {

include/matador/object/collection_resolver.hpp

@@ -8,6 +8,19 @@
 #include <vector>
 
 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<typename Type>
 class collection_resolver : public abstract_type_resolver {
 public:

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<abstract_collection_resolver> 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<abstract_collection_resolver> &&resolver) = 0;
+};
+
 class collection_resolver_factory : public abstract_type_resolver_factory {
 public:
   template<class Type>
   std::shared_ptr<collection_resolver<Type>> resolver() {
-    const auto res = acquire_resolver(typeid(std::vector<object_ptr<Type>>));
+    const auto res = acquire_object_resolver(typeid(std::vector<object_ptr<Type>>));
     if (!res) {
       return std::dynamic_pointer_cast<collection_resolver<Type>>(res);
     }

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 <memory>
+#include <vector>
+
+namespace matador::utils {
+class identifier;
+}
+
+namespace matador::object {
+template<typename Type>
+class container_resolver : public abstract_type_resolver {
+public:
+  container_resolver() : abstract_type_resolver(typeid(Type)) {}
+
+  virtual std::shared_ptr<std::vector<Type>> resolve(const utils::identifier& id) = 0;
+};
+}
+
+#endif //MATADOR_CONTAINER_RESOLVER_HPP

include/matador/object/object_resolver.hpp

@@ -2,6 +2,7 @@
 #define MATADOR_OBJECT_LOADER_HPP
 
 #include "matador/object/abstract_type_resolver.hpp"
+
 #include <memory>
 
 namespace matador::utils {

include/matador/object/object_resolver_factory.hpp

@@ -10,23 +10,18 @@ class object_resolver_factory : public abstract_type_resolver_factory {
 public:
   template<class Type>
   std::shared_ptr<object_resolver<Type>> 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<object_resolver<Type>>(res);
     }
 
     return std::dynamic_pointer_cast<object_resolver<Type>>(res);
   }
-  //
-  // template<class Type>
-  // std::shared_ptr<collection_resolver<Type>> 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<collection_resolver<Type>>(res);
-  //   }
-  //
-  //   return std::dynamic_pointer_cast<collection_resolver<Type>>(res);
-  // }
 };
+
+class object_resolver_service : public object_resolver_factory, public collection_resolver_factory {
+public:
+};
+
 }
 #endif //MATADOR_OBJECT_RESOLVER_FACTORY_HPP

include/matador/query/basic_schema.hpp

@@ -58,7 +58,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::resolver_producer>> resolver_producers_;
+  std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_producer>> resolver_producers_;
 };
 }
 #endif //MATADOR_BASIC_SCHEMA_HPP

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<typename Type>
+class query_container_resolver : public object::container_resolver<Type> {
+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<Type> 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<sql::statement, utils::error> prepare_collection_statement(sql::executor& exec, entity_query_data &&data);
+
+template<typename Type>
+std::shared_ptr<Type> query_container_resolver<Type>::resolve(const utils::identifier &id) {
+
+}
+}
+#endif //MATADOR_QUERY_CONTAINER_RESOLVER_HPP

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<typename Type>
-class query_resolver_producer : public sql::resolver_producer {
+class query_object_resolver_producer : public sql::object_resolver_producer {
 public:
-  query_resolver_producer() = default;
+  query_object_resolver_producer() = default;
-  query_resolver_producer(const basic_schema& repo, const table& tab, std::string pk_name)
+  query_object_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)) {}
@@ -38,11 +38,11 @@ private:
 };
 
 template<typename Type>
-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<Type>::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<query_resolver_producer<Type>>(schema_, it->second.table(), it->second.node().info().primary_key_attribute()->name());
+    auto producer = std::make_unique<query_object_resolver_producer<Type>>(schema_, it->second.table(), it->second.node().info().primary_key_attribute()->name());
     schema_.resolver_producers_[typeid(Type)] = std::move(producer);
   }
 }

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<object::abstract_type_resolver> 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_;

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 <unordered_map>
 
@@ -13,8 +13,8 @@ class executor;
 class producer_resolver_factory : public object::object_resolver_factory {
 public:
 
-  std::shared_ptr<object::abstract_type_resolver> acquire_resolver(const std::type_index &type) override;
+  std::shared_ptr<object::abstract_type_resolver> acquire_object_resolver(const std::type_index &type) override;
-  void register_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) override;
+  void register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) override;
 
 private:
   std::unordered_map<std::type_index, std::shared_ptr<object::abstract_type_resolver>> resolvers_;

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})

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

source/orm/query/basic_schema.cpp

@@ -85,7 +85,7 @@ void basic_schema::initialize_executor(sql::executor &exec) const {
   auto factory = std::make_shared<sql::producer_resolver_factory>();
   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));
   }
 }
 

source/orm/query/query_container_resolver.cpp

@@ -0,0 +1,14 @@
+#include "matador/query/query_container_resolver.hpp"
+
+namespace matador::query {
+utils::result<sql::statement, utils::error> 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);
+}
+
+}

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) {}
+}

source/orm/sql/internal/resolver_producer.cpp

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

source/orm/sql/producer_resolver_factory.cpp

@@ -1,14 +1,14 @@
 #include "matador/sql/producer_resolver_factory.hpp"
 
 namespace matador::sql {
-std::shared_ptr<object::abstract_type_resolver> producer_resolver_factory::acquire_resolver(const std::type_index &type) {
+std::shared_ptr<object::abstract_type_resolver> 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<object::abstract_type_resolver> &&resolver) {
+void producer_resolver_factory::register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) {
   resolvers_[resolver->type()] = std::move(resolver);
 }
 }