Starting 'Select *' implementation

e2e/e2e.sh

@@ -60,9 +60,9 @@ PROJECT_DIR=$(readlink -f -- "$(dirname ${BASH_SOURCE[0]})/..")
 
 # Change to the project directory so we can use simple relative paths
 echo "Changing to project directory: $PROJECT_DIR"
-pushd $PROJECT_DIR
+pushd "$PROJECT_DIR"
 BINARY_DIR=$(readlink -f -- ./build)
-if [ ! -e $BINARY_DIR ]; then
+if [ ! -e "$BINARY_DIR" ]; then
 	BINARY_DIR=$(readlink -f -- .)
 fi
 echo "Binary dir is $BINARY_DIR"
@@ -88,7 +88,7 @@ mkdir -p "$INDEX_DIR"
 # Travis' caching creates it
 if [ ! -e "$INPUT.nt" ]; then
 	# Why the hell is this a ZIP that can't easily be decompressed from stdin?!?
-	unzip -j $ZIPPED_INPUT -d "$INPUT_DIR/"
+	unzip -j "$ZIPPED_INPUT" -d "$INPUT_DIR/"
 fi;
 
 
@@ -123,5 +123,5 @@ echo "Waiting for ServerMain to launch and open port"
 while ! curl --max-time 1 --output /dev/null --silent http://localhost:9099/; do
 	sleep 1
 done
-$PYTHON_BINARY "$PROJECT_DIR/e2e/queryit.py" "$PROJECT_DIR/e2e/scientists_queries.yaml" "http://localhost:9099" &> $BINARY_DIR/query_log.txt || bail "Querying Server failed"
+$PYTHON_BINARY "$PROJECT_DIR/e2e/queryit.py" "$PROJECT_DIR/e2e/scientists_queries.yaml" "http://localhost:9099" &> "$BINARY_DIR/query_log.txt" || bail "Querying Server failed"
 popd

src/engine/QueryExecutionTree.cpp

@@ -8,6 +8,7 @@
 #include <sstream>
 #include <string>
 #include <utility>
+#include <variant>
 
 #include "../parser/RdfEscaping.h"
 #include "./Distinct.h"
