arangodb
diff --git a/‎arangod/Aql/AqlCall.cpp
Lines changed: 10 additions & 0 deletions b/‎arangod/Aql/AqlCall.cpp
Lines changed: 10 additions & 0 deletions
diff --git a/‎arangod/Aql/AqlCall.h
Lines changed: 5 additions & 3 deletions b/‎arangod/Aql/AqlCall.h
Lines changed: 5 additions & 3 deletions
diff --git a/‎arangod/Aql/AqlCallList.cpp
Lines changed: 41 additions & 2 deletions b/‎arangod/Aql/AqlCallList.cpp
Lines changed: 41 additions & 2 deletions
diff --git a/‎arangod/Aql/AqlCallList.h
Lines changed: 14 additions & 0 deletions b/‎arangod/Aql/AqlCallList.h
Lines changed: 14 additions & 0 deletions
diff --git a/‎arangod/Aql/AqlCallStack.cpp
Lines changed: 23 additions & 0 deletions b/‎arangod/Aql/AqlCallStack.cpp
Lines changed: 23 additions & 0 deletions
diff --git a/‎arangod/Aql/AqlCallStack.h
Lines changed: 24 additions & 0 deletions b/‎arangod/Aql/AqlCallStack.h
Lines changed: 24 additions & 0 deletions
diff --git a/‎arangod/Aql/AqlItemBlockInputRange.h
Lines changed: 0 additions & 1 deletion b/‎arangod/Aql/AqlItemBlockInputRange.h
Lines changed: 0 additions & 1 deletion
diff --git a/‎arangod/Aql/BlocksWithClients.cpp
Lines changed: 0 additions & 38 deletions b/‎arangod/Aql/BlocksWithClients.cpp
Lines changed: 0 additions & 38 deletions
diff --git a/‎arangod/Aql/BlocksWithClients.h
Lines changed: 0 additions & 8 deletions b/‎arangod/Aql/BlocksWithClients.h
Lines changed: 0 additions & 8 deletions
diff --git a/‎arangod/Aql/CalculationExecutor.cpp
Lines changed: 1 addition & 52 deletions b/‎arangod/Aql/CalculationExecutor.cpp
Lines changed: 1 addition & 52 deletions
diff --git a/‎arangod/Aql/CalculationExecutor.h
Lines changed: 0 additions & 9 deletions b/‎arangod/Aql/CalculationExecutor.h
Lines changed: 0 additions & 9 deletions
@@ -281,6 +281,16 @@ auto AqlCall::toString() const -> std::string {
   return stream.str();
 }
 
