quickstep-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jign...@apache.org
Subject [1/5] incubator-quickstep git commit: Adds support for left/right outer join (#178) [Forced Update!]
Date Thu, 21 Apr 2016 15:01:05 GMT
Repository: incubator-quickstep
Updated Branches:
  refs/heads/master f9b48a8ab -> cd93fd743 (forced update)


http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/ef383ef2/relational_operators/WorkOrderFactory.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/WorkOrderFactory.cpp b/relational_operators/WorkOrderFactory.cpp
index 92c1140..964c11c 100644
--- a/relational_operators/WorkOrderFactory.cpp
+++ b/relational_operators/WorkOrderFactory.cpp
@@ -135,11 +135,39 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
           query_context->getInsertDestination(
               proto.GetExtension(serialization::FinalizeAggregationWorkOrder::insert_destination_index)));
     }
+    case serialization::HASH_ANTI_JOIN: {
+      LOG(INFO) << "Creating HashAntiJoinWorkOrder";
+      vector<attribute_id> join_key_attributes;
+      const int join_key_attributes_size =
+          proto.ExtensionSize(serialization::HashAntiJoinWorkOrder::join_key_attributes);
+      for (int i = 0; i < join_key_attributes_size; ++i) {
+        join_key_attributes.push_back(
+            proto.GetExtension(serialization::HashAntiJoinWorkOrder::join_key_attributes,
i));
+      }
+
+      return new HashAntiJoinWorkOrder(
+          catalog_database->getRelationSchemaById(
+              proto.GetExtension(serialization::HashAntiJoinWorkOrder::build_relation_id)),
+          catalog_database->getRelationSchemaById(
+              proto.GetExtension(serialization::HashAntiJoinWorkOrder::probe_relation_id)),
+          move(join_key_attributes),
+          proto.GetExtension(serialization::HashAntiJoinWorkOrder::any_join_key_attributes_nullable),
+          proto.GetExtension(serialization::HashAntiJoinWorkOrder::block_id),
+          query_context->getPredicate(
+              proto.GetExtension(serialization::HashAntiJoinWorkOrder::residual_predicate_index)),
+          query_context->getScalarGroup(
+              proto.GetExtension(serialization::HashAntiJoinWorkOrder::selection_index)),
+          *query_context->getJoinHashTable(
+              proto.GetExtension(serialization::HashAntiJoinWorkOrder::join_hash_table_index)),
+          query_context->getInsertDestination(
+              proto.GetExtension(serialization::HashAntiJoinWorkOrder::insert_destination_index)),
+          storage_manager);
+    }
     case serialization::HASH_INNER_JOIN: {
       LOG(INFO) << "Creating HashInnerJoinWorkOrder";
       vector<attribute_id> join_key_attributes;
       const int join_key_attributes_size =
-          proto.ExtensionSize(serialization::HashAntiJoinWorkOrder::join_key_attributes);
+          proto.ExtensionSize(serialization::HashInnerJoinWorkOrder::join_key_attributes);
       for (int i = 0; i < join_key_attributes_size; ++i) {
         join_key_attributes.push_back(
             proto.GetExtension(serialization::HashInnerJoinWorkOrder::join_key_attributes,
i));
@@ -163,60 +191,66 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
               proto.GetExtension(serialization::HashInnerJoinWorkOrder::insert_destination_index)),
           storage_manager);
     }
