Add support for FROM and GRAPH with fixed IRI

src/engine/CountAvailablePredicates.cpp

@@ -122,12 +122,12 @@ ProtoResult CountAvailablePredicates::computeResult(
     if (!indexScan) {
       return false;
     }
-    if (!indexScan->getSubject().isVariable() ||
-        !indexScan->getObject().isVariable()) {
+    if (!indexScan->subject().isVariable() ||
+        !indexScan->object().isVariable()) {
       return false;
     }
 
-    return indexScan->getPredicate() == HAS_PATTERN_PREDICATE;
+    return indexScan->predicate() == HAS_PATTERN_PREDICATE;
   }();
 
   if (isPatternTrickForAllEntities) {

src/engine/GroupBy.cpp

@@ -580,7 +580,8 @@ std::optional<IdTable> GroupBy::computeGroupByForSingleIndexScan() const {
     return std::nullopt;
   }
 
-  if (indexScan->getResultWidth() <= 1 || !_groupByVariables.empty()) {
+  if (indexScan->getResultWidth() <= 1 ||
+      indexScan->graphsToFilter().has_value() || !_groupByVariables.empty()) {
     return std::nullopt;
   }
 
@@ -624,7 +625,8 @@ std::optional<IdTable> GroupBy::computeGroupByObjectWithCount() const {
   // The child must be an `IndexScan` with exactly two variables.
   auto indexScan =
       std::dynamic_pointer_cast<IndexScan>(_subtree->getRootOperation());
-  if (!indexScan || indexScan->numVariables() != 2) {
+  if (!indexScan || indexScan->graphsToFilter().has_value() ||
+      indexScan->numVariables() != 2) {
     return std::nullopt;
   }
   const auto& permutedTriple = indexScan->getPermutedTriple();
@@ -741,22 +743,23 @@ std::optional<Permutation::Enum> GroupBy::getPermutationForThreeVariableTriple(
   auto indexScan =
       std::dynamic_pointer_cast<const IndexScan>(tree.getRootOperation());
 
-  if (!indexScan || indexScan->getResultWidth() != 3) {
+  if (!indexScan || indexScan->graphsToFilter().has_value() ||
+      indexScan->getResultWidth() != 3) {
     return std::nullopt;
   }
   {
     auto v = variableThatMustBeContained;
-    if (v != indexScan->getSubject() && v != indexScan->getPredicate() &&
-        v != indexScan->getObject()) {
+    if (v != indexScan->subject() && v != indexScan->predicate() &&
+        v != indexScan->object()) {
       return std::nullopt;
     }
   }
 
-  if (variableByWhichToSort == indexScan->getSubject()) {
+  if (variableByWhichToSort == indexScan->subject()) {
     return Permutation::SPO;
-  } else if (variableByWhichToSort == indexScan->getPredicate()) {
+  } else if (variableByWhichToSort == indexScan->predicate()) {
     return Permutation::POS;
-  } else if (variableByWhichToSort == indexScan->getObject()) {
+  } else if (variableByWhichToSort == indexScan->object()) {
     return Permutation::OSP;
   } else {
     return std::nullopt;

src/engine/IndexScan.cpp

@@ -80,6 +80,16 @@ string IndexScan::getCacheKeyImpl() const {
     os << " Additional Columns: ";
     os << absl::StrJoin(additionalColumns(), " ");
   }
+  if (graphsToFilter_.has_value()) {
+    // The graphs are stored as a hash set, but we need a deterministic order.
+    std::vector<std::string> graphIdVec;
+    std::ranges::transform(graphsToFilter_.value(),
+                           std::back_inserter(graphIdVec),
+                           &TripleComponent::toRdfLiteral);
+    std::ranges::sort(graphIdVec);
+    os << "\nFiltered by Graphs:";
+    os << absl::StrJoin(graphIdVec, " ");
+  }
   return std::move(os).str();
 }
 
@@ -151,7 +161,7 @@ ProtoResult IndexScan::computeResult(bool requestLaziness) {
   using enum Permutation::Enum;
   idTable.setNumColumns(numVariables_);
   const auto& index = _executionContext->getIndex();
-  if (numVariables_ < 3) {
+  if (numVariables_ < 3 || !additionalColumns().empty()) {
     idTable = index.scan(getScanSpecification(), permutation_,
                          additionalColumns(), cancellationHandle_, getLimit());
   } else {

src/engine/IndexScan.h

@@ -37,9 +37,10 @@ class IndexScan final : public Operation {
 
   ~IndexScan() override = default;
 
-  const TripleComponent& getPredicate() const { return predicate_; }
-  const TripleComponent& getSubject() const { return subject_; }
-  const TripleComponent& getObject() const { return object_; }
+  const TripleComponent& predicate() const { return predicate_; }
+  const TripleComponent& subject() const { return subject_; }
+  const TripleComponent& object() const { return object_; }
+  const auto& graphsToFilter() const { return graphsToFilter_; }
 
   const std::vector<ColumnIndex>& additionalColumns() const {
     return additionalColumns_;

src/engine/Join.cpp

@@ -565,6 +565,13 @@
   rti.addDetail("num-blocks-read", metadata.numBlocksRead_);
   rti.addDetail("num-blocks-all", metadata.numBlocksAll_);
   rti.addDetail("num-elements-read", metadata.numElementsRead_);
+  if (metadata.numBlocksSkippedBecauseOfGraph_ > 0) {
+    rti.addDetail("num-blocks-skipped-graph",
+                  metadata.numBlocksSkippedBecauseOfGraph_);
+  }
+  if (metadata.numBlocksPostprocessed_ > 0) {
+    rti.addDetail("num-blocks-postprocessed", metadata.numBlocksPostprocessed_);
+  }
 }
 }  // namespace
 

src/engine/QueryPlanner.cpp

@@ -33,6 +33,8 @@
 #include "engine/TransitivePathBase.h"
 #include "engine/Union.h"
 #include "engine/Values.h"
+#include "engine/sparqlExpressions/LiteralExpression.h"
+#include "engine/sparqlExpressions/RelationalExpressions.h"
 #include "parser/Alias.h"
 #include "parser/SparqlParserHelpers.h"
 
@@ -78,11 +80,26 @@ QueryPlanner::QueryPlanner(QueryExecutionContext* qec,
 
 // _____________________________________________________________________________
 std::vector<QueryPlanner::SubtreePlan> QueryPlanner::createExecutionTrees(
-    ParsedQuery& pq) {
+    ParsedQuery& pq, bool isSubquery) {
+  // Store the dataset clause (FROM and FROM NAMED clauses), s.t. we have access
+  // to them down the callstack. Subqueries can't have their own dataset clause,
+  // but inherit it from the parent query.
+  auto datasetClauseIsEmpty = [](const auto& datasetClause) {
+    return !datasetClause.defaultGraphs_.has_value() &&
+           !datasetClause.namedGraphs_.has_value();
+  };
+  if (!isSubquery) {
+    AD_CORRECTNESS_CHECK(datasetClauseIsEmpty(activeDatasetClauses_));
+    activeDatasetClauses_ = pq.datasetClauses_;
+  } else {
+    AD_CORRECTNESS_CHECK(datasetClauseIsEmpty(pq.datasetClauses_));
+  }
+
   // Look for ql:has-predicate to determine if the pattern trick should be used.
   // If the pattern trick is used, the ql:has-predicate triple will be removed
   // from the list of where clause triples. Otherwise, the ql:has-predicate
   // triple will be handled using a `HasPredicateScan`.
+
   using checkUsePatternTrick::PatternTrickTuple;
   const auto patternTrickTuple =
       _enablePatternTrick ? checkUsePatternTrick::checkUsePatternTrick(&pq)
@@ -166,13 +183,22 @@ std::vector<QueryPlanner::SubtreePlan> QueryPlanner::createExecutionTrees(
   }
 
   checkCancellation();
+
+  const auto& fromNamed = pq.datasetClauses_.namedGraphs_;
+  if (fromNamed.has_value()) {
+    AD_CORRECTNESS_CHECK(!fromNamed.value().empty());
+    throw std::runtime_error(
+        "FROM NAMED clauses are not yet supported by QLever");
+  }
+
   return lastRow;
 }
 
 // _____________________________________________________________________
-QueryExecutionTree QueryPlanner::createExecutionTree(ParsedQuery& pq) {
+QueryExecutionTree QueryPlanner::createExecutionTree(ParsedQuery& pq,
+                                                     bool isSubquery) {
   try {
-    auto lastRow = createExecutionTrees(pq);
+    auto lastRow = createExecutionTrees(pq, isSubquery);
     auto minInd = findCheapestExecutionTree(lastRow);
     LOG(DEBUG) << "Done creating execution plan.\n";
     return *lastRow[minInd]._qet;
@@ -662,6 +688,7 @@ auto QueryPlanner::seedWithScansAndText(
     }
     idShift++;
   }
+
   for (size_t i = 0; i < tg._nodeMap.size(); ++i) {
     const TripleGraph::Node& node = *tg._nodeMap.find(i)->second;
 
@@ -696,18 +723,18 @@ auto QueryPlanner::seedWithScansAndText(
       continue;
     }
 
-    auto addIndexScan = [this, pushPlan, node](
-                            Permutation::Enum permutation,
-                            std::optional<SparqlTripleSimple> triple =
-                                std::nullopt) {
-      if (!triple.has_value()) {
-        pushPlan(makeSubtreePlan<IndexScan>(_qec, permutation,
-                                            node.triple_.getSimple()));
-      } else {
-        pushPlan(makeSubtreePlan<IndexScan>(_qec, permutation,
-                                            std::move(triple.value())));
-      }
-    };
+    auto addIndexScan =
+        [this, pushPlan, node,
+         &relevantGraphs = activeDatasetClauses_.defaultGraphs_](
+            Permutation::Enum permutation,
+            std::optional<SparqlTripleSimple> triple = std::nullopt) {
+          if (!triple.has_value()) {
+            triple = node.triple_.getSimple();
+          }
+
+          pushPlan(makeSubtreePlan<IndexScan>(
+              _qec, permutation, std::move(triple.value()), relevantGraphs));
+        };
 
     auto addFilter = [&filters = result.filters_](SparqlFilter filter) {
       filters.push_back(std::move(filter));
@@ -2014,13 +2041,28 @@ void QueryPlanner::GraphPatternPlanner::graphPatternOperationVisitor(Arg& arg) {
   using SubtreePlan = QueryPlanner::SubtreePlan;
   if constexpr (std::is_same_v<T, p::Optional> ||
                 std::is_same_v<T, p::GroupGraphPattern>) {
+    // If this is a `GRAPH <graph> {...}` clause, then we have to overwrite the
+    // default graphs while planning this clause, and reset them when leaving
+    // the clause.
+    std::optional<ParsedQuery::DatasetClauses> datasetBackup;
+    if constexpr (std::is_same_v<T, p::GroupGraphPattern>) {
+      if (arg._graphIri.has_value()) {
+        datasetBackup = planner_.activeDatasetClauses_;
+        planner_.activeDatasetClauses_.defaultGraphs_.emplace(
+            {arg._graphIri.value()});
+      }
+    }
+
     auto candidates = planner_.optimize(&arg._child);
     if constexpr (std::is_same_v<T, p::Optional>) {
       for (auto& c : candidates) {
         c.type = SubtreePlan::OPTIONAL;
       }
     }
     visitGroupOptionalOrMinus(std::move(candidates));
+    if (datasetBackup.has_value()) {
+      planner_.activeDatasetClauses_ = std::move(datasetBackup.value());
+    }
   } else if constexpr (std::is_same_v<T, p::Union>) {
     visitUnion(arg);
   } else if constexpr (std::is_same_v<T, p::Subquery>) {
@@ -2173,7 +2215,7 @@ void QueryPlanner::GraphPatternPlanner::visitSubquery(
 
   // For a subquery, make sure that one optimal result for each ordering
   // of the result (by a single column) is contained.
-  auto candidatesForSubquery = planner_.createExecutionTrees(subquery);
+  auto candidatesForSubquery = planner_.createExecutionTrees(subquery, true);
   // Make sure that variables that are not selected by the subquery are
   // not visible.
   auto setSelectedVariables = [&](SubtreePlan& plan) {

src/engine/QueryPlanner.h

@@ -20,13 +20,16 @@ class QueryPlanner {
   template <typename T>
   using vector = std::vector<T>;
 
+  ParsedQuery::DatasetClauses activeDatasetClauses_;
+
  public:
   explicit QueryPlanner(QueryExecutionContext* qec,
                         CancellationHandle cancellationHandle);
 
   // Create the best execution tree for the given query according to the
   // optimization algorithm and cost estimates of the QueryPlanner.
-  QueryExecutionTree createExecutionTree(ParsedQuery& pq);
+  QueryExecutionTree createExecutionTree(ParsedQuery& pq,
+                                         bool isSubquery = false);
 
   class TripleGraph {
    public:
@@ -211,7 +214,8 @@ class QueryPlanner {
   // result. This is relevant for subqueries, which are currently optimized
   // independently of the rest of the query, but where it depends on the rest
   // of the query, which ordering of the result is best.
-  [[nodiscard]] std::vector<SubtreePlan> createExecutionTrees(ParsedQuery& pq);
+  [[nodiscard]] std::vector<SubtreePlan> createExecutionTrees(
+      ParsedQuery& pq, bool isSubquery = false);
 
  private:
   QueryExecutionContext* _qec;

src/engine/Result.cpp

@@ -202,9 +202,10 @@ void Result::checkDefinedness(const VariableToColumnMap& varColMap) {
   if (isFullyMaterialized()) {
     AD_EXPENSIVE_CHECK(performCheck(varColMap, std::get<IdTable>(data_)));
   } else {
-    auto generator = [](cppcoro::generator<IdTable> original,
-                        VariableToColumnMap varColMap,
-                        auto performCheck) -> cppcoro::generator<IdTable> {
+    auto generator =
+        [](cppcoro::generator<IdTable> original,
+           [[maybe_unused]] VariableToColumnMap varColMap,
+           [[maybe_unused]] auto performCheck) -> cppcoro::generator<IdTable> {
       for (IdTable& idTable : original) {
         // No need to check subsequent idTables assuming the datatypes
         // don't change mid result.

src/engine/TransitivePathBase.cpp

@@ -179,7 +179,7 @@ std::string TransitivePathBase::getDescriptor() const {
   auto scanOperation =
       std::dynamic_pointer_cast<IndexScan>(subtree_->getRootOperation());
   if (scanOperation != nullptr) {
-    os << " " << scanOperation->getPredicate() << " ";
+    os << " " << scanOperation->predicate() << " ";
   } else {
     // Escaped the question marks to avoid a warning about ignored trigraphs.
     os << R"( <???> )";

src/engine/sparqlExpressions/LiteralExpression.h

@@ -48,7 +48,9 @@ class LiteralExpression : public SparqlExpression {
       if (auto ptr = cachedResult_.load(std::memory_order_relaxed)) {
         return *ptr;
       }
-      auto id = context->_qec.getIndex().getId(s);
+      TripleComponent tc{s};
+      std::optional<Id> id = tc.toValueId(context->_qec.getIndex().getVocab());
+      // auto id = context->_qec.getIndex().getId(s);
       IdOrLiteralOrIri result =
           id.has_value()
               ? IdOrLiteralOrIri{id.value()}

src/index/Index.cpp

@@ -77,22 +77,6 @@ std::string_view Index::indexToString(WordVocabIndex id) const {
   return pimpl_->indexToString(id);
 }
 
-// ____________________________________________________________________________
-std::optional<Id> Index::getId(
-    const ad_utility::triple_component::LiteralOrIri& element) const {
-  return pimpl_->getId(element);
-}
-// ____________________________________________________________________________
-std::optional<Id> Index::getId(
-    const ad_utility::triple_component::Iri& element) const {
-  return pimpl_->getId(element);
-}
-// ____________________________________________________________________________
-std::optional<Id> Index::getId(
-    const ad_utility::triple_component::Literal& element) const {
-  return pimpl_->getId(element);
-}
-
 // ____________________________________________________________________________
 Index::Vocab::PrefixRanges Index::prefixRanges(std::string_view prefix) const {
   return pimpl_->prefixRanges(prefix);

src/index/Index.h

@@ -123,13 +123,6 @@ class Index {
   std::string indexToString(VocabIndex id) const;
   std::string_view indexToString(WordVocabIndex id) const;
 
-  std::optional<Id> getId(
-      const ad_utility::triple_component::LiteralOrIri& element) const;
-  std::optional<Id> getId(
-      const ad_utility::triple_component::Literal& element) const;
-  std::optional<Id> getId(
-      const ad_utility::triple_component::Iri& element) const;
-
   [[nodiscard]] Vocab::PrefixRanges prefixRanges(std::string_view prefix) const;
 
   [[nodiscard]] const CompactVectorOfStrings<Id>& getPatterns() const;

src/index/IndexImpl.cpp

@@ -1353,35 +1353,6 @@ std::string_view IndexImpl::indexToString(WordVocabIndex id) const {
   return textVocab_[id];
 }
 
-// ___________________________________________________________________________
-std::optional<Id> IndexImpl::getIdImpl(const auto& element) const {
-  VocabIndex vocabIndex;
-  auto success =
-      getVocab().getId(element.toStringRepresentation(), &vocabIndex);
-  if (!success) {
-    return std::nullopt;
-  }
-  return Id::makeFromVocabIndex(vocabIndex);
-}
-
-// ___________________________________________________________________________
-std::optional<Id> IndexImpl::getId(
-    const ad_utility::triple_component::LiteralOrIri& element) const {
-  return getIdImpl(element);
-}
-
-// ___________________________________________________________________________
-std::optional<Id> IndexImpl::getId(
-    const ad_utility::triple_component::Literal& element) const {
-  return getIdImpl(element);
-}
-
-// ___________________________________________________________________________
-std::optional<Id> IndexImpl::getId(
-    const ad_utility::triple_component::Iri& element) const {
-  return getIdImpl(element);
-}
-
 // ___________________________________________________________________________
 Index::Vocab::PrefixRanges IndexImpl::prefixRanges(
     std::string_view prefix) const {