arangodb
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
diff --git a/‎arangod/Aql/ConstFetcher.cpp
Lines changed: 9 additions & 24 deletions b/‎arangod/Aql/ConstFetcher.cpp
Lines changed: 9 additions & 24 deletions
diff --git a/‎arangod/Aql/ConstFetcher.h
Lines changed: 0 additions & 3 deletions b/‎arangod/Aql/ConstFetcher.h
Lines changed: 0 additions & 3 deletions
diff --git a/‎arangod/Aql/ConstrainedSortExecutor.cpp
Lines changed: 20 additions & 29 deletions b/‎arangod/Aql/ConstrainedSortExecutor.cpp
Lines changed: 20 additions & 29 deletions
diff --git a/‎arangod/Aql/ConstrainedSortExecutor.h
Lines changed: 2 additions & 3 deletions b/‎arangod/Aql/ConstrainedSortExecutor.h
Lines changed: 2 additions & 3 deletions
diff --git a/‎arangod/Aql/CountCollectExecutor.cpp
Lines changed: 8 additions & 5 deletions b/‎arangod/Aql/CountCollectExecutor.cpp
Lines changed: 8 additions & 5 deletions
diff --git a/‎arangod/Aql/CountCollectExecutor.h
Lines changed: 0 additions & 2 deletions b/‎arangod/Aql/CountCollectExecutor.h
Lines changed: 0 additions & 2 deletions
@@ -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);
 
@@ -153,7 +153,6 @@ auto ConstFetcher::execute(AqlCallStack& stack)
     _rowIndex = 0;
     SkipResult skipped{};
     skipped.didSkip(call.getSkipCount());
-
     return {ExecutionState::DONE, skipped,
             DataRange{ExecutorState::DONE, call.getSkipCount(), resultBlock, 0}};
   }
@@ -171,28 +170,23 @@ auto ConstFetcher::execute(AqlCallStack& stack)
     // Remove the indexes from the slice list
     sliceIndexes.erase(sliceIndexes.begin());
   }
-  // NOTE: The above if may have invalidated from and to memory.
-  // Do not use them below this point!
 
-  if (sliceIndexes.empty()) {
-    // No data to be returned
-    // Block is dropped.
-    resultBlock = nullptr;
-    SkipResult skipped{};
-    skipped.didSkip(call.getSkipCount());
-    return {ExecutionState::DONE, skipped,
-            DataRange{ExecutorState::DONE, call.getSkipCount()}};
-  }
-
-  // Slowest path need to slice, this unfortunately requires copy of data
   ExecutionState resState =
       _blockForPassThrough == nullptr ? ExecutionState::DONE : ExecutionState::HASMORE;
   ExecutorState rangeState =
       _blockForPassThrough == nullptr ? ExecutorState::DONE : ExecutorState::HASMORE;
 
-  resultBlock = resultBlock->slice(sliceIndexes);
   skipped.didSkip(call.getSkipCount());
+
+  if (sliceIndexes.empty()) {
+    // No data to be returned
+    resultBlock = nullptr;
+    return {resState, skipped, DataRange{rangeState, call.getSkipCount()}};
+  }
+
+  // Slowest path need to slice, this unfortunately requires copy of data
+  resultBlock = resultBlock->slice(sliceIndexes);
   return {resState, skipped, DataRange{rangeState, call.getSkipCount(), resultBlock, 0}};
 }
 
@@ -278,15 +272,6 @@ auto ConstFetcher::canUseFullBlock(std::vector<std::pair<size_t, size_t>> const&
   return true;
 }
 
-std::pair<ExecutionState, SharedAqlItemBlockPtr> ConstFetcher::fetchBlockForPassthrough(size_t) {
-  // Should only be called once, and then _blockForPassThrough should be
-  // initialized. However, there are still some blocks left that ask their
-  // parent even after they got DONE the last time, and I don't currently have
-  // time to track them down. Thus the following assert is commented out.
-  // TRI_ASSERT(_blockForPassThrough != nullptr);
-  return {ExecutionState::DONE, std::move(_blockForPassThrough)};
-}
-
 std::pair<ExecutionState, ShadowAqlItemRow> ConstFetcher::fetchShadowRow(size_t) const {
   return {ExecutionState::DONE, ShadowAqlItemRow{CreateInvalidShadowRowHint{}}};
 }
