arangodb
diff --git a/‎arangod/Aql/AqlCallStack.h
Lines changed: 25 additions & 10 deletions b/‎arangod/Aql/AqlCallStack.h
Lines changed: 25 additions & 10 deletions
diff --git a/‎arangod/Aql/ExecutionBlockImpl.cpp
Lines changed: 29 additions & 9 deletions b/‎arangod/Aql/ExecutionBlockImpl.cpp
Lines changed: 29 additions & 9 deletions
@@ -63,14 +63,6 @@ class AqlCallStack {
   // Put another call on top of the stack.
   void pushCall(AqlCall&& call);
 
-  // fill up all missing calls within this stack s.t. we reach depth == 0
-  // This needs to be called if an executor requires to be fully executed, even if skipped,
-  // even if the subquery it is located in is skipped.
-  // The default operations added here will correspond to produce all Rows, unlimitted.
-  // e.g. every Modification Executor needs to call this functionality, as modifictions need to be
-  // performed even if skipped.
-  void stackUpMissingCalls();
-
   // Pops one subquery level.
   // if this isRelevent it pops the top-most call from the stack.
   // if this is not revelent it reduces the depth by 1.
@@ -94,12 +86,35 @@ class AqlCallStack {
 
   auto is36Compatible() const noexcept -> bool { return _compatibilityMode3_6; }
 
+  /**
+   * @brief Create an equivalent call stack that does a full-produce
+   *        of all Subquery levels. This is required for blocks
+   *        that are not allowed to be bpassed.
+   *        The top-most call remains unmodified, as the Executor might
+   *        require some soft limit on it.
+   *
+   * @return AqlCallStack a stack of equivalent size, that does not skip
+   *         on any lower subquery.
+   */
+  auto createEquivalentFetchAllShadowRowsStack() const -> AqlCallStack;
+
+  /**
+   * @brief Check if we are in a subquery that is in-fact required to
+   *        be skipped. This is relevant for executors that have created
+   *        an equivalentFetchAllShadowRows stack, in order to decide if
+   *        the need to produce output or if they are skipped.
+   *
+   * @return true
+   * @return false
+   */
+  auto needToSkipSubquery() const noexcept -> bool;
+
  private:
-  explicit AqlCallStack(std::stack<AqlCall>&& operations);
+  explicit AqlCallStack(std::vector<AqlCall>&& operations);
 
  private:
   // The list of operations, stacked by depth (e.g. bottom element is from main query)
-  std::stack<AqlCall> _operations;
+  std::vector<AqlCall> _operations;
 
   // The depth of subqueries that have not issued calls into operations,
   // as they have been skipped.
 
@@ -1229,14 +1229,7 @@ static auto fastForwardType(AqlCall const& call, Executor const& e) -> FastForwa
   }
   // TODO: We only need to do this is the executor actually require to call.
   // e.g. Modifications will always need to be called. Limit only if it needs to report fullCount
-  if constexpr (is_one_of_v<Executor, LimitExecutor, ModificationExecutor<AllRowsFetcher, InsertModifier>,
-                            ModificationExecutor<SingleRowFetcher<BlockPassthrough::Disable>, InsertModifier>,
-                            ModificationExecutor<AllRowsFetcher, RemoveModifier>,
-                            ModificationExecutor<SingleRowFetcher<BlockPassthrough::Disable>, RemoveModifier>,
-                            ModificationExecutor<AllRowsFetcher, UpdateReplaceModifier>,
-                            ModificationExecutor<SingleRowFetcher<BlockPassthrough::Disable>, UpdateReplaceModifier>,
-                            ModificationExecutor<AllRowsFetcher, UpsertModifier>,
-                            ModificationExecutor<SingleRowFetcher<BlockPassthrough::Disable>, UpsertModifier>>) {
+  if constexpr (std::is_same_v<Executor, LimitExecutor> || executorHasSideEffects<Executor>) {
     return FastForwardVariant::EXECUTOR;
   }
   return FastForwardVariant::FETCHER;
@@ -1676,6 +1669,16 @@ ExecutionBlockImpl<Executor>::executeWithoutTrace(AqlCallStack stack) {
         case ExecState::CHECKCALL: {
           LOG_QUERY("cfe46", DEBUG)
               << printTypeInfo() << " determine next action on call " << clientCall;
+
+          if constexpr (executorHasSideEffects<Executor>) {
+            // If the executor has sideEffects, and we need to skip the results we would
+            // produce here because we actually skip the subquery, we instead do a
+            // hardLimit 0 (aka FastForward) call instead to the local Executor
+            if (stack.needToSkipSubquery()) {
+              _execState = ExecState::FASTFORWARD;
+              break;
+            }
+          }
           _execState = nextState(clientCall);
           break;
         }
@@ -1830,8 +1833,25 @@ ExecutionBlockImpl<Executor>::executeWithoutTrace(AqlCallStack stack) {
         case ExecState::FASTFORWARD: {
           LOG_QUERY("96e2c", DEBUG)
               << printTypeInfo() << " all produced, fast forward to end up (sub-)query.";
+          AqlCall callCopy = clientCall;
+          if constexpr (executorHasSideEffects<Executor>) {
+            if (stack.needToSkipSubquery()) {
+              // Fast Forward call.
+              callCopy = AqlCall{0, false, 0, AqlCall::LimitType::HARD};
+            }
+          }
           auto [state, stats, skippedLocal, call, dependency] =
-              executeFastForward(_lastRange, clientCall);
+              executeFastForward(_lastRange, callCopy);
+          if constexpr (executorHasSideEffects<Executor>) {
+            if (!stack.needToSkipSubquery()) {
+              // We need to modify the original call.
+              clientCall = callCopy;
+            }
+            // else: We are bypassing the results.
+            // Do not count them here.
+          } else {
+            clientCall = callCopy;
+          }
 
           _requestedDependency = dependency;
           _skipped.didSkip(skippedLocal);