few additional adaptations

src/engine/Filter.cpp

@@ -48,12 +48,11 @@ string Filter::getDescriptor() const {
 void Filter::setPrefilterExpressionForIndexScanChildren() {
   const std::vector<PrefilterVariablePair>& prefilterVec =
       _expression.getPrefilterExpressionForMetadata();
-  this->forAllDescendants(
-      [&prefilterVec](const QueryExecutionTree* ptr) -> void {
-        if (ptr) {
-          ptr->setPrefilterExpression(prefilterVec);
-        }
-      });
+  this->forAllDescendants([&prefilterVec](const QueryExecutionTree* ptr) {
+    if (ptr) {
+      ptr->setPrefilterExpression(prefilterVec);
+    }
+  });
 }
 
 // _____________________________________________________________________________

src/engine/IndexScan.cpp

@@ -157,7 +157,7 @@ VariableToColumnMap IndexScan::computeVariableToColumnMap() const {
 
 //______________________________________________________________________________
 std::vector<CompressedBlockMetadata> IndexScan::applyFilterBlockMetadata(
-    const std::vector<CompressedBlockMetadata>& blocks) const {
+    std::vector<CompressedBlockMetadata>&& blocks) const {
   std::ranges::for_each(prefilters_, [&blocks](const PrefilterIndexPair& pair) {
     pair.first->evaluate(blocks, pair.second);
   });
@@ -276,7 +276,7 @@ ScanSpecificationAsTripleComponent IndexScan::getScanSpecificationTc() const {
 
 // _____________________________________________________________________________
 Permutation::IdTableGenerator IndexScan::getLazyScan(
-    std::vector<CompressedBlockMetadata> blocks) const {
+    std::vector<CompressedBlockMetadata>&& blocks) const {
   // If there is a LIMIT or OFFSET clause that constrains the scan
   // (which can happen with an explicit subquery), we cannot use the prefiltered
   // blocks, as we currently have no mechanism to include limits and offsets
@@ -344,7 +344,8 @@ IndexScan::lazyScanForJoinOfTwoScans(const IndexScan& s1, const IndexScan& s2) {
   auto [blocks1, blocks2] = CompressedRelationReader::getBlocksForJoin(
       metaBlocks1.value(), metaBlocks2.value());
 
-  std::array result{s1.getLazyScan(blocks1), s2.getLazyScan(blocks2)};
+  std::array result{s1.getLazyScan(std::move(blocks1)),
+                    s2.getLazyScan(std::move(blocks2))};
   result[0].details().numBlocksAll_ = metaBlocks1.value().blockMetadata_.size();
   result[1].details().numBlocksAll_ = metaBlocks2.value().blockMetadata_.size();
   return result;
@@ -365,7 +366,7 @@ Permutation::IdTableGenerator IndexScan::lazyScanForJoinOfColumnWithScan(
   auto blocks = CompressedRelationReader::getBlocksForJoin(joinColumn,
                                                            metaBlocks1.value());
 
-  auto result = getLazyScan(blocks);
+  auto result = getLazyScan(std::move(blocks));
   result.details().numBlocksAll_ = metaBlocks1.value().blockMetadata_.size();
   return result;
 }

src/engine/IndexScan.h

@@ -147,7 +147,7 @@ class IndexScan final : public Operation {
   // Filter relevant `CompressedBlockMetadata` blocks by applying the
   // `PrefilterExpression`s from `prefilters_`.
   std::vector<CompressedBlockMetadata> applyFilterBlockMetadata(
-      const std::vector<CompressedBlockMetadata>& blocks) const;
+      std::vector<CompressedBlockMetadata>&& blocks) const;
 
   // Return the (lazy) `IdTable` for this `IndexScan` in chunks.
   Result::Generator chunkedIndexScan() const;
@@ -157,6 +157,6 @@ class IndexScan final : public Operation {
   // Helper functions for the public `getLazyScanFor...` methods and
   // `chunkedIndexScan` (see above).
   Permutation::IdTableGenerator getLazyScan(
-      std::vector<CompressedBlockMetadata> blocks) const;
+      std::vector<CompressedBlockMetadata>&& blocks) const;
   std::optional<Permutation::MetadataAndBlocks> getMetadataForScan() const;
 };

src/engine/Operation.h

@@ -79,7 +79,15 @@ class Operation {
 
   // Set `PrefilterExpression`s (for `IndexScan`).
   virtual void setPrefilterExpression(
-      const std::vector<PrefilterVariablePair>&){};
+      const std::vector<PrefilterVariablePair>&){
+      // The prefiltering procedure is implemented by applying the
+      // PrefilterExpressions directly on the CompressedBlockMetadata.
+      // This is currently done while performing the result computation for
+      // IndexScan.
+      // (1) Overwrite this method for the derived IndexScan class.
+      // (2) The default method for all other derived classes is implemented
+      // here, no PrefilterExpressions need to be set.
+  };
 
   // Apply the provided void function for all descendants. The given function
   // must be invocable with a `const QueryExecutionTree*` object.

src/engine/sparqlExpressions/RelationalExpressions.cpp

@@ -448,22 +448,21 @@ RelationalExpression<comp>::getPrefilterExpressionForMetadata(
   };
 
   const auto tryGetPrefilterExprVariablePairVec =
-      [&mirroredExpression](
-          const SparqlExpression* child0, const SparqlExpression* child1,
-          bool reversed) -> std::vector<PrefilterExprVariablePair> {
-    std::vector<PrefilterExprVariablePair> resVec{};
-    if (const auto* variable =
-            dynamic_cast<const VariableExpression*>(child0)) {
-      if (const auto* valueId = dynamic_cast<const IdExpression*>(child1)) {
-        resVec.emplace_back(std::make_pair(
-            reversed ? mirroredExpression(valueId->value())
-                     : std::make_unique<p::RelationalExpression<comp>>(
-                           valueId->value()),
-            variable->value()));
-      }
-    }
-    return resVec;
-  };
+      [&mirroredExpression](const SparqlExpression* child0,
+                            const SparqlExpression* child1, bool reversed) {
+        std::vector<PrefilterExprVariablePair> resVec{};
+        if (const auto* variable =
+                dynamic_cast<const VariableExpression*>(child0)) {
+          if (const auto* valueId = dynamic_cast<const IdExpression*>(child1)) {
+            resVec.emplace_back(
+                reversed ? mirroredExpression(valueId->value())
+                         : std::make_unique<p::RelationalExpression<comp>>(
+                               valueId->value()),
+                variable->value());
+          }
+        }
+        return resVec;
+      };
   // Option 1:
   // RelationalExpression containing a VariableExpression as the first child
   // and an IdExpression as the second child.

src/engine/sparqlExpressions/StringExpressions.cpp

@@ -244,23 +244,23 @@ class StrStartsExpressionImpl : public NaryExpression<NaryOperation> {
     AD_CORRECTNESS_CHECK(this->N == 2);
     const SparqlExpression* child0 = this->getNthChild(0).value();
     const SparqlExpression* child1 = this->getNthChild(1).value();
-    const auto getPrefilterExprVariableVec =
-        [](const SparqlExpression* child0, const SparqlExpression* child1,
-           bool startsWithVar) -> std::vector<PrefilterExprVariablePair> {
+    const auto getPrefilterExprVariableVec = [](const SparqlExpression* child0,
+                                                const SparqlExpression* child1,
+                                                bool startsWithVar) {
       using namespace prefilterExpressions;
       std::vector<PrefilterExprVariablePair> resVec{};
       if (const auto* variable =
               dynamic_cast<const VariableExpression*>(child0)) {
         if (const auto* valueId = dynamic_cast<const IdExpression*>(child1)) {
           !startsWithVar
-              // make {<(>= VocabId(n)), ?var>} (Option 1)
-              ? resVec.emplace_back(std::make_pair(
+              // Will return: {<(>= VocabId(n)), ?var>} (Option 1)
+              ? resVec.emplace_back(
                     std::make_unique<GreaterEqualExpression>(valueId->value()),
-                    variable->value()))
-              // make {<(<= VocabId(n)), ?var>} (Option 2)
-              : resVec.emplace_back(std::make_pair(
+                    variable->value())
+              // Will return: {<(<= VocabId(n)), ?var>} (Option 2)
+              : resVec.emplace_back(
                     std::make_unique<LessEqualExpression>(valueId->value()),
-                    variable->value()));
+                    variable->value());
         }
       }
       return resVec;

src/index/CompressedBlockPrefiltering.cpp

@@ -269,7 +269,7 @@ std::vector<BlockMetadata> RelationalExpression<Comparison>::evaluateImpl(
 template <CompOp Comparison>
 bool RelationalExpression<Comparison>::operator==(
     const PrefilterExpression& other) const {
-  const RelationalExpression<Comparison>* otherRelational =
+  const auto* otherRelational =
       dynamic_cast<const RelationalExpression<Comparison>*>(&other);
   if (!otherRelational) {
     return false;
@@ -333,7 +333,7 @@ std::vector<BlockMetadata> LogicalExpression<Operation>::evaluateImpl(
 template <LogicalOperator Operation>
 bool LogicalExpression<Operation>::operator==(
     const PrefilterExpression& other) const {
-  const LogicalExpression<Operation>* otherlogical =
+  const auto* otherlogical =
       dynamic_cast<const LogicalExpression<Operation>*>(&other);
   if (!otherlogical) {
     return false;
@@ -382,8 +382,7 @@ std::vector<BlockMetadata> NotExpression::evaluateImpl(
 
 //______________________________________________________________________________
 bool NotExpression::operator==(const PrefilterExpression& other) const {
-  const NotExpression* otherNotExpression =
-      dynamic_cast<const NotExpression*>(&other);
+  const auto* otherNotExpression = dynamic_cast<const NotExpression*>(&other);
   if (!otherNotExpression) {
     return false;
   }

src/index/Permutation.cpp

@@ -66,8 +66,7 @@ IdTable Permutation::scan(
   const auto& p = getActualPermutation(scanSpec);
 
   return p.reader().scan(
-      scanSpec,
-      blocks.has_value() ? std::move(blocks.value()) : p.meta_.blockData(),
+      scanSpec, blocks.has_value() ? blocks.value() : p.meta_.blockData(),
       additionalColumns, cancellationHandle,
       getLocatedTriplesForPermutation(locatedTriplesSnapshot), limitOffset);
 }