Magic service query for text search.

src/engine/CheckUsePatternTrick.cpp

@@ -72,9 +72,12 @@
     } else if constexpr (std::is_same_v<T, p::Service>) {
       return ad_utility::contains(arg.visibleVariables_, variable);
     } else {
-      static_assert(
-          std::is_same_v<T, p::TransPath> || std::is_same_v<T, p::PathQuery> ||
-          std::is_same_v<T, p::Describe> || std::is_same_v<T, p::SpatialQuery>);
+      static_assert(std::is_same_v<T, p::TransPath> ||
+                    std::is_same_v<T, p::PathQuery> ||
+                    std::is_same_v<T, p::Describe> ||
+                    std::is_same_v<T, p::SpatialQuery> ||
+                    std::is_same_v<T, p::WordSearchQuery> ||
+                    std::is_same_v<T, p::EntitySearchQuery>);
       // The `TransPath` is set up later in the query planning, when this
       // function should not be called anymore.
       AD_FAIL();

src/engine/QueryPlanner.cpp

@@ -2358,6 +2358,10 @@
     visitDescribe(arg);
   } else if constexpr (std::is_same_v<T, p::SpatialQuery>) {
     visitSpatialSearch(arg);
+  } else if constexpr (std::is_same_v<T, p::WordSearchQuery>) {
+    visitWordSearch(arg);
+  } else if constexpr (std::is_same_v<T, p::EntitySearchQuery>) {
+    visitEntitySearch(arg);
   } else {
     static_assert(std::is_same_v<T, p::BasicGraphPattern>);
     visitBasicGraphPattern(arg);
@@ -2531,6 +2535,26 @@
   visitGroupOptionalOrMinus(std::move(candidatesOut));
 }
 