+auto AqlCall::requestLessDataThan(AqlCall const& other) const noexcept -> bool {
+  if (getOffset() > other.getOffset()) {
+    return false;
+  }
+  if (getLimit() > other.getLimit()) {
+    return false;
+  }
+  return needsFullCount() == other.needsFullCount();
+}
+
 auto aql::operator<<(std::ostream& out, AqlCall::Limit const& limit) -> std::ostream& {
   return std::visit(overload{[&out](size_t const& i) -> std::ostream& {
                                return out << i;
 
@@ -51,16 +51,16 @@ struct AqlCall {
 
   AqlCall() = default;
   // Replacements for struct initialization
-  // cppcheck-suppress * 
+  // cppcheck-suppress *
   explicit constexpr AqlCall(size_t offset, Limit softLimit = Infinity{},
                              Limit hardLimit = Infinity{}, bool fullCount = false)
       : offset{offset}, softLimit{softLimit}, hardLimit{hardLimit}, fullCount{fullCount} {}
 
   enum class LimitType { SOFT, HARD };
-  // cppcheck-suppress * 
+  // cppcheck-suppress *
   constexpr AqlCall(size_t offset, bool fullCount, Infinity)
       : offset{offset}, softLimit{Infinity{}}, hardLimit{Infinity{}}, fullCount{fullCount} {}
-  // cppcheck-suppress * 
+  // cppcheck-suppress *
   constexpr AqlCall(size_t offset, bool fullCount, size_t limit, LimitType limitType)
       : offset{offset},
         softLimit{limitType == LimitType::SOFT ? Limit{limit} : Limit{Infinity{}}},
@@ -195,6 +195,8 @@ struct AqlCall {
   bool shouldSkip() const {
     return getOffset() > 0 || (getLimit() == 0 && needsFullCount());
   }
+
+  auto requestLessDataThan(AqlCall const& other) const noexcept -> bool;
 };
 
 constexpr bool operator<(AqlCall::Limit const& a, AqlCall::Limit const& b) {
 
@@ -245,6 +245,44 @@ auto AqlCallList::toString() const -> std::string {
   return stream.str();
 }
 
+auto AqlCallList::requestLessDataThan(AqlCallList const& other) const noexcept -> bool {
+  if (other._defaultCall.has_value()) {
+    // Let is straightly check the default call.
+    // We do not know if we have already filled one specific call
+    if (!_defaultCall.has_value()) {
+      // We cannot lose the default call
+      return false;
+    }
+
+    if (!(_defaultCall.value() == other._defaultCall.value())) {
+      return false;
+    }
+
+    for (auto const& call : _specificCalls) {
+      if (!call.requestLessDataThan(other._defaultCall.value())) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (_defaultCall.has_value()) {
+    // We cannot reach a state with default call, if the original does not have one
+    return false;
+  }
+  // NOTE: For simplicity we only implemented this for the single specific call
+  // used up to now.
+  TRI_ASSERT(_specificCalls.size() <= 1);
+  TRI_ASSERT(other._specificCalls.size() <= 1);
+  if (!_specificCalls.empty()) {
+    if (other._specificCalls.empty()) {
+      // Cannot have generated a specific call
+      return false;
+    }
+    return _specificCalls[0].requestLessDataThan(other._specificCalls[0]);
+  }
+  return true;
+}
+
 bool arangodb::aql::operator==(AqlCallList const& left, AqlCallList const& right) {
   if (left._specificCalls.size() != right._specificCalls.size()) {
     return false;
@@ -262,7 +300,7 @@ bool arangodb::aql::operator==(AqlCallList const& left, AqlCallList const& right
 }
 
 auto arangodb::aql::operator<<(std::ostream& out, AqlCallList const& list) -> std::ostream& {
-  out << "specific: [ ";
+  out << "{specific: [ ";
   for (auto const& [index, call] : enumerate(list._specificCalls)) {
     if (index > 0) {
       out << ", ";
@@ -271,7 +309,8 @@ auto arangodb::aql::operator<<(std::ostream& out, AqlCallList const& list) -> st
   }
   out << " ]";
   if (list._defaultCall.has_value()) {
-    out << " default: " << list._defaultCall.value();
+    out << ", default: " << list._defaultCall.value();
   }
+  out << "}";
   return out;
 }
@@ -125,6 +125,20 @@ class AqlCallList {
   auto toVelocyPack(velocypack::Builder&) const -> void;
   auto toString() const -> std::string;
 
+  /**
+   * @brief Tests if this requires at most an identical
+   *        amount of data as the other list does.
+   *
+   *        Or in other words: Starting with the other stack,
+   *        is there a combination of didSkip/didProduce
+   *        calls to reach this state. (empty combination allowed)
+   *        This also checks if the depths of the stacks are identical
+   *
+   * @return true
+   * @return false
+   */
+  auto requestLessDataThan(AqlCallList const& other) const noexcept -> bool;
+
  private:
   /**
    * @brief A list of specific calls for subqueries.
 
@@ -219,3 +219,26 @@ auto AqlCallStack::modifyTopCall() -> AqlCall& {
   TRI_ASSERT(!_operations.empty());
   return modifyCallAtDepth(0);
 }
+
+auto AqlCallStack::hasAllValidCalls() const noexcept -> bool {
+  return std::all_of(_operations.begin(), _operations.end(), [](AqlCallList const& list) {
+    if (!list.hasMoreCalls()) {
+      return false;
+    }
+    auto const& call = list.peekNextCall();
+    // We cannot continue if any of our calls has a softLimit reached.
+    return !(call.hasSoftLimit() && call.getLimit() == 0 && call.getOffset() == 0);
+  });
+}
+
+auto AqlCallStack::requestLessDataThan(AqlCallStack const& other) const noexcept -> bool {
+  if (_operations.size() != other._operations.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < _operations.size(); ++i) {
+    if (!_operations[i].requestLessDataThan(other._operations[i])) {
+      return false;
+    }
+  }
+  return true;
+}
@@ -141,6 +141,30 @@ class AqlCallStack {
    */
   auto modifyTopCall() -> AqlCall&;
 
+  /**
+   * @brief Test if this stack has at least 1 valid call
+   *        on every subquery depth. If not, we canot continue with this stack
+   *        but need to return.
+   *
+   * @return true We have all valid calls
+   * @return false We ahve at least on depth without a valid call
+   */
+  auto hasAllValidCalls() const noexcept -> bool;
+
+  /**
+   * @brief Tests if this requires at most an identical
+   *        amount of data as the other stack does.
+   *
+   *        Or in other words: Starting with the other stack,
+   *        is there a combination of didSkip/didProduce
+   *        calls to reach this state. (empty combination allowed)
+   *        This also checks if the depths of the stacks are identical
+   *
+   * @return true
+   * @return false
+   */
+  auto requestLessDataThan(AqlCallStack const& other) const noexcept -> bool;
+
  private:
   explicit AqlCallStack(std::vector<AqlCallList>&& operations);
 
 
@@ -58,7 +58,6 @@ class AqlItemBlockInputRange {
   bool hasShadowRow() const noexcept;
 
   arangodb::aql::ShadowAqlItemRow peekShadowRow() const;
-  std::pair<ExecutorState, arangodb::aql::ShadowAqlItemRow> peekShadowRowAndState() const;
 
   std::pair<ExecutorState, arangodb::aql::ShadowAqlItemRow> nextShadowRow();
 
 
@@ -118,32 +118,6 @@ auto BlocksWithClientsImpl<Executor>::initializeCursor(InputAqlItemRow const& in
   return ExecutionBlock::initializeCursor(input);
 }
 
-template <class Executor>
-auto BlocksWithClientsImpl<Executor>::getBlock(size_t atMost)
-    -> std::pair<ExecutionState, bool> {
-  if (_engine->getQuery()->killed()) {
-    THROW_ARANGO_EXCEPTION(TRI_ERROR_QUERY_KILLED);
-  }
-
-  auto res = _dependencies[0]->getSome(atMost);
-  if (res.first == ExecutionState::WAITING) {
-    return {res.first, false};
-  }
-
-  TRI_IF_FAILURE("ExecutionBlock::getBlock") {
-    THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
-  }
-
-  _upstreamState = res.first;
-
-  if (res.second != nullptr) {
-    _buffer.emplace_back(std::move(res.second));
-    return {res.first, true};
-  }
-
-  return {res.first, false};
-}
-
 /// @brief shutdown
 template <class Executor>
 auto BlocksWithClientsImpl<Executor>::shutdown(int errorCode)
@@ -176,18 +150,6 @@ size_t BlocksWithClientsImpl<Executor>::getClientId(std::string const& shardId)
   return it->second;
 }
 
-template <class Executor>
-std::pair<ExecutionState, SharedAqlItemBlockPtr> BlocksWithClientsImpl<Executor>::getSome(size_t) {
-  TRI_ASSERT(false);
-  THROW_ARANGO_EXCEPTION(TRI_ERROR_NOT_IMPLEMENTED);
-}
-
-template <class Executor>
-std::pair<ExecutionState, size_t> BlocksWithClientsImpl<Executor>::skipSome(size_t) {
-  TRI_ASSERT(false);
-  THROW_ARANGO_EXCEPTION(TRI_ERROR_NOT_IMPLEMENTED);
-}
-
 template <class Executor>
 std::tuple<ExecutionState, SkipResult, SharedAqlItemBlockPtr>
 BlocksWithClientsImpl<Executor>::execute(AqlCallStack stack) {
 
@@ -122,14 +122,6 @@ class BlocksWithClientsImpl : public ExecutionBlock, public BlocksWithClients {
   /// @brief shutdown
   std::pair<ExecutionState, Result> shutdown(int) override;
 
-  std::pair<ExecutionState, bool> getBlock(size_t atMost);
-
-  /// @brief getSome: shouldn't be used, use skipSomeForShard
-  std::pair<ExecutionState, SharedAqlItemBlockPtr> getSome(size_t atMost) final;
-
-  /// @brief skipSome: shouldn't be used, use skipSomeForShard
-  std::pair<ExecutionState, size_t> skipSome(size_t atMost) final;
-
   /// @brief execute: shouldn't be used, use executeForClient
   std::tuple<ExecutionState, SkipResult, SharedAqlItemBlockPtr> execute(AqlCallStack stack) override;
 
 
@@ -86,50 +86,6 @@ std::vector<RegisterId> const& CalculationExecutorInfos::getExpInRegs() const no
   return _expInRegs;
 }
 
-template <CalculationType calculationType>
-std::pair<ExecutionState, typename CalculationExecutor<calculationType>::Stats>
-CalculationExecutor<calculationType>::produceRows(OutputAqlItemRow& output) {
-  // TRI_ASSERT(false);
-  // THROW_ARANGO_EXCEPTION(TRI_ERROR_NOT_IMPLEMENTED);
-  ExecutionState state;
-  InputAqlItemRow row = InputAqlItemRow{CreateInvalidInputRowHint{}};
-  std::tie(state, row) = _fetcher.fetchRow();
-
-  if (state == ExecutionState::WAITING) {
-    TRI_ASSERT(!row);
-    TRI_ASSERT(!_infos.getQuery().hasEnteredContext());
-    return {state, NoStats{}};
-  }
-
-  if (!row) {
-    TRI_ASSERT(state == ExecutionState::DONE);
-#ifdef ARANGODB_ENABLE_MAINTAINER_MODE
-    TRI_ASSERT(_fetcher.isAtShadowRow() || (!_fetcher.hasRowsLeftInBlock() &&
-                                            !_infos.getQuery().hasEnteredContext()));
-#endif
-    return {state, NoStats{}};
-  }
-
-  doEvaluation(row, output);
-
-  // _hasEnteredContext implies the query has entered the context, but not
-  // the other way round because it may be owned by exterior.
-  TRI_ASSERT(!_hasEnteredContext || _infos.getQuery().hasEnteredContext());
-
-  // The following only affects V8Conditions. If we should exit the V8 context
-  // between blocks, because we might have to wait for client or upstream, then
-  //   hasEnteredContext => state == HASMORE,
-  // as we only leave the context open when there are rows left in the current
-  // block.
-  // Note that _infos.getQuery().hasEnteredContext() may be true, even if
-  // _hasEnteredContext is false, if (and only if) the query context is owned
-  // by exterior.
-  TRI_ASSERT(!shouldExitContextBetweenBlocks() || !_hasEnteredContext ||
-             state == ExecutionState::HASMORE);
-
-  return {state, NoStats{}};
-}
-
 template <CalculationType calculationType>
 std::tuple<ExecutorState, typename CalculationExecutor<calculationType>::Stats, AqlCall>
 CalculationExecutor<calculationType>::produceRows(AqlItemBlockInputRange& inputRange,
@@ -143,7 +99,7 @@ CalculationExecutor<calculationType>::produceRows(AqlItemBlockInputRange& inputR
   while (inputRange.hasDataRow()) {
     // This executor is passthrough. it has enough place to write.
     TRI_ASSERT(!output.isFull());
-    std::tie(state, input) = inputRange.nextDataRow(); 
+    std::tie(state, input) = inputRange.nextDataRow();
     TRI_ASSERT(input.isInitialized());
 
     doEvaluation(input, output);
@@ -168,13 +124,6 @@ CalculationExecutor<calculationType>::produceRows(AqlItemBlockInputRange& inputR
   return {inputRange.upstreamState(), NoStats{}, output.getClientCall()};
 }
 
-template <CalculationType calculationType>
-std::tuple<ExecutionState, typename CalculationExecutor<calculationType>::Stats, SharedAqlItemBlockPtr>
-CalculationExecutor<calculationType>::fetchBlockForPassthrough(size_t atMost) {
-  auto rv = _fetcher.fetchBlockForPassthrough(atMost);
-  return {rv.first, {}, std::move(rv.second)};
-}
-
 template <CalculationType calculationType>
 template <CalculationType U, typename>
 void CalculationExecutor<calculationType>::enterContext() {
 
@@ -99,13 +99,6 @@ class CalculationExecutor {
   CalculationExecutor(Fetcher& fetcher, CalculationExecutorInfos&);
   ~CalculationExecutor();
 
-  /**
-   * @brief produce the next Row of Aql Values.
-   *
-   * @return ExecutionState, and if successful exactly one new Row of AqlItems.
-   */
-  std::pair<ExecutionState, Stats> produceRows(OutputAqlItemRow& output);
-
   /**
    * @brief produce the next Row of Aql Values.
    *
@@ -114,8 +107,6 @@ class CalculationExecutor {
   [[nodiscard]] std::tuple<ExecutorState, Stats, AqlCall> produceRows(
       AqlItemBlockInputRange& inputRange, OutputAqlItemRow& output);
 
-  std::tuple<ExecutionState, Stats, SharedAqlItemBlockPtr> fetchBlockForPassthrough(size_t atMost);
-
  private:
   // specialized implementations
   void doEvaluation(InputAqlItemRow& input, OutputAqlItemRow& output);