Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/tests/Aql/TraversalExecutorTest.cpp

624 lines
24 KiB
C++
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2018 ArangoDB GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
/// http://www.apache.org/licenses/LICENSE-2.0
///
/// 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
////////////////////////////////////////////////////////////////////////////////
#include "RowFetcherHelper.h"
#include "catch.hpp"
#include "Aql/AqlItemBlock.h"
#include "Aql/ExecutorInfos.h"
#include "Aql/InputAqlItemRow.h"
#include "Aql/OutputAqlItemRow.h"
#include "Aql/Query.h"
#include "Aql/ResourceUsage.h"
#include "Aql/SingleRowFetcher.h"
#include "Aql/TraversalExecutor.h"
#include "Basics/VelocyPackHelper.h"
#include "Graph/Traverser.h"
#include "Graph/TraverserOptions.h"
#include "tests/Mocks/Servers.h"
#include <velocypack/Buffer.h>
#include <velocypack/Builder.h>
#include <velocypack/Slice.h>
#include <velocypack/velocypack-aliases.h>
using namespace arangodb;
using namespace arangodb::aql;
using namespace arangodb::traverser;
namespace arangodb {
namespace tests {
namespace aql {
class TestGraph {
public:
TestGraph(std::string const& vertexCollection, std::string const& edgeCollection)
: _vertexCollection(vertexCollection), _edgeCollection(edgeCollection) {}
void addVertex(std::string key) {
VPackBuilder vertex;
vertex.openObject();
vertex.add(StaticStrings::IdString, VPackValue(_vertexCollection + "/" + key));
vertex.add(StaticStrings::KeyString, VPackValue(key));
vertex.add(StaticStrings::RevString, VPackValue("123")); // just to have it there
vertex.close();
auto vslice = vertex.slice();
arangodb::velocypack::StringRef id(vslice.get(StaticStrings::IdString));
_dataLake.emplace_back(vertex.steal());
_vertices.emplace(id, vslice);
}
void addEdge(std::string const& from, std::string const& to, std::string const& key) {
VPackBuilder edge;
std::string fromVal = _vertexCollection + "/" + from;
std::string toVal = _vertexCollection + "/" + to;
edge.openObject();
edge.add(StaticStrings::IdString, VPackValue(_edgeCollection + "/" + key));
edge.add(StaticStrings::KeyString, VPackValue(key));
edge.add(StaticStrings::RevString, VPackValue("123")); // just to have it there
edge.add(StaticStrings::FromString, VPackValue(fromVal));
edge.add(StaticStrings::ToString, VPackValue(toVal));
edge.close();
auto eslice = edge.slice();
_outEdges[arangodb::velocypack::StringRef(eslice.get(StaticStrings::FromString))].emplace_back(eslice);
_inEdges[arangodb::velocypack::StringRef(eslice.get(StaticStrings::ToString))].emplace_back(eslice);
_dataLake.emplace_back(edge.steal());
}
VPackSlice getVertexData(arangodb::velocypack::StringRef id) const {
auto const& it = _vertices.find(id);
REQUIRE(it != _vertices.end());
return it->second;
}
std::vector<VPackSlice> const& getInEdges(arangodb::velocypack::StringRef id) const {
auto it = _inEdges.find(id);
if (it == _inEdges.end()) {
return _noEdges;
}
return it->second;
}
std::vector<VPackSlice> const& getOutEdges(arangodb::velocypack::StringRef id) const {
auto it = _outEdges.find(id);
if (it == _outEdges.end()) {
return _noEdges;
}
return it->second;
}
private:
std::string const _vertexCollection;
std::string const _edgeCollection;
std::vector<VPackSlice> _noEdges;
std::vector<std::shared_ptr<VPackBuffer<uint8_t>>> _dataLake;
std::unordered_map<arangodb::velocypack::StringRef, VPackSlice> _vertices;
std::unordered_map<arangodb::velocypack::StringRef, std::vector<VPackSlice>> _outEdges;
std::unordered_map<arangodb::velocypack::StringRef, std::vector<VPackSlice>> _inEdges;
};
// @brief
// A graph enumerator fakes a PathEnumerator that is inderectly used by the
// TraversalExecutor.
// It mostly does a breath first enumeration on the given TestGraph
// instance originating from the given startVertex.
class GraphEnumerator : public PathEnumerator {
public:
GraphEnumerator(Traverser* traverser, std::string const& startVertex,
TraverserOptions* opts, TestGraph const& g)
: PathEnumerator(traverser, startVertex, opts),
_graph(g),
_idx(0),
_depth(0),
_currentDepth{},
_nextDepth{arangodb::velocypack::StringRef(startVertex)} {}
~GraphEnumerator() {}
bool next() override {
++_idx;
while (true) {
if (_idx < _edges.size()) {
_nextDepth.emplace_back(arangodb::velocypack::StringRef(_edges.at(_idx).get(StaticStrings::ToString)));
return true;
} else {
if (_currentDepth.empty()) {
if (_nextDepth.empty() || _depth >= _opts->maxDepth) {
return false;
}
_depth++;
_currentDepth.swap(_nextDepth);
}
_edges = _graph.getOutEdges(_currentDepth.back());
_idx = 0;
_currentDepth.pop_back();
}
}
}
arangodb::aql::AqlValue lastVertexToAqlValue() override {
return AqlValue(_graph.getVertexData(_nextDepth.back()));
}
arangodb::aql::AqlValue lastEdgeToAqlValue() override {
return AqlValue(_edges.at(_idx));
}
arangodb::aql::AqlValue pathToAqlValue(VPackBuilder& builder) override {
return AqlValue(AqlValueHintNull());
}
private:
TestGraph const& _graph;
size_t _idx;
size_t _depth;
std::vector<VPackSlice> _edges;
std::vector<arangodb::velocypack::StringRef> _currentDepth;
std::vector<arangodb::velocypack::StringRef> _nextDepth;
};
class TraverserHelper : public Traverser {
public:
TraverserHelper(TraverserOptions* opts, transaction::Methods* trx, TestGraph const& g)
: Traverser(opts, trx), _graph(g) {}
void setStartVertex(std::string const& value) override {
_usedVertexAt.push_back(value);
_enumerator.reset(new GraphEnumerator(this, _usedVertexAt.back(), _opts, _graph));
_done = false;
}
bool getVertex(VPackSlice edge, std::vector<arangodb::velocypack::StringRef>& result) override {
// Implement
return false;
}
bool getSingleVertex(VPackSlice edge, arangodb::velocypack::StringRef const sourceVertex,
uint64_t depth, arangodb::velocypack::StringRef& targetVertex) override {
// Implement
return false;
}
AqlValue fetchVertexData(arangodb::velocypack::StringRef vid) override {
VPackSlice v = _graph.getVertexData(vid);
return AqlValue(v);
}
void addVertexToVelocyPack(arangodb::velocypack::StringRef vid, VPackBuilder& builder) override {
REQUIRE(builder.isOpenArray());
VPackSlice v = _graph.getVertexData(vid);
builder.add(v);
return;
}
void destroyEngines() override {}
std::string const& startVertexUsedAt(uint64_t index) {
REQUIRE(index < _usedVertexAt.size());
return _usedVertexAt[index];
}
std::string const& currentStartVertex() {
REQUIRE(!_usedVertexAt.empty());
return _usedVertexAt.back();
}
private:
std::vector<std::string> _usedVertexAt;
TestGraph const& _graph;
};
SCENARIO("TraversalExecutor", "[AQL][EXECUTOR][TRAVEXE]") {
ExecutionState state;
mocks::MockAqlServer server{};
std::unique_ptr<arangodb::aql::Query> fakedQuery = server.createFakeQuery();
ResourceMonitor monitor;
AqlItemBlockManager itemBlockManager{&monitor};
SharedAqlItemBlockPtr block{new AqlItemBlock(itemBlockManager, 1000, 2)};
TraverserOptions traversalOptions(fakedQuery.get());
traversalOptions.minDepth = 1;
traversalOptions.maxDepth = 1;
arangodb::transaction::Methods* trx = fakedQuery->trx();
std::vector<std::pair<Variable const*, RegisterId>> filterConditionVariables{};
TestGraph myGraph("v", "e");
auto traverserPtr = std::make_unique<TraverserHelper>(&traversalOptions, trx, myGraph);
GIVEN("using input as start vertex") {
RegisterId inReg = 0;
RegisterId outReg = 1;
auto traverser = traverserPtr.get();
auto inputRegisters = std::make_shared<std::unordered_set<RegisterId>>(
std::initializer_list<RegisterId>{inReg});
auto outputRegisters = std::make_shared<std::unordered_set<RegisterId>>(
std::initializer_list<RegisterId>{outReg});
std::unordered_map<TraversalExecutorInfos::OutputName, RegisterId, TraversalExecutorInfos::OutputNameHash> registerMapping{
{TraversalExecutorInfos::OutputName::VERTEX, outReg}};
std::string const noFixed = "";
TraversalExecutorInfos infos(inputRegisters, outputRegisters, 1, 2, {}, {0},
std::move(traverserPtr), registerMapping,
noFixed, inReg, filterConditionVariables);
GIVEN("there are no rows upstream") {
VPackBuilder input;
WHEN("the producer does not wait") {
SingleRowFetcherHelper<false> fetcher(input.steal(), false);
TraversalExecutor testee(fetcher, infos);
TraversalStats stats{};
THEN("the executor should return DONE and no result") {
OutputAqlItemRow result(std::move(block), infos.getOutputRegisters(),
infos.registersToKeep(), infos.registersToClear());
std::tie(state, stats) = testee.produceRows(result);
REQUIRE(state == ExecutionState::DONE);
REQUIRE(!result.produced());
}
}
WHEN("the producer waits") {
SingleRowFetcherHelper<false> fetcher(input.steal(), true);
TraversalExecutor testee(fetcher, infos);
TraversalStats stats{};
THEN("the executor should first return WAIT and no result") {
OutputAqlItemRow result(std::move(block), infos.getOutputRegisters(),
infos.registersToKeep(), infos.registersToClear());
std::tie(state, stats) = testee.produceRows(result);
REQUIRE(state == ExecutionState::WAITING);
REQUIRE(!result.produced());
REQUIRE(stats.getFiltered() == 0);
AND_THEN("the executor should return DONE and no result") {
std::tie(state, stats) = testee.produceRows(result);
REQUIRE(state == ExecutionState::DONE);
REQUIRE(!result.produced());
REQUIRE(stats.getFiltered() == 0);
}
}
}
}
GIVEN("there are rows in the upstream") {
myGraph.addVertex("1");
myGraph.addVertex("2");
myGraph.addVertex("3");
auto input = VPackParser::fromJson(R"([["v/1"], ["v/2"], ["v/3"]])");
WHEN("the producer does not wait") {
SingleRowFetcherHelper<false> fetcher(input->steal(), false);
TraversalExecutor testee(fetcher, infos);
TraversalStats stats{};
WHEN("no edges are connected to vertices") {
THEN("the executor should fetch all rows, but not return") {
OutputAqlItemRow row(std::move(block), infos.getOutputRegisters(),
infos.registersToKeep(), infos.registersToClear());
std::tie(state, stats) = testee.produceRows(row);
REQUIRE(state == ExecutionState::DONE);
REQUIRE(stats.getFiltered() == 0);
REQUIRE(!row.produced());
REQUIRE(fetcher.isDone());
REQUIRE(fetcher.nrCalled() == 3);
REQUIRE(traverser->startVertexUsedAt(0) == "v/1");
REQUIRE(traverser->startVertexUsedAt(1) == "v/2");
REQUIRE(traverser->startVertexUsedAt(2) == "v/3");
AND_THEN("The output should stay stable") {
std::tie(state, stats) = testee.produceRows(row);
REQUIRE(state == ExecutionState::DONE);
REQUIRE(stats.getFiltered() == 0);
REQUIRE(!row.produced());
REQUIRE(fetcher.isDone());
REQUIRE(fetcher.nrCalled() == 3);
}
}
}
}
WHEN("the producer waits") {
SingleRowFetcherHelper<false> fetcher(input->steal(), true);
TraversalExecutor testee(fetcher, infos);
TraversalStats stats{};
WHEN("no edges are connected to vertices") {
THEN("the executor should fetch all rows, but not return") {
OutputAqlItemRow row(std::move(block), infos.getOutputRegisters(),
infos.registersToKeep(), infos.registersToClear());
for (size_t i = 0; i < 3; ++i) {
// We expect to wait 3 times
std::tie(state, stats) = testee.produceRows(row);
REQUIRE(state == ExecutionState::WAITING);
}
std::tie(state, stats) = testee.produceRows(row);
REQUIRE(state == ExecutionState::DONE);
REQUIRE(stats.getFiltered() == 0);
REQUIRE(!row.produced());
REQUIRE(fetcher.isDone());
REQUIRE(fetcher.nrCalled() == 3);
REQUIRE(traverser->startVertexUsedAt(0) == "v/1");
REQUIRE(traverser->startVertexUsedAt(1) == "v/2");
REQUIRE(traverser->startVertexUsedAt(2) == "v/3");
AND_THEN("The output should stay stable") {
std::tie(state, stats) = testee.produceRows(row);
REQUIRE(state == ExecutionState::DONE);
REQUIRE(stats.getFiltered() == 0);
REQUIRE(!row.produced());
REQUIRE(fetcher.isDone());
// WAITING is not part of called counts
REQUIRE(fetcher.nrCalled() == 3);
}
}
}
WHEN("edges are connected to vertices") {
myGraph.addEdge("1", "2", "1->2");
myGraph.addEdge("2", "3", "2->3");
myGraph.addEdge("3", "1", "3->1");
ExecutionStats total;
THEN("the executor should fetch all rows") {
OutputAqlItemRow row(std::move(block), infos.getOutputRegisters(),
infos.registersToKeep(), infos.registersToClear());
for (int64_t i = 0; i < 3; ++i) {
// We expect to wait 3 times
std::tie(state, stats) = testee.produceRows(row);
total += stats;
REQUIRE(state == ExecutionState::WAITING);
REQUIRE(!row.produced());
std::tie(state, stats) = testee.produceRows(row);
REQUIRE(row.produced());
REQUIRE(state == ExecutionState::HASMORE);
row.advanceRow();
total += stats;
REQUIRE(total.filtered == 0);
/* We cannot ASSERT this because of internally to complex
mechanism */
// REQUIRE(total.scannedIndex == i + 1);
REQUIRE(fetcher.nrCalled() == (uint64_t)(i + 1));
}
REQUIRE(fetcher.isDone());
// The traverser will lie
std::tie(state, stats) = testee.produceRows(row);
REQUIRE(state == ExecutionState::DONE);
REQUIRE(!row.produced());
REQUIRE(traverser->startVertexUsedAt(0) == "v/1");
REQUIRE(traverser->startVertexUsedAt(1) == "v/2");
REQUIRE(traverser->startVertexUsedAt(2) == "v/3");
std::vector<std::string> expectedResult{"v/2", "v/3", "v/1"};
auto block = row.stealBlock();
for (std::size_t index = 0; index < 3; index++) {
AqlValue value = block->getValue(index, outReg);
REQUIRE(value.isObject());
REQUIRE(arangodb::basics::VelocyPackHelper::compare(
value.slice(),
myGraph.getVertexData(arangodb::velocypack::StringRef(expectedResult.at(index))),
false) == 0);
}
}
}
}
}
}
GIVEN("using constant as start vertex") {
RegisterId outReg = 1;
auto traverser = traverserPtr.get();
auto inputRegisters = std::make_shared<std::unordered_set<RegisterId>>(
std::initializer_list<RegisterId>{});
auto outputRegisters = std::make_shared<std::unordered_set<RegisterId>>(
std::initializer_list<RegisterId>{1});
std::unordered_map<TraversalExecutorInfos::OutputName, RegisterId, TraversalExecutorInfos::OutputNameHash> registerMapping{
{TraversalExecutorInfos::OutputName::VERTEX, outReg}};
std::string const fixed = "v/1";
TraversalExecutorInfos infos(inputRegisters, outputRegisters, 1, 2, {}, {0},
std::move(traverserPtr), registerMapping, fixed,
ExecutionNode::MaxRegisterId, filterConditionVariables);
GIVEN("there are no rows upstream") {
VPackBuilder input;
WHEN("the producer does not wait") {
SingleRowFetcherHelper<false> fetcher(input.steal(), false);
TraversalExecutor testee(fetcher, infos);
TraversalStats stats{};
THEN("the executor should return DONE and no result") {
OutputAqlItemRow result(std::move(block), infos.getOutputRegisters(),
infos.registersToKeep(), infos.registersToClear());
std::tie(state, stats) = testee.produceRows(result);
REQUIRE(state == ExecutionState::DONE);
REQUIRE(!result.produced());
}
}
WHEN("the producer waits") {
SingleRowFetcherHelper<false> fetcher(input.steal(), true);
TraversalExecutor testee(fetcher, infos);
TraversalStats stats{};
THEN("the executor should first return WAIT and no result") {
OutputAqlItemRow result(std::move(block), infos.getOutputRegisters(),
infos.registersToKeep(), infos.registersToClear());
std::tie(state, stats) = testee.produceRows(result);
REQUIRE(state == ExecutionState::WAITING);
REQUIRE(!result.produced());
REQUIRE(stats.getFiltered() == 0);
AND_THEN("the executor should return DONE and no result") {
std::tie(state, stats) = testee.produceRows(result);
REQUIRE(state == ExecutionState::DONE);
REQUIRE(!result.produced());
REQUIRE(stats.getFiltered() == 0);
}
}
}
}
GIVEN("there are rows in the upstream") {
myGraph.addVertex("1");
myGraph.addVertex("2");
myGraph.addVertex("3");
auto input = VPackParser::fromJson(R"([ ["v/1"], ["v/2"], ["v/3"] ])");
WHEN("the producer does not wait") {
SingleRowFetcherHelper<false> fetcher(input->steal(), false);
TraversalExecutor testee(fetcher, infos);
TraversalStats stats{};
WHEN("no edges are connected to vertices") {
THEN("the executor should fetch all rows, but not return") {
OutputAqlItemRow row(std::move(block), infos.getOutputRegisters(),
infos.registersToKeep(), infos.registersToClear());
std::tie(state, stats) = testee.produceRows(row);
REQUIRE(state == ExecutionState::DONE);
REQUIRE(stats.getFiltered() == 0);
REQUIRE(!row.produced());
REQUIRE(fetcher.isDone());
REQUIRE(fetcher.nrCalled() == 3);
REQUIRE(traverser->startVertexUsedAt(0) == "v/1");
REQUIRE(traverser->startVertexUsedAt(1) == "v/1");
REQUIRE(traverser->startVertexUsedAt(2) == "v/1");
AND_THEN("The output should stay stable") {
std::tie(state, stats) = testee.produceRows(row);
REQUIRE(state == ExecutionState::DONE);
REQUIRE(stats.getFiltered() == 0);
REQUIRE(!row.produced());
REQUIRE(fetcher.isDone());
REQUIRE(fetcher.nrCalled() == 3);
}
}
}
}
WHEN("the producer waits") {
SingleRowFetcherHelper<false> fetcher(input->steal(), true);
TraversalExecutor testee(fetcher, infos);
TraversalStats stats{};
WHEN("no edges are connected to vertices") {
THEN("the executor should fetch all rows, but not return") {
OutputAqlItemRow row(std::move(block), infos.getOutputRegisters(),
infos.registersToKeep(), infos.registersToClear());
for (size_t i = 0; i < 3; ++i) {
// We expect to wait 3 times
std::tie(state, stats) = testee.produceRows(row);
REQUIRE(state == ExecutionState::WAITING);
}
std::tie(state, stats) = testee.produceRows(row);
REQUIRE(state == ExecutionState::DONE);
REQUIRE(stats.getFiltered() == 0);
REQUIRE(!row.produced());
REQUIRE(fetcher.isDone());
REQUIRE(fetcher.nrCalled() == 3);
REQUIRE(traverser->startVertexUsedAt(0) == "v/1");
REQUIRE(traverser->startVertexUsedAt(1) == "v/1");
REQUIRE(traverser->startVertexUsedAt(2) == "v/1");
AND_THEN("The output should stay stable") {
std::tie(state, stats) = testee.produceRows(row);
REQUIRE(state == ExecutionState::DONE);
REQUIRE(stats.getFiltered() == 0);
REQUIRE(!row.produced());
REQUIRE(fetcher.isDone());
// WAITING is not part of called counts
REQUIRE(fetcher.nrCalled() == 3);
}
}
}
WHEN("edges are connected to vertices") {
myGraph.addEdge("1", "2", "1->2");
myGraph.addEdge("2", "3", "2->3");
myGraph.addEdge("3", "1", "3->1");
ExecutionStats total;
THEN("the executor should fetch all rows, but not return") {
OutputAqlItemRow row(std::move(block), infos.getOutputRegisters(),
infos.registersToKeep(), infos.registersToClear());
for (int64_t i = 0; i < 3; ++i) {
// We expect to wait 3 times
std::tie(state, stats) = testee.produceRows(row);
total += stats;
REQUIRE(state == ExecutionState::WAITING);
REQUIRE(!row.produced());
std::tie(state, stats) = testee.produceRows(row);
REQUIRE(row.produced());
REQUIRE(state == ExecutionState::HASMORE);
row.advanceRow();
total += stats;
REQUIRE(total.filtered == 0);
/* We cannot ASSERT this because of internally to complex
mechanism */
// REQUIRE(total.scannedIndex == i + 1);
REQUIRE(fetcher.nrCalled() == (uint64_t)(i + 1));
}
REQUIRE(fetcher.isDone());
// The traverser will lie
std::tie(state, stats) = testee.produceRows(row);
REQUIRE(state == ExecutionState::DONE);
REQUIRE(!row.produced());
REQUIRE(traverser->startVertexUsedAt(0) == "v/1");
REQUIRE(traverser->startVertexUsedAt(1) == "v/1");
REQUIRE(traverser->startVertexUsedAt(2) == "v/1");
std::vector<std::string> expectedResult{"v/2", "v/2", "v/2"};
auto block = row.stealBlock();
for (std::size_t index = 0; index < 3; index++) {
AqlValue value = block->getValue(index, outReg);
REQUIRE(value.isObject());
REQUIRE(arangodb::basics::VelocyPackHelper::compare(
value.slice(),
myGraph.getVertexData(arangodb::velocypack::StringRef(expectedResult.at(index))),
false) == 0);
}
}
}
}
}
}
}
} // namespace aql
} // namespace tests
} // namespace arangodb
Reference in New Issue View Git Blame Copy Permalink