@@ -95,9 +95,6 @@ class ConstFetcher {
   TEST_VIRTUAL std::pair<ExecutionState, size_t> skipRows(size_t);
   void injectBlock(SharedAqlItemBlockPtr block);
 
-  // Argument will be ignored!
-  std::pair<ExecutionState, SharedAqlItemBlockPtr> fetchBlockForPassthrough(size_t);
-
   void setDistributeId(std::string const&) {
     // This is not implemented for this fetcher
     TRI_ASSERT(false);
 
@@ -134,8 +134,6 @@ bool ConstrainedSortExecutor::compareInput(size_t const& rowPos,
 
 ConstrainedSortExecutor::ConstrainedSortExecutor(Fetcher& fetcher, SortExecutorInfos& infos)
     : _infos(infos),
-      _fetcher(fetcher),
-      _state(ExecutionState::HASMORE),
       _returnNext(0),
       _rowsPushed(0),
       _rowsRead(0),
@@ -271,33 +269,26 @@ auto ConstrainedSortExecutor::skipRowsRange(AqlItemBlockInputRange& inputRange,
   return {state, NoStats{}, call.getSkipCount(), AqlCall{}};
 }
 
-std::pair<ExecutionState, size_t> ConstrainedSortExecutor::expectedNumberOfRows(size_t) const {
-  // This block cannot support atMost
-  size_t rowsLeft = 0;
-  if (_state != ExecutionState::DONE) {
-    ExecutionState state;
-    size_t expectedRows;
-    std::tie(state, expectedRows) =
-        _fetcher.preFetchNumberOfRows(ExecutionBlock::DefaultBatchSize);
-    if (state == ExecutionState::WAITING) {
-      TRI_ASSERT(expectedRows == 0);
-      return {state, 0};
-    }
-    // Return the minimum of upstream + limit
-    rowsLeft = (std::min)(expectedRows, _infos.limit());
-  } else {
-    // We have exactly the following rows available:
-    rowsLeft = _rows.size() - _returnNext;
+[[nodiscard]] auto ConstrainedSortExecutor::expectedNumberOfRowsNew(
+    AqlItemBlockInputRange const& input, AqlCall const& call) const noexcept -> size_t {
+  size_t rowsPerBlock = _infos.limit();
+  size_t subqueries = input.countShadowRows();
+  if (subqueries == 0) {
+    // we are a top level block, just pretend we run in the only subquery.
+    subqueries = 1;
   }
-
-  if (rowsLeft == 0) {
-    if (doneSkipping()) {
-      return {ExecutionState::DONE, rowsLeft};
-    }
-    // We always report at least 1 row here, for a possible LIMIT block with fullCount to work.
-    // However, we should never have to do this if the LIMIT block doesn't overfetch with getSome.
-    rowsLeft = 1;
+  // we return rowsPerBlock for every subquery.
+  size_t totalRows = subqueries * rowsPerBlock;
+  // We can only have returnNext reach the total amount of Rows in a block
+  // We have at least 1 block, hence totalRows needs to be higher
+  TRI_ASSERT(_returnNext <= totalRows);
+  // We have totalRows at most available.
+  // adn we have _returnNext many of them already returned
+  // from the first data-rows block.
+  // In unlucky case we overestumate here, if we get called
+  // while operating on any other data-row block then the first.
+  if (input.countShadowRows() == 0) {
+    return std::min(call.getLimit(), totalRows - _returnNext);
   }
-
-  return {ExecutionState::HASMORE, rowsLeft};
+  return totalRows - _returnNext;
 }
@@ -90,7 +90,8 @@ class ConstrainedSortExecutor {
    * @brief This Executor knows how many rows it will produce and most by itself
    *        It also knows that it could produce less if the upstream only has fewer rows.
    */
-  std::pair<ExecutionState, size_t> expectedNumberOfRows(size_t atMost) const;
+  [[nodiscard]] auto expectedNumberOfRowsNew(AqlItemBlockInputRange const& input,
+                                             AqlCall const& call) const noexcept -> size_t;
 
  private:
   bool compareInput(size_t const& rosPos, InputAqlItemRow const& row) const;
@@ -108,8 +109,6 @@ class ConstrainedSortExecutor {
 
  private:
   Infos& _infos;
-  Fetcher& _fetcher;
-  ExecutionState _state;
   size_t _returnNext;
   std::vector<size_t> _rows;
   size_t _rowsPushed;
 
@@ -103,14 +103,17 @@ auto CountCollectExecutor::skipRowsRange(AqlItemBlockInputRange& inputRange, Aql
           AqlCall{0, false, 0, AqlCall::LimitType::HARD}};
 }
 
-std::pair<ExecutionState, size_t> CountCollectExecutor::expectedNumberOfRows(size_t) const {
-  TRI_ASSERT(false);
-  return {ExecutionState::HASMORE, 1};
-}
-
 auto CountCollectExecutor::expectedNumberOfRowsNew(AqlItemBlockInputRange const& input,
                                                    AqlCall const& call) const
     noexcept -> size_t {
+  auto subqueries = input.countShadowRows();
+  if (subqueries > 0) {
+    // We will return 1 row for every subquery execution.
+    // We do overallocate here if we have nested subqueries
+    return subqueries;
+  }
+  // No subqueries, we are at the end of the execution.
+  // We either return 1, or the callLimit.
   return std::min<size_t>(1, call.getLimit());
 }
 
 
@@ -103,8 +103,6 @@ class CountCollectExecutor {
   [[nodiscard]] auto skipRowsRange(AqlItemBlockInputRange& inputRange, AqlCall& call)
       -> std::tuple<ExecutorState, Stats, size_t, AqlCall>;
 
-  std::pair<ExecutionState, size_t> expectedNumberOfRows(size_t atMost) const;
-
   [[nodiscard]] auto expectedNumberOfRowsNew(AqlItemBlockInputRange const& input,
                                              AqlCall const& call) const noexcept -> size_t;