collection resolver progress

source/core/CMakeLists.txt

@@ -120,6 +120,8 @@ add_library(matador-core STATIC
   utils/uuid.cpp
   utils/value.cpp
   utils/version.cpp
+  ../../include/matador/object/collection_utils.hpp
+  object/collection_utils.cpp
 )
 
 target_link_libraries(matador-core ${CMAKE_DL_LIBS})

source/core/object/collection_utils.cpp

@@ -0,0 +1,22 @@
+#include "matador/object/collection_utils.hpp"
+
+namespace matador::object {
+bool collection_composite_key::operator==(const collection_composite_key &other) const {
+  return root_type == other.root_type &&
+         type == other.type &&
+         name == other.name;
+}
+
+std::size_t collection_composite_key_hash::operator()(const collection_composite_key &k) const noexcept {
+  const std::size_t h1 = std::hash<std::type_index>{}(k.root_type);
+  const std::size_t h2 = std::hash<std::type_index>{}(k.type);
+  const std::size_t h3 = std::hash<std::string>{}(k.name);
+
+  // Klassische Hash-Kombination (Boost-Style)
+  std::size_t seed = h1;
+  seed ^= h2 + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+  seed ^= h3 + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+
+  return seed;
+}
+}

source/orm/query/internal/query_result_impl.cpp

@@ -39,6 +39,16 @@ query_result_impl::on_attribute(const char *id, utils::value &val, const utils::
   reader_->read_value(id, column_index_++, val, attr.size());
 }
 
+bool query_result_impl::fetch(record &rec) {
+  if (auto fetched = reader_->fetch(); !fetched.is_ok() || !*fetched) {
+    return false;
+  }
+
+  column_index_ = reader_->start_column_index();
+  access::process(*this, rec);
+  return true;
+}
+
 const std::vector<object::attribute> &query_result_impl::prototype() const {
   return prototype_;
 }

source/orm/sql/connection.cpp

@@ -244,7 +244,12 @@ utils::result<std::unique_ptr<statement_impl>, utils::error> connection::perform
         const auto rit = std::find_if(
           std::begin(*result),
           std::end(*result),
-          [&col](const auto &value) { return value.name() == col.name(); }
+          [&col, &ctx](const auto &value) {
+            if (ctx.table_name.empty()) {
+              return value.name() == col.name();
+            }
+            return value.name() == col.name() || ctx.table_name + "." + value.name() == col.name();
+          }
         );
         if (col.type() == utils::basic_type::Null && rit != result->end()) {
           const_cast<object::attribute&>(col).change_type(rit->type());

source/orm/sql/internal/collection_resolver_producer.cpp

@@ -4,12 +4,15 @@ 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)

source/orm/sql/producer_resolver_factory.cpp

@@ -15,14 +15,14 @@ std::shared_ptr<object::abstract_collection_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 {
-  const composite_key key{root_type, element_type, collection_name};
+  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_collection_resolver_factory::register_collection_resolver(std::shared_ptr<object::abstract_collection_resolver>&& resolver) {
-  const composite_key key{resolver->root_type(), resolver->type(), resolver->collection_name()};
+  const object::collection_composite_key key{resolver->root_type(), resolver->type(), resolver->collection_name()};
   resolvers_[key] = std::move(resolver);
 }
 }  // namespace matador::sql