mirror of https://gitee.com/bigwinds/arangodb
2025 lines
63 KiB
Plaintext
2025 lines
63 KiB
Plaintext
%define api.pure
|
|
%name-prefix "Aql"
|
|
%locations
|
|
%defines
|
|
%parse-param { arangodb::aql::Parser* parser }
|
|
%lex-param { void* scanner }
|
|
%error-verbose
|
|
|
|
%{
|
|
// we are using alloca here explicitly because we may
|
|
// otherwise leak error messages that are generated by Bison.
|
|
// Bison reports all its errors via the function `Aqlerror`, which
|
|
// will receive the error message as a constant string. So we
|
|
// must not free the string inside `Aqlerror`, and we cannot even
|
|
// tell if the error message is a dynamically allocated error
|
|
// message or a hard-coded error message that resides in some
|
|
// static part of the program.
|
|
// Even worse, `Aqlerror` does not return control to Bison but throws
|
|
// an exception... So the best thing we can do here is to not use
|
|
// dynamically memory allocation by Bison, but make it use alloca.
|
|
#define YYSTACK_USE_ALLOCA 1
|
|
|
|
#include "Aql/Aggregator.h"
|
|
#include "Aql/AstNode.h"
|
|
#include "Aql/Function.h"
|
|
#include "Aql/Parser.h"
|
|
#include "Aql/Quantifier.h"
|
|
#include "Aql/Query.h"
|
|
#include "Aql/types.h"
|
|
#include "Basics/tri-strings.h"
|
|
#include "Transaction/Context.h"
|
|
#include "VocBase/AccessMode.h"
|
|
%}
|
|
|
|
%union {
|
|
arangodb::aql::AstNode* node;
|
|
struct {
|
|
char* value;
|
|
size_t length;
|
|
} strval;
|
|
bool boolval;
|
|
int64_t intval;
|
|
}
|
|
|
|
%{
|
|
|
|
using namespace arangodb::aql;
|
|
|
|
/// @brief shortcut macro for signaling out of memory
|
|
#define ABORT_OOM \
|
|
parser->registerError(TRI_ERROR_OUT_OF_MEMORY); \
|
|
YYABORT;
|
|
|
|
#define scanner parser->scanner()
|
|
|
|
/// @brief forward for lexer function defined in Aql/tokens.ll
|
|
int Aqllex(YYSTYPE*, YYLTYPE*, void*);
|
|
|
|
/// @brief register parse error (this will also abort the currently running query)
|
|
void Aqlerror(YYLTYPE* locp,
|
|
arangodb::aql::Parser* parser,
|
|
char const* message) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, message, locp->first_line, locp->first_column);
|
|
}
|
|
|
|
/// @brief check if any of the variables used in the INTO expression were
|
|
/// introduced by the COLLECT itself, in which case it would fail
|
|
static void CheckIntoVariables(Parser* parser, AstNode const* expression,
|
|
int line, int column,
|
|
arangodb::HashSet<Variable const*> const& variablesIntroduced) {
|
|
if (expression == nullptr) {
|
|
return;
|
|
}
|
|
|
|
arangodb::HashSet<Variable const*> varsInAssignment;
|
|
Ast::getReferencedVariables(expression, varsInAssignment);
|
|
|
|
for (auto const& it : varsInAssignment) {
|
|
if (variablesIntroduced.find(it) != variablesIntroduced.end()) {
|
|
std::string msg("use of COLLECT variable '" + it->name + "' inside same COLLECT's INTO expression");
|
|
parser->registerParseError(TRI_ERROR_QUERY_VARIABLE_NAME_UNKNOWN, msg.c_str(), it->name.c_str(), line, column);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// @brief register variables in the scope
|
|
static void RegisterAssignVariables(Parser* parser, arangodb::aql::Scopes* scopes,
|
|
int line, int column,
|
|
arangodb::HashSet<Variable const*>& variablesIntroduced,
|
|
AstNode const* vars) {
|
|
arangodb::HashSet<Variable const*> varsInAssignment;
|
|
|
|
size_t const n = vars->numMembers();
|
|
|
|
for (size_t i = 0; i < n; ++i) {
|
|
auto member = vars->getMemberUnchecked(i);
|
|
|
|
if (member != nullptr) {
|
|
TRI_ASSERT(member->type == NODE_TYPE_ASSIGN);
|
|
// check if any of the assignment refers to a variable introduced by this very
|
|
// same COLLECT, e.g. COLLECT aggregate x = .., y = x
|
|
varsInAssignment.clear();
|
|
Ast::getReferencedVariables(member->getMember(1), varsInAssignment);
|
|
for (auto const& it : varsInAssignment) {
|
|
if (variablesIntroduced.find(it) != variablesIntroduced.end()) {
|
|
std::string msg("use of COLLECT variable '" + it->name + "' inside same COLLECT");
|
|
parser->registerParseError(TRI_ERROR_QUERY_VARIABLE_NAME_UNKNOWN, msg.c_str(), it->name.c_str(), line, column);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// keep track of the variable for our assignment
|
|
auto v = static_cast<Variable*>(member->getMember(0)->getData());
|
|
scopes->addVariable(v);
|
|
variablesIntroduced.emplace(v);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// @brief validate the aggregate variables expressions
|
|
static bool ValidateAggregates(Parser* parser, AstNode const* aggregates) {
|
|
size_t const n = aggregates->numMembers();
|
|
|
|
for (size_t i = 0; i < n; ++i) {
|
|
auto member = aggregates->getMemberUnchecked(i);
|
|
|
|
if (member != nullptr) {
|
|
TRI_ASSERT(member->type == NODE_TYPE_ASSIGN);
|
|
|
|
auto func = member->getMember(1);
|
|
|
|
bool isValid = true;
|
|
if (func->type != NODE_TYPE_FCALL) {
|
|
// aggregate expression must be a function call
|
|
isValid = false;
|
|
}
|
|
else {
|
|
auto f = static_cast<arangodb::aql::Function*>(func->getData());
|
|
if (!Aggregator::isValid(f->name)) {
|
|
// aggregate expression must be a call to MIN|MAX|LENGTH...
|
|
isValid = false;
|
|
}
|
|
}
|
|
|
|
if (!isValid) {
|
|
parser->registerError(TRI_ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// @brief start a new scope for the collect
|
|
static bool StartCollectScope(arangodb::aql::Scopes* scopes) {
|
|
// check if we are in the main scope
|
|
if (scopes->type() == arangodb::aql::AQL_SCOPE_MAIN) {
|
|
return false;
|
|
}
|
|
|
|
// end the active scopes
|
|
scopes->endNested();
|
|
// start a new scope
|
|
scopes->start(arangodb::aql::AQL_SCOPE_COLLECT);
|
|
return true;
|
|
}
|
|
|
|
/// @brief get the INTO variable stored in a node (may not exist)
|
|
static AstNode const* GetIntoVariable(Parser* parser, AstNode const* node) {
|
|
if (node == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (node->type == NODE_TYPE_VALUE) {
|
|
// node is a string containing the variable name
|
|
return parser->ast()->createNodeVariable(node->getStringValue(), node->getStringLength(), true);
|
|
}
|
|
|
|
// node is an array with the variable name as the first member
|
|
TRI_ASSERT(node->type == NODE_TYPE_ARRAY);
|
|
TRI_ASSERT(node->numMembers() == 2);
|
|
|
|
auto v = node->getMember(0);
|
|
TRI_ASSERT(v->type == NODE_TYPE_VALUE);
|
|
return parser->ast()->createNodeVariable(v->getStringValue(), v->getStringLength(), true);
|
|
}
|
|
|
|
/// @brief get the INTO variable = expression stored in a node (may not exist)
|
|
static AstNode const* GetIntoExpression(AstNode const* node) {
|
|
if (node == nullptr || node->type == NODE_TYPE_VALUE) {
|
|
return nullptr;
|
|
}
|
|
|
|
// node is an array with the expression as the second member
|
|
TRI_ASSERT(node->type == NODE_TYPE_ARRAY);
|
|
TRI_ASSERT(node->numMembers() == 2);
|
|
|
|
return node->getMember(1);
|
|
}
|
|
|
|
static AstNode* TransformOutputVariables(Parser* parser, AstNode const* names) {
|
|
auto wrapperNode = parser->ast()->createNodeArray();
|
|
for (size_t i = 0; i < names->numMembers(); ++i) {
|
|
AstNode* variableNameNode = names->getMemberUnchecked(i);
|
|
TRI_ASSERT(variableNameNode->isStringValue());
|
|
AstNode* variableNode = parser->ast()->createNodeVariable(variableNameNode->getStringValue(), variableNameNode->getStringLength(), true);
|
|
wrapperNode->addMember(variableNode);
|
|
}
|
|
return wrapperNode;
|
|
}
|
|
|
|
%}
|
|
|
|
/* define tokens and "nice" token names */
|
|
%token T_FOR "FOR declaration"
|
|
%token T_LET "LET declaration"
|
|
%token T_FILTER "FILTER declaration"
|
|
%token T_RETURN "RETURN declaration"
|
|
%token T_COLLECT "COLLECT declaration"
|
|
%token T_SORT "SORT declaration"
|
|
%token T_LIMIT "LIMIT declaration"
|
|
|
|
%token T_ASC "ASC keyword"
|
|
%token T_DESC "DESC keyword"
|
|
%token T_IN "IN keyword"
|
|
%token T_WITH "WITH keyword"
|
|
%token T_INTO "INTO keyword"
|
|
%token T_AGGREGATE "AGGREGATE keyword"
|
|
|
|
%token T_GRAPH "GRAPH keyword"
|
|
%token T_SHORTEST_PATH "SHORTEST_PATH keyword"
|
|
%token T_K_SHORTEST_PATHS "K_SHORTEST_PATHS keyword"
|
|
%token T_DISTINCT "DISTINCT modifier"
|
|
|
|
%token T_REMOVE "REMOVE command"
|
|
%token T_INSERT "INSERT command"
|
|
%token T_UPDATE "UPDATE command"
|
|
%token T_REPLACE "REPLACE command"
|
|
%token T_UPSERT "UPSERT command"
|
|
|
|
%token T_NULL "null"
|
|
%token T_TRUE "true"
|
|
%token T_FALSE "false"
|
|
%token T_STRING "identifier"
|
|
%token T_QUOTED_STRING "quoted string"
|
|
%token T_INTEGER "integer number"
|
|
%token T_DOUBLE "number"
|
|
%token T_PARAMETER "bind parameter"
|
|
%token T_DATA_SOURCE_PARAMETER "bind data source parameter"
|
|
|
|
%token T_ASSIGN "assignment"
|
|
|
|
%token T_NOT "not operator"
|
|
%token T_AND "and operator"
|
|
%token T_OR "or operator"
|
|
|
|
%token T_REGEX_MATCH "~= operator"
|
|
%token T_REGEX_NON_MATCH "~! operator"
|
|
|
|
%token T_EQ "== operator"
|
|
%token T_NE "!= operator"
|
|
%token T_LT "< operator"
|
|
%token T_GT "> operator"
|
|
%token T_LE "<= operator"
|
|
%token T_GE ">= operator"
|
|
|
|
%token T_LIKE "like operator"
|
|
|
|
%token T_PLUS "+ operator"
|
|
%token T_MINUS "- operator"
|
|
%token T_TIMES "* operator"
|
|
%token T_DIV "/ operator"
|
|
%token T_MOD "% operator"
|
|
|
|
%token T_QUESTION "?"
|
|
%token T_COLON ":"
|
|
%token T_SCOPE "::"
|
|
%token T_RANGE ".."
|
|
|
|
%token T_COMMA ","
|
|
%token T_OPEN "("
|
|
%token T_CLOSE ")"
|
|
%token T_OBJECT_OPEN "{"
|
|
%token T_OBJECT_CLOSE "}"
|
|
%token T_ARRAY_OPEN "["
|
|
%token T_ARRAY_CLOSE "]"
|
|
|
|
%token T_END 0 "end of query string"
|
|
|
|
%token T_OUTBOUND "outbound modifier"
|
|
%token T_INBOUND "inbound modifier"
|
|
|
|
%token T_ANY "any modifier"
|
|
%token T_ALL "all modifier"
|
|
%token T_NONE "none modifier"
|
|
|
|
/* define operator precedence */
|
|
%left T_COMMA
|
|
%left T_DISTINCT
|
|
%right T_QUESTION T_COLON
|
|
%right T_ASSIGN
|
|
%left T_WITH
|
|
%nonassoc T_INTO
|
|
%left T_OR
|
|
%left T_AND
|
|
%nonassoc T_OUTBOUND T_INBOUND T_ANY T_ALL T_NONE
|
|
%left T_EQ T_NE T_LIKE T_REGEX_MATCH T_REGEX_NON_MATCH
|
|
%left T_IN T_NOT
|
|
%left T_LT T_GT T_LE T_GE
|
|
%left T_RANGE
|
|
%left T_PLUS T_MINUS
|
|
%left T_TIMES T_DIV T_MOD
|
|
%right UMINUS UPLUS UNEGATION
|
|
%left FUNCCALL
|
|
%left REFERENCE
|
|
%left INDEXED
|
|
%left EXPANSION
|
|
%left T_SCOPE
|
|
|
|
/* define token return types */
|
|
%type <strval> T_STRING
|
|
%type <strval> T_QUOTED_STRING
|
|
%type <node> T_INTEGER
|
|
%type <node> T_DOUBLE
|
|
%type <strval> T_PARAMETER;
|
|
%type <strval> T_DATA_SOURCE_PARAMETER;
|
|
%type <node> with_collection;
|
|
%type <node> sort_list;
|
|
%type <node> sort_element;
|
|
%type <node> sort_direction;
|
|
%type <node> collect_list;
|
|
%type <node> collect_element;
|
|
%type <node> collect_variable_list;
|
|
%type <node> keep;
|
|
%type <node> aggregate;
|
|
%type <node> collect_optional_into;
|
|
%type <strval> count_into;
|
|
%type <node> expression;
|
|
%type <node> expression_or_query;
|
|
%type <node> distinct_expression;
|
|
%type <node> operator_unary;
|
|
%type <node> operator_binary;
|
|
%type <node> operator_ternary;
|
|
%type <node> function_call;
|
|
%type <strval> function_name;
|
|
%type <node> optional_function_call_arguments;
|
|
%type <node> function_arguments_list;
|
|
%type <node> compound_value;
|
|
%type <node> array;
|
|
%type <node> for_output_variables;
|
|
%type <node> traversal_graph_info;
|
|
%type <node> shortest_path_graph_info;
|
|
%type <node> k_shortest_paths_graph_info;
|
|
%type <node> optional_array_elements;
|
|
%type <node> array_elements_list;
|
|
%type <node> for_options;
|
|
%type <node> object;
|
|
%type <node> options;
|
|
%type <node> optional_object_elements;
|
|
%type <node> object_elements_list;
|
|
%type <node> object_element;
|
|
%type <strval> object_element_name;
|
|
%type <intval> array_filter_operator;
|
|
%type <node> optional_array_filter;
|
|
%type <node> optional_array_limit;
|
|
%type <node> optional_array_return;
|
|
%type <node> graph_subject;
|
|
%type <intval> graph_direction;
|
|
%type <node> graph_direction_steps;
|
|
%type <node> graph_collection;
|
|
%type <node> reference;
|
|
%type <node> simple_value;
|
|
%type <node> value_literal;
|
|
%type <node> in_or_into_collection;
|
|
%type <node> in_or_into_collection_name;
|
|
%type <node> bind_parameter;
|
|
%type <strval> variable_name;
|
|
%type <node> numeric_value;
|
|
%type <intval> update_or_replace;
|
|
%type <node> quantifier;
|
|
|
|
|
|
/* define start token of language */
|
|
%start queryStart
|
|
|
|
%%
|
|
|
|
with_collection:
|
|
T_STRING {
|
|
$$ = parser->ast()->createNodeValueString($1.value, $1.length);
|
|
}
|
|
| bind_parameter {
|
|
char const* p = $1->getStringValue();
|
|
size_t const len = $1->getStringLength();
|
|
|
|
if (len < 2 || *p != '@') {
|
|
parser->registerParseError(TRI_ERROR_QUERY_BIND_PARAMETER_TYPE, TRI_errno_string(TRI_ERROR_QUERY_BIND_PARAMETER_TYPE), p, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
|
|
$$ = $1;
|
|
}
|
|
;
|
|
|
|
with_collection_list:
|
|
with_collection {
|
|
auto node = static_cast<AstNode*>(parser->peekStack());
|
|
node->addMember($1);
|
|
}
|
|
| with_collection_list T_COMMA with_collection {
|
|
auto node = static_cast<AstNode*>(parser->peekStack());
|
|
node->addMember($3);
|
|
}
|
|
| with_collection_list with_collection {
|
|
auto node = static_cast<AstNode*>(parser->peekStack());
|
|
node->addMember($2);
|
|
}
|
|
;
|
|
|
|
optional_with:
|
|
/* empty */ {
|
|
}
|
|
| T_WITH {
|
|
auto node = parser->ast()->createNodeArray();
|
|
parser->pushStack(node);
|
|
} with_collection_list {
|
|
auto node = static_cast<AstNode*>(parser->popStack());
|
|
auto const& resolver = parser->query()->resolver();
|
|
auto withNode = parser->ast()->createNodeWithCollections(node, resolver);
|
|
parser->ast()->addOperation(withNode);
|
|
}
|
|
;
|
|
|
|
queryStart:
|
|
optional_with query {
|
|
}
|
|
;
|
|
|
|
query:
|
|
optional_statement_block_statements final_statement {
|
|
}
|
|
;
|
|
|
|
final_statement:
|
|
return_statement {
|
|
}
|
|
| remove_statement {
|
|
parser->ast()->scopes()->endNested();
|
|
}
|
|
| insert_statement {
|
|
parser->ast()->scopes()->endNested();
|
|
}
|
|
| update_statement {
|
|
parser->ast()->scopes()->endNested();
|
|
}
|
|
| replace_statement {
|
|
parser->ast()->scopes()->endNested();
|
|
}
|
|
| upsert_statement {
|
|
parser->ast()->scopes()->endNested();
|
|
}
|
|
;
|
|
|
|
optional_statement_block_statements:
|
|
/* empty */ {
|
|
}
|
|
| optional_statement_block_statements statement_block_statement {
|
|
}
|
|
;
|
|
|
|
statement_block_statement:
|
|
for_statement {
|
|
}
|
|
| let_statement {
|
|
}
|
|
| filter_statement {
|
|
}
|
|
| collect_statement {
|
|
}
|
|
| sort_statement {
|
|
}
|
|
| limit_statement {
|
|
}
|
|
| remove_statement {
|
|
}
|
|
| insert_statement {
|
|
}
|
|
| update_statement {
|
|
}
|
|
| replace_statement {
|
|
}
|
|
| upsert_statement {
|
|
}
|
|
;
|
|
|
|
more_output_variables:
|
|
variable_name {
|
|
auto wrapperNode = parser->ast()->createNodeArray();
|
|
parser->pushArray(wrapperNode);
|
|
// This is guaranteed to be called on the first variable
|
|
AstNode* node = parser->ast()->createNodeValueString($1.value, $1.length);
|
|
parser->pushArrayElement(node);
|
|
}
|
|
| more_output_variables T_COMMA variable_name {
|
|
AstNode* node = parser->ast()->createNodeValueString($3.value, $3.length);
|
|
parser->pushArrayElement(node);
|
|
}
|
|
;
|
|
|
|
for_output_variables:
|
|
more_output_variables {
|
|
$$ = parser->popArray();
|
|
}
|
|
;
|
|
|
|
prune_and_options:
|
|
/* empty no prune, no options, add two NOPS */ {
|
|
auto node = static_cast<AstNode*>(parser->peekStack());
|
|
// Prune
|
|
node->addMember(parser->ast()->createNodeNop());
|
|
// Options
|
|
node->addMember(parser->ast()->createNodeNop());
|
|
}
|
|
| T_STRING expression {
|
|
auto node = static_cast<AstNode*>(parser->peekStack());
|
|
if (TRI_CaseEqualString($1.value, "PRUNE")) {
|
|
/* Only Prune */
|
|
if ($2 == nullptr) {
|
|
ABORT_OOM
|
|
}
|
|
// Prune
|
|
node->addMember($2);
|
|
// Options
|
|
node->addMember(parser->ast()->createNodeNop());
|
|
} else if (TRI_CaseEqualString($1.value, "OPTIONS")) {
|
|
/* Only Options */
|
|
if ($2 == nullptr) {
|
|
ABORT_OOM
|
|
}
|
|
if (!$2->isObject()) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "traversal 'OPTIONS' have to be an object", $1.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
// Prune
|
|
node->addMember(parser->ast()->createNodeNop());
|
|
// Options
|
|
node->addMember($2);
|
|
} else {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "unexpected qualifier '%s', expecting 'PRUNE' or 'OPTIONS'", $1.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
}
|
|
| T_STRING expression T_STRING object {
|
|
/* prune and options */
|
|
auto node = static_cast<AstNode*>(parser->peekStack());
|
|
if (!TRI_CaseEqualString($1.value, "PRUNE")) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "unexpected qualifier '%s', expecting 'PRUNE'", $1.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
if ($2 == nullptr) {
|
|
ABORT_OOM
|
|
}
|
|
if (!TRI_CaseEqualString($3.value, "OPTIONS")) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "unexpected qualifier '%s', expecting 'OPTIONS'", $3.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
if ($4 == nullptr) {
|
|
ABORT_OOM
|
|
}
|
|
// Prune
|
|
node->addMember($2);
|
|
// Options
|
|
node->addMember($4);
|
|
}
|
|
;
|
|
|
|
traversal_graph_info:
|
|
graph_direction_steps expression graph_subject {
|
|
auto infoNode = parser->ast()->createNodeArray();
|
|
// Direction
|
|
infoNode->addMember($1);
|
|
// Source
|
|
infoNode->addMember($2);
|
|
// Graph
|
|
infoNode->addMember($3);
|
|
$$ = infoNode;
|
|
}
|
|
;
|
|
|
|
shortest_path_graph_info:
|
|
graph_direction T_SHORTEST_PATH expression T_STRING expression graph_subject options {
|
|
if (!TRI_CaseEqualString($4.value, "TO")) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "unexpected qualifier '%s', expecting 'TO'", $4.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
auto infoNode = parser->ast()->createNodeArray();
|
|
auto dirNode = parser->ast()->createNodeValueInt($1);
|
|
// Direction
|
|
infoNode->addMember(dirNode);
|
|
// Source
|
|
infoNode->addMember($3);
|
|
// Target
|
|
infoNode->addMember($5);
|
|
// Graph
|
|
infoNode->addMember($6);
|
|
// Opts
|
|
auto opts = parser->ast()->createNodeOptions($7);
|
|
TRI_ASSERT(opts != nullptr);
|
|
infoNode->addMember(opts);
|
|
$$ = infoNode;
|
|
}
|
|
;
|
|
|
|
k_shortest_paths_graph_info:
|
|
graph_direction T_K_SHORTEST_PATHS expression T_STRING expression graph_subject options {
|
|
if (!TRI_CaseEqualString($4.value, "TO")) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "unexpected qualifier '%s', expecting 'TO'", $4.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
auto infoNode = parser->ast()->createNodeArray();
|
|
auto dirNode = parser->ast()->createNodeValueInt($1);
|
|
// Direction
|
|
infoNode->addMember(dirNode);
|
|
// Source
|
|
infoNode->addMember($3);
|
|
// Target
|
|
infoNode->addMember($5);
|
|
// Graph
|
|
infoNode->addMember($6);
|
|
// Opts
|
|
auto opts = parser->ast()->createNodeOptions($7);
|
|
TRI_ASSERT(opts != nullptr);
|
|
infoNode->addMember(opts);
|
|
$$ = infoNode;
|
|
}
|
|
;
|
|
|
|
for_statement:
|
|
T_FOR for_output_variables T_IN expression {
|
|
// first open a new scope (after expression is evaluated)
|
|
parser->ast()->scopes()->start(arangodb::aql::AQL_SCOPE_FOR);
|
|
AstNode* variablesNode = static_cast<AstNode*>($2);
|
|
TRI_ASSERT(variablesNode != nullptr);
|
|
TRI_ASSERT(variablesNode->type == NODE_TYPE_ARRAY);
|
|
if (variablesNode->numMembers() != 1) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "Collections and Views only have one return variable", yylloc.first_line, yylloc.first_column);
|
|
}
|
|
|
|
// now create an out variable for the FOR statement
|
|
// this prepares us to handle the optional SEARCH condition, which may
|
|
// or may not refer to the FOR's variable
|
|
AstNode* variableNameNode = variablesNode->getMemberUnchecked(0);
|
|
TRI_ASSERT(variableNameNode->isStringValue());
|
|
AstNode* variableNode = parser->ast()->createNodeVariable(variableNameNode->getStringValue(), variableNameNode->getStringLength(), true);
|
|
|
|
parser->pushStack(variableNode);
|
|
} for_options {
|
|
// now we can handle the optional SEARCH condition and OPTIONS.
|
|
AstNode* variableNode = static_cast<AstNode*>(parser->popStack());
|
|
|
|
Variable* variable = static_cast<Variable*>(variableNode->getData());
|
|
|
|
AstNode* node = nullptr;
|
|
AstNode* search = nullptr;
|
|
AstNode* options = nullptr;
|
|
|
|
if ($6 != nullptr) {
|
|
// we got a SEARCH and/or OPTIONS clause
|
|
TRI_ASSERT($6->type == NODE_TYPE_ARRAY);
|
|
TRI_ASSERT($6->numMembers() == 2);
|
|
|
|
search = $6->getMemberUnchecked(0);
|
|
if (search->type == NODE_TYPE_NOP) {
|
|
search = nullptr;
|
|
}
|
|
options = $6->getMemberUnchecked(1);
|
|
if (options->type == NODE_TYPE_NOP) {
|
|
options = nullptr;
|
|
}
|
|
}
|
|
|
|
if (search != nullptr) {
|
|
// we got a SEARCH clause. this is always a view.
|
|
node = parser->ast()->createNodeForView(variable, $4, search, options);
|
|
|
|
if ($4->type != NODE_TYPE_PARAMETER_DATASOURCE &&
|
|
$4->type != NODE_TYPE_VIEW &&
|
|
$4->type != NODE_TYPE_COLLECTION) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "SEARCH condition used on non-view", yylloc.first_line, yylloc.first_column);
|
|
}
|
|
} else {
|
|
node = parser->ast()->createNodeFor(variable, $4, options);
|
|
}
|
|
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
| T_FOR for_output_variables T_IN traversal_graph_info {
|
|
// first open a new scope (after expression is evaluated)
|
|
parser->ast()->scopes()->start(arangodb::aql::AQL_SCOPE_FOR);
|
|
// Traversal
|
|
auto variableNamesNode = static_cast<AstNode*>($2);
|
|
TRI_ASSERT(variableNamesNode != nullptr);
|
|
TRI_ASSERT(variableNamesNode->type == NODE_TYPE_ARRAY);
|
|
if (variableNamesNode->numMembers() > 3) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "Traversals only have one, two or three return variables", yylloc.first_line, yylloc.first_column);
|
|
}
|
|
auto variablesNode = TransformOutputVariables(parser, variableNamesNode);
|
|
auto graphInfoNode = static_cast<AstNode*>($4);
|
|
TRI_ASSERT(graphInfoNode != nullptr);
|
|
TRI_ASSERT(graphInfoNode->type == NODE_TYPE_ARRAY);
|
|
parser->pushStack(variablesNode);
|
|
parser->pushStack(graphInfoNode);
|
|
// This stack push/pop magic is necessary to allow v, e, and p in the prune condition
|
|
} prune_and_options {
|
|
auto graphInfoNode = static_cast<AstNode*>(parser->popStack());
|
|
auto variablesNode = static_cast<AstNode*>(parser->popStack());
|
|
|
|
auto prune = graphInfoNode->getMember(3);
|
|
if (prune != nullptr) {
|
|
Ast::traverseReadOnly(prune, [&](AstNode const* node) {
|
|
if (node->type == NODE_TYPE_REFERENCE && node->hasFlag(AstNodeFlagType::FLAG_SUBQUERY_REFERENCE)) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "prune condition must not use a subquery", yylloc.first_line, yylloc.first_column);
|
|
}
|
|
});
|
|
}
|
|
auto node = parser->ast()->createNodeTraversal(variablesNode, graphInfoNode);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
| T_FOR for_output_variables T_IN shortest_path_graph_info {
|
|
// first open a new scope (after expression is evaluated)
|
|
parser->ast()->scopes()->start(arangodb::aql::AQL_SCOPE_FOR);
|
|
// Shortest Path
|
|
auto variableNamesNode = static_cast<AstNode*>($2);
|
|
TRI_ASSERT(variableNamesNode != nullptr);
|
|
TRI_ASSERT(variableNamesNode->type == NODE_TYPE_ARRAY);
|
|
if (variableNamesNode->numMembers() > 2) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "ShortestPath only has one or two return variables", yylloc.first_line, yylloc.first_column);
|
|
}
|
|
auto variablesNode = TransformOutputVariables(parser, variableNamesNode);
|
|
auto graphInfoNode = static_cast<AstNode*>($4);
|
|
TRI_ASSERT(graphInfoNode != nullptr);
|
|
TRI_ASSERT(graphInfoNode->type == NODE_TYPE_ARRAY);
|
|
auto node = parser->ast()->createNodeShortestPath(variablesNode, graphInfoNode);
|
|
parser->ast()->addOperation(node);
|
|
|
|
}
|
|
| T_FOR for_output_variables T_IN k_shortest_paths_graph_info {
|
|
// first open a new scope (after expression is evaluated)
|
|
parser->ast()->scopes()->start(arangodb::aql::AQL_SCOPE_FOR);
|
|
// K Shortest Paths
|
|
auto variableNamesNode = static_cast<AstNode*>($2);
|
|
TRI_ASSERT(variableNamesNode != nullptr);
|
|
TRI_ASSERT(variableNamesNode->type == NODE_TYPE_ARRAY);
|
|
if (variableNamesNode->numMembers() > 1) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "k Shortest Paths only has one return variable", yylloc.first_line, yylloc.first_column);
|
|
}
|
|
auto variablesNode = TransformOutputVariables(parser, variableNamesNode);
|
|
auto graphInfoNode = static_cast<AstNode*>($4);
|
|
TRI_ASSERT(graphInfoNode != nullptr);
|
|
TRI_ASSERT(graphInfoNode->type == NODE_TYPE_ARRAY);
|
|
auto node = parser->ast()->createNodeKShortestPaths(variablesNode, graphInfoNode);
|
|
parser->ast()->addOperation(node);
|
|
|
|
}
|
|
|
|
;
|
|
|
|
filter_statement:
|
|
T_FILTER expression {
|
|
// operand is a reference. can use it directly
|
|
auto node = parser->ast()->createNodeFilter($2);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
;
|
|
|
|
let_statement:
|
|
T_LET let_list {
|
|
}
|
|
;
|
|
|
|
let_list:
|
|
let_element {
|
|
}
|
|
| let_list T_COMMA let_element {
|
|
}
|
|
;
|
|
|
|
let_element:
|
|
variable_name T_ASSIGN expression {
|
|
auto node = parser->ast()->createNodeLet($1.value, $1.length, $3, true);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
;
|
|
|
|
count_into:
|
|
T_WITH T_STRING T_INTO variable_name {
|
|
if (!TRI_CaseEqualString($2.value, "COUNT")) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "unexpected qualifier '%s', expecting 'COUNT'", $2.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
|
|
$$ = $4;
|
|
}
|
|
;
|
|
|
|
collect_variable_list:
|
|
T_COLLECT {
|
|
auto node = parser->ast()->createNodeArray();
|
|
parser->pushStack(node);
|
|
} collect_list {
|
|
auto list = static_cast<AstNode*>(parser->popStack());
|
|
|
|
if (list == nullptr) {
|
|
ABORT_OOM
|
|
}
|
|
$$ = list;
|
|
}
|
|
;
|
|
|
|
collect_statement:
|
|
T_COLLECT count_into options {
|
|
/* COLLECT WITH COUNT INTO var OPTIONS ... */
|
|
auto scopes = parser->ast()->scopes();
|
|
|
|
StartCollectScope(scopes);
|
|
|
|
auto node = parser->ast()->createNodeCollectCount(parser->ast()->createNodeArray(), $2.value, $2.length, $3);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
| collect_variable_list count_into options {
|
|
/* COLLECT var = expr WITH COUNT INTO var OPTIONS ... */
|
|
auto scopes = parser->ast()->scopes();
|
|
|
|
if (StartCollectScope(scopes)) {
|
|
arangodb::HashSet<Variable const*> variables;
|
|
RegisterAssignVariables(parser, scopes, yylloc.first_line, yylloc.first_column, variables, $1);
|
|
}
|
|
|
|
auto node = parser->ast()->createNodeCollectCount($1, $2.value, $2.length, $3);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
| T_COLLECT aggregate collect_optional_into options {
|
|
/* AGGREGATE var = expr OPTIONS ... */
|
|
arangodb::HashSet<Variable const*> variablesIntroduced;
|
|
auto scopes = parser->ast()->scopes();
|
|
|
|
if (StartCollectScope(scopes)) {
|
|
RegisterAssignVariables(parser, scopes, yylloc.first_line, yylloc.first_column, variablesIntroduced, $2);
|
|
}
|
|
|
|
// validate aggregates
|
|
if (!ValidateAggregates(parser, $2)) {
|
|
YYABORT;
|
|
}
|
|
|
|
if ($3 != nullptr && $3->type == NODE_TYPE_ARRAY) {
|
|
CheckIntoVariables(parser, $3->getMember(1), yylloc.first_line, yylloc.first_column, variablesIntroduced);
|
|
}
|
|
|
|
AstNode const* into = GetIntoVariable(parser, $3);
|
|
AstNode const* intoExpression = GetIntoExpression($3);
|
|
|
|
auto node = parser->ast()->createNodeCollect(parser->ast()->createNodeArray(), $2, into, intoExpression, nullptr, $3);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
| collect_variable_list aggregate collect_optional_into options {
|
|
/* COLLECT var = expr AGGREGATE var = expr OPTIONS ... */
|
|
arangodb::HashSet<Variable const*> variablesIntroduced;
|
|
auto scopes = parser->ast()->scopes();
|
|
|
|
if (StartCollectScope(scopes)) {
|
|
RegisterAssignVariables(parser, scopes, yylloc.first_line, yylloc.first_column, variablesIntroduced, $1);
|
|
RegisterAssignVariables(parser, scopes, yylloc.first_line, yylloc.first_column, variablesIntroduced, $2);
|
|
}
|
|
|
|
if (! ValidateAggregates(parser, $2)) {
|
|
YYABORT;
|
|
}
|
|
|
|
if ($3 != nullptr && $3->type == NODE_TYPE_ARRAY) {
|
|
CheckIntoVariables(parser, $3->getMember(1), yylloc.first_line, yylloc.first_column, variablesIntroduced);
|
|
}
|
|
|
|
// note all group variables
|
|
arangodb::HashSet<Variable const*> groupVars;
|
|
size_t n = $1->numMembers();
|
|
for (size_t i = 0; i < n; ++i) {
|
|
auto member = $1->getMember(i);
|
|
|
|
if (member != nullptr) {
|
|
TRI_ASSERT(member->type == NODE_TYPE_ASSIGN);
|
|
groupVars.emplace(static_cast<Variable const*>(member->getMember(0)->getData()));
|
|
}
|
|
}
|
|
|
|
// now validate if any aggregate refers to one of the group variables
|
|
n = $2->numMembers();
|
|
for (size_t i = 0; i < n; ++i) {
|
|
auto member = $2->getMember(i);
|
|
|
|
if (member != nullptr) {
|
|
TRI_ASSERT(member->type == NODE_TYPE_ASSIGN);
|
|
arangodb::HashSet<Variable const*> variablesUsed;
|
|
Ast::getReferencedVariables(member->getMember(1), variablesUsed);
|
|
|
|
for (auto& it : groupVars) {
|
|
if (variablesUsed.find(it) != variablesUsed.end()) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_VARIABLE_NAME_UNKNOWN,
|
|
"use of unknown variable '%s' in AGGREGATE expression", it->name.c_str(), yylloc.first_line, yylloc.first_column);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
AstNode const* into = GetIntoVariable(parser, $3);
|
|
AstNode const* intoExpression = GetIntoExpression($3);
|
|
|
|
auto node = parser->ast()->createNodeCollect($1, $2, into, intoExpression, nullptr, $4);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
| collect_variable_list collect_optional_into options {
|
|
/* COLLECT var = expr INTO var OPTIONS ... */
|
|
arangodb::HashSet<Variable const*> variablesIntroduced;
|
|
auto scopes = parser->ast()->scopes();
|
|
|
|
if (StartCollectScope(scopes)) {
|
|
RegisterAssignVariables(parser, scopes, yylloc.first_line, yylloc.first_column, variablesIntroduced, $1);
|
|
}
|
|
|
|
if ($2 != nullptr && $2->type == NODE_TYPE_ARRAY) {
|
|
CheckIntoVariables(parser, $2->getMember(1), yylloc.first_line, yylloc.first_column, variablesIntroduced);
|
|
}
|
|
|
|
AstNode const* into = GetIntoVariable(parser, $2);
|
|
AstNode const* intoExpression = GetIntoExpression($2);
|
|
|
|
auto node = parser->ast()->createNodeCollect($1, parser->ast()->createNodeArray(), into, intoExpression, nullptr, $3);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
| collect_variable_list collect_optional_into keep options {
|
|
/* COLLECT var = expr INTO var KEEP ... OPTIONS ... */
|
|
arangodb::HashSet<Variable const*> variablesIntroduced;
|
|
auto scopes = parser->ast()->scopes();
|
|
|
|
if (StartCollectScope(scopes)) {
|
|
RegisterAssignVariables(parser, scopes, yylloc.first_line, yylloc.first_column, variablesIntroduced, $1);
|
|
}
|
|
|
|
if ($2 == nullptr &&
|
|
$3 != nullptr) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "use of 'KEEP' without 'INTO'", yylloc.first_line, yylloc.first_column);
|
|
}
|
|
|
|
if ($2 != nullptr && $2->type == NODE_TYPE_ARRAY) {
|
|
CheckIntoVariables(parser, $2->getMember(1), yylloc.first_line, yylloc.first_column, variablesIntroduced);
|
|
}
|
|
|
|
AstNode const* into = GetIntoVariable(parser, $2);
|
|
AstNode const* intoExpression = GetIntoExpression($2);
|
|
|
|
auto node = parser->ast()->createNodeCollect($1, parser->ast()->createNodeArray(), into, intoExpression, $3, $4);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
;
|
|
|
|
collect_list:
|
|
collect_element {
|
|
}
|
|
| collect_list T_COMMA collect_element {
|
|
}
|
|
;
|
|
|
|
collect_element:
|
|
variable_name T_ASSIGN expression {
|
|
auto node = parser->ast()->createNodeAssign($1.value, $1.length, $3);
|
|
parser->pushArrayElement(node);
|
|
}
|
|
;
|
|
|
|
collect_optional_into:
|
|
/* empty */ {
|
|
$$ = nullptr;
|
|
}
|
|
| T_INTO variable_name {
|
|
$$ = parser->ast()->createNodeValueString($2.value, $2.length);
|
|
}
|
|
| T_INTO variable_name T_ASSIGN expression {
|
|
auto node = parser->ast()->createNodeArray();
|
|
node->addMember(parser->ast()->createNodeValueString($2.value, $2.length));
|
|
node->addMember($4);
|
|
$$ = node;
|
|
}
|
|
;
|
|
|
|
variable_list:
|
|
variable_name {
|
|
if (! parser->ast()->scopes()->existsVariable($1.value, $1.length)) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "use of unknown variable '%s' for KEEP", $1.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
|
|
auto node = parser->ast()->createNodeReference($1.value, $1.length);
|
|
if (node == nullptr) {
|
|
ABORT_OOM
|
|
}
|
|
|
|
// indicate the this node is a reference to the variable name, not the variable value
|
|
node->setFlag(FLAG_KEEP_VARIABLENAME);
|
|
parser->pushArrayElement(node);
|
|
}
|
|
| variable_list T_COMMA variable_name {
|
|
if (! parser->ast()->scopes()->existsVariable($3.value, $3.length)) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "use of unknown variable '%s' for KEEP", $3.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
|
|
auto node = parser->ast()->createNodeReference($3.value, $3.length);
|
|
if (node == nullptr) {
|
|
ABORT_OOM
|
|
}
|
|
|
|
// indicate the this node is a reference to the variable name, not the variable value
|
|
node->setFlag(FLAG_KEEP_VARIABLENAME);
|
|
parser->pushArrayElement(node);
|
|
}
|
|
;
|
|
|
|
keep:
|
|
T_STRING {
|
|
if (!TRI_CaseEqualString($1.value, "KEEP")) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "unexpected qualifier '%s', expecting 'KEEP'", $1.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
|
|
auto node = parser->ast()->createNodeArray();
|
|
parser->pushStack(node);
|
|
} variable_list {
|
|
auto list = static_cast<AstNode*>(parser->popStack());
|
|
$$ = list;
|
|
}
|
|
;
|
|
|
|
aggregate:
|
|
T_AGGREGATE {
|
|
auto node = parser->ast()->createNodeArray();
|
|
parser->pushStack(node);
|
|
} collect_list {
|
|
auto list = static_cast<AstNode*>(parser->popStack());
|
|
$$ = list;
|
|
}
|
|
;
|
|
|
|
sort_statement:
|
|
T_SORT {
|
|
auto node = parser->ast()->createNodeArray();
|
|
parser->pushStack(node);
|
|
} sort_list {
|
|
auto list = static_cast<AstNode const*>(parser->popStack());
|
|
auto node = parser->ast()->createNodeSort(list);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
;
|
|
|
|
sort_list:
|
|
sort_element {
|
|
parser->pushArrayElement($1);
|
|
}
|
|
| sort_list T_COMMA sort_element {
|
|
parser->pushArrayElement($3);
|
|
}
|
|
;
|
|
|
|
sort_element:
|
|
expression sort_direction {
|
|
$$ = parser->ast()->createNodeSortElement($1, $2);
|
|
}
|
|
;
|
|
|
|
sort_direction:
|
|
/* empty */ {
|
|
$$ = parser->ast()->createNodeValueBool(true);
|
|
}
|
|
| T_ASC {
|
|
$$ = parser->ast()->createNodeValueBool(true);
|
|
}
|
|
| T_DESC {
|
|
$$ = parser->ast()->createNodeValueBool(false);
|
|
}
|
|
| simple_value {
|
|
$$ = $1;
|
|
}
|
|
;
|
|
|
|
limit_statement:
|
|
T_LIMIT expression {
|
|
auto offset = parser->ast()->createNodeValueInt(0);
|
|
auto node = parser->ast()->createNodeLimit(offset, $2);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
| T_LIMIT expression T_COMMA expression {
|
|
auto node = parser->ast()->createNodeLimit($2, $4);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
;
|
|
|
|
return_statement:
|
|
T_RETURN distinct_expression {
|
|
auto node = parser->ast()->createNodeReturn($2);
|
|
parser->ast()->addOperation(node);
|
|
parser->ast()->scopes()->endNested();
|
|
}
|
|
;
|
|
|
|
in_or_into_collection:
|
|
T_IN in_or_into_collection_name {
|
|
$$ = $2;
|
|
}
|
|
| T_INTO in_or_into_collection_name {
|
|
$$ = $2;
|
|
}
|
|
;
|
|
|
|
remove_statement:
|
|
T_REMOVE expression in_or_into_collection options {
|
|
if (!parser->configureWriteQuery($3, $4)) {
|
|
YYABORT;
|
|
}
|
|
auto node = parser->ast()->createNodeRemove($2, $3, $4);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
;
|
|
|
|
insert_statement:
|
|
T_INSERT expression in_or_into_collection options {
|
|
if (!parser->configureWriteQuery($3, $4)) {
|
|
YYABORT;
|
|
}
|
|
auto node = parser->ast()->createNodeInsert($2, $3, $4);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
;
|
|
|
|
update_parameters:
|
|
expression in_or_into_collection options {
|
|
if (!parser->configureWriteQuery($2, $3)) {
|
|
YYABORT;
|
|
}
|
|
|
|
AstNode* node = parser->ast()->createNodeUpdate(nullptr, $1, $2, $3);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
| expression T_WITH expression in_or_into_collection options {
|
|
if (!parser->configureWriteQuery($4, $5)) {
|
|
YYABORT;
|
|
}
|
|
|
|
AstNode* node = parser->ast()->createNodeUpdate($1, $3, $4, $5);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
;
|
|
|
|
update_statement:
|
|
T_UPDATE update_parameters {
|
|
}
|
|
;
|
|
|
|
replace_parameters:
|
|
expression in_or_into_collection options {
|
|
if (!parser->configureWriteQuery($2, $3)) {
|
|
YYABORT;
|
|
}
|
|
|
|
AstNode* node = parser->ast()->createNodeReplace(nullptr, $1, $2, $3);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
| expression T_WITH expression in_or_into_collection options {
|
|
if (!parser->configureWriteQuery($4, $5)) {
|
|
YYABORT;
|
|
}
|
|
|
|
AstNode* node = parser->ast()->createNodeReplace($1, $3, $4, $5);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
;
|
|
|
|
replace_statement:
|
|
T_REPLACE replace_parameters {
|
|
}
|
|
;
|
|
|
|
update_or_replace:
|
|
T_UPDATE {
|
|
$$ = static_cast<int64_t>(NODE_TYPE_UPDATE);
|
|
}
|
|
| T_REPLACE {
|
|
$$ = static_cast<int64_t>(NODE_TYPE_REPLACE);
|
|
}
|
|
;
|
|
|
|
upsert_statement:
|
|
T_UPSERT {
|
|
// reserve a variable named "$OLD", we might need it in the update expression
|
|
// and in a later return thing
|
|
parser->pushStack(parser->ast()->createNodeVariable(TRI_CHAR_LENGTH_PAIR(Variable::NAME_OLD), true));
|
|
} expression {
|
|
AstNode* variableNode = static_cast<AstNode*>(parser->popStack());
|
|
|
|
auto scopes = parser->ast()->scopes();
|
|
|
|
scopes->start(arangodb::aql::AQL_SCOPE_SUBQUERY);
|
|
parser->ast()->startSubQuery();
|
|
|
|
scopes->start(arangodb::aql::AQL_SCOPE_FOR);
|
|
std::string const variableName = parser->ast()->variables()->nextName();
|
|
auto forNode = parser->ast()->createNodeFor(variableName.c_str(), variableName.size(), parser->ast()->createNodeArray(), false);
|
|
parser->ast()->addOperation(forNode);
|
|
|
|
auto filterNode = parser->ast()->createNodeUpsertFilter(parser->ast()->createNodeReference(variableName), $3);
|
|
parser->ast()->addOperation(filterNode);
|
|
|
|
auto offsetValue = parser->ast()->createNodeValueInt(0);
|
|
auto limitValue = parser->ast()->createNodeValueInt(1);
|
|
auto limitNode = parser->ast()->createNodeLimit(offsetValue, limitValue);
|
|
parser->ast()->addOperation(limitNode);
|
|
|
|
auto refNode = parser->ast()->createNodeReference(variableName);
|
|
auto returnNode = parser->ast()->createNodeReturn(refNode);
|
|
parser->ast()->addOperation(returnNode);
|
|
scopes->endNested();
|
|
|
|
AstNode* subqueryNode = parser->ast()->endSubQuery();
|
|
scopes->endCurrent();
|
|
|
|
std::string const subqueryName = parser->ast()->variables()->nextName();
|
|
auto subQuery = parser->ast()->createNodeLet(subqueryName.c_str(), subqueryName.size(), subqueryNode, false);
|
|
parser->ast()->addOperation(subQuery);
|
|
|
|
auto index = parser->ast()->createNodeValueInt(0);
|
|
auto firstDoc = parser->ast()->createNodeLet(variableNode, parser->ast()->createNodeIndexedAccess(parser->ast()->createNodeReference(subqueryName), index));
|
|
parser->ast()->addOperation(firstDoc);
|
|
|
|
parser->pushStack(forNode);
|
|
} T_INSERT expression update_or_replace expression in_or_into_collection options {
|
|
AstNode* forNode = static_cast<AstNode*>(parser->popStack());
|
|
forNode->changeMember(1, $9);
|
|
|
|
if (!parser->configureWriteQuery($9, $10)) {
|
|
YYABORT;
|
|
}
|
|
|
|
auto node = parser->ast()->createNodeUpsert(static_cast<AstNodeType>($7), parser->ast()->createNodeReference(TRI_CHAR_LENGTH_PAIR(Variable::NAME_OLD)), $6, $8, $9, $10);
|
|
parser->ast()->addOperation(node);
|
|
}
|
|
;
|
|
|
|
quantifier:
|
|
T_ALL {
|
|
$$ = parser->ast()->createNodeQuantifier(Quantifier::ALL);
|
|
}
|
|
| T_ANY {
|
|
$$ = parser->ast()->createNodeQuantifier(Quantifier::ANY);
|
|
}
|
|
| T_NONE {
|
|
$$ = parser->ast()->createNodeQuantifier(Quantifier::NONE);
|
|
}
|
|
;
|
|
|
|
distinct_expression:
|
|
T_DISTINCT {
|
|
auto const scopeType = parser->ast()->scopes()->type();
|
|
|
|
if (scopeType == AQL_SCOPE_MAIN ||
|
|
scopeType == AQL_SCOPE_SUBQUERY) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "cannot use DISTINCT modifier on top-level query element", yylloc.first_line, yylloc.first_column);
|
|
}
|
|
} expression {
|
|
$$ = parser->ast()->createNodeDistinct($3);
|
|
}
|
|
| expression {
|
|
$$ = $1;
|
|
}
|
|
;
|
|
|
|
expression:
|
|
operator_unary {
|
|
$$ = $1;
|
|
}
|
|
| operator_binary {
|
|
$$ = $1;
|
|
}
|
|
| operator_ternary {
|
|
$$ = $1;
|
|
}
|
|
| value_literal {
|
|
$$ = $1;
|
|
}
|
|
| reference {
|
|
$$ = $1;
|
|
}
|
|
| expression T_RANGE expression {
|
|
$$ = parser->ast()->createNodeRange($1, $3);
|
|
}
|
|
;
|
|
|
|
function_name:
|
|
T_STRING {
|
|
$$ = $1;
|
|
}
|
|
| function_name T_SCOPE T_STRING {
|
|
std::string temp($1.value, $1.length);
|
|
temp.append("::");
|
|
temp.append($3.value, $3.length);
|
|
auto p = parser->query()->registerString(temp);
|
|
|
|
if (p == nullptr) {
|
|
ABORT_OOM
|
|
}
|
|
|
|
$$.value = p;
|
|
$$.length = temp.size();
|
|
}
|
|
;
|
|
|
|
function_call:
|
|
function_name T_OPEN {
|
|
parser->pushStack($1.value);
|
|
|
|
auto node = parser->ast()->createNodeArray();
|
|
parser->pushStack(node);
|
|
} optional_function_call_arguments T_CLOSE %prec FUNCCALL {
|
|
auto list = static_cast<AstNode const*>(parser->popStack());
|
|
$$ = parser->ast()->createNodeFunctionCall(static_cast<char const*>(parser->popStack()), list);
|
|
}
|
|
| T_LIKE T_OPEN {
|
|
auto node = parser->ast()->createNodeArray();
|
|
parser->pushStack(node);
|
|
} optional_function_call_arguments T_CLOSE %prec FUNCCALL {
|
|
auto list = static_cast<AstNode const*>(parser->popStack());
|
|
$$ = parser->ast()->createNodeFunctionCall(TRI_CHAR_LENGTH_PAIR("LIKE"), list);
|
|
}
|
|
;
|
|
|
|
operator_unary:
|
|
T_PLUS expression %prec UPLUS {
|
|
$$ = parser->ast()->createNodeUnaryOperator(NODE_TYPE_OPERATOR_UNARY_PLUS, $2);
|
|
}
|
|
| T_MINUS expression %prec UMINUS {
|
|
$$ = parser->ast()->createNodeUnaryOperator(NODE_TYPE_OPERATOR_UNARY_MINUS, $2);
|
|
}
|
|
| T_NOT expression %prec UNEGATION {
|
|
$$ = parser->ast()->createNodeUnaryOperator(NODE_TYPE_OPERATOR_UNARY_NOT, $2);
|
|
}
|
|
;
|
|
|
|
operator_binary:
|
|
expression T_OR expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_OR, $1, $3);
|
|
}
|
|
| expression T_AND expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_AND, $1, $3);
|
|
}
|
|
| expression T_PLUS expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_PLUS, $1, $3);
|
|
}
|
|
| expression T_MINUS expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_MINUS, $1, $3);
|
|
}
|
|
| expression T_TIMES expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_TIMES, $1, $3);
|
|
}
|
|
| expression T_DIV expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_DIV, $1, $3);
|
|
}
|
|
| expression T_MOD expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_MOD, $1, $3);
|
|
}
|
|
| expression T_EQ expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_EQ, $1, $3);
|
|
}
|
|
| expression T_NE expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_NE, $1, $3);
|
|
}
|
|
| expression T_LT expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_LT, $1, $3);
|
|
}
|
|
| expression T_GT expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_GT, $1, $3);
|
|
}
|
|
| expression T_LE expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_LE, $1, $3);
|
|
}
|
|
| expression T_GE expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_GE, $1, $3);
|
|
}
|
|
| expression T_IN expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_IN, $1, $3);
|
|
}
|
|
| expression T_NOT T_IN expression {
|
|
$$ = parser->ast()->createNodeBinaryOperator(NODE_TYPE_OPERATOR_BINARY_NIN, $1, $4);
|
|
}
|
|
| expression T_NOT T_LIKE expression {
|
|
AstNode* arguments = parser->ast()->createNodeArray(2);
|
|
arguments->addMember($1);
|
|
arguments->addMember($4);
|
|
AstNode* expression = parser->ast()->createNodeFunctionCall(TRI_CHAR_LENGTH_PAIR("LIKE"), arguments);
|
|
$$ = parser->ast()->createNodeUnaryOperator(NODE_TYPE_OPERATOR_UNARY_NOT, expression);
|
|
}
|
|
| expression T_NOT T_REGEX_MATCH expression {
|
|
AstNode* arguments = parser->ast()->createNodeArray(2);
|
|
arguments->addMember($1);
|
|
arguments->addMember($4);
|
|
AstNode* expression = parser->ast()->createNodeFunctionCall(TRI_CHAR_LENGTH_PAIR("REGEX_TEST"), arguments);
|
|
$$ = parser->ast()->createNodeUnaryOperator(NODE_TYPE_OPERATOR_UNARY_NOT, expression);
|
|
}
|
|
| expression T_NOT T_REGEX_NON_MATCH expression {
|
|
AstNode* arguments = parser->ast()->createNodeArray(2);
|
|
arguments->addMember($1);
|
|
arguments->addMember($4);
|
|
$$ = parser->ast()->createNodeFunctionCall(TRI_CHAR_LENGTH_PAIR("REGEX_TEST"), arguments);
|
|
}
|
|
| expression T_LIKE expression {
|
|
AstNode* arguments = parser->ast()->createNodeArray(2);
|
|
arguments->addMember($1);
|
|
arguments->addMember($3);
|
|
$$ = parser->ast()->createNodeFunctionCall(TRI_CHAR_LENGTH_PAIR("LIKE"), arguments);
|
|
}
|
|
| expression T_REGEX_MATCH expression {
|
|
AstNode* arguments = parser->ast()->createNodeArray(2);
|
|
arguments->addMember($1);
|
|
arguments->addMember($3);
|
|
$$ = parser->ast()->createNodeFunctionCall(TRI_CHAR_LENGTH_PAIR("REGEX_TEST"), arguments);
|
|
}
|
|
| expression T_REGEX_NON_MATCH expression {
|
|
AstNode* arguments = parser->ast()->createNodeArray(2);
|
|
arguments->addMember($1);
|
|
arguments->addMember($3);
|
|
AstNode* node = parser->ast()->createNodeFunctionCall(TRI_CHAR_LENGTH_PAIR("REGEX_TEST"), arguments);
|
|
$$ = parser->ast()->createNodeUnaryOperator(NODE_TYPE_OPERATOR_UNARY_NOT, node);
|
|
}
|
|
| expression quantifier T_EQ expression {
|
|
$$ = parser->ast()->createNodeBinaryArrayOperator(NODE_TYPE_OPERATOR_BINARY_ARRAY_EQ, $1, $4, $2);
|
|
}
|
|
| expression quantifier T_NE expression {
|
|
$$ = parser->ast()->createNodeBinaryArrayOperator(NODE_TYPE_OPERATOR_BINARY_ARRAY_NE, $1, $4, $2);
|
|
}
|
|
| expression quantifier T_LT expression {
|
|
$$ = parser->ast()->createNodeBinaryArrayOperator(NODE_TYPE_OPERATOR_BINARY_ARRAY_LT, $1, $4, $2);
|
|
}
|
|
| expression quantifier T_GT expression {
|
|
$$ = parser->ast()->createNodeBinaryArrayOperator(NODE_TYPE_OPERATOR_BINARY_ARRAY_GT, $1, $4, $2);
|
|
}
|
|
| expression quantifier T_LE expression {
|
|
$$ = parser->ast()->createNodeBinaryArrayOperator(NODE_TYPE_OPERATOR_BINARY_ARRAY_LE, $1, $4, $2);
|
|
}
|
|
| expression quantifier T_GE expression {
|
|
$$ = parser->ast()->createNodeBinaryArrayOperator(NODE_TYPE_OPERATOR_BINARY_ARRAY_GE, $1, $4, $2);
|
|
}
|
|
| expression quantifier T_IN expression {
|
|
$$ = parser->ast()->createNodeBinaryArrayOperator(NODE_TYPE_OPERATOR_BINARY_ARRAY_IN, $1, $4, $2);
|
|
}
|
|
| expression T_ALL T_NOT T_IN expression {
|
|
auto quantifier = parser->ast()->createNodeQuantifier(Quantifier::ALL);
|
|
$$ = parser->ast()->createNodeBinaryArrayOperator(NODE_TYPE_OPERATOR_BINARY_ARRAY_NIN, $1, $5, quantifier);
|
|
}
|
|
| expression T_ANY T_NOT T_IN expression {
|
|
auto quantifier = parser->ast()->createNodeQuantifier(Quantifier::ANY);
|
|
$$ = parser->ast()->createNodeBinaryArrayOperator(NODE_TYPE_OPERATOR_BINARY_ARRAY_NIN, $1, $5, quantifier);
|
|
}
|
|
| expression T_NONE T_NOT T_IN expression {
|
|
auto quantifier = parser->ast()->createNodeQuantifier(Quantifier::NONE);
|
|
$$ = parser->ast()->createNodeBinaryArrayOperator(NODE_TYPE_OPERATOR_BINARY_ARRAY_NIN, $1, $5, quantifier);
|
|
}
|
|
;
|
|
|
|
operator_ternary:
|
|
expression T_QUESTION expression T_COLON expression {
|
|
$$ = parser->ast()->createNodeTernaryOperator($1, $3, $5);
|
|
}
|
|
| expression T_QUESTION T_COLON expression {
|
|
$$ = parser->ast()->createNodeTernaryOperator($1, $1, $4);
|
|
}
|
|
;
|
|
|
|
optional_function_call_arguments:
|
|
/* empty */ {
|
|
}
|
|
| function_arguments_list {
|
|
}
|
|
;
|
|
|
|
expression_or_query:
|
|
expression {
|
|
$$ = $1;
|
|
}
|
|
| {
|
|
parser->ast()->scopes()->start(arangodb::aql::AQL_SCOPE_SUBQUERY);
|
|
parser->ast()->startSubQuery();
|
|
} query {
|
|
AstNode* node = parser->ast()->endSubQuery();
|
|
parser->ast()->scopes()->endCurrent();
|
|
|
|
std::string const variableName = parser->ast()->variables()->nextName();
|
|
auto subQuery = parser->ast()->createNodeLet(variableName.c_str(), variableName.size(), node, false);
|
|
parser->ast()->addOperation(subQuery);
|
|
|
|
$$ = parser->ast()->createNodeSubqueryReference(variableName);
|
|
}
|
|
;
|
|
|
|
function_arguments_list:
|
|
expression_or_query {
|
|
parser->pushArrayElement($1);
|
|
}
|
|
| function_arguments_list T_COMMA expression_or_query {
|
|
parser->pushArrayElement($3);
|
|
}
|
|
;
|
|
|
|
compound_value:
|
|
array {
|
|
$$ = $1;
|
|
}
|
|
| object {
|
|
$$ = $1;
|
|
}
|
|
;
|
|
|
|
array:
|
|
T_ARRAY_OPEN {
|
|
auto node = parser->ast()->createNodeArray();
|
|
parser->pushArray(node);
|
|
} optional_array_elements T_ARRAY_CLOSE {
|
|
$$ = parser->popArray();
|
|
}
|
|
;
|
|
|
|
optional_array_elements:
|
|
/* empty */ {
|
|
}
|
|
| array_elements_list {
|
|
}
|
|
;
|
|
|
|
array_elements_list:
|
|
expression {
|
|
parser->pushArrayElement($1);
|
|
}
|
|
| array_elements_list T_COMMA expression {
|
|
parser->pushArrayElement($3);
|
|
}
|
|
;
|
|
|
|
for_options:
|
|
/* empty */ {
|
|
$$ = nullptr;
|
|
}
|
|
| T_STRING expression {
|
|
if ($2 == nullptr) {
|
|
ABORT_OOM
|
|
}
|
|
|
|
// we always return an array with two values: SEARCH and OPTIONS
|
|
// as only one of these values will be set here, the other value is NOP
|
|
auto node = parser->ast()->createNodeArray(2);
|
|
// only one extra qualifier. now we need to check if it is SEARCH or OPTIONS
|
|
|
|
if (TRI_CaseEqualString($1.value, "SEARCH")) {
|
|
// found SEARCH
|
|
node->addMember($2);
|
|
node->addMember(parser->ast()->createNodeNop());
|
|
} else {
|
|
// everything else must be OPTIONS
|
|
if (!TRI_CaseEqualString($1.value, "OPTIONS")) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "unexpected qualifier '%s', expecting 'SEARCH' or 'OPTIONS'", $1.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
|
|
node->addMember(parser->ast()->createNodeNop());
|
|
node->addMember($2);
|
|
}
|
|
|
|
$$ = node;
|
|
}
|
|
| T_STRING expression T_STRING expression {
|
|
if ($2 == nullptr) {
|
|
ABORT_OOM
|
|
}
|
|
|
|
// two extra qualifiers. we expect them in the order: SEARCH, then OPTIONS
|
|
|
|
if (!TRI_CaseEqualString($1.value, "SEARCH") ||
|
|
!TRI_CaseEqualString($3.value, "OPTIONS")) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "unexpected qualifier '%s', expecting 'SEARCH' and 'OPTIONS'", $1.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
|
|
auto node = parser->ast()->createNodeArray(2);
|
|
node->addMember($2);
|
|
node->addMember($4);
|
|
$$ = node;
|
|
}
|
|
;
|
|
|
|
options:
|
|
/* empty */ {
|
|
$$ = nullptr;
|
|
}
|
|
| T_STRING object {
|
|
if ($2 == nullptr) {
|
|
ABORT_OOM
|
|
}
|
|
|
|
if (!TRI_CaseEqualString($1.value, "OPTIONS")) {
|
|
parser->registerParseError(TRI_ERROR_QUERY_PARSE, "unexpected qualifier '%s', expecting 'OPTIONS'", $1.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
|
|
$$ = $2;
|
|
}
|
|
;
|
|
|
|
object:
|
|
T_OBJECT_OPEN {
|
|
auto node = parser->ast()->createNodeObject();
|
|
parser->pushStack(node);
|
|
} optional_object_elements T_OBJECT_CLOSE {
|
|
$$ = static_cast<AstNode*>(parser->popStack());
|
|
}
|
|
;
|
|
|
|
optional_object_elements:
|
|
/* empty */ {
|
|
}
|
|
| object_elements_list {
|
|
}
|
|
;
|
|
|
|
object_elements_list:
|
|
object_element {
|
|
}
|
|
| object_elements_list T_COMMA object_element {
|
|
}
|
|
;
|
|
|
|
object_element:
|
|
T_STRING {
|
|
// attribute-name-only (comparable to JS enhanced object literals, e.g. { foo, bar })
|
|
auto ast = parser->ast();
|
|
auto variable = ast->scopes()->getVariable($1.value, $1.length, true);
|
|
|
|
if (variable == nullptr) {
|
|
// variable does not exist
|
|
parser->registerParseError(TRI_ERROR_QUERY_VARIABLE_NAME_UNKNOWN, "use of unknown variable '%s' in object literal", $1.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
|
|
// create a reference to the variable
|
|
auto node = ast->createNodeReference(variable);
|
|
parser->pushObjectElement($1.value, $1.length, node);
|
|
}
|
|
| object_element_name T_COLON expression {
|
|
// attribute-name : attribute-value
|
|
parser->pushObjectElement($1.value, $1.length, $3);
|
|
}
|
|
| T_PARAMETER T_COLON expression {
|
|
// bind-parameter : attribute-value
|
|
if ($1.length < 1 || $1.value[0] == '@') {
|
|
parser->registerParseError(TRI_ERROR_QUERY_BIND_PARAMETER_TYPE, TRI_errno_string(TRI_ERROR_QUERY_BIND_PARAMETER_TYPE), $1.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
|
|
auto param = parser->ast()->createNodeParameter($1.value, $1.length);
|
|
parser->pushObjectElement(param, $3);
|
|
}
|
|
| T_ARRAY_OPEN expression T_ARRAY_CLOSE T_COLON expression {
|
|
// [ attribute-name-expression ] : attribute-value
|
|
parser->pushObjectElement($2, $5);
|
|
}
|
|
;
|
|
|
|
array_filter_operator:
|
|
T_TIMES {
|
|
$$ = 1;
|
|
}
|
|
| array_filter_operator T_TIMES {
|
|
$$ = $1 + 1;
|
|
}
|
|
;
|
|
|
|
optional_array_filter:
|
|
/* empty */ {
|
|
$$ = nullptr;
|
|
}
|
|
| T_FILTER expression {
|
|
$$ = $2;
|
|
}
|
|
;
|
|
|
|
optional_array_limit:
|
|
/* empty */ {
|
|
$$ = nullptr;
|
|
}
|
|
| T_LIMIT expression {
|
|
$$ = parser->ast()->createNodeArrayLimit(nullptr, $2);
|
|
}
|
|
| T_LIMIT expression T_COMMA expression {
|
|
$$ = parser->ast()->createNodeArrayLimit($2, $4);
|
|
}
|
|
;
|
|
|
|
optional_array_return:
|
|
/* empty */ {
|
|
$$ = nullptr;
|
|
}
|
|
| T_RETURN expression {
|
|
$$ = $2;
|
|
}
|
|
;
|
|
|
|
graph_collection:
|
|
T_STRING {
|
|
$$ = parser->ast()->createNodeValueString($1.value, $1.length);
|
|
}
|
|
| bind_parameter {
|
|
$$ = $1;
|
|
}
|
|
| graph_direction T_STRING {
|
|
auto tmp = parser->ast()->createNodeValueString($2.value, $2.length);
|
|
$$ = parser->ast()->createNodeCollectionDirection($1, tmp);
|
|
}
|
|
| graph_direction bind_parameter {
|
|
$$ = parser->ast()->createNodeCollectionDirection($1, $2);
|
|
}
|
|
;
|
|
|
|
graph_collection_list:
|
|
graph_collection {
|
|
auto node = static_cast<AstNode*>(parser->peekStack());
|
|
node->addMember($1);
|
|
}
|
|
| graph_collection_list T_COMMA graph_collection {
|
|
auto node = static_cast<AstNode*>(parser->peekStack());
|
|
node->addMember($3);
|
|
}
|
|
;
|
|
|
|
graph_subject:
|
|
graph_collection {
|
|
auto node = parser->ast()->createNodeArray();
|
|
node->addMember($1);
|
|
auto const& resolver = parser->query()->resolver();
|
|
$$ = parser->ast()->createNodeCollectionList(node, resolver);
|
|
}
|
|
| graph_collection T_COMMA {
|
|
auto node = parser->ast()->createNodeArray();
|
|
parser->pushStack(node);
|
|
node->addMember($1);
|
|
} graph_collection_list {
|
|
auto node = static_cast<AstNode*>(parser->popStack());
|
|
auto const& resolver = parser->query()->resolver();
|
|
$$ = parser->ast()->createNodeCollectionList(node, resolver);
|
|
}
|
|
| T_GRAPH bind_parameter {
|
|
// graph name
|
|
$$ = $2;
|
|
}
|
|
| T_GRAPH T_QUOTED_STRING {
|
|
// graph name
|
|
$$ = parser->ast()->createNodeValueString($2.value, $2.length);
|
|
}
|
|
;
|
|
|
|
graph_direction:
|
|
// Returns the edge direction number.
|
|
// Identical order as TRI_edge_direction_e
|
|
T_OUTBOUND {
|
|
$$ = 2;
|
|
}
|
|
| T_INBOUND {
|
|
$$ = 1;
|
|
}
|
|
| T_ANY {
|
|
$$ = 0;
|
|
}
|
|
;
|
|
|
|
graph_direction_steps:
|
|
graph_direction {
|
|
$$ = parser->ast()->createNodeDirection($1, 1);
|
|
}
|
|
| expression graph_direction %prec T_OUTBOUND {
|
|
$$ = parser->ast()->createNodeDirection($2, $1);
|
|
}
|
|
;
|
|
|
|
reference:
|
|
T_STRING {
|
|
// variable or collection or view
|
|
auto ast = parser->ast();
|
|
AstNode* node = nullptr;
|
|
|
|
auto variable = ast->scopes()->getVariable($1.value, $1.length, true);
|
|
|
|
if (variable == nullptr) {
|
|
// variable does not exist
|
|
// now try special variables
|
|
if (ast->scopes()->canUseCurrentVariable() && strcmp($1.value, "CURRENT") == 0) {
|
|
variable = ast->scopes()->getCurrentVariable();
|
|
} else if (strcmp($1.value, Variable::NAME_CURRENT) == 0) {
|
|
variable = ast->scopes()->getCurrentVariable();
|
|
}
|
|
}
|
|
|
|
if (variable != nullptr) {
|
|
// variable alias exists, now use it
|
|
node = ast->createNodeReference(variable);
|
|
}
|
|
|
|
if (node == nullptr) {
|
|
// variable not found. so it must have been a collection or view
|
|
auto const& resolver = parser->query()->resolver();
|
|
node = ast->createNodeDataSource(resolver, $1.value, $1.length, arangodb::AccessMode::Type::READ, true, false);
|
|
}
|
|
|
|
TRI_ASSERT(node != nullptr);
|
|
|
|
$$ = node;
|
|
}
|
|
| compound_value {
|
|
$$ = $1;
|
|
}
|
|
| bind_parameter {
|
|
$$ = $1;
|
|
}
|
|
| function_call {
|
|
$$ = $1;
|
|
|
|
if ($$ == nullptr) {
|
|
ABORT_OOM
|
|
}
|
|
}
|
|
| T_OPEN expression T_CLOSE {
|
|
if ($2->type == NODE_TYPE_EXPANSION) {
|
|
// create a dummy passthru node that reduces and evaluates the expansion first
|
|
// and the expansion on top of the stack won't be chained with any other expansions
|
|
$$ = parser->ast()->createNodePassthru($2);
|
|
}
|
|
else {
|
|
$$ = $2;
|
|
}
|
|
}
|
|
| T_OPEN {
|
|
parser->ast()->scopes()->start(arangodb::aql::AQL_SCOPE_SUBQUERY);
|
|
parser->ast()->startSubQuery();
|
|
} query T_CLOSE {
|
|
AstNode* node = parser->ast()->endSubQuery();
|
|
parser->ast()->scopes()->endCurrent();
|
|
|
|
std::string const variableName = parser->ast()->variables()->nextName();
|
|
auto subQuery = parser->ast()->createNodeLet(variableName.c_str(), variableName.size(), node, false);
|
|
parser->ast()->addOperation(subQuery);
|
|
|
|
$$ = parser->ast()->createNodeReference(variableName);
|
|
}
|
|
| reference '.' T_STRING %prec REFERENCE {
|
|
// named variable access, e.g. variable.reference
|
|
if ($1->type == NODE_TYPE_EXPANSION) {
|
|
// if left operand is an expansion already...
|
|
// dive into the expansion's right-hand child nodes for further expansion and
|
|
// patch the bottom-most one
|
|
auto current = const_cast<AstNode*>(parser->ast()->findExpansionSubNode($1));
|
|
TRI_ASSERT(current->type == NODE_TYPE_EXPANSION);
|
|
current->changeMember(1, parser->ast()->createNodeAttributeAccess(current->getMember(1), $3.value, $3.length));
|
|
$$ = $1;
|
|
}
|
|
else {
|
|
$$ = parser->ast()->createNodeAttributeAccess($1, $3.value, $3.length);
|
|
}
|
|
}
|
|
| reference '.' bind_parameter %prec REFERENCE {
|
|
// named variable access, e.g. variable.@reference
|
|
if ($1->type == NODE_TYPE_EXPANSION) {
|
|
// if left operand is an expansion already...
|
|
// patch the existing expansion
|
|
auto current = const_cast<AstNode*>(parser->ast()->findExpansionSubNode($1));
|
|
TRI_ASSERT(current->type == NODE_TYPE_EXPANSION);
|
|
current->changeMember(1, parser->ast()->createNodeBoundAttributeAccess(current->getMember(1), $3));
|
|
$$ = $1;
|
|
}
|
|
else {
|
|
$$ = parser->ast()->createNodeBoundAttributeAccess($1, $3);
|
|
}
|
|
}
|
|
| reference T_ARRAY_OPEN expression T_ARRAY_CLOSE %prec INDEXED {
|
|
// indexed variable access, e.g. variable[index]
|
|
if ($1->type == NODE_TYPE_EXPANSION) {
|
|
// if left operand is an expansion already...
|
|
// patch the existing expansion
|
|
auto current = const_cast<AstNode*>(parser->ast()->findExpansionSubNode($1));
|
|
TRI_ASSERT(current->type == NODE_TYPE_EXPANSION);
|
|
current->changeMember(1, parser->ast()->createNodeIndexedAccess(current->getMember(1), $3));
|
|
$$ = $1;
|
|
}
|
|
else {
|
|
$$ = parser->ast()->createNodeIndexedAccess($1, $3);
|
|
}
|
|
}
|
|
| reference T_ARRAY_OPEN array_filter_operator {
|
|
// variable expansion, e.g. variable[*], with optional FILTER, LIMIT and RETURN clauses
|
|
if ($3 > 1 && $1->type == NODE_TYPE_EXPANSION) {
|
|
// create a dummy passthru node that reduces and evaluates the expansion first
|
|
// and the expansion on top of the stack won't be chained with any other expansions
|
|
$1 = parser->ast()->createNodePassthru($1);
|
|
}
|
|
|
|
// create a temporary iterator variable
|
|
std::string const nextName = parser->ast()->variables()->nextName() + "_";
|
|
|
|
if ($1->type == NODE_TYPE_EXPANSION) {
|
|
auto iterator = parser->ast()->createNodeIterator(nextName.c_str(), nextName.size(), $1->getMember(1));
|
|
parser->pushStack(iterator);
|
|
}
|
|
else {
|
|
auto iterator = parser->ast()->createNodeIterator(nextName.c_str(), nextName.size(), $1);
|
|
parser->pushStack(iterator);
|
|
}
|
|
|
|
auto scopes = parser->ast()->scopes();
|
|
scopes->stackCurrentVariable(scopes->getVariable(nextName));
|
|
} optional_array_filter optional_array_limit optional_array_return T_ARRAY_CLOSE %prec EXPANSION {
|
|
auto scopes = parser->ast()->scopes();
|
|
scopes->unstackCurrentVariable();
|
|
|
|
auto iterator = static_cast<AstNode const*>(parser->popStack());
|
|
auto variableNode = iterator->getMember(0);
|
|
TRI_ASSERT(variableNode->type == NODE_TYPE_VARIABLE);
|
|
auto variable = static_cast<Variable const*>(variableNode->getData());
|
|
|
|
if ($1->type == NODE_TYPE_EXPANSION) {
|
|
auto expand = parser->ast()->createNodeExpansion($3, iterator, parser->ast()->createNodeReference(variable->name), $5, $6, $7);
|
|
$1->changeMember(1, expand);
|
|
$$ = $1;
|
|
}
|
|
else {
|
|
$$ = parser->ast()->createNodeExpansion($3, iterator, parser->ast()->createNodeReference(variable->name), $5, $6, $7);
|
|
}
|
|
}
|
|
;
|
|
|
|
simple_value:
|
|
value_literal {
|
|
$$ = $1;
|
|
}
|
|
| bind_parameter {
|
|
$$ = $1;
|
|
}
|
|
;
|
|
|
|
numeric_value:
|
|
T_INTEGER {
|
|
if ($1 == nullptr) {
|
|
ABORT_OOM
|
|
}
|
|
|
|
$$ = $1;
|
|
}
|
|
| T_DOUBLE {
|
|
if ($1 == nullptr) {
|
|
ABORT_OOM
|
|
}
|
|
|
|
$$ = $1;
|
|
}
|
|
;
|
|
|
|
value_literal:
|
|
T_QUOTED_STRING {
|
|
$$ = parser->ast()->createNodeValueString($1.value, $1.length);
|
|
}
|
|
| numeric_value {
|
|
$$ = $1;
|
|
}
|
|
| T_NULL {
|
|
$$ = parser->ast()->createNodeValueNull();
|
|
}
|
|
| T_TRUE {
|
|
$$ = parser->ast()->createNodeValueBool(true);
|
|
}
|
|
| T_FALSE {
|
|
$$ = parser->ast()->createNodeValueBool(false);
|
|
}
|
|
;
|
|
|
|
in_or_into_collection_name:
|
|
T_STRING {
|
|
auto const& resolver = parser->query()->resolver();
|
|
$$ = parser->ast()->createNodeCollection(resolver, $1.value, $1.length, arangodb::AccessMode::Type::WRITE);
|
|
}
|
|
| T_QUOTED_STRING {
|
|
auto const& resolver = parser->query()->resolver();
|
|
$$ = parser->ast()->createNodeCollection(resolver, $1.value, $1.length, arangodb::AccessMode::Type::WRITE);
|
|
}
|
|
| T_DATA_SOURCE_PARAMETER {
|
|
if ($1.length < 2 || $1.value[0] != '@') {
|
|
parser->registerParseError(TRI_ERROR_QUERY_BIND_PARAMETER_TYPE, TRI_errno_string(TRI_ERROR_QUERY_BIND_PARAMETER_TYPE), $1.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
|
|
$$ = parser->ast()->createNodeParameterDatasource($1.value, $1.length);
|
|
}
|
|
;
|
|
|
|
bind_parameter:
|
|
T_DATA_SOURCE_PARAMETER {
|
|
if ($1.length < 2 || $1.value[0] != '@') {
|
|
parser->registerParseError(TRI_ERROR_QUERY_BIND_PARAMETER_TYPE, TRI_errno_string(TRI_ERROR_QUERY_BIND_PARAMETER_TYPE), $1.value, yylloc.first_line, yylloc.first_column);
|
|
}
|
|
|
|
$$ = parser->ast()->createNodeParameterDatasource($1.value, $1.length);
|
|
}
|
|
| T_PARAMETER {
|
|
$$ = parser->ast()->createNodeParameter($1.value, $1.length);
|
|
}
|
|
;
|
|
|
|
object_element_name:
|
|
T_STRING {
|
|
$$ = $1;
|
|
}
|
|
| T_QUOTED_STRING {
|
|
$$ = $1;
|
|
}
|
|
|
|
variable_name:
|
|
T_STRING {
|
|
$$ = $1;
|
|
}
|
|
;
|