Tests pass for SubqueryStartExecutor

arangodb · mchacki · Feb 29, 2020 · Jan 29, 2020 · Jan 31, 2020 · Jan 31, 2020
commit 147cd0c0e180557232b7ef55e41284f307b00330
diff --git a/arangod/Aql/SubqueryStartExecutor.cpp b/arangod/Aql/SubqueryStartExecutor.cpp
@@ -27,6 +27,8 @@
 #include "Aql/SingleRowFetcher.h"
 #include "Aql/Stats.h"
 
+#include "Logger/LogMacros.h"
+
 using namespace arangodb;
 using namespace arangodb::aql;
 
@@ -50,7 +52,7 @@ auto SubqueryStartExecutor::produceRows(AqlItemBlockInputRange& input, OutputAql
           // might have shadow rows we need to pass through
           // We don't have a data row, but upstream might still have
           // data to process
-          return {_upstreamState, NoStats{}, AqlCall{}};
+          return {input.upstreamState(), NoStats{}, AqlCall{}};
         }
       } break;
       case State::PRODUCE_DATA_ROW: {
@@ -76,7 +78,7 @@ auto SubqueryStartExecutor::produceRows(AqlItemBlockInputRange& input, OutputAql
   // When we reach here, then output is full
   if (_produceState == State::READ_DATA_ROW) {
     TRI_ASSERT(!_inputRow.isInitialized());
-    return {_upstreamState, NoStats{}, AqlCall{}};
+    return {input.upstreamState(), NoStats{}, AqlCall{}};
   }
   // PRODUCE_DATA_ROW should always immediately be processed without leaving the
   // loop

diff --git a/tests/Aql/SubqueryStartExecutorTest.cpp b/tests/Aql/SubqueryStartExecutorTest.cpp
@@ -23,7 +23,10 @@
 #include "RowFetcherHelper.h"
 #include "gtest/gtest.h"
 
+#include "Aql/AqlItemBlock.h"
+#include "Aql/AqlItemBlockHelper.h"
 #include "Aql/ExecutorInfos.h"
+#include "Aql/InputAqlItemRow.h"
 #include "Aql/OutputAqlItemRow.h"
 #include "Aql/Stats.h"
 #include "Aql/SubqueryStartExecutor.h"
@@ -32,6 +35,7 @@
 #include <velocypack/Parser.h>
 #include <velocypack/velocypack-aliases.h>
 
+#include "Logger/LogMacros.h"
 using namespace arangodb;
 using namespace arangodb::aql;
 using namespace arangodb::tests;
@@ -63,6 +67,9 @@ class SubqueryStartExecutorTest : public ::testing::Test {
  protected:
   ResourceMonitor monitor;
   AqlItemBlockManager itemBlockManager{&monitor, SerializationFormat::SHADOWROWS};
+  SingleRowFetcherHelper<::arangodb::aql::BlockPassthrough::Disable> fetcher{
+      itemBlockManager, VPackParser::fromJson("[]")->steal(), false};
+  AqlCall call{};
 };
 
 TEST_F(SubqueryStartExecutorTest, check_properties) {
@@ -77,39 +84,45 @@ TEST_F(SubqueryStartExecutorTest, check_properties) {
 }
 
 TEST_F(SubqueryStartExecutorTest, empty_input_does_not_add_shadow_rows) {
-  SharedAqlItemBlockPtr block{new AqlItemBlock(itemBlockManager, 1000, 1)};
-  VPackBuilder input;
-  SingleRowFetcherHelper<::arangodb::aql::BlockPassthrough::Disable> fetcher(
-      itemBlockManager, input.steal(), false);
   auto infos = MakeBaseInfos(1);
+
   SubqueryStartExecutor testee(fetcher, infos);
 
   NoStats stats{};
-  ExecutionState state{ExecutionState::HASMORE};
+  auto state = ExecutorState::HASMORE;
+
+  auto input = AqlItemBlockInputRange{ExecutorState::DONE};
+
+  SharedAqlItemBlockPtr block = itemBlockManager.requestBlock(1000, 1);
   OutputAqlItemRow output{std::move(block), infos.getOutputRegisters(),
                           infos.registersToKeep(), infos.registersToClear()};
-  std::tie(state, stats) = testee.produceRows(output);
-  EXPECT_EQ(state, ExecutionState::DONE);
+
+  std::tie(state, stats, call) = testee.produceRows(input, output);
+
+  EXPECT_EQ(state, ExecutorState::DONE);
   EXPECT_FALSE(output.produced());
   EXPECT_EQ(output.numRowsWritten(), 0);
 }
 
 TEST_F(SubqueryStartExecutorTest, adds_a_shadowrow_after_single_input) {
-  SharedAqlItemBlockPtr block{new AqlItemBlock(itemBlockManager, 1000, 1)};
-  auto input = VPackParser::fromJson(R"([
-      ["a"]
-  ])");
-  SingleRowFetcherHelper<::arangodb::aql::BlockPassthrough::Disable> fetcher(
-      itemBlockManager, input->steal(), false);
+  SharedAqlItemBlockPtr block = itemBlockManager.requestBlock(1000, 1);
+
   auto infos = MakeBaseInfos(1);
   SubqueryStartExecutor testee(fetcher, infos);
 
   NoStats stats{};
-  ExecutionState state{ExecutionState::HASMORE};
+  auto state = ExecutorState::HASMORE;
+
+  auto inputBlock = buildBlock<1>(itemBlockManager, MatrixBuilder<1>{{{{R"("a")"}}}});
+  auto input =
+      AqlItemBlockInputRange{ExecutorState::DONE, inputBlock, 0, inputBlock->size()};
+
   OutputAqlItemRow output{std::move(block), infos.getOutputRegisters(),
                           infos.registersToKeep(), infos.registersToClear()};
-  std::tie(state, stats) = testee.produceRows(output);
-  EXPECT_EQ(state, ExecutionState::DONE);
+
+  std::tie(state, stats, call) = testee.produceRows(input, output);
+
+  EXPECT_EQ(state, ExecutorState::DONE);
   EXPECT_FALSE(output.produced());
   EXPECT_EQ(output.numRowsWritten(), 2);
 
@@ -119,23 +132,25 @@ TEST_F(SubqueryStartExecutorTest, adds_a_shadowrow_after_single_input) {
 }
 
 TEST_F(SubqueryStartExecutorTest, adds_a_shadowrow_after_every_input_line_in_single_pass) {
-  SharedAqlItemBlockPtr block{new AqlItemBlock(itemBlockManager, 1000, 1)};
-  auto input = VPackParser::fromJson(R"([
-      ["a"],
-      ["b"],
-      ["c"]
-  ])");
-  SingleRowFetcherHelper<::arangodb::aql::BlockPassthrough::Disable> fetcher(
-      itemBlockManager, input->steal(), false);
   auto infos = MakeBaseInfos(1);
   SubqueryStartExecutor testee(fetcher, infos);
 
   NoStats stats{};
-  ExecutionState state{ExecutionState::HASMORE};
+  auto state = ExecutorState::HASMORE;
+
+  auto inputBlock =
+      buildBlock<1>(itemBlockManager,
+                    MatrixBuilder<1>{{{{{R"("a")"}}}, {{{R"("b")"}}}, {{R"("c")"}}}});
+  auto input =
+      AqlItemBlockInputRange{ExecutorState::DONE, inputBlock, 0, inputBlock->size()};
+
+  SharedAqlItemBlockPtr block = itemBlockManager.requestBlock(1000, 1);
   OutputAqlItemRow output{std::move(block), infos.getOutputRegisters(),
                           infos.registersToKeep(), infos.registersToClear()};
-  std::tie(state, stats) = testee.produceRows(output);
-  EXPECT_EQ(state, ExecutionState::DONE);
+
+  std::tie(state, stats, call) = testee.produceRows(input, output);
+
+  EXPECT_EQ(state, ExecutorState::DONE);
   EXPECT_FALSE(output.produced());
   EXPECT_EQ(output.numRowsWritten(), 6);
 
@@ -149,24 +164,25 @@ TEST_F(SubqueryStartExecutorTest, adds_a_shadowrow_after_every_input_line_in_sin
 }
 
 TEST_F(SubqueryStartExecutorTest, shadow_row_does_not_fit_in_current_block) {
-  auto input = VPackParser::fromJson(R"([
-      ["a"],
-      ["b"],
-      ["c"]
-  ])");
-  SingleRowFetcherHelper<::arangodb::aql::BlockPassthrough::Disable> fetcher(
-      itemBlockManager, input->steal(), false);
   auto infos = MakeBaseInfos(1);
+  auto inputBlock =
+      buildBlock<1>(itemBlockManager,
+                    MatrixBuilder<1>{{{{{R"("a")"}}}, {{{R"("b")"}}}, {{R"("c")"}}}});
+  auto input =
+      AqlItemBlockInputRange{ExecutorState::DONE, inputBlock, 0, inputBlock->size()};
+
+  SharedAqlItemBlockPtr block = itemBlockManager.requestBlock(3, 1);
+  OutputAqlItemRow output{std::move(block), infos.getOutputRegisters(),
+                          infos.registersToKeep(), infos.registersToClear()};
+
   SubqueryStartExecutor testee(fetcher, infos);
 
   NoStats stats{};
-  ExecutionState state{ExecutionState::HASMORE};
+  auto state = ExecutorState::HASMORE;
   {
-    SharedAqlItemBlockPtr block{new AqlItemBlock(itemBlockManager, 3, 1)};
-    OutputAqlItemRow output{std::move(block), infos.getOutputRegisters(),
-                            infos.registersToKeep(), infos.registersToClear()};
-    std::tie(state, stats) = testee.produceRows(output);
-    EXPECT_EQ(state, ExecutionState::HASMORE);
+    std::tie(state, stats, call) = testee.produceRows(input, output);
+
+    EXPECT_EQ(state, ExecutorState::HASMORE);
     EXPECT_FALSE(output.produced());
     EXPECT_EQ(output.numRowsWritten(), 3);
 
@@ -176,11 +192,13 @@ TEST_F(SubqueryStartExecutorTest, shadow_row_does_not_fit_in_current_block) {
     EXPECT_FALSE(block->isShadowRow(2));
   }
   {
-    SharedAqlItemBlockPtr block{new AqlItemBlock(itemBlockManager, 3, 1)};
+    SharedAqlItemBlockPtr block = itemBlockManager.requestBlock(3, 1);
     OutputAqlItemRow output{std::move(block), infos.getOutputRegisters(),
                             infos.registersToKeep(), infos.registersToClear()};
-    std::tie(state, stats) = testee.produceRows(output);
-    EXPECT_EQ(state, ExecutionState::DONE);
+
+    std::tie(state, stats, call) = testee.produceRows(input, output);
+
+    EXPECT_EQ(state, ExecutorState::DONE);
     EXPECT_FALSE(output.produced());
     EXPECT_EQ(output.numRowsWritten(), 3);
 
@@ -190,64 +208,3 @@ TEST_F(SubqueryStartExecutorTest, shadow_row_does_not_fit_in_current_block) {
     TestShadowRow(block, 2, true);
   }
 }
-
-// TODO:
-// This test can be enabled and should work as soon as the Fetcher skips non-relevant Subqueries
-TEST_F(SubqueryStartExecutorTest, does_only_add_shadowrows_on_data_rows) {
-  SharedAqlItemBlockPtr block{new AqlItemBlock(itemBlockManager, 1000, 1)};
-  auto input = VPackParser::fromJson(R"([
-      ["a"],
-      ["b"],
-      ["c"]
-  ])");
-
-  auto infos = MakeBaseInfos(1);
-  {
-    SingleRowFetcherHelper<::arangodb::aql::BlockPassthrough::Disable> fetcher(
-        itemBlockManager, input->steal(), false);
-    SubqueryStartExecutor testee(fetcher, infos);
-
-    NoStats stats{};
-    ExecutionState state{ExecutionState::HASMORE};
-    OutputAqlItemRow output{std::move(block), infos.getOutputRegisters(),
-                            infos.registersToKeep(), infos.registersToClear()};
-    std::tie(state, stats) = testee.produceRows(output);
-    EXPECT_EQ(state, ExecutionState::DONE);
-    EXPECT_FALSE(output.produced());
-    ASSERT_EQ(output.numRowsWritten(), 6);
-    block = output.stealBlock();
-    EXPECT_FALSE(block->isShadowRow(0));
-    TestShadowRow(block, 1, true);
-    EXPECT_FALSE(block->isShadowRow(2));
-    TestShadowRow(block, 3, true);
-    EXPECT_FALSE(block->isShadowRow(4));
-    TestShadowRow(block, 5, true);
-    // Taken from test above. We now have produced a block
-    // having 3 data rows alternating with 3 shadow rows
-  }
-  {
-    SingleRowFetcherHelper<::arangodb::aql::BlockPassthrough::Disable> fetcher(itemBlockManager,
-                                                                               6, false, block);
-    SubqueryStartExecutor testee(fetcher, infos);
-    block.reset(new AqlItemBlock(itemBlockManager, 1000, 1));
-
-    NoStats stats{};
-    ExecutionState state{ExecutionState::HASMORE};
-    OutputAqlItemRow output{std::move(block), infos.getOutputRegisters(),
-                            infos.registersToKeep(), infos.registersToClear()};
-    std::tie(state, stats) = testee.produceRows(output);
-    EXPECT_EQ(state, ExecutionState::DONE);
-    EXPECT_FALSE(output.produced());
-    ASSERT_EQ(output.numRowsWritten(), 9);
-    block = output.stealBlock();
-    EXPECT_FALSE(block->isShadowRow(0));
-    TestShadowRow(block, 1, true);
-    TestShadowRow(block, 2, false);
-    EXPECT_FALSE(block->isShadowRow(3));
-    TestShadowRow(block, 4, true);
-    TestShadowRow(block, 5, false);
-    EXPECT_FALSE(block->isShadowRow(6));
-    TestShadowRow(block, 7, true);
-    TestShadowRow(block, 8, false);
-  }
-}