arangodb · hkernbach · Apr 28, 2025 · May 6, 2025 · May 6, 2025 · May 13, 2025
diff --git a/arangod/Aql/ExecutionNode/EnumeratePathsNode.cpp b/arangod/Aql/ExecutionNode/EnumeratePathsNode.cpp
@@ -432,7 +432,7 @@ std::unique_ptr<ExecutionBlock> EnumeratePathsNode::createBlock(
   TRI_ASSERT(pathType() != arangodb::graph::PathType::Type::ShortestPath);
 
   arangodb::graph::TwoSidedEnumeratorOptions enumeratorOptions{
-      opts->getMinDepth(), opts->getMaxDepth(), pathType()};
+      opts->getMinDepth(), opts->getMaxDepth(), pathType(), opts->query()};
   PathValidatorOptions validatorOptions(opts->tmpVar(),
                                         opts->getExpressionCtx());
 
@@ -476,13 +476,14 @@ std::unique_ptr<ExecutionBlock> EnumeratePathsNode::createBlock(
     SingleServerBaseProviderOptions forwardProviderOptions(
         opts->tmpVar(), std::move(usedIndexes), opts->getExpressionCtx(), {},
         opts->collectionToShard(), opts->getVertexProjections(),
-        opts->getEdgeProjections(), opts->produceVertices(), opts->useCache());
+        opts->getEdgeProjections(), opts->produceVertices(), opts->useCache(),
+        opts->query());
 
     SingleServerBaseProviderOptions backwardProviderOptions(
         opts->tmpVar(), std::move(reversedUsedIndexes),
         opts->getExpressionCtx(), {}, opts->collectionToShard(),
         opts->getVertexProjections(), opts->getEdgeProjections(),
-        opts->produceVertices(), opts->useCache());
+        opts->produceVertices(), opts->useCache(), opts->query());
 
     using Provider = SingleServerProvider<SingleServerProviderStep>;
     if (opts->query().queryOptions().getTraversalProfileLevel() ==
@@ -678,11 +679,11 @@ std::unique_ptr<ExecutionBlock> EnumeratePathsNode::createBlock(
   } else {  // Cluster case (on coordinator)
     auto cache = std::make_shared<RefactoredClusterTraverserCache>(
         opts->query().resourceMonitor());
-    ClusterBaseProviderOptions forwardProviderOptions(cache, engines(), false,
-                                                      opts->produceVertices());
+    ClusterBaseProviderOptions forwardProviderOptions(
+        cache, engines(), false, opts->produceVertices(), opts->query());
     forwardProviderOptions.setClearEdgeCacheOnClear(false);
-    ClusterBaseProviderOptions backwardProviderOptions(cache, engines(), true,
-                                                       opts->produceVertices());
+    ClusterBaseProviderOptions backwardProviderOptions(
+        cache, engines(), true, opts->produceVertices(), opts->query());
     backwardProviderOptions.setClearEdgeCacheOnClear(false);
     // A comment is in order here: For all cases covered here
     // (k-shortest-paths, all shortest paths, k-paths) we do not need to

diff --git a/arangod/Aql/ExecutionNode/ShortestPathNode.cpp b/arangod/Aql/ExecutionNode/ShortestPathNode.cpp
@@ -419,7 +419,7 @@ std::unique_ptr<ExecutionBlock> ShortestPathNode::createBlock(
 
   arangodb::graph::TwoSidedEnumeratorOptions enumeratorOptions{
       0, std::numeric_limits<size_t>::max(),
-      arangodb::graph::PathType::Type::ShortestPath};
+      arangodb::graph::PathType::Type::ShortestPath, opts->query()};
   PathValidatorOptions validatorOptions(opts->tmpVar(),
                                         opts->getExpressionCtx());
 
@@ -437,13 +437,14 @@ std::unique_ptr<ExecutionBlock> ShortestPathNode::createBlock(
     SingleServerBaseProviderOptions forwardProviderOptions(
         opts->tmpVar(), std::move(usedIndexes), opts->getExpressionCtx(), {},
         opts->collectionToShard(), opts->getVertexProjections(),
-        opts->getEdgeProjections(), opts->produceVertices(), opts->useCache());
+        opts->getEdgeProjections(), opts->produceVertices(), opts->useCache(),
+        opts->query());
 
     SingleServerBaseProviderOptions backwardProviderOptions(
         opts->tmpVar(), std::move(reversedUsedIndexes),
         opts->getExpressionCtx(), {}, opts->collectionToShard(),
         opts->getVertexProjections(), opts->getEdgeProjections(),
-        opts->produceVertices(), opts->useCache());
+        opts->produceVertices(), opts->useCache(), opts->query());
 
     auto usesWeight =
         checkWeight(forwardProviderOptions, backwardProviderOptions);
@@ -510,10 +511,10 @@ std::unique_ptr<ExecutionBlock> ShortestPathNode::createBlock(
     using ClusterProvider = ClusterProvider<ClusterProviderStep>;
     auto cache = std::make_shared<RefactoredClusterTraverserCache>(
         opts->query().resourceMonitor());
-    ClusterBaseProviderOptions forwardProviderOptions(cache, engines(), false,
-                                                      opts->produceVertices());
-    ClusterBaseProviderOptions backwardProviderOptions(cache, engines(), true,
-                                                       opts->produceVertices());
+    ClusterBaseProviderOptions forwardProviderOptions(
+        cache, engines(), false, opts->produceVertices(), opts->query());
+    ClusterBaseProviderOptions backwardProviderOptions(
+        cache, engines(), true, opts->produceVertices(), opts->query());
 
     auto usesWeight =
         checkWeight(forwardProviderOptions, backwardProviderOptions);

diff --git a/arangod/Aql/ExecutionNode/TraversalNode.cpp b/arangod/Aql/ExecutionNode/TraversalNode.cpp
@@ -817,8 +817,8 @@ std::unique_ptr<ExecutionBlock> TraversalNode::createBlock(
     bool isSmart) const {
   TraverserOptions* opts = this->options();
 
-  arangodb::graph::OneSidedEnumeratorOptions options{opts->minDepth,
-                                                     opts->maxDepth};
+  arangodb::graph::OneSidedEnumeratorOptions options{
+      opts->minDepth, opts->maxDepth, opts->query()};
   /*
    * PathValidator Disjoint Helper (TODO [GraphRefactor]: Copy from createBlock)
    * Clean this up as soon we clean up the whole TraversalNode as well.
@@ -915,7 +915,8 @@ ClusterBaseProviderOptions TraversalNode::getClusterBaseProviderOptions(
           opts->produceVertices(),
           &opts->getExpressionCtx(),
           filterConditionVariables,
-          std::move(availableDepthsSpecificConditions)};
+          std::move(availableDepthsSpecificConditions),
+          opts->query()};
 }
 
 SingleServerBaseProviderOptions
@@ -936,7 +937,8 @@ TraversalNode::getSingleServerBaseProviderOptions(
           opts->getVertexProjections(),
           opts->getEdgeProjections(),
           opts->produceVertices(),
-          opts->useCache()};
+          opts->useCache(),
+          opts->query()};
 }
 
 /// @brief creates corresponding ExecutionBlock

diff --git a/arangod/Graph/Enumerators/OneSidedEnumerator.cpp b/arangod/Graph/Enumerators/OneSidedEnumerator.cpp
@@ -107,8 +107,11 @@ void OneSidedEnumerator<Configuration>::clearProvider() {
 }
 
 template<class Configuration>
-auto OneSidedEnumerator<Configuration>::computeNeighbourhoodOfNextVertex()
-    -> void {
+void OneSidedEnumerator<Configuration>::computeNeighbourhoodOfNextVertex() {
+  if (_options.isKilled()) {
+    THROW_ARANGO_EXCEPTION(TRI_ERROR_QUERY_KILLED);
+  }
+
   // Pull next element from Queue
   // Do 1 step search
   TRI_ASSERT(!_queue.isEmpty());

diff --git a/arangod/Graph/Enumerators/TwoSidedEnumerator.cpp b/arangod/Graph/Enumerators/TwoSidedEnumerator.cpp
@@ -197,6 +197,10 @@ template<class QueueType, class PathStoreType, class ProviderType,
 auto TwoSidedEnumerator<QueueType, PathStoreType, ProviderType, PathValidator>::
     Ball::computeNeighbourhoodOfNextVertex(Ball& other, ResultList& results)
         -> void {
+  if (_graphOptions.isKilled()) {
+    THROW_ARANGO_EXCEPTION(TRI_ERROR_QUERY_KILLED);
+  }
+
   // Pull next element from Queue
   // Do 1 step search
   TRI_ASSERT(!_queue.isEmpty());
@@ -451,6 +455,13 @@ void TwoSidedEnumerator<QueueType, PathStoreType, ProviderType,
                         PathValidator>::searchMoreResults() {
   while (_results.empty() && !searchDone()) {
     _resultsFetched = false;
+
+    // Check for kill signal before proceeding
+    // We will also do additional checks in computeNeighbourhoodOfNextVertex
+    if (_options.isKilled()) {
+      THROW_ARANGO_EXCEPTION(TRI_ERROR_QUERY_KILLED);
+    }
+
     if (_searchLeft) {
       if (ADB_UNLIKELY(_left.doneWithDepth())) {
         startNextDepth();

diff --git a/arangod/Graph/Enumerators/WeightedTwoSidedEnumerator.cpp b/arangod/Graph/Enumerators/WeightedTwoSidedEnumerator.cpp
@@ -254,6 +254,10 @@ auto WeightedTwoSidedEnumerator<QueueType, PathStoreType, ProviderType,
                                 PathValidator>::Ball::
     computeNeighbourhoodOfNextVertex(Ball& other, CandidatesStore& candidates)
         -> void {
+  if (_graphOptions.isKilled()) {
+    THROW_ARANGO_EXCEPTION(TRI_ERROR_QUERY_KILLED);
+  }
+
   ensureQueueHasProcessableElement();
   auto tmp = _queue.pop();
 
@@ -862,6 +866,9 @@ template<class QueueType, class PathStoreType, class ProviderType,
          class PathValidator>
 auto WeightedTwoSidedEnumerator<QueueType, PathStoreType, ProviderType,
                                 PathValidator>::searchDone() const -> bool {
+  if (_options.isKilled()) {
+    THROW_ARANGO_EXCEPTION(TRI_ERROR_QUERY_KILLED);
+  }
   if ((_left.noPathLeft() && _right.noPathLeft()) || isAlgorithmFinished()) {
     return true;
   }

diff --git a/arangod/Graph/Enumerators/WeightedTwoSidedEnumerator.h b/arangod/Graph/Enumerators/WeightedTwoSidedEnumerator.h
@@ -259,13 +259,15 @@ class WeightedTwoSidedEnumerator {
       return _haveSeenOtherSide;
     }
 
-    auto setForbiddenVertices(std::shared_ptr<VertexSet> forbidden)
-        -> void requires HasForbidden<PathValidatorType> {
+    auto setForbiddenVertices(std::shared_ptr<VertexSet> forbidden) -> void
+      requires HasForbidden<PathValidatorType>
+    {
       _validator.setForbiddenVertices(std::move(forbidden));
     };
 
-    auto setForbiddenEdges(std::shared_ptr<EdgeSet> forbidden)
-        -> void requires HasForbidden<PathValidatorType> {
+    auto setForbiddenEdges(std::shared_ptr<EdgeSet> forbidden) -> void
+      requires HasForbidden<PathValidatorType>
+    {
       _validator.setForbiddenEdges(std::move(forbidden));
     };
 
@@ -398,19 +400,22 @@ class WeightedTwoSidedEnumerator {
    */
   auto stealStats() -> aql::TraversalStats;
 
-  auto setForbiddenVertices(std::shared_ptr<VertexSet> forbidden)
-      -> void requires HasForbidden<PathValidatorType> {
+  auto setForbiddenVertices(std::shared_ptr<VertexSet> forbidden) -> void
+    requires HasForbidden<PathValidatorType>
+  {
     _left.setForbiddenVertices(forbidden);
     _right.setForbiddenVertices(std::move(forbidden));
   };
 
-  auto setForbiddenEdges(std::shared_ptr<EdgeSet> forbidden)
-      -> void requires HasForbidden<PathValidatorType> {
+  auto setForbiddenEdges(std::shared_ptr<EdgeSet> forbidden) -> void
+    requires HasForbidden<PathValidatorType>
+  {
     _left.setForbiddenEdges(forbidden);
     _right.setForbiddenEdges(std::move(forbidden));
   };
 
- private : [[nodiscard]] auto searchDone() const -> bool;
+ private:
+  [[nodiscard]] auto searchDone() const -> bool;
   // Ensure that we have fetched all vertices in the _results list. Otherwise,
   // we will not be able to generate the resulting path
   auto fetchResults() -> void;

diff --git a/arangod/Graph/Options/OneSidedEnumeratorOptions.cpp b/arangod/Graph/Options/OneSidedEnumeratorOptions.cpp
@@ -28,8 +28,9 @@ using namespace arangodb;
 using namespace arangodb::graph;
 
 OneSidedEnumeratorOptions::OneSidedEnumeratorOptions(size_t minDepth,
-                                                     size_t maxDepth)
-    : _minDepth(minDepth), _maxDepth(maxDepth) {}
+                                                     size_t maxDepth,
+                                                     aql::QueryContext& query)
+    : _minDepth(minDepth), _maxDepth(maxDepth), _observer(query) {}
 
 OneSidedEnumeratorOptions::~OneSidedEnumeratorOptions() = default;
 

diff --git a/arangod/Graph/Options/OneSidedEnumeratorOptions.h b/arangod/Graph/Options/OneSidedEnumeratorOptions.h
@@ -24,20 +24,24 @@
 
 #pragma once
 
+#include "Graph/Options/QueryContextObserver.h"
 #include <cstddef>
 
 namespace arangodb::graph {
 
 struct OneSidedEnumeratorOptions {
  public:
-  OneSidedEnumeratorOptions(size_t minDepth, size_t maxDepth);
+  OneSidedEnumeratorOptions(size_t minDepth, size_t maxDepth,
+                            aql::QueryContext& query);
   ~OneSidedEnumeratorOptions();
 
   [[nodiscard]] size_t getMinDepth() const noexcept;
   [[nodiscard]] size_t getMaxDepth() const noexcept;
+  [[nodiscard]] bool isKilled() const noexcept { return _observer.isKilled(); }
 
  private:
   size_t const _minDepth;
   size_t const _maxDepth;
+  QueryContextObserver _observer;
 };
 }  // namespace arangodb::graph
diff --git a/arangod/Graph/Options/QueryContextObserver.h b/arangod/Graph/Options/QueryContextObserver.h
@@ -0,0 +1,52 @@
+////////////////////////////////////////////////////////////////////////////////
+/// DISCLAIMER
+///
+/// Copyright 2014-2024 ArangoDB GmbH, Cologne, Germany
+/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
+///
+/// Licensed under the Business Source License 1.1 (the "License");
+/// you may not use this file except in compliance with the License.
+/// You may obtain a copy of the License at
+///
+///     https://github.com/arangodb/arangodb/blob/devel/LICENSE
+///
+/// Unless required by applicable law or agreed to in writing, software
+/// distributed under the License is distributed on an "AS IS" BASIS,
+/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+/// See the License for the specific language governing permissions and
+/// limitations under the License.
+///
+/// Copyright holder is ArangoDB GmbH, Cologne, Germany
+///
+/// @author Michael Hackstein
+/// @author Heiko Kernbach
+////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "Aql/QueryContext.h"
+
+// This class serves as a wrapper around QueryContext to explicitly track where
+// query killing is being used in the graph traversal code. It provides a single
+// point of access to check if a query has been killed, making it easier to
+// maintain and modify the query killing behavior if needed.
+//
+// While this adds a small layer of indirection, it helps with code clarity and
+// maintainability. If profiling shows this wrapper causes significant overhead,
+// we can remove it and use QueryContext directly.
+//
+// We can change this or discuss if this approach is not liked.
+
+namespace arangodb::graph {
+
+class QueryContextObserver {
+ public:
+  explicit QueryContextObserver(aql::QueryContext& query) : _query(query) {}
+
+  [[nodiscard]] bool isKilled() const { return _query.killed(); }
+
+ private:
+  aql::QueryContext& _query;
+};
+
+}  // namespace arangodb::graph
diff --git a/arangod/Graph/Options/TwoSidedEnumeratorOptions.cpp b/arangod/Graph/Options/TwoSidedEnumeratorOptions.cpp
@@ -29,8 +29,12 @@ using namespace arangodb::graph;
 
 TwoSidedEnumeratorOptions::TwoSidedEnumeratorOptions(size_t minDepth,
                                                      size_t maxDepth,
-                                                     PathType::Type pathType)
-    : _minDepth(minDepth), _maxDepth(maxDepth), _pathType(pathType) {
+                                                     PathType::Type pathType,
+                                                     aql::QueryContext& query)
+    : _minDepth(minDepth),
+      _maxDepth(maxDepth),
+      _pathType(pathType),
+      _observer(query) {
   if (getPathType() == PathType::Type::AllShortestPaths) {
     setStopAtFirstDepth(true);
   } else if (getPathType() == PathType::Type::ShortestPath) {

diff --git a/arangod/Graph/Options/TwoSidedEnumeratorOptions.h b/arangod/Graph/Options/TwoSidedEnumeratorOptions.h
@@ -25,17 +25,23 @@
 #pragma once
 
 #include "Graph/PathType.h"
+#include "Graph/Options/QueryContextObserver.h"
 
 #include <numeric>
 #include <cstddef>
 
 namespace arangodb {
+
+namespace aql {
+class QueryContext;
+}
+
 namespace graph {
 
 struct TwoSidedEnumeratorOptions {
  public:
   TwoSidedEnumeratorOptions(size_t minDepth, size_t maxDepth,
-                            PathType::Type pathType);
+                            PathType::Type pathType, aql::QueryContext& query);
 
   ~TwoSidedEnumeratorOptions();
 
@@ -46,6 +52,7 @@ struct TwoSidedEnumeratorOptions {
   [[nodiscard]] PathType::Type getPathType() const;
   [[nodiscard]] bool getStopAtFirstDepth() const;
   [[nodiscard]] bool onlyProduceOnePath() const;
+  [[nodiscard]] bool isKilled() const noexcept { return _observer.isKilled(); }
 
   void setStopAtFirstDepth(bool stopAtFirstDepth);
   void setOnlyProduceOnePath(bool onlyProduceOnePath);
@@ -57,6 +64,7 @@ struct TwoSidedEnumeratorOptions {
   bool _stopAtFirstDepth{false};
   bool _onlyProduceOnePath{false};
   PathType::Type _pathType;
+  QueryContextObserver _observer;
 };
 }  // namespace graph
 }  // namespace arangodb