+// _______________________________________________________________
+void QueryPlanner::GraphPatternPlanner::visitWordSearch(
+    parsedQuery::WordSearchQuery& wordSearchQuery) {
+  auto config = wordSearchQuery.toTextIndexScanForWordConfiguration();
+  std::vector<SubtreePlan> candidatesOut;
+  auto plan = makeSubtreePlan<TextIndexScanForWord>(qec_, config);
+  candidatesOut.push_back(std::move(plan));
+  visitGroupOptionalOrMinus(std::move(candidatesOut));
+}
+
+// _______________________________________________________________
+void QueryPlanner::GraphPatternPlanner::visitEntitySearch(
+    parsedQuery::EntitySearchQuery& entitySearchQuery) {
+  auto config = entitySearchQuery.toTextIndexScanForEntityConfiguration();
+  std::vector<SubtreePlan> candidatesOut;
+  auto plan = makeSubtreePlan<TextIndexScanForEntity>(qec_, config);
+  candidatesOut.push_back(std::move(plan));
+  visitGroupOptionalOrMinus(std::move(candidatesOut));
+}
+
 // _______________________________________________________________
 void QueryPlanner::GraphPatternPlanner::visitUnion(parsedQuery::Union& arg) {
   // TODO<joka921> here we could keep all the candidates, and create a

src/engine/QueryPlanner.h

@@ -541,6 +541,8 @@ class QueryPlanner {
     void visitTransitivePath(parsedQuery::TransPath& transitivePath);
     void visitPathSearch(parsedQuery::PathQuery& config);
     void visitSpatialSearch(parsedQuery::SpatialQuery& config);
+    void visitWordSearch(parsedQuery::WordSearchQuery& config);
+    void visitEntitySearch(parsedQuery::EntitySearchQuery& config);
     void visitUnion(parsedQuery::Union& un);
     void visitSubquery(parsedQuery::Subquery& subquery);
     void visitDescribe(parsedQuery::Describe& describe);

src/engine/TextIndexScanForEntity.cpp

@@ -4,14 +4,29 @@
 
 #include "engine/TextIndexScanForEntity.h"
 
+// _____________________________________________________________________________
+TextIndexScanForEntity::TextIndexScanForEntity(
+    QueryExecutionContext* qec, TextIndexScanForEntityConfiguration config)
+    : Operation(qec),
+      config_(std::move(config)),
+      textRecordVar_(config_.varToBindText_),
+      varOrFixed_(qec, config_.entity_),
+      word_(config_.word_) {
+  setVariableToColumnMap();
+}
+
 // _____________________________________________________________________________
 TextIndexScanForEntity::TextIndexScanForEntity(
     QueryExecutionContext* qec, Variable textRecordVar,
     std::variant<Variable, std::string> entity, string word)
     : Operation(qec),
-      textRecordVar_(std::move(textRecordVar)),
-      varOrFixed_(qec, std::move(entity)),
-      word_(std::move(word)) {}
+      config_(TextIndexScanForEntityConfiguration{textRecordVar, entity, word,
+                                                  std::nullopt}),
+      textRecordVar_(config_.varToBindText_),
+      varOrFixed_(qec, config_.entity_),
+      word_(config_.word_) {
+  setVariableToColumnMap();
+}
 
 // _____________________________________________________________________________
 ProtoResult TextIndexScanForEntity::computeResult(
@@ -43,21 +58,34 @@
 }
 
 // _____________________________________________________________________________
-VariableToColumnMap TextIndexScanForEntity::computeVariableToColumnMap() const {
-  VariableToColumnMap vcmap;
-  auto addDefinedVar = [&vcmap,
-                        index = ColumnIndex{0}](const Variable& var) mutable {
-    vcmap[var] = makeAlwaysDefinedColumn(index);
-    ++index;
-  };
-  addDefinedVar(textRecordVar_);
+void TextIndexScanForEntity::setVariableToColumnMap() {
+  ColumnIndex index = ColumnIndex{0};
+  variableColumns_[textRecordVar_] = makeAlwaysDefinedColumn(index);
+  index++;
   if (hasFixedEntity()) {
-    addDefinedVar(textRecordVar_.getEntityScoreVariable(fixedEntity()));
+    if (config_.varToBindScore_.has_value()) {
+      variableColumns_[config_.varToBindScore_.value()] =
+          makeAlwaysDefinedColumn(index);
+    } else {
+      variableColumns_[textRecordVar_.getEntityScoreVariable(fixedEntity())] =
+          makeAlwaysDefinedColumn(index);
+    }
   } else {
-    addDefinedVar(entityVariable());
-    addDefinedVar(textRecordVar_.getEntityScoreVariable(entityVariable()));
+    variableColumns_[entityVariable()] = makeAlwaysDefinedColumn(index);
+    index++;
+    if (config_.varToBindScore_.has_value()) {
+      variableColumns_[config_.varToBindScore_.value()] =
+          makeAlwaysDefinedColumn(index);
+    } else {
+      variableColumns_[textRecordVar_.getEntityScoreVariable(
+          entityVariable())] = makeAlwaysDefinedColumn(index);
+    }
   }
-  return vcmap;
+}
+
+// _____________________________________________________________________________
+VariableToColumnMap TextIndexScanForEntity::computeVariableToColumnMap() const {
+  return variableColumns_;
 }
 
 // _____________________________________________________________________________

src/engine/TextIndexScanForEntity.h

@@ -7,6 +7,14 @@
 #include <string>
 
 #include "./Operation.h"
+#include "parser/MagicServiceQuery.h"
+
+struct TextIndexScanForEntityConfiguration {
+  Variable varToBindText_;
+  std::variant<Variable, std::string> entity_;
+  std::string word_;
+  std::optional<Variable> varToBindScore_;
+};
 
 // This operation retrieves all text records and their corresponding
 // entities from the fulltext index that contain a certain word or prefix.
@@ -48,11 +56,16 @@ class TextIndexScanForEntity : public Operation {
     }
   };
 
-  const Variable textRecordVar_;
-  const VarOrFixedEntity varOrFixed_;
-  const string word_;
+  TextIndexScanForEntityConfiguration config_;
+  VariableToColumnMap variableColumns_;
+  Variable textRecordVar_;
+  VarOrFixedEntity varOrFixed_;
+  string word_;
 
  public:
+  TextIndexScanForEntity(QueryExecutionContext* qec,
+                         TextIndexScanForEntityConfiguration config);
+
   TextIndexScanForEntity(QueryExecutionContext* qec, Variable textRecordVar,
                          std::variant<Variable, std::string> entity,
                          string word);
@@ -93,6 +106,8 @@ class TextIndexScanForEntity : public Operation {
 
   vector<ColumnIndex> resultSortedOn() const override;
 
+  void setVariableToColumnMap();
+
   VariableToColumnMap computeVariableToColumnMap() const override;
 
  private:

src/engine/TextIndexScanForWord.cpp

@@ -4,13 +4,28 @@
 
 #include "engine/TextIndexScanForWord.h"
 
+// _____________________________________________________________________________
+TextIndexScanForWord::TextIndexScanForWord(
+    QueryExecutionContext* qec, TextIndexScanForWordConfiguration config)
+    : Operation(qec),
+      config_(std::move(config)),
+      textRecordVar_(config_.varToBindText_),
+      word_(config_.word),
+      isPrefix_(word_.ends_with('*')) {
+  setVariableToColumnMap();
+}
+
 // _____________________________________________________________________________
 TextIndexScanForWord::TextIndexScanForWord(QueryExecutionContext* qec,
                                            Variable textRecordVar, string word)
     : Operation(qec),
-      textRecordVar_(std::move(textRecordVar)),
-      word_(std::move(word)),
-      isPrefix_(word_.ends_with('*')) {}
+      config_(TextIndexScanForWordConfiguration{textRecordVar, word,
+                                                std::nullopt, std::nullopt}),
+      textRecordVar_(config_.varToBindText_),
+      word_(config_.word),
+      isPrefix_(word_.ends_with('*')) {
+  setVariableToColumnMap();
+}
 
 // _____________________________________________________________________________
 ProtoResult TextIndexScanForWord::computeResult(
@@ -33,20 +48,33 @@
 }
 
 // _____________________________________________________________________________
-VariableToColumnMap TextIndexScanForWord::computeVariableToColumnMap() const {
-  VariableToColumnMap vcmap;
-  auto addDefinedVar = [&vcmap,
-                        index = ColumnIndex{0}](const Variable& var) mutable {
-    vcmap[var] = makeAlwaysDefinedColumn(index);
-    ++index;
-  };
-  addDefinedVar(textRecordVar_);
+void TextIndexScanForWord::setVariableToColumnMap() {
+  ColumnIndex index = ColumnIndex{0};
+  variableColumns_[textRecordVar_] = makeAlwaysDefinedColumn(index);
+  index++;
   if (isPrefix_) {
-    addDefinedVar(textRecordVar_.getMatchingWordVariable(
-        std::string_view(word_).substr(0, word_.size() - 1)));
+    if (config_.varToBindMatch_.has_value()) {
+      variableColumns_[config_.varToBindMatch_.value()] =
+          makeAlwaysDefinedColumn(index);
+    } else {
+      variableColumns_[textRecordVar_.getMatchingWordVariable(
+          std::string_view(word_).substr(0, word_.size() - 1))] =
+          makeAlwaysDefinedColumn(index);
+    }
+    index++;
   }
-  addDefinedVar(textRecordVar_.getWordScoreVariable(word_, isPrefix_));
-  return vcmap;
+  if (config_.varToBindScore_.has_value()) {
+    variableColumns_[config_.varToBindScore_.value()] =
+        makeAlwaysDefinedColumn(index);
+  } else {
+    variableColumns_[textRecordVar_.getWordScoreVariable(word_, isPrefix_)] =
+        makeAlwaysDefinedColumn(index);
+  }
+}
+
+// _____________________________________________________________________________
+VariableToColumnMap TextIndexScanForWord::computeVariableToColumnMap() const {
+  return variableColumns_;
 }
 
 // _____________________________________________________________________________

src/engine/TextIndexScanForWord.h

@@ -7,16 +7,29 @@
 #include <string>
 
 #include "./Operation.h"
+#include "parser/MagicServiceQuery.h"
+
+struct TextIndexScanForWordConfiguration {
+  Variable varToBindText_;
+  string word;
+  std::optional<Variable> varToBindMatch_;
+  std::optional<Variable> varToBindScore_;
+};
 
 // This operation retrieves all text records from the fulltext index that
 // contain a certain word or prefix.
 class TextIndexScanForWord : public Operation {
  private:
-  const Variable textRecordVar_;
-  const string word_;
+  TextIndexScanForWordConfiguration config_;
+  VariableToColumnMap variableColumns_;
+  Variable textRecordVar_;
+  string word_;
   bool isPrefix_ = false;
 
  public:
+  TextIndexScanForWord(QueryExecutionContext* qec,
+                       TextIndexScanForWordConfiguration config);
+
   TextIndexScanForWord(QueryExecutionContext* qec, Variable textRecordVar,
                        string word);
 
@@ -45,6 +58,8 @@ class TextIndexScanForWord : public Operation {
 
   vector<ColumnIndex> resultSortedOn() const override;
 
+  void setVariableToColumnMap();
+
   VariableToColumnMap computeVariableToColumnMap() const override;
 
  private:

src/parser/CMakeLists.txt

@@ -31,6 +31,8 @@ add_library(parser
         Literal.cpp
         LiteralOrIri.cpp
         DatasetClauses.cpp
+        WordSearchQuery.cpp
+        EntitySearchQuery.cpp
 )
 qlever_target_link_libraries(parser sparqlParser parserData sparqlExpressions rdfEscaping re2::re2 util engine index)
 

src/parser/EntitySearchQuery.cpp

@@ -0,0 +1,72 @@
+// Copyright 2024, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Author: Felix Meisen (fesemeisen@outlook.de)
+
+#include "parser/EntitySearchQuery.h"
+
+#include "parser/MagicServiceIriConstants.h"
+
+namespace parsedQuery {
+
+// ____________________________________________________________________________
+void EntitySearchQuery::addParameter(const SparqlTriple& triple) {
+  auto sipmleTriple = triple.getSimple();
+  TripleComponent predicate = sipmleTriple.p_;
+  TripleComponent object = sipmleTriple.o_;
+
+  auto predString = extractParameterName(predicate, ENTITY_SEARCH_IRI);
+
+  // TODO find a smoother way to interpret given strings than reading them as
+  // literals
+  if (predString == "containedWithWord") {
+    if (!object.isLiteral()) {
+      throw EntitySearchException(
+          "The parameter <containedWithWord> expects a literal consisting of "
+          "one search word");
+    }
+    std::string_view literal = object.getLiteral().toStringRepresentation();
+    word_ = std::string(literal.substr(1, literal.size() - 2));
+  } else if (predString == "containsEntity") {
+    if (object.isLiteral()) {
+      std::string_view literal = object.getLiteral().toStringRepresentation();
+      fixedEntity_ = std::string(literal.substr(1, literal.size() - 2));
+    } else if (object.isVariable()) {
+      setVariable("containsEntity", object, entityVar_);
+    } else {
+      throw EntitySearchException(
+          "The parameter <containsEntity> expects a literal which is "
+          "interpreted as fixed entity or a variable to bind the entity to");
+    }
+  } else if (predString == "bindScore") {
+    setVariable("bindScore", object, scoreVar_);
+  } else if (predString == "bindText") {
+    setVariable("bindText", object, textVar_);
+  }
+}
+
+// ____________________________________________________________________________
+TextIndexScanForEntityConfiguration
+EntitySearchQuery::toTextIndexScanForEntityConfiguration() const {
+  if (!word_.has_value()) {
+    throw EntitySearchException(
+        "Missing parameter <containedWithWord> in entity search.");
+  } else if (!textVar_.has_value()) {
+    throw EntitySearchException(
+        "Missing parameter <bindText> in entity search.");
+  } else if (!(fixedEntity_.has_value() || entityVar_.has_value())) {
+    throw EntitySearchException(
+        "Missing parameter <containsEntity> in entity search.");
+  } else if (fixedEntity_.has_value() && entityVar_.has_value()) {
+    throw EntitySearchException(
+        "<containsEntity> should be used exactly once in entity search.");
+  }
+  if (entityVar_.has_value()) {
+    return TextIndexScanForEntityConfiguration{
+        textVar_.value(), entityVar_.value(), word_.value(), scoreVar_};
+  } else {
+    return TextIndexScanForEntityConfiguration{
+        textVar_.value(), fixedEntity_.value(), word_.value(), scoreVar_};
+  }
+}
+
+}  // namespace parsedQuery