tursom/memgraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Change CollectProduce to immediately return results

Browse Source 
Reviewers: florijan, mislav.bradac

Reviewed By: florijan, mislav.bradac

Subscribers: pullbot

Differential Revision: https://phabricator.memgraph.io/D406
This commit is contained in:
Teon Banek 2017-05-30 15:19:38 +02:00
parent a5e2ccb94f
commit ffcc8b8d12
6 changed files with 56 additions and 56 deletions

2
tests/unit/query_common.hpp
View File

@ -18,6 +18,8 @@
/// convenient to use the macros.
///
#pragma once
#include <utility>
#include <vector>

20
tests/unit/query_plan_accumulate_aggregate.cpp
View File

@ -71,9 +71,9 @@ TEST(QueryPlan, Accumulate) {
auto m_p_ne = NEXPR("m.p", m_p);
symbol_table[*m_p_ne] = symbol_table.CreateSymbol("m_p_ne", true);
auto produce = MakeProduce(last_op, n_p_ne, m_p_ne);
ResultStreamFaker results = CollectProduce(produce, symbol_table, *dba);
auto results = CollectProduce(produce.get(), symbol_table, *dba);
std::vector<int> results_data;
for (const auto &row : results.GetResults())
for (const auto &row : results)
for (const auto &column : row)
results_data.emplace_back(column.Value<int64_t>());
if (accumulate)
@ -187,7 +187,7 @@ class QueryPlanAggregateOps : public ::testing::Test {
auto produce =
MakeAggregationProduce(n.op_, symbol_table, storage,
aggregation_expressions, ops, group_bys, {});
return CollectProduce(produce, symbol_table, *dba).GetResults();
return CollectProduce(produce.get(), symbol_table, *dba);
}
};
@ -319,7 +319,7 @@ TEST(QueryPlan, AggregateGroupByValues) {
MakeAggregationProduce(n.op_, symbol_table, storage, {n_p},
{Aggregation::Op::COUNT}, {n_p}, {n.sym_});
auto results = CollectProduce(produce, symbol_table, *dba).GetResults();
auto results = CollectProduce(produce.get(), symbol_table, *dba);
ASSERT_EQ(results.size(), group_by_vals.size() - 2);
TypedValue::unordered_set result_group_bys;
for (const auto &row : results) {
@ -366,7 +366,7 @@ TEST(QueryPlan, AggregateMultipleGroupBy) {
{Aggregation::Op::COUNT},
{n_p1, n_p2, n_p3}, {n.sym_});
auto results = CollectProduce(produce, symbol_table, *dba).GetResults();
auto results = CollectProduce(produce.get(), symbol_table, *dba);
EXPECT_EQ(results.size(), 2 * 3 * 5);
}
@ -382,7 +382,7 @@ TEST(QueryPlan, AggregateNoInput) {
auto produce = MakeAggregationProduce(nullptr, symbol_table, storage, {two},
{Aggregation::Op::COUNT}, {}, {});
auto results = CollectProduce(produce, symbol_table, *dba).GetResults();
auto results = CollectProduce(produce.get(), symbol_table, *dba);
EXPECT_EQ(1, results.size());
EXPECT_EQ(1, results[0].size());
EXPECT_EQ(TypedValue::Type::Int, results[0][0].type());
@ -414,7 +414,7 @@ TEST(QueryPlan, AggregateCountEdgeCases) {
auto count = [&]() {
auto produce = MakeAggregationProduce(n.op_, symbol_table, storage, {n_p},
{Aggregation::Op::COUNT}, {}, {});
auto results = CollectProduce(produce, symbol_table, *dba).GetResults();
auto results = CollectProduce(produce.get(), symbol_table, *dba);
if (results.size() == 0) return -1L;
EXPECT_EQ(1, results.size());
EXPECT_EQ(1, results[0].size());
@ -473,7 +473,7 @@ TEST(QueryPlan, AggregateFirstValueTypes) {
auto aggregate = [&](Expression *expression, Aggregation::Op aggr_op) {
auto produce = MakeAggregationProduce(n.op_, symbol_table, storage,
{expression}, {aggr_op}, {}, {});
CollectProduce(produce, symbol_table, *dba).GetResults();
CollectProduce(produce.get(), symbol_table, *dba);
};
// everything except for COUNT fails on a Vertex
@ -528,7 +528,7 @@ TEST(QueryPlan, AggregateTypes) {
auto aggregate = [&](Expression *expression, Aggregation::Op aggr_op) {
auto produce = MakeAggregationProduce(n.op_, symbol_table, storage,
{expression}, {aggr_op}, {}, {});
CollectProduce(produce, symbol_table, *dba).GetResults();
CollectProduce(produce.get(), symbol_table, *dba);
};
// everything except for COUNT fails on a Vertex
@ -579,7 +579,7 @@ TEST(QueryPlan, Unwind) {
symbol_table[*y_ne] = symbol_table.CreateSymbol("y_ne", true);
auto produce = MakeProduce(unwind_1, x_ne, y_ne);
auto results = CollectProduce(produce, symbol_table, *dba).GetResults();
auto results = CollectProduce(produce.get(), symbol_table, *dba);
ASSERT_EQ(4, results.size());
const std::vector<int> expected_x_card{3, 3, 3, 1};
auto expected_x_card_it = expected_x_card.begin();

4
tests/unit/query_plan_bag_semantics.cpp
View File

@ -159,7 +159,7 @@ TEST(QueryPlan, OrderBy) {
auto n_p_ne = NEXPR("n.p", n_p);
symbol_table[*n_p_ne] = symbol_table.CreateSymbol("n.p", true);
auto produce = MakeProduce(order_by, n_p_ne);
auto results = CollectProduce(produce, symbol_table, *dba).GetResults();
auto results = CollectProduce(produce.get(), symbol_table, *dba);
ASSERT_EQ(values.size(), results.size());
for (int j = 0; j < results.size(); ++j)
EXPECT_TRUE(TypedValue::BoolEqual{}(results[j][0], values[j]));
@ -212,7 +212,7 @@ TEST(QueryPlan, OrderByMultiple) {
auto n_p2_ne = NEXPR("n.p2", n_p2);
symbol_table[*n_p2_ne] = symbol_table.CreateSymbol("n.p2", true);
auto produce = MakeProduce(order_by, n_p1_ne, n_p2_ne);
auto results = CollectProduce(produce, symbol_table, *dba).GetResults();
auto results = CollectProduce(produce.get(), symbol_table, *dba);
ASSERT_EQ(N * N, results.size());
for (int j = 0; j < N * N; ++j) {
ASSERT_EQ(results[j][0].type(), TypedValue::Type::Int);

10
tests/unit/query_plan_common.hpp
View File

@ -3,6 +3,8 @@
// Created by Florijan Stamenkovic on 14.03.17.
//
#pragma once
#include <iterator>
#include <memory>
#include <vector>
@ -20,15 +22,15 @@ using namespace query::plan;
/**
* Helper function that collects all the results from the given
* Produce into a ResultStreamFaker and returns that object.
* Produce into a ResultStreamFaker and returns the results from it.
*
* @param produce
* @param symbol_table
* @param db_accessor
* @return
*/
auto CollectProduce(std::shared_ptr<Produce> produce, SymbolTable &symbol_table,
GraphDbAccessor &db_accessor) {
std::vector<std::vector<TypedValue>> CollectProduce(
Produce *produce, SymbolTable &symbol_table, GraphDbAccessor &db_accessor) {
ResultStreamFaker stream;
Frame frame(symbol_table.max_position());
@ -56,7 +58,7 @@ auto CollectProduce(std::shared_ptr<Produce> produce, SymbolTable &symbol_table,
stream.Summary({{std::string("type"), TypedValue("r")}});
return stream;
return stream.GetResults();
}
int PullAll(std::shared_ptr<LogicalOperator> logical_op, GraphDbAccessor &db,

22
tests/unit/query_plan_create_set_remove_delete.cpp
View File

@ -84,16 +84,14 @@ TEST(QueryPlan, CreateReturn) {
symbol_table[*named_expr_n->expression_] = sym_n;
auto produce = MakeProduce(create, named_expr_n, named_expr_n_p);
auto result = CollectProduce(produce, symbol_table, *dba);
EXPECT_EQ(1, result.GetResults().size());
EXPECT_EQ(2, result.GetResults()[0].size());
EXPECT_EQ(TypedValue::Type::Vertex, result.GetResults()[0][0].type());
EXPECT_EQ(1,
result.GetResults()[0][0].Value<VertexAccessor>().labels().size());
EXPECT_EQ(label,
result.GetResults()[0][0].Value<VertexAccessor>().labels()[0]);
EXPECT_EQ(TypedValue::Type::Int, result.GetResults()[0][1].type());
EXPECT_EQ(42, result.GetResults()[0][1].Value<int64_t>());
auto results = CollectProduce(produce.get(), symbol_table, *dba);
EXPECT_EQ(1, results.size());
EXPECT_EQ(2, results[0].size());
EXPECT_EQ(TypedValue::Type::Vertex, results[0][0].type());
EXPECT_EQ(1, results[0][0].Value<VertexAccessor>().labels().size());
EXPECT_EQ(label, results[0][0].Value<VertexAccessor>().labels()[0]);
EXPECT_EQ(TypedValue::Type::Int, results[0][1].type());
EXPECT_EQ(42, results[0][1].Value<int64_t>());
dba->advance_command();
EXPECT_EQ(1, CountIterable(dba->vertices()));
@ -407,8 +405,8 @@ TEST(QueryPlan, DeleteReturn) {
symbol_table[*n_p] = symbol_table.CreateSymbol("bla", true);
auto produce = MakeProduce(delete_op, n_p);
auto result = CollectProduce(produce, symbol_table, *dba);
EXPECT_EQ(4, result.GetResults().size());
auto results = CollectProduce(produce.get(), symbol_table, *dba);
EXPECT_EQ(4, results.size());
dba->advance_command();
EXPECT_EQ(0, CountIterable(dba->vertices()));
}

54
tests/unit/query_plan_match_filter_return.cpp
View File

@ -76,15 +76,14 @@ TEST(QueryPlan, MatchReturnCartesian) {
symbol_table.CreateSymbol("named_expression_2", true);
auto produce = MakeProduce(m.op_, return_n, return_m);
ResultStreamFaker result = CollectProduce(produce, symbol_table, *dba);
auto result_data = result.GetResults();
EXPECT_EQ(result_data.size(), 4);
auto results = CollectProduce(produce.get(), symbol_table, *dba);
EXPECT_EQ(results.size(), 4);
// ensure the result ordering is OK:
// "n" from the results is the same for the first two rows, while "m" isn't
EXPECT_EQ(result_data[0][0].Value<VertexAccessor>(),
result_data[1][0].Value<VertexAccessor>());
EXPECT_NE(result_data[0][1].Value<VertexAccessor>(),
result_data[1][1].Value<VertexAccessor>());
EXPECT_EQ(results[0][0].Value<VertexAccessor>(),
results[1][0].Value<VertexAccessor>());
EXPECT_NE(results[0][1].Value<VertexAccessor>(),
results[1][1].Value<VertexAccessor>());
}
TEST(QueryPlan, StandaloneReturn) {
@ -103,10 +102,10 @@ TEST(QueryPlan, StandaloneReturn) {
auto produce = MakeProduce(std::shared_ptr<LogicalOperator>(nullptr), output);
symbol_table[*output] = symbol_table.CreateSymbol("named_expression_1", true);
ResultStreamFaker result = CollectProduce(produce, symbol_table, *dba);
EXPECT_EQ(result.GetResults().size(), 1);
EXPECT_EQ(result.GetResults()[0].size(), 1);
EXPECT_EQ(result.GetResults()[0][0].Value<int64_t>(), 42);
auto results = CollectProduce(produce.get(), symbol_table, *dba);
EXPECT_EQ(results.size(), 1);
EXPECT_EQ(results[0].size(), 1);
EXPECT_EQ(results[0][0].Value<int64_t>(), 42);
}
TEST(QueryPlan, NodeFilterLabelsAndProperties) {
@ -211,8 +210,8 @@ TEST(QueryPlan, NodeFilterMultipleLabels) {
symbol_table[*output] = symbol_table.CreateSymbol("named_expression_1", true);
symbol_table[*output->expression_] = n.sym_;
ResultStreamFaker result = CollectProduce(produce, symbol_table, *dba);
EXPECT_EQ(result.GetResults().size(), 2);
auto results = CollectProduce(produce.get(), symbol_table, *dba);
EXPECT_EQ(results.size(), 2);
}
TEST(QueryPlan, Expand) {
@ -310,7 +309,7 @@ TEST(QueryPlan, ExpandOptional) {
symbol_table[*m_ne] = symbol_table.CreateSymbol("m", true);
auto produce = MakeProduce(optional, n_ne, r_ne, m_ne);
auto results = CollectProduce(produce, symbol_table, *dba).GetResults();
auto results = CollectProduce(produce.get(), symbol_table, *dba);
ASSERT_EQ(4, results.size());
int v1_is_n_count = 0;
for (auto &row : results) {
@ -347,7 +346,7 @@ TEST(QueryPlan, OptionalMatchEmptyDB) {
std::vector<Symbol>{n.sym_});
auto produce = MakeProduce(optional, n_ne);
auto results = CollectProduce(produce, symbol_table, *dba).GetResults();
auto results = CollectProduce(produce.get(), symbol_table, *dba);
ASSERT_EQ(1, results.size());
EXPECT_EQ(results[0][0].type(), TypedValue::Type::Null);
}
@ -375,7 +374,7 @@ TEST(QueryPlan, OptionalMatchEmptyDBExpandFromNode) {
symbol_table[*m_ne->expression_] = r_m.node_sym_;
symbol_table[*m_ne] = symbol_table.CreateSymbol("m", true);
auto produce = MakeProduce(r_m.op_, m_ne);
auto results = CollectProduce(produce, symbol_table, *dba).GetResults();
auto results = CollectProduce(produce.get(), symbol_table, *dba);
EXPECT_EQ(0, results.size());
}
@ -422,7 +421,7 @@ TEST(QueryPlan, OptionalMatchThenExpandToMissingNode) {
symbol_table[*m_ne->expression_] = m.sym_;
symbol_table[*m_ne] = symbol_table.CreateSymbol("m", true);
auto produce = MakeProduce(expand, m_ne);
auto results = CollectProduce(produce, symbol_table, *dba).GetResults();
auto results = CollectProduce(produce.get(), symbol_table, *dba);
EXPECT_EQ(0, results.size());
}
@ -472,7 +471,7 @@ TEST(QueryPlan, OptionalMatchThenExpandToMissingEdge) {
symbol_table[*a_ne->expression_] = a.sym_;
symbol_table[*a_ne] = symbol_table.CreateSymbol("a", true);
auto produce = MakeProduce(expand, a_ne);
auto results = CollectProduce(produce, symbol_table, *dba).GetResults();
auto results = CollectProduce(produce.get(), symbol_table, *dba);
EXPECT_EQ(0, results.size());
}
@ -508,8 +507,8 @@ TEST(QueryPlan, ExpandExistingNode) {
symbol_table.CreateSymbol("named_expression_1", true);
auto produce = MakeProduce(r_n.op_, output);
ResultStreamFaker result = CollectProduce(produce, symbol_table, *dba);
EXPECT_EQ(result.GetResults().size(), expected_result_count);
auto results = CollectProduce(produce.get(), symbol_table, *dba);
EXPECT_EQ(results.size(), expected_result_count);
};
test_existing(true, 1);
@ -553,8 +552,8 @@ TEST(QueryPlan, ExpandExistingEdge) {
symbol_table.CreateSymbol("named_expression_1", true);
auto produce = MakeProduce(r_k.op_, output);
ResultStreamFaker result = CollectProduce(produce, symbol_table, *dba);
EXPECT_EQ(result.GetResults().size(), expected_result_count);
auto results = CollectProduce(produce.get(), symbol_table, *dba);
EXPECT_EQ(results.size(), expected_result_count);
};
@ -686,8 +685,8 @@ TEST(QueryPlan, EdgeFilterMultipleTypes) {
symbol_table[*output] = symbol_table.CreateSymbol("named_expression_1", true);
symbol_table[*output->expression_] = r_m.node_sym_;
ResultStreamFaker result = CollectProduce(produce, symbol_table, *dba);
EXPECT_EQ(result.GetResults().size(), 2);
auto results = CollectProduce(produce.get(), symbol_table, *dba);
EXPECT_EQ(results.size(), 2);
}
TEST(QueryPlan, Filter) {
@ -716,7 +715,7 @@ TEST(QueryPlan, Filter) {
symbol_table[*output] = symbol_table.CreateSymbol("named_expression_1", true);
auto produce = MakeProduce(f, output);
EXPECT_EQ(CollectProduce(produce, symbol_table, *dba).GetResults().size(), 2);
EXPECT_EQ(CollectProduce(produce.get(), symbol_table, *dba).size(), 2);
}
TEST(QueryPlan, ExpandUniquenessFilter) {
@ -789,7 +788,7 @@ TEST(QueryPlan, Distinct) {
symbol_table[*x_ne] = symbol_table.CreateSymbol("x_ne", true);
auto produce = MakeProduce(distinct, x_ne);
auto results = CollectProduce(produce, symbol_table, *dba).GetResults();
auto results = CollectProduce(produce.get(), symbol_table, *dba);
ASSERT_EQ(output.size(), results.size());
auto output_it = output.begin();
for (const auto &row : results) {
@ -828,8 +827,7 @@ TEST(QueryPlan, ScanAllByLabel) {
auto produce = MakeProduce(scan_all_by_label.op_, output);
symbol_table[*output->expression_] = scan_all_by_label.sym_;
symbol_table[*output] = symbol_table.CreateSymbol("n", true);
auto result_stream = CollectProduce(produce, symbol_table, *dba);
auto results = result_stream.GetResults();
auto results = CollectProduce(produce.get(), symbol_table, *dba);
ASSERT_EQ(results.size(), 1);
auto result_row = results[0];
ASSERT_EQ(result_row.size(), 1);