Use one LocalVocab for each block during lazy evaluation

src/engine/Bind.cpp

@@ -131,13 +131,12 @@
     LOG(DEBUG) << "BIND result computation done." << std::endl;
     return {std::move(result), resultSortedOn(), std::move(localVocab)};
   }
-  auto localVocab = std::make_shared<LocalVocab>();
   auto generator =
       [](auto applyBind,
          std::shared_ptr<const Result> result) -> Result::Generator {
-    for (Result::IdTableVocabPair& pair : result->idTables()) {
-      IdTable idTable = applyBind(std::move(pair.idTable_), &pair.localVocab_);
-      co_yield {std::move(idTable), std::move(pair.localVocab_)};
+    for (auto& [idTable, localVocab] : result->idTables()) {
+      IdTable resultTable = applyBind(std::move(idTable), &localVocab);
+      co_yield {std::move(resultTable), std::move(localVocab)};
     }
   }(std::move(applyBind), std::move(subRes));
   return {std::move(generator), resultSortedOn()};
@@ -196,7 +195,7 @@
         for (auto& resultValue : resultGenerator) {
           outputColumn[i] =
               sparqlExpression::detail::constantExpressionResultToId(
                   std::move(resultValue), *localVocab);
           i++;
           checkCancellation();
         }

src/engine/Filter.cpp

@@ -58,10 +58,10 @@ ProtoResult Filter::computeResult(bool requestLaziness) {
 
   if (requestLaziness) {
     return {[](auto subRes, auto* self) -> Result::Generator {
-              for (Result::IdTableVocabPair& pair : subRes->idTables()) {
-                IdTable result = self->filterIdTable(
-                    subRes->sortedBy(), pair.idTable_, pair.localVocab_);
-                co_yield {std::move(result), std::move(pair.localVocab_)};
+              for (auto& [idTable, localVocab] : subRes->idTables()) {
+                IdTable result = self->filterIdTable(subRes->sortedBy(),
+                                                     idTable, localVocab);
+                co_yield {std::move(result), std::move(localVocab)};
               }
             }(std::move(subRes), this),
             resultSortedOn()};

src/engine/GroupBy.cpp

@@ -533,7 +533,8 @@ Result::Generator GroupBy::computeResultLazily(
       // Reuse buffer if not moved out
       resultTable = std::move(outputPair.idTable_);
       resultTable.clear();
-      currentLocalVocab = LocalVocab{};
+      // Keep last local vocab for next commit.
+      currentLocalVocab = std::move(storedLocalVocabs.back());
       storedLocalVocabs.clear();
     }
   }

src/engine/Union.cpp

@@ -264,10 +264,9 @@ Result::Generator Union::computeResultLazily(
         transformToCorrectColumnFormat(result1->idTable().clone(), permutation),
         result1->getCopyOfLocalVocab()};
   } else {
-    for (Result::IdTableVocabPair& pair : result1->idTables()) {
-      co_yield {
-          transformToCorrectColumnFormat(std::move(pair.idTable_), permutation),
-          std::move(pair.localVocab_)};
+    for (auto& [idTable, localVocab] : result1->idTables()) {
+      co_yield {transformToCorrectColumnFormat(std::move(idTable), permutation),
+                std::move(localVocab)};
     }
   }
   permutation = computePermutation<false>();
@@ -276,10 +275,9 @@ Result::Generator Union::computeResultLazily(
         transformToCorrectColumnFormat(result2->idTable().clone(), permutation),
         result2->getCopyOfLocalVocab()};
   } else {
-    for (Result::IdTableVocabPair& pair : result2->idTables()) {
-      co_yield {
-          transformToCorrectColumnFormat(std::move(pair.idTable_), permutation),
-          std::move(pair.localVocab_)};
+    for (auto& [idTable, localVocab] : result2->idTables()) {
+      co_yield {transformToCorrectColumnFormat(std::move(idTable), permutation),
+                std::move(localVocab)};
     }
   }
 }

test/FilterTest.cpp

@@ -21,6 +21,10 @@ ValueId asBool(bool value) { return Id::makeFromBool(value); }
 std::vector<IdTable> toVector(Result::Generator generator) {
   std::vector<IdTable> result;
   for (auto& pair : generator) {
+    // IMPORTANT: The `LocalVocab` contained in the pair will be destroyed at
+    // the end of the iteration. The underlying assumption is that the
+    // `LocalVocab` will be empty and the `IdTable` won't contain any dangling
+    // references.
     result.push_back(std::move(pair.idTable_));
   }
   return result;