@@ -91,22 +92,41 @@ void QueryExecutionTree::setVariableColumns(
 // _____________________________________________________________________________
 template <QueryExecutionTree::ExportSubFormat format>
 ad_utility::stream_generator::stream_generator
-QueryExecutionTree::generateResults(const vector<string>& selectVars,
+QueryExecutionTree::generateResults(const SelectedVarsOrAsterisk & selectedVarsOrAsterisk,
                                     size_t limit, size_t offset) const {
   // They may trigger computation (but does not have to).
   shared_ptr<const ResultTable> resultTable = getResult();
   LOG(DEBUG) << "Resolving strings for finished binary result...\n";
   vector<std::optional<pair<size_t, ResultTable::ResultType>>> validIndices;
-  for (auto var : selectVars) {
-    if (ad_utility::startsWith(var, "TEXT(")) {
-      var = var.substr(5, var.rfind(')') - 5);
+  if(selectedVarsOrAsterisk.isAsterisk()) {
+    list<string> orderedVariables = selectedVarsOrAsterisk.retrieveOrder();
+    auto allVars = getVariableColumns();
+    for (const auto& var : orderedVariables) {
+      auto it = allVars.find(var);
+      if (it != allVars.end()) {
+        validIndices.emplace_back(pair<size_t, ResultTable::ResultType>(
+            it->second, resultTable->getResultType(it->second)));
+        allVars.erase(it);
+      } else {
+        validIndices.emplace_back(std::nullopt);
+      }
     }
-    auto it = getVariableColumns().find(var);
-    if (it != getVariableColumns().end()) {
-      validIndices.push_back(pair<size_t, ResultTable::ResultType>(
-          it->second, resultTable->getResultType(it->second)));
-    } else {
-      validIndices.push_back(std::nullopt);
+    for(const auto& var : allVars){
+      LOG(DEBUG) << "Variable " << var.first << " was not parsed!! \n";
+    }
+  }
+  else {
+    for (auto var : selectedVarsOrAsterisk.getSelectVariables()) {
+      if (ad_utility::startsWith(var, "TEXT(")) {
+        var = var.substr(5, var.rfind(')') - 5);
+      }
+      auto it = getVariableColumns().find(var);
+      if (it != getVariableColumns().end()) {
+        validIndices.emplace_back(pair<size_t, ResultTable::ResultType>(
+            it->second, resultTable->getResultType(it->second)));
+      } else {
+        validIndices.emplace_back(std::nullopt);
+      }
     }
   }
   if (validIndices.empty()) {
@@ -123,48 +143,61 @@ QueryExecutionTree::generateResults(const vector<string>& selectVars,
 
 template ad_utility::stream_generator::stream_generator
 QueryExecutionTree::generateResults<QueryExecutionTree::ExportSubFormat::CSV>(
-    const vector<string>& selectVars, size_t limit, size_t offset) const;
+    const SelectedVarsOrAsterisk & selectedVarsOrAsterisk, size_t limit, size_t offset) const;
 
 template ad_utility::stream_generator::stream_generator
 QueryExecutionTree::generateResults<QueryExecutionTree::ExportSubFormat::TSV>(
-    const vector<string>& selectVars, size_t limit, size_t offset) const;
+    const SelectedVarsOrAsterisk & selectedVarsOrAsterisk, size_t limit, size_t offset) const;
 
 template ad_utility::stream_generator::stream_generator QueryExecutionTree::
     generateResults<QueryExecutionTree::ExportSubFormat::BINARY>(
-        const vector<string>& selectVars, size_t limit, size_t offset) const;
+        const SelectedVarsOrAsterisk & selectedVarsOrAsterisk, size_t limit, size_t offset) const;
 
 // ___________________________________________________________________________
 QueryExecutionTree::ColumnIndicesAndTypes
 QueryExecutionTree::selectedVariablesToColumnIndices(
-    const std::vector<string>& selectVariables,
+    SelectedVarsOrAsterisk selectedVarsOrAsterisk,
     const ResultTable& resultTable) const {
   ColumnIndicesAndTypes exportColumns;
-  for (auto var : selectVariables) {
-    if (ad_utility::startsWith(var, "TEXT(")) {
-      var = var.substr(5, var.rfind(')') - 5);
+  if(selectedVarsOrAsterisk.isAsterisk()) {
+    for(auto var: selectedVarsOrAsterisk.retrieveOrder()){
+      if (getVariableColumns().contains(var)) {
+        auto columnIndex = getVariableColumns().at(var);
+        exportColumns.push_back(VariableAndColumnIndex{
+            var, columnIndex, resultTable.getResultType(columnIndex)});
+      } else {
+        exportColumns.emplace_back(std::nullopt);
+      }
     }
-    if (getVariableColumns().contains(var)) {
-      auto columnIndex = getVariableColumns().at(var);
-      exportColumns.push_back(VariableAndColumnIndex{
-          var, columnIndex, resultTable.getResultType(columnIndex)});
-    } else {
-      exportColumns.emplace_back(std::nullopt);
+  }
+  else {
+    for (auto var : selectedVarsOrAsterisk.getSelectVariables()) {
+      if (ad_utility::startsWith(var, "TEXT(")) {
+        var = var.substr(5, var.rfind(')') - 5);
+      }
+      if (getVariableColumns().contains(var)) {
+        auto columnIndex = getVariableColumns().at(var);
+        exportColumns.push_back(VariableAndColumnIndex{
+            var, columnIndex, resultTable.getResultType(columnIndex)});
+      } else {
+        exportColumns.emplace_back(std::nullopt);
+      }
     }
   }
   return exportColumns;
 }
 
 // _____________________________________________________________________________
 nlohmann::json QueryExecutionTree::writeResultAsQLeverJson(
-    const vector<string>& selectVars, size_t limit, size_t offset,
+    const SelectedVarsOrAsterisk & selectedVarsOrAsterisk, size_t limit, size_t offset,
     shared_ptr<const ResultTable> resultTable) const {
   // They may trigger computation (but does not have to).
   if (!resultTable) {
     resultTable = getResult();
   }
   LOG(DEBUG) << "Resolving strings for finished binary result...\n";
   ColumnIndicesAndTypes validIndices =
-      selectedVariablesToColumnIndices(selectVars, *resultTable);
+      selectedVariablesToColumnIndices(selectedVarsOrAsterisk, *resultTable);
   if (validIndices.empty()) {
     return {std::vector<std::string>()};
   }
@@ -175,7 +208,7 @@ nlohmann::json QueryExecutionTree::writeResultAsQLeverJson(
 
 // _____________________________________________________________________________
 nlohmann::json QueryExecutionTree::writeResultAsSparqlJson(
-    const vector<string>& selectVars, size_t limit, size_t offset,
+    const SelectedVarsOrAsterisk & selectedVarsOrAsterisk, size_t limit, size_t offset,
     shared_ptr<const ResultTable> resultTable) const {
   using nlohmann::json;
 
@@ -186,7 +219,7 @@ nlohmann::json QueryExecutionTree::writeResultAsSparqlJson(
   LOG(DEBUG) << "Finished computing the query result in the ID space. "
                 "Resolving strings in result...\n";
   ColumnIndicesAndTypes columns =
-      selectedVariablesToColumnIndices(selectVars, *resultTable);
+      selectedVariablesToColumnIndices(selectedVarsOrAsterisk, *resultTable);
 
   std::erase(columns, std::nullopt);
 
@@ -197,7 +230,17 @@ nlohmann::json QueryExecutionTree::writeResultAsSparqlJson(
   const IdTable& idTable = resultTable->_idTable;
 
   json result;
-  result["head"]["vars"] = selectVars;
+
+  if(selectedVarsOrAsterisk.isAsterisk()) {
+    vector<string> vars_names;
+    for(auto const & variable: selectedVarsOrAsterisk.retrieveOrder()) {
+      vars_names.push_back(variable);
+    }
+    result["head"]["vars"] = vars_names;
+  }
+  else {
+    result["head"]["vars"] = selectedVarsOrAsterisk.getSelectVariables();
+  }
 
   json bindings = json::array();
 
@@ -242,6 +285,7 @@ nlohmann::json QueryExecutionTree::writeResultAsSparqlJson(
   };
 
   for (size_t rowIndex = offset; rowIndex < upperBound; ++rowIndex) {
+    // Due to be an 'nlohmann' object, object keys are alphabetically sorted!
     nlohmann::ordered_json binding;
     for (const auto& column : columns) {
       const auto& currentId = idTable(rowIndex, column->_columnIndex);

src/engine/QueryExecutionTree.h

@@ -18,6 +18,7 @@
 #include "../util/streamable_generator.h"
 #include "./Operation.h"
 #include "./QueryExecutionContext.h"
+#include "../parser/ParsedQuery.h"
 
 using std::shared_ptr;
 using std::string;
@@ -101,17 +102,19 @@ class QueryExecutionTree {
     ResultTable::ResultType _resultType;
   };
 
+  using SelectedVarsOrAsterisk = ParsedQuery::SelectedVarsOrAsterisk;
+
   using ColumnIndicesAndTypes = vector<std::optional<VariableAndColumnIndex>>;
 
   // Returns a vector where the i-th element contains the column index and
   // `ResultType` of the i-th `selectVariable` in the `resultTable`
   ColumnIndicesAndTypes selectedVariablesToColumnIndices(
-      const std::vector<string>& selectVariables,
+      SelectedVarsOrAsterisk selectedVarsOrAsterisk,
       const ResultTable& resultTable) const;
 
   template <ExportSubFormat format>
   ad_utility::stream_generator::stream_generator generateResults(
-      const vector<string>& selectVars, size_t limit = MAX_NOF_ROWS_IN_RESULT,
+      const SelectedVarsOrAsterisk & selectedVarsOrAsterisk, size_t limit = MAX_NOF_ROWS_IN_RESULT,
       size_t offset = 0) const;
 
   // Generate an RDF graph in turtle format for a CONSTRUCT query.
@@ -131,11 +134,11 @@ class QueryExecutionTree {
       size_t offset, std::shared_ptr<const ResultTable> res) const;
 
   nlohmann::json writeResultAsQLeverJson(
-      const vector<string>& selectVars, size_t limit, size_t offset,
+      const SelectedVarsOrAsterisk & selectedVarsOrAsterisk, size_t limit, size_t offset,
       shared_ptr<const ResultTable> resultTable = nullptr) const;
 
   nlohmann::json writeResultAsSparqlJson(
-      const vector<string>& selectVars, size_t limit, size_t offset,
+      const SelectedVarsOrAsterisk & selectedVarsOrAsterisk, size_t limit, size_t offset,
       shared_ptr<const ResultTable> preComputedResult = nullptr) const;
 
   const std::vector<size_t>& resultSortedOn() const {

src/engine/QueryPlanner.cpp

@@ -497,9 +497,14 @@ bool QueryPlanner::checkUsePatternTrick(
         continue;
       }
 
-      // check that all selected variables are outputs of
+      // Check that all selected variables are outputs of
       // CountAvailablePredicates
-      for (const std::string& s : selectClause._selectedVariables) {
+      if(selectClause._varsOrAsterisk.isAsterisk()) {
+        return false;
+      }
+
+      const auto& selectedVariables = selectClause._varsOrAsterisk.getSelectVariables();
+      for (const std::string& s : selectedVariables) {
         if (s != t._o && s != count_var_name) {
           usePatternTrick = false;
           break;
@@ -568,10 +573,12 @@ bool QueryPlanner::checkUsePatternTrick(
               return;
             }
             const auto& selectClause = arg._subquery.selectClause();
-            for (const auto& v : selectClause._selectedVariables) {
-              if (v == t._o) {
-                usePatternTrick = false;
-                break;
+            if(selectClause._varsOrAsterisk.isVariables()) {
+              for (const auto& v : selectClause._varsOrAsterisk.getSelectVariables()) {
+                if (v == t._o) {
+                  usePatternTrick = false;
+                  break;
+                }
               }
             }
           } else if constexpr (std::is_same_v<T, GraphPatternOperation::Bind>) {
@@ -620,10 +627,12 @@ bool QueryPlanner::checkUsePatternTrick(
                 return;
               }
               const auto& selectClause = arg._subquery.selectClause();
-              for (const auto& v : selectClause._selectedVariables) {
-                if (v == t._o) {
-                  usePatternTrick = false;
-                  break;
+              if(selectClause._varsOrAsterisk.isVariables()) {
+                for (const auto& v : selectClause._varsOrAsterisk.getSelectVariables()) {
+                  if (v == t._o) {
+                    usePatternTrick = false;
+                    break;
+                  }
                 }
               }
             } else if constexpr (std::is_same_v<T, GraphPatternOperation::
@@ -828,25 +837,27 @@ vector<QueryPlanner::SubtreePlan> QueryPlanner::getDistinctRow(
     vector<size_t> keepIndices;
     ad_utility::HashSet<size_t> indDone;
     const auto& colMap = parent._qet->getVariableColumns();
-    for (const auto& var : selectClause._selectedVariables) {
-      const auto it = colMap.find(var);
-      if (it != colMap.end()) {
-        auto ind = it->second;
-        if (indDone.count(ind) == 0) {
-          keepIndices.push_back(ind);
-          indDone.insert(ind);
-        }
-      } else if (ad_utility::startsWith(var, "SCORE(") ||
-                 ad_utility::startsWith(var, "TEXT(")) {
-        auto varInd = var.find('?');
-        auto cVar = var.substr(varInd, var.rfind(')') - varInd);
-        const auto it = colMap.find(cVar);
+    if(selectClause._varsOrAsterisk.isVariables()){
+      for (const auto& var : selectClause._varsOrAsterisk.getSelectVariables()) {
+        const auto it = colMap.find(var);
         if (it != colMap.end()) {
           auto ind = it->second;
           if (indDone.count(ind) == 0) {
             keepIndices.push_back(ind);
             indDone.insert(ind);
           }
+        } else if (ad_utility::startsWith(var, "SCORE(") ||
+                   ad_utility::startsWith(var, "TEXT(")) {
+          auto varInd = var.find('?');
+          auto cVar = var.substr(varInd, var.rfind(')') - varInd);
+          const auto it = colMap.find(cVar);
+          if (it != colMap.end()) {
+            auto ind = it->second;
+            if (indDone.count(ind) == 0) {
+              keepIndices.push_back(ind);
+              indDone.insert(ind);
+            }
+          }
         }
       }
     }

src/engine/Server.cpp

@@ -169,10 +169,19 @@ Awaitable<json> Server::composeResponseQleverJson(
     j["query"] = query._originalString;
     j["status"] = "OK";
     j["warnings"] = qet.collectWarnings();
-    j["selected"] =
-        query.hasSelectClause()
-            ? query.selectClause()._selectedVariables
-            : std::vector<std::string>{"?subject", "?predicate", "?object"};
+    if(query.hasSelectClause()){
+      if(query.selectClause()._varsOrAsterisk.isAsterisk()) {
+        auto list = query.selectClause()._varsOrAsterisk.retrieveOrder();
+        std::vector<string> result{ list.begin(),list.end() };
+        j["selected"] = result;
+      }
+      else {
+        j["selected"] = query.selectClause()._varsOrAsterisk.getSelectVariables();
+      }
+    }
+    else {
+      j["selected"] = std::vector<std::string>{"?subject", "?predicate", "?object"};
+    }
 
     j["runtimeInformation"] = RuntimeInformation::ordered_json(
         qet.getRootOperation()->getRuntimeInfo());
@@ -184,7 +193,7 @@ Awaitable<json> Server::composeResponseQleverJson(
       requestTimer.cont();
       j["res"] = query.hasSelectClause()
                      ? qet.writeResultAsQLeverJson(
-                           query.selectClause()._selectedVariables, limit,
+                           query.selectClause()._varsOrAsterisk, limit,
                            offset, std::move(resultTable))
                      : qet.writeRdfGraphJson(query.constructClause(), limit,
                                              offset, std::move(resultTable));
@@ -220,8 +229,9 @@ Awaitable<json> Server::composeResponseSparqlJson(
         std::min(query._limit.value_or(MAX_NOF_ROWS_IN_RESULT), maxSend);
     size_t offset = query._offset.value_or(0);
     requestTimer.cont();
-    j = qet.writeResultAsSparqlJson(query.selectClause()._selectedVariables,
+    j = qet.writeResultAsSparqlJson(query.selectClause()._varsOrAsterisk,
                                     limit, offset, std::move(resultTable));
+
     requestTimer.stop();
     return j;
   };
@@ -238,7 +248,7 @@ Server::composeResponseSepValues(const ParsedQuery& query,
     size_t offset = query._offset.value_or(0);
     return query.hasSelectClause()
                ? qet.generateResults<format>(
-                     query.selectClause()._selectedVariables, limit, offset)
+                     query.selectClause()._varsOrAsterisk, limit, offset)
                : qet.writeRdfGraphSeparatedValues<format>(
                      query.constructClause(), limit, offset, qet.getResult());
   };