-    case serialization::HASH_SEMI_JOIN: {
-      LOG(INFO) << "Creating HashSemiJoinWorkOrder";
+    case serialization::HASH_OUTER_JOIN: {
+      LOG(INFO) << "Creating HashOuterJoinWorkOrder";
       vector<attribute_id> join_key_attributes;
       const int join_key_attributes_size =
-          proto.ExtensionSize(serialization::HashAntiJoinWorkOrder::join_key_attributes);
+          proto.ExtensionSize(serialization::HashOuterJoinWorkOrder::join_key_attributes);
       for (int i = 0; i < join_key_attributes_size; ++i) {
         join_key_attributes.push_back(
-            proto.GetExtension(serialization::HashSemiJoinWorkOrder::join_key_attributes,
i));
+            proto.GetExtension(serialization::HashOuterJoinWorkOrder::join_key_attributes,
i));
+      }
+      vector<bool> is_selection_on_build;
+      const int is_selection_on_build_size =
+          proto.ExtensionSize(serialization::HashOuterJoinWorkOrder::is_selection_on_build);
+      for (int i = 0; i < is_selection_on_build_size; ++i) {
+        is_selection_on_build.push_back(
+            proto.GetExtension(serialization::HashOuterJoinWorkOrder::is_selection_on_build,
i));
       }
 
-      return new HashSemiJoinWorkOrder(
+      return new HashOuterJoinWorkOrder(
           catalog_database->getRelationSchemaById(
-              proto.GetExtension(serialization::HashSemiJoinWorkOrder::build_relation_id)),
+              proto.GetExtension(serialization::HashOuterJoinWorkOrder::build_relation_id)),
           catalog_database->getRelationSchemaById(
-              proto.GetExtension(serialization::HashSemiJoinWorkOrder::probe_relation_id)),
+              proto.GetExtension(serialization::HashOuterJoinWorkOrder::probe_relation_id)),
           move(join_key_attributes),
-          proto.GetExtension(serialization::HashSemiJoinWorkOrder::any_join_key_attributes_nullable),
-          proto.GetExtension(serialization::HashSemiJoinWorkOrder::block_id),
-          query_context->getPredicate(
-              proto.GetExtension(serialization::HashSemiJoinWorkOrder::residual_predicate_index)),
+          proto.GetExtension(serialization::HashOuterJoinWorkOrder::any_join_key_attributes_nullable),
+          proto.GetExtension(serialization::HashOuterJoinWorkOrder::block_id),
           query_context->getScalarGroup(
-              proto.GetExtension(serialization::HashSemiJoinWorkOrder::selection_index)),
+              proto.GetExtension(serialization::HashOuterJoinWorkOrder::selection_index)),
+          move(is_selection_on_build),
           *query_context->getJoinHashTable(
-              proto.GetExtension(serialization::HashSemiJoinWorkOrder::join_hash_table_index)),
+              proto.GetExtension(serialization::HashOuterJoinWorkOrder::join_hash_table_index)),
           query_context->getInsertDestination(
-              proto.GetExtension(serialization::HashSemiJoinWorkOrder::insert_destination_index)),
+              proto.GetExtension(serialization::HashOuterJoinWorkOrder::insert_destination_index)),
           storage_manager);
     }
-    case serialization::HASH_ANTI_JOIN: {
-      LOG(INFO) << "Creating HashAntiJoinWorkOrder";
+    case serialization::HASH_SEMI_JOIN: {
+      LOG(INFO) << "Creating HashSemiJoinWorkOrder";
       vector<attribute_id> join_key_attributes;
       const int join_key_attributes_size =
-          proto.ExtensionSize(serialization::HashAntiJoinWorkOrder::join_key_attributes);
+          proto.ExtensionSize(serialization::HashSemiJoinWorkOrder::join_key_attributes);
       for (int i = 0; i < join_key_attributes_size; ++i) {
         join_key_attributes.push_back(
-            proto.GetExtension(serialization::HashAntiJoinWorkOrder::join_key_attributes,
i));
+            proto.GetExtension(serialization::HashSemiJoinWorkOrder::join_key_attributes,
i));
       }
 
-      return new HashAntiJoinWorkOrder(
+      return new HashSemiJoinWorkOrder(
           catalog_database->getRelationSchemaById(
-              proto.GetExtension(serialization::HashAntiJoinWorkOrder::build_relation_id)),
+              proto.GetExtension(serialization::HashSemiJoinWorkOrder::build_relation_id)),
           catalog_database->getRelationSchemaById(
-              proto.GetExtension(serialization::HashAntiJoinWorkOrder::probe_relation_id)),
+              proto.GetExtension(serialization::HashSemiJoinWorkOrder::probe_relation_id)),
           move(join_key_attributes),
-          proto.GetExtension(serialization::HashAntiJoinWorkOrder::any_join_key_attributes_nullable),
-          proto.GetExtension(serialization::HashAntiJoinWorkOrder::block_id),
+          proto.GetExtension(serialization::HashSemiJoinWorkOrder::any_join_key_attributes_nullable),
+          proto.GetExtension(serialization::HashSemiJoinWorkOrder::block_id),
           query_context->getPredicate(
-              proto.GetExtension(serialization::HashAntiJoinWorkOrder::residual_predicate_index)),
+              proto.GetExtension(serialization::HashSemiJoinWorkOrder::residual_predicate_index)),
           query_context->getScalarGroup(
-              proto.GetExtension(serialization::HashAntiJoinWorkOrder::selection_index)),
+              proto.GetExtension(serialization::HashSemiJoinWorkOrder::selection_index)),
           *query_context->getJoinHashTable(
-              proto.GetExtension(serialization::HashAntiJoinWorkOrder::join_hash_table_index)),
+              proto.GetExtension(serialization::HashSemiJoinWorkOrder::join_hash_table_index)),
           query_context->getInsertDestination(
-              proto.GetExtension(serialization::HashAntiJoinWorkOrder::insert_destination_index)),
+              proto.GetExtension(serialization::HashSemiJoinWorkOrder::insert_destination_index)),
           storage_manager);
     }
     case serialization::INSERT: {
@@ -452,6 +486,50 @@ bool WorkOrderFactory::ProtoIsValid(const serialization::WorkOrder &proto,
              query_context.isValidInsertDestinationId(
                  proto.GetExtension(serialization::FinalizeAggregationWorkOrder::insert_destination_index));
     }
+    case serialization::HASH_ANTI_JOIN: {
+      if (!proto.HasExtension(serialization::HashAntiJoinWorkOrder::build_relation_id) ||
+          !proto.HasExtension(serialization::HashAntiJoinWorkOrder::probe_relation_id)) {
+        return false;
+      }
+
+      const relation_id build_relation_id =
+          proto.GetExtension(serialization::HashAntiJoinWorkOrder::build_relation_id);
+      if (!catalog_database.hasRelationWithId(build_relation_id)) {
+        return false;
+      }
+
+      const relation_id probe_relation_id =
+          proto.GetExtension(serialization::HashAntiJoinWorkOrder::probe_relation_id);
+      if (!catalog_database.hasRelationWithId(probe_relation_id)) {
+        return false;
+      }
+
+      const CatalogRelationSchema &build_relation = catalog_database.getRelationSchemaById(build_relation_id);
+      const CatalogRelationSchema &probe_relation = catalog_database.getRelationSchemaById(probe_relation_id);
+      for (int i = 0; i < proto.ExtensionSize(serialization::HashAntiJoinWorkOrder::join_key_attributes);
++i) {
+        const attribute_id attr_id =
+            proto.GetExtension(serialization::HashAntiJoinWorkOrder::join_key_attributes,
i);
+        if (!build_relation.hasAttributeWithId(attr_id) ||
+            !probe_relation.hasAttributeWithId(attr_id)) {
+          return false;
+        }
+      }
+
+      return proto.HasExtension(serialization::HashAntiJoinWorkOrder::any_join_key_attributes_nullable)
&&
+             proto.HasExtension(serialization::HashAntiJoinWorkOrder::insert_destination_index)
&&
+             query_context.isValidInsertDestinationId(
+                 proto.GetExtension(serialization::HashAntiJoinWorkOrder::insert_destination_index))
&&
+             proto.HasExtension(serialization::HashAntiJoinWorkOrder::join_hash_table_index)
&&
+             query_context.isValidJoinHashTableId(
+                 proto.GetExtension(serialization::HashAntiJoinWorkOrder::join_hash_table_index))
&&
+             proto.HasExtension(serialization::HashAntiJoinWorkOrder::residual_predicate_index)
&&
+             query_context.isValidPredicate(
+                 proto.GetExtension(serialization::HashAntiJoinWorkOrder::residual_predicate_index))
&&
+             proto.HasExtension(serialization::HashAntiJoinWorkOrder::selection_index) &&
+             query_context.isValidScalarGroupId(
+                 proto.GetExtension(serialization::HashAntiJoinWorkOrder::selection_index))
&&
+             proto.HasExtension(serialization::HashAntiJoinWorkOrder::block_id);
+    }
     case serialization::HASH_INNER_JOIN: {
       if (!proto.HasExtension(serialization::HashInnerJoinWorkOrder::build_relation_id) ||
           !proto.HasExtension(serialization::HashInnerJoinWorkOrder::probe_relation_id))
{
@@ -496,93 +574,91 @@ bool WorkOrderFactory::ProtoIsValid(const serialization::WorkOrder &proto,
                  proto.GetExtension(serialization::HashInnerJoinWorkOrder::selection_index))
&&
              proto.HasExtension(serialization::HashInnerJoinWorkOrder::block_id);
     }
-    case serialization::HASH_SEMI_JOIN: {
-      if (!proto.HasExtension(serialization::HashSemiJoinWorkOrder::build_relation_id) ||
-          !proto.HasExtension(serialization::HashSemiJoinWorkOrder::probe_relation_id)) {
+    case serialization::HASH_OUTER_JOIN: {
+      if (!proto.HasExtension(serialization::HashOuterJoinWorkOrder::build_relation_id) ||
+          !proto.HasExtension(serialization::HashOuterJoinWorkOrder::probe_relation_id))
{
         return false;
       }
 
       const relation_id build_relation_id =
-          proto.GetExtension(serialization::HashSemiJoinWorkOrder::build_relation_id);
+          proto.GetExtension(serialization::HashOuterJoinWorkOrder::build_relation_id);
       if (!catalog_database.hasRelationWithId(build_relation_id)) {
         return false;
       }
 
       const relation_id probe_relation_id =
-          proto.GetExtension(serialization::HashSemiJoinWorkOrder::probe_relation_id);
+          proto.GetExtension(serialization::HashOuterJoinWorkOrder::probe_relation_id);
       if (!catalog_database.hasRelationWithId(probe_relation_id)) {
         return false;
       }
 
       const CatalogRelationSchema &build_relation = catalog_database.getRelationSchemaById(build_relation_id);
       const CatalogRelationSchema &probe_relation = catalog_database.getRelationSchemaById(probe_relation_id);
-      for (int i = 0; i < proto.ExtensionSize(serialization::HashSemiJoinWorkOrder::join_key_attributes);
++i) {
+      for (int i = 0; i < proto.ExtensionSize(serialization::HashOuterJoinWorkOrder::join_key_attributes);
++i) {
         const attribute_id attr_id =
-            proto.GetExtension(serialization::HashSemiJoinWorkOrder::join_key_attributes,
i);
+            proto.GetExtension(serialization::HashOuterJoinWorkOrder::join_key_attributes,
i);
         if (!build_relation.hasAttributeWithId(attr_id) ||
             !probe_relation.hasAttributeWithId(attr_id)) {
           return false;
         }
       }
 
-      return proto.HasExtension(serialization::HashSemiJoinWorkOrder::any_join_key_attributes_nullable)
&&
-             proto.HasExtension(serialization::HashSemiJoinWorkOrder::insert_destination_index)
&&
+      return proto.HasExtension(serialization::HashOuterJoinWorkOrder::any_join_key_attributes_nullable)
&&
+             proto.HasExtension(serialization::HashOuterJoinWorkOrder::insert_destination_index)
&&
              query_context.isValidInsertDestinationId(
-                 proto.GetExtension(serialization::HashSemiJoinWorkOrder::insert_destination_index))
&&
-             proto.HasExtension(serialization::HashSemiJoinWorkOrder::join_hash_table_index)
&&
+                 proto.GetExtension(serialization::HashOuterJoinWorkOrder::insert_destination_index))
&&
+             proto.HasExtension(serialization::HashOuterJoinWorkOrder::join_hash_table_index)
&&
              query_context.isValidJoinHashTableId(
-                 proto.GetExtension(serialization::HashSemiJoinWorkOrder::join_hash_table_index))
&&
-             proto.HasExtension(serialization::HashSemiJoinWorkOrder::residual_predicate_index)
&&
-             query_context.isValidPredicate(
-                 proto.GetExtension(serialization::HashSemiJoinWorkOrder::residual_predicate_index))
&&
-             proto.HasExtension(serialization::HashSemiJoinWorkOrder::selection_index) &&
+                 proto.GetExtension(serialization::HashOuterJoinWorkOrder::join_hash_table_index))
&&
+             proto.HasExtension(serialization::HashOuterJoinWorkOrder::selection_index) &&
              query_context.isValidScalarGroupId(
-                 proto.GetExtension(serialization::HashSemiJoinWorkOrder::selection_index))
&&
-             proto.HasExtension(serialization::HashSemiJoinWorkOrder::block_id);
+                 proto.GetExtension(serialization::HashOuterJoinWorkOrder::selection_index))
&&
+             proto.HasExtension(serialization::HashOuterJoinWorkOrder::is_selection_on_build)
&&
+             proto.HasExtension(serialization::HashOuterJoinWorkOrder::block_id);
     }
-    case serialization::HASH_ANTI_JOIN: {
-      if (!proto.HasExtension(serialization::HashAntiJoinWorkOrder::build_relation_id) ||
-          !proto.HasExtension(serialization::HashAntiJoinWorkOrder::probe_relation_id)) {
+    case serialization::HASH_SEMI_JOIN: {
+      if (!proto.HasExtension(serialization::HashSemiJoinWorkOrder::build_relation_id) ||
+          !proto.HasExtension(serialization::HashSemiJoinWorkOrder::probe_relation_id)) {
         return false;
       }
 
       const relation_id build_relation_id =
-          proto.GetExtension(serialization::HashAntiJoinWorkOrder::build_relation_id);
+          proto.GetExtension(serialization::HashSemiJoinWorkOrder::build_relation_id);
       if (!catalog_database.hasRelationWithId(build_relation_id)) {
         return false;
       }
 
       const relation_id probe_relation_id =
-          proto.GetExtension(serialization::HashAntiJoinWorkOrder::probe_relation_id);
+          proto.GetExtension(serialization::HashSemiJoinWorkOrder::probe_relation_id);
       if (!catalog_database.hasRelationWithId(probe_relation_id)) {
         return false;
       }
 
       const CatalogRelationSchema &build_relation = catalog_database.getRelationSchemaById(build_relation_id);
       const CatalogRelationSchema &probe_relation = catalog_database.getRelationSchemaById(probe_relation_id);
-      for (int i = 0; i < proto.ExtensionSize(serialization::HashAntiJoinWorkOrder::join_key_attributes);
++i) {
+      for (int i = 0; i < proto.ExtensionSize(serialization::HashSemiJoinWorkOrder::join_key_attributes);
++i) {
         const attribute_id attr_id =
-            proto.GetExtension(serialization::HashAntiJoinWorkOrder::join_key_attributes,
i);
+            proto.GetExtension(serialization::HashSemiJoinWorkOrder::join_key_attributes,
i);
         if (!build_relation.hasAttributeWithId(attr_id) ||
             !probe_relation.hasAttributeWithId(attr_id)) {
           return false;
         }
       }
 
-      return proto.HasExtension(serialization::HashAntiJoinWorkOrder::any_join_key_attributes_nullable)
&&
-             proto.HasExtension(serialization::HashAntiJoinWorkOrder::insert_destination_index)
&&
+      return proto.HasExtension(serialization::HashSemiJoinWorkOrder::any_join_key_attributes_nullable)
&&
+             proto.HasExtension(serialization::HashSemiJoinWorkOrder::insert_destination_index)
&&
              query_context.isValidInsertDestinationId(
-                 proto.GetExtension(serialization::HashAntiJoinWorkOrder::insert_destination_index))
&&
-             proto.HasExtension(serialization::HashAntiJoinWorkOrder::join_hash_table_index)
&&
+                 proto.GetExtension(serialization::HashSemiJoinWorkOrder::insert_destination_index))
&&
+             proto.HasExtension(serialization::HashSemiJoinWorkOrder::join_hash_table_index)
&&
              query_context.isValidJoinHashTableId(
-                 proto.GetExtension(serialization::HashAntiJoinWorkOrder::join_hash_table_index))
&&
-             proto.HasExtension(serialization::HashAntiJoinWorkOrder::residual_predicate_index)
&&
+                 proto.GetExtension(serialization::HashSemiJoinWorkOrder::join_hash_table_index))
&&
+             proto.HasExtension(serialization::HashSemiJoinWorkOrder::residual_predicate_index)
&&
              query_context.isValidPredicate(
-                 proto.GetExtension(serialization::HashAntiJoinWorkOrder::residual_predicate_index))
&&
-             proto.HasExtension(serialization::HashAntiJoinWorkOrder::selection_index) &&
+                 proto.GetExtension(serialization::HashSemiJoinWorkOrder::residual_predicate_index))
&&
+             proto.HasExtension(serialization::HashSemiJoinWorkOrder::selection_index) &&
              query_context.isValidScalarGroupId(
-                 proto.GetExtension(serialization::HashAntiJoinWorkOrder::selection_index))
&&
-             proto.HasExtension(serialization::HashAntiJoinWorkOrder::block_id);
+                 proto.GetExtension(serialization::HashSemiJoinWorkOrder::selection_index))
&&
+             proto.HasExtension(serialization::HashSemiJoinWorkOrder::block_id);
     }
     case serialization::INSERT: {
       return proto.HasExtension(serialization::InsertWorkOrder::insert_destination_index)
&&

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/ef383ef2/storage/HashTable.hpp
----------------------------------------------------------------------
diff --git a/storage/HashTable.hpp b/storage/HashTable.hpp
index ef79d11..667848e 100644
--- a/storage/HashTable.hpp
+++ b/storage/HashTable.hpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015-2016 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -707,8 +709,8 @@ class HashTable : public HashTableBase<resizable,
                                FunctorT *functor) const;
 
   /**
-   * @brief Lookup (multiple) keys from a ValueAccessor, apply a functor to
-   *        the matching values and additionally call a hasMatch() function of
+   * @brief Lookup (multiple) keys from a ValueAccessor, apply a functor to the
+   *        matching values and additionally call a recordMatch() function of
    *        the functor when the first match for a key is found.
    * @warning This method assumes that no concurrent calls to put(),
    *          putCompositeKey(), putValueAccessor(),
@@ -749,8 +751,8 @@ class HashTable : public HashTableBase<resizable,
       FunctorT *functor) const;
 
   /**
-   * @brief Lookup (multiple) keys from a ValueAccessor, apply a functor to
-   *        the matching values and additionally call a hasMatch() function of
+   * @brief Lookup (multiple) keys from a ValueAccessor, apply a functor to the
+   *        matching values and additionally call a recordMatch() function of
    *        the functor when the first match for a key is found. Composite key
    *        version.
    * @warning This method assumes that no concurrent calls to put(),
@@ -1905,17 +1907,19 @@ void HashTable<ValueT,
       if (check_for_null_keys && key.isNull()) {
         continue;
       }
-      const std::size_t hash_code = adjust_hashes_ ? AdjustHash(key.getHash())
-                                                   : key.getHash();
+      const std::size_t hash_code =
+          adjust_hashes_ ? HashTable<ValueT, resizable, serializable, force_key_copy,
allow_duplicate_keys>
+                               ::AdjustHash(key.getHash())
+                         : key.getHash();
       std::size_t entry_num = 0;
       const ValueT *value;
-      if (getNextEntryForKey(key, hash_code, &value, &entry_num)) {
+      if (this->getNextEntryForKey(key, hash_code, &value, &entry_num)) {
         functor->recordMatch(*accessor);
         (*functor)(*accessor, *value);
         if (!allow_duplicate_keys) {
            continue;
         }
-        while (getNextEntryForKey(key, hash_code, &value, &entry_num)) {
+        while (this->getNextEntryForKey(key, hash_code, &value, &entry_num)) {
           (*functor)(*accessor, *value);
         }
       }
@@ -1956,17 +1960,19 @@ void HashTable<ValueT, resizable, serializable, force_key_copy,
allow_duplicate_
         continue;
       }
 
-      const std::size_t hash_code = adjust_hashes_ ? AdjustHash(hashCompositeKey(key_vector))
-                                                   : hashCompositeKey(key_vector);
+      const std::size_t hash_code =
+          adjust_hashes_ ? HashTable<ValueT, resizable, serializable, force_key_copy,
allow_duplicate_keys>
+                               ::AdjustHash(this->hashCompositeKey(key_vector))
+                         : this->hashCompositeKey(key_vector);
       std::size_t entry_num = 0;
       const ValueT *value;
-      if (getNextEntryForCompositeKey(key_vector, hash_code, &value, &entry_num))
{
+      if (this->getNextEntryForCompositeKey(key_vector, hash_code, &value, &entry_num))
{
         functor->recordMatch(*accessor);
         (*functor)(*accessor, *value);
         if (!allow_duplicate_keys) {
           continue;
         }
-        while (getNextEntryForCompositeKey(key_vector, hash_code, &value, &entry_num))
{
+        while (this->getNextEntryForCompositeKey(key_vector, hash_code, &value, &entry_num))
{
           (*functor)(*accessor, *value);
         }
       }


Mime
View raw message