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

Move common members of Return and With to ReturnBody

Browse Source 
Reviewers: florijan, mislav.bradac

Reviewed By: florijan

Subscribers: pullbot

Differential Revision: https://phabricator.memgraph.io/D303
This commit is contained in:
Teon Banek 2017-04-20 13:16:14 +02:00
parent 2b6baeae93
commit 4ec363c272
7 changed files with 90 additions and 69 deletions

47
src/query/frontend/ast/ast.hpp
View File

@ -648,6 +648,25 @@ class Match : public Clause {
Match(int uid) : Clause(uid) {}
};
/** @brief Defines the order for sorting values (ascending or descending). */
enum class Ordering { ASC, DESC };
/**
* @brief Contents common to @c Return and @c With clauses.
*/
struct ReturnBody {
/** @brief True if distinct results should be produced. */
bool distinct = false;
/** @brief Expressions which are used to produce results. */
std::vector<NamedExpression *> named_expressions;
/** @brief Expressions used for ordering the results. */
std::vector<std::pair<Ordering, Expression *>> order_by;
/** @brief Optional expression on how many results to skip. */
Expression *skip = nullptr;
/** @brief Optional expression on how much to limit the results. */
Expression *limit = nullptr;
};
class Return : public Clause {
friend class AstTreeStorage;
@ -655,17 +674,19 @@ class Return : public Clause {
void Accept(TreeVisitorBase &visitor) override {
if (visitor.PreVisit(*this)) {
visitor.Visit(*this);
for (auto &expr : named_expressions_) {
for (auto &expr : body_.named_expressions) {
expr->Accept(visitor);
}
if (skip_) skip_->Accept(visitor);
if (limit_) limit_->Accept(visitor);
for (auto &order_by : body_.order_by) {
order_by.second->Accept(visitor);
}
if (body_.skip) body_.skip->Accept(visitor);
if (body_.limit) body_.limit->Accept(visitor);
visitor.PostVisit(*this);
}
}
std::vector<NamedExpression *> named_expressions_;
Expression *skip_ = nullptr;
Expression *limit_ = nullptr;
ReturnBody body_;
protected:
Return(int uid) : Clause(uid) {}
@ -678,21 +699,21 @@ class With : public Clause {
void Accept(TreeVisitorBase &visitor) override {
if (visitor.PreVisit(*this)) {
visitor.Visit(*this);
for (auto &expr : named_expressions_) {
for (auto &expr : body_.named_expressions) {
expr->Accept(visitor);
}
for (auto &order_by : body_.order_by) {
order_by.second->Accept(visitor);
}
if (where_) where_->Accept(visitor);
if (skip_) skip_->Accept(visitor);
if (limit_) limit_->Accept(visitor);
if (body_.skip) body_.skip->Accept(visitor);
if (body_.limit) body_.limit->Accept(visitor);
visitor.PostVisit(*this);
}
}
bool distinct_ = false;
std::vector<NamedExpression *> named_expressions_;
ReturnBody body_;
Where *where_ = nullptr;
Expression *skip_ = nullptr;
Expression *limit_ = nullptr;
protected:
With(int uid) : Clause(uid) {}

4
src/query/frontend/ast/cypher_main_visitor.cpp
View File

@ -149,7 +149,7 @@ antlrcpp::Any CypherMainVisitor::visitCypherReturn(
// TODO: implement other clauses.
throw NotYetImplemented();
}
return_clause->named_expressions_ =
return_clause->body_.named_expressions =
ctx->returnBody()->accept(this).as<std::vector<NamedExpression *>>();
return return_clause;
}
@ -910,7 +910,7 @@ antlrcpp::Any CypherMainVisitor::visitWith(CypherParser::WithContext *ctx) {
// TODO: implement this
throw NotYetImplemented();
}
with->named_expressions_ =
with->body_.named_expressions =
ctx->returnBody()->accept(this).as<std::vector<NamedExpression *>>();
if (ctx->where()) {
with->where_ = ctx->where()->accept(this);

6
src/query/frontend/semantic/symbol_generator.cpp
View File

@ -53,13 +53,13 @@ void SymbolGenerator::Visit(Return &ret) { scope_.in_return = true; }
void SymbolGenerator::PostVisit(Return &ret) {
// Named expressions establish bindings for expressions which come after
// return, but not for the expressions contained inside.
BindNamedExpressionSymbols(ret.named_expressions_);
BindNamedExpressionSymbols(ret.body_.named_expressions);
scope_.in_return = false;
}
bool SymbolGenerator::PreVisit(With &with) {
scope_.in_with = true;
for (auto &expr : with.named_expressions_) {
for (auto &expr : with.body_.named_expressions) {
expr->Accept(*this);
}
scope_.in_with = false;
@ -67,7 +67,7 @@ bool SymbolGenerator::PreVisit(With &with) {
// only those established through named expressions. New declarations must not
// be visible inside named expressions themselves.
scope_.symbols.clear();
BindNamedExpressionSymbols(with.named_expressions_);
BindNamedExpressionSymbols(with.body_.named_expressions);
if (with.where_) with.where_->Accept(*this);
return false; // We handled the traversal ourselves.
}

8
src/query/plan/planner.cpp
View File

@ -307,7 +307,7 @@ auto GenWith(With &with, LogicalOperator *input_op,
std::unordered_set<int> &bound_symbols) {
// WITH clause is Accumulate/Aggregate (advance_command) + Produce and
// optional Filter.
if (with.distinct_) {
if (with.body_.distinct) {
// TODO: Plan distinct with, when operator available.
throw NotYetImplemented();
}
@ -317,11 +317,11 @@ auto GenWith(With &with, LogicalOperator *input_op,
// No need to advance the command if we only performed reads.
bool advance_command = is_write;
LogicalOperator *last_op =
GenReturnBody(input_op, advance_command, with.named_expressions_,
GenReturnBody(input_op, advance_command, with.body_.named_expressions,
symbol_table, accumulate);
// Reset bound symbols, so that only those in WITH are exposed.
bound_symbols.clear();
for (auto &named_expr : with.named_expressions_) {
for (auto &named_expr : with.body_.named_expressions) {
BindSymbol(bound_symbols, symbol_table.at(*named_expr));
}
if (with.where_) {
@ -341,7 +341,7 @@ auto GenReturn(Return &ret, LogicalOperator *input_op,
// value is the same, final result of 'k' increments.
bool accumulate = is_write;
bool advance_command = false;
return GenReturnBody(input_op, advance_command, ret.named_expressions_,
return GenReturnBody(input_op, advance_command, ret.body_.named_expressions,
symbol_table, accumulate);
}

72
tests/unit/cypher_main_visitor.cpp
View File

@ -59,7 +59,7 @@ TEST(CypherMainVisitorTest, PropertyLookup) {
ASSERT_EQ(query->clauses_.size(), 1U);
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *property_lookup = dynamic_cast<PropertyLookup *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(property_lookup->expression_);
auto identifier = dynamic_cast<Identifier *>(property_lookup->expression_);
ASSERT_TRUE(identifier);
@ -72,7 +72,7 @@ TEST(CypherMainVisitorTest, ReturnNamedIdentifier) {
AstGenerator ast_generator("RETURN var AS var5");
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *named_expr = return_clause->named_expressions_[0];
auto *named_expr = return_clause->body_.named_expressions[0];
ASSERT_EQ(named_expr->name_, "var5");
auto *identifier = dynamic_cast<Identifier *>(named_expr->expression_);
ASSERT_EQ(identifier->name_, "var");
@ -83,7 +83,7 @@ TEST(CypherMainVisitorTest, IntegerLiteral) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *literal = dynamic_cast<Literal *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(literal);
ASSERT_EQ(literal->value_.Value<int64_t>(), 42);
}
@ -98,7 +98,7 @@ TEST(CypherMainVisitorTest, BooleanLiteralTrue) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *literal = dynamic_cast<Literal *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(literal);
ASSERT_EQ(literal->value_.Value<bool>(), true);
}
@ -108,7 +108,7 @@ TEST(CypherMainVisitorTest, BooleanLiteralFalse) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *literal = dynamic_cast<Literal *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(literal);
ASSERT_EQ(literal->value_.Value<bool>(), false);
}
@ -118,7 +118,7 @@ TEST(CypherMainVisitorTest, NullLiteral) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *literal = dynamic_cast<Literal *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(literal);
ASSERT_EQ(literal->value_.type(), TypedValue::Type::Null);
}
@ -128,7 +128,7 @@ TEST(CypherMainVisitorTest, ParenthesizedExpression) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *literal = dynamic_cast<Literal *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(literal);
ASSERT_EQ(literal->value_.Value<int64_t>(), 2);
}
@ -139,7 +139,7 @@ TEST(CypherMainVisitorTest, OrOperator) {
ASSERT_EQ(query->clauses_.size(), 1U);
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *or_operator2 = dynamic_cast<OrOperator *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(or_operator2);
auto *or_operator1 = dynamic_cast<OrOperator *>(or_operator2->expression1_);
ASSERT_TRUE(or_operator1);
@ -159,7 +159,7 @@ TEST(CypherMainVisitorTest, XorOperator) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *xor_operator = dynamic_cast<XorOperator *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
auto *operand1 = dynamic_cast<Literal *>(xor_operator->expression1_);
ASSERT_TRUE(operand1);
ASSERT_EQ(operand1->value_.Value<bool>(), true);
@ -173,7 +173,7 @@ TEST(CypherMainVisitorTest, AndOperator) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *and_operator = dynamic_cast<AndOperator *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
auto *operand1 = dynamic_cast<Literal *>(and_operator->expression1_);
ASSERT_TRUE(operand1);
ASSERT_EQ(operand1->value_.Value<bool>(), true);
@ -187,7 +187,7 @@ TEST(CypherMainVisitorTest, AdditionSubtractionOperators) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *addition_operator = dynamic_cast<AdditionOperator *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(addition_operator);
auto *subtraction_operator =
dynamic_cast<SubtractionOperator *>(addition_operator->expression1_);
@ -208,7 +208,7 @@ TEST(CypherMainVisitorTest, MulitplicationOperator) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *mult_operator = dynamic_cast<MultiplicationOperator *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
auto *operand1 = dynamic_cast<Literal *>(mult_operator->expression1_);
ASSERT_TRUE(operand1);
ASSERT_EQ(operand1->value_.Value<int64_t>(), 2);
@ -222,7 +222,7 @@ TEST(CypherMainVisitorTest, DivisionOperator) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *div_operator = dynamic_cast<DivisionOperator *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
auto *operand1 = dynamic_cast<Literal *>(div_operator->expression1_);
ASSERT_TRUE(operand1);
ASSERT_EQ(operand1->value_.Value<int64_t>(), 2);
@ -236,7 +236,7 @@ TEST(CypherMainVisitorTest, ModOperator) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *mod_operator = dynamic_cast<ModOperator *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
auto *operand1 = dynamic_cast<Literal *>(mod_operator->expression1_);
ASSERT_TRUE(operand1);
ASSERT_EQ(operand1->value_.Value<int64_t>(), 2);
@ -262,7 +262,7 @@ TEST(CypherMainVisitorTest, ComparisonOperators) {
AstGenerator ast_generator("RETURN 2 = 3 != 4 <> 5 < 6 > 7 <= 8 >= 9");
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
Expression *_operator = return_clause->named_expressions_[0]->expression_;
Expression *_operator = return_clause->body_.named_expressions[0]->expression_;
CHECK_COMPARISON(GreaterEqualOperator, 8, 9);
CHECK_COMPARISON(LessEqualOperator, 7, 8);
CHECK_COMPARISON(GreaterOperator, 6, 7);
@ -284,7 +284,7 @@ TEST(CypherMainVisitorTest, IsNull) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *is_type_operator = dynamic_cast<IsNullOperator *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
auto *operand1 = dynamic_cast<Literal *>(is_type_operator->expression_);
ASSERT_TRUE(operand1);
ASSERT_EQ(operand1->value_.Value<int64_t>(), 2);
@ -295,7 +295,7 @@ TEST(CypherMainVisitorTest, IsNotNull) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *not_operator = dynamic_cast<NotOperator *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
auto *is_type_operator =
dynamic_cast<IsNullOperator *>(not_operator->expression_);
auto *operand1 = dynamic_cast<Literal *>(is_type_operator->expression_);
@ -308,7 +308,7 @@ TEST(CypherMainVisitorTest, NotOperator) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *not_operator = dynamic_cast<NotOperator *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
auto *operand = dynamic_cast<Literal *>(not_operator->expression_);
ASSERT_TRUE(operand);
ASSERT_EQ(operand->value_.Value<bool>(), true);
@ -319,7 +319,7 @@ TEST(CypherMainVisitorTest, UnaryMinusPlusOperators) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *unary_minus_operator = dynamic_cast<UnaryMinusOperator *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(unary_minus_operator);
auto *unary_plus_operator =
dynamic_cast<UnaryPlusOperator *>(unary_minus_operator->expression_);
@ -333,14 +333,14 @@ TEST(CypherMainVisitorTest, Aggregation) {
AstGenerator ast_generator("RETURN COUNT(a), MIN(b), MAX(c), SUM(d), AVG(e)");
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
ASSERT_EQ(return_clause->named_expressions_.size(), 5);
ASSERT_EQ(return_clause->body_.named_expressions.size(), 5);
Aggregation::Op ops[] = {Aggregation::Op::COUNT, Aggregation::Op::MIN,
Aggregation::Op::MAX, Aggregation::Op::SUM,
Aggregation::Op::AVG};
std::string ids[] = {"a", "b", "c", "d", "e"};
for (int i = 0; i < 5; ++i) {
auto *aggregation = dynamic_cast<Aggregation *>(
return_clause->named_expressions_[i]->expression_);
return_clause->body_.named_expressions[i]->expression_);
ASSERT_TRUE(aggregation);
ASSERT_EQ(aggregation->op_, ops[i]);
auto *identifier = dynamic_cast<Identifier *>(aggregation->expression_);
@ -360,9 +360,9 @@ TEST(CypherMainVisitorTest, Function) {
AstGenerator ast_generator("RETURN abs(n, 2)");
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
ASSERT_EQ(return_clause->named_expressions_.size(), 1);
ASSERT_EQ(return_clause->body_.named_expressions.size(), 1);
auto *function = dynamic_cast<Function *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(function);
ASSERT_TRUE(function->function_);
// Check if function is abs.
@ -375,7 +375,7 @@ TEST(CypherMainVisitorTest, StringLiteralDoubleQuotes) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *literal = dynamic_cast<Literal *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(literal);
ASSERT_EQ(literal->value_.Value<std::string>(), "mi'rko");
}
@ -385,7 +385,7 @@ TEST(CypherMainVisitorTest, StringLiteralSingleQuotes) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *literal = dynamic_cast<Literal *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(literal);
ASSERT_EQ(literal->value_.Value<std::string>(), "mi\"rko");
}
@ -396,7 +396,7 @@ TEST(CypherMainVisitorTest, StringLiteralEscapedChars) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *literal = dynamic_cast<Literal *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(literal);
ASSERT_EQ(literal->value_.Value<std::string>(), "\\'\"\b\b\f\f\n\n\r\r\t\t");
}
@ -406,7 +406,7 @@ TEST(CypherMainVisitorTest, StringLiteralEscapedUtf16) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *literal = dynamic_cast<Literal *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(literal);
ASSERT_EQ(literal->value_.Value<std::string>(), u8"\u221daaa\u221daaa");
}
@ -416,7 +416,7 @@ TEST(CypherMainVisitorTest, StringLiteralEscapedUtf32) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *literal = dynamic_cast<Literal *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(literal);
ASSERT_EQ(literal->value_.Value<std::string>(),
u8"\U0001F600aaaa\U0001F600aaaaaaaa");
@ -427,7 +427,7 @@ TEST(CypherMainVisitorTest, DoubleLiteral) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *literal = dynamic_cast<Literal *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(literal);
ASSERT_EQ(literal->value_.Value<double>(), 3.5);
}
@ -437,7 +437,7 @@ TEST(CypherMainVisitorTest, DoubleLiteralExponent) {
auto *query = ast_generator.query_;
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
auto *literal = dynamic_cast<Literal *>(
return_clause->named_expressions_[0]->expression_);
return_clause->body_.named_expressions[0]->expression_);
ASSERT_TRUE(literal);
ASSERT_EQ(literal->value_.Value<double>(), 0.5);
}
@ -634,8 +634,8 @@ TEST(CypherMainVisitorTest, ReturnUnanemdIdentifier) {
ASSERT_EQ(query->clauses_.size(), 1U);
auto *return_clause = dynamic_cast<Return *>(query->clauses_[0]);
ASSERT_TRUE(return_clause);
ASSERT_EQ(return_clause->named_expressions_.size(), 1U);
auto *named_expr = return_clause->named_expressions_[0];
ASSERT_EQ(return_clause->body_.named_expressions.size(), 1U);
auto *named_expr = return_clause->body_.named_expressions[0];
ASSERT_TRUE(named_expr);
ASSERT_EQ(named_expr->name_, "var");
auto *identifier = dynamic_cast<Identifier *>(named_expr->expression_);
@ -787,8 +787,8 @@ TEST(CypherMainVisitorTest, With) {
auto *with = dynamic_cast<With *>(query->clauses_[0]);
ASSERT_TRUE(with);
ASSERT_FALSE(with->where_);
ASSERT_EQ(with->named_expressions_.size(), 1U);
auto *named_expr = with->named_expressions_[0];
ASSERT_EQ(with->body_.named_expressions.size(), 1U);
auto *named_expr = with->body_.named_expressions[0];
ASSERT_EQ(named_expr->name_, "m");
auto *identifier = dynamic_cast<Identifier *>(named_expr->expression_);
ASSERT_EQ(identifier->name_, "n");
@ -804,8 +804,8 @@ TEST(CypherMainVisitorTest, WithWhere) {
auto *identifier = dynamic_cast<Identifier *>(with->where_->expression_);
ASSERT_TRUE(identifier);
ASSERT_EQ(identifier->name_, "k");
ASSERT_EQ(with->named_expressions_.size(), 1U);
auto *named_expr = with->named_expressions_[0];
ASSERT_EQ(with->body_.named_expressions.size(), 1U);
auto *named_expr = with->body_.named_expressions[0];
ASSERT_EQ(named_expr->name_, "m");
auto *identifier2 = dynamic_cast<Identifier *>(named_expr->expression_);
ASSERT_EQ(identifier2->name_, "n");

16
tests/unit/query_common.hpp
View File

@ -112,26 +112,26 @@ auto GetQuery(AstTreeStorage &storage, Clause *clause, T *... clauses) {
/// Create the return clause with given named expressions.
///
auto GetReturn(Return *ret, NamedExpression *named_expr) {
ret->named_expressions_.emplace_back(named_expr);
ret->body_.named_expressions.emplace_back(named_expr);
return ret;
}
auto GetReturn(Return *ret, Expression *expr, NamedExpression *named_expr) {
// This overload supports `RETURN(expr, AS(name))` construct, since
// NamedExpression does not inherit Expression.
named_expr->expression_ = expr;
ret->named_expressions_.emplace_back(named_expr);
ret->body_.named_expressions.emplace_back(named_expr);
return ret;
}
template <class... T>
auto GetReturn(Return *ret, Expression *expr, NamedExpression *named_expr,
T *... rest) {
named_expr->expression_ = expr;
ret->named_expressions_.emplace_back(named_expr);
ret->body_.named_expressions.emplace_back(named_expr);
return GetReturn(ret, rest...);
}
template <class... T>
auto GetReturn(Return *ret, NamedExpression *named_expr, T *... rest) {
ret->named_expressions_.emplace_back(named_expr);
ret->body_.named_expressions.emplace_back(named_expr);
return GetReturn(ret, rest...);
}
template <class... T>
@ -144,26 +144,26 @@ auto GetReturn(AstTreeStorage &storage, T *... exprs) {
/// Create the with clause with given named expressions.
///
auto GetWith(With *with, NamedExpression *named_expr) {
with->named_expressions_.emplace_back(named_expr);
with->body_.named_expressions.emplace_back(named_expr);
return with;
}
auto GetWith(With *with, Expression *expr, NamedExpression *named_expr) {
// This overload supports `RETURN(expr, AS(name))` construct, since
// NamedExpression does not inherit Expression.
named_expr->expression_ = expr;
with->named_expressions_.emplace_back(named_expr);
with->body_.named_expressions.emplace_back(named_expr);
return with;
}
template <class... T>
auto GetWith(With *with, Expression *expr, NamedExpression *named_expr,
T *... rest) {
named_expr->expression_ = expr;
with->named_expressions_.emplace_back(named_expr);
with->body_.named_expressions.emplace_back(named_expr);
return GetWith(with, rest...);
}
template <class... T>
auto GetWith(With *with, NamedExpression *named_expr, T *... rest) {
with->named_expressions_.emplace_back(named_expr);
with->body_.named_expressions.emplace_back(named_expr);
return GetWith(with, rest...);
}
template <class... T>

6
tests/unit/query_semantic.cpp
View File

@ -29,7 +29,7 @@ TEST(TestSymbolGenerator, MatchNodeReturn) {
EXPECT_EQ(node_sym.name_, "node_atom_1");
EXPECT_EQ(node_sym.type_, Symbol::Type::Vertex);
auto ret = dynamic_cast<Return *>(query_ast->clauses_[1]);
auto named_expr = ret->named_expressions_[0];
auto named_expr = ret->body_.named_expressions[0];
auto column_sym = symbol_table[*named_expr];
EXPECT_EQ(node_sym.name_, column_sym.name_);
EXPECT_NE(node_sym, column_sym);
@ -97,7 +97,7 @@ TEST(TestSymbolGenerator, MatchSameEdge) {
EXPECT_EQ(edge_symbol, symbol);
}
auto ret = dynamic_cast<Return *>(query_ast->clauses_[1]);
auto named_expr = ret->named_expressions_[0];
auto named_expr = ret->body_.named_expressions[0];
auto ret_symbol = symbol_table[*named_expr->expression_];
EXPECT_EQ(edge_symbol, ret_symbol);
}
@ -132,7 +132,7 @@ TEST(TestSymbolGenerator, CreateNodeReturn) {
EXPECT_EQ(node_sym.name_, "n");
EXPECT_EQ(node_sym.type_, Symbol::Type::Vertex);
auto ret = dynamic_cast<Return *>(query_ast->clauses_[1]);
auto named_expr = ret->named_expressions_[0];
auto named_expr = ret->body_.named_expressions[0];
auto column_sym = symbol_table[*named_expr];
EXPECT_EQ(node_sym.name_, column_sym.name_);
EXPECT_NE(node_sym, column_sym);