collection resolver progress

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_resolver_producer(const basic_schema& repo, const table& tab, std::string pk_name)
-  : resolver_producer(typeid(Type))
+  query_object_resolver_producer() = default;
+  query_object_resolver_producer(const basic_schema& repo, const table& tab, std::string pk_name)
+  : 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);
   }
 }