From: Thomas Walker Lynch Date: Tue, 3 Sep 2024 02:03:17 +0000 (+0000) Subject: start of using ANTLR grammar grammar to parse then make more abstract the GQL grammar... X-Git-Url: https://git.reasoningtechnology.com/usr/lib/python2.7/gettext.py?a=commitdiff_plain;h=3787ca666518c448f56e5a25673ab8ca0179cc89;p=GQL-to-Cypher start of using ANTLR grammar grammar to parse then make more abstract the GQL grammar file --- diff --git a/developer/ANTLR/ANTLRv4Lexer.g4 b/developer/ANTLR/ANTLRv4Lexer.g4 new file mode 100644 index 0000000..bf389d0 --- /dev/null +++ b/developer/ANTLR/ANTLRv4Lexer.g4 @@ -0,0 +1,437 @@ +/* + * [The "BSD license"] + * Copyright (c) 2012-2015 Terence Parr + * Copyright (c) 2012-2015 Sam Harwell + * Copyright (c) 2015 Gerald Rosenberg + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/** + * A grammar for ANTLR v4 implemented using v4 syntax + * + * Modified 2015.06.16 gbr + * -- update for compatibility with Antlr v4.5 + */ + +// $antlr-format alignTrailingComments on, columnLimit 130, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments off +// $antlr-format useTab off, allowShortRulesOnASingleLine off, allowShortBlocksOnASingleLine on, alignSemicolons hanging +// $antlr-format alignColons hanging + +// ====================================================== +// Lexer specification +// ====================================================== + +lexer grammar ANTLRv4Lexer; + +options { + superClass = LexerAdaptor; +} + +import LexBasic; + +// Standard set of fragments +tokens { + TOKEN_REF, + RULE_REF, + LEXER_CHAR_SET +} + +channels { + OFF_CHANNEL, + COMMENT +} + +// ------------------------- +// Comments +DOC_COMMENT + : DocComment -> channel (COMMENT) + ; + +BLOCK_COMMENT + : BlockComment -> channel (COMMENT) + ; + +LINE_COMMENT + : LineComment -> channel (COMMENT) + ; + +// ------------------------- +// Integer + +INT + : DecimalNumeral + ; + +// ------------------------- +// Literal string +// +// ANTLR makes no distinction between a single character literal and a +// multi-character string. All literals are single quote delimited and +// may contain unicode escape sequences of the form \uxxxx, where x +// is a valid hexadecimal number (per Unicode standard). +STRING_LITERAL + : SQuoteLiteral + ; + +UNTERMINATED_STRING_LITERAL + : USQuoteLiteral + ; + +// ------------------------- +// Arguments +// +// Certain argument lists, such as those specifying call parameters +// to a rule invocation, or input parameters to a rule specification +// are contained within square brackets. +BEGIN_ARGUMENT + : LBrack { this.handleBeginArgument(); } + ; + +// ------------------------- +// Target Language Actions +BEGIN_ACTION + : LBrace -> pushMode (TargetLanguageAction) + ; + +// ------------------------- +// Keywords +// +// 'options', 'tokens', and 'channels' are considered keywords +// but only when followed by '{', and considered as a single token. +// Otherwise, the symbols are tokenized as RULE_REF and allowed as +// an identifier in a labeledElement. +OPTIONS + : 'options' WSNLCHARS* '{' + ; + +TOKENS + : 'tokens' WSNLCHARS* '{' + ; + +CHANNELS + : 'channels' WSNLCHARS* '{' + ; + +fragment WSNLCHARS + : ' ' + | '\t' + | '\f' + | '\n' + | '\r' + ; + +IMPORT + : 'import' + ; + +FRAGMENT + : 'fragment' + ; + +LEXER + : 'lexer' + ; + +PARSER + : 'parser' + ; + +GRAMMAR + : 'grammar' + ; + +PROTECTED + : 'protected' + ; + +PUBLIC + : 'public' + ; + +PRIVATE + : 'private' + ; + +RETURNS + : 'returns' + ; + +LOCALS + : 'locals' + ; + +THROWS + : 'throws' + ; + +CATCH + : 'catch' + ; + +FINALLY + : 'finally' + ; + +MODE + : 'mode' + ; + +// ------------------------- +// Punctuation + +COLON + : Colon + ; + +COLONCOLON + : DColon + ; + +COMMA + : Comma + ; + +SEMI + : Semi + ; + +LPAREN + : LParen + ; + +RPAREN + : RParen + ; + +LBRACE + : LBrace + ; + +RBRACE + : RBrace + ; + +RARROW + : RArrow + ; + +LT + : Lt + ; + +GT + : Gt + ; + +ASSIGN + : Equal + ; + +QUESTION + : Question + ; + +STAR + : Star + ; + +PLUS_ASSIGN + : PlusAssign + ; + +PLUS + : Plus + ; + +OR + : Pipe + ; + +DOLLAR + : Dollar + ; + +RANGE + : Range + ; + +DOT + : Dot + ; + +AT + : At + ; + +POUND + : Pound + ; + +NOT + : Tilde + ; + +// ------------------------- +// Identifiers - allows unicode rule/token names + +ID + : Id + ; + +// ------------------------- +// Whitespace + +WS + : Ws+ -> channel (OFF_CHANNEL) + ; + +// ------------------------- +// Illegal Characters +// +// This is an illegal character trap which is always the last rule in the +// lexer specification. It matches a single character of any value and being +// the last rule in the file will match when no other rule knows what to do +// about the character. It is reported as an error but is not passed on to the +// parser. This means that the parser to deal with the gramamr file anyway +// but we will not try to analyse or code generate from a file with lexical +// errors. + +// Comment this rule out to allow the error to be propagated to the parser +ERRCHAR + : . -> channel (HIDDEN) + ; + +// ====================================================== +// Lexer modes +// ------------------------- +// Arguments +mode Argument; + +// E.g., [int x, List a[]] +NESTED_ARGUMENT + : LBrack -> type (ARGUMENT_CONTENT), pushMode (Argument) + ; + +ARGUMENT_ESCAPE + : EscAny -> type (ARGUMENT_CONTENT) + ; + +ARGUMENT_STRING_LITERAL + : DQuoteLiteral -> type (ARGUMENT_CONTENT) + ; + +ARGUMENT_CHAR_LITERAL + : SQuoteLiteral -> type (ARGUMENT_CONTENT) + ; + +END_ARGUMENT + : RBrack { this.handleEndArgument(); } + ; + +// added this to return non-EOF token type here. EOF does something weird +UNTERMINATED_ARGUMENT + : EOF -> popMode + ; + +ARGUMENT_CONTENT + : . + ; + +// TODO: This grammar and the one used in the Intellij Antlr4 plugin differ +// for "actions". This needs to be resolved at some point. +// The Intellij Antlr4 grammar is here: +// https://github.com/antlr/intellij-plugin-v4/blob/1f36fde17f7fa63cb18d7eeb9cb213815ac658fb/src/main/antlr/org/antlr/intellij/plugin/parser/ANTLRv4Lexer.g4#L587 + +// ------------------------- +// Target Language Actions +// +// Many language targets use {} as block delimiters and so we +// must recursively match {} delimited blocks to balance the +// braces. Additionally, we must make some assumptions about +// literal string representation in the target language. We assume +// that they are delimited by ' or " and so consume these +// in their own alts so as not to inadvertantly match {}. +mode TargetLanguageAction; + +NESTED_ACTION + : LBrace -> type (ACTION_CONTENT), pushMode (TargetLanguageAction) + ; + +ACTION_ESCAPE + : EscAny -> type (ACTION_CONTENT) + ; + +ACTION_STRING_LITERAL + : DQuoteLiteral -> type (ACTION_CONTENT) + ; + +ACTION_CHAR_LITERAL + : SQuoteLiteral -> type (ACTION_CONTENT) + ; + +ACTION_DOC_COMMENT + : DocComment -> type (ACTION_CONTENT) + ; + +ACTION_BLOCK_COMMENT + : BlockComment -> type (ACTION_CONTENT) + ; + +ACTION_LINE_COMMENT + : LineComment -> type (ACTION_CONTENT) + ; + +END_ACTION + : RBrace { this.handleEndAction(); } + ; + +UNTERMINATED_ACTION + : EOF -> popMode + ; + +ACTION_CONTENT + : . + ; + +// ------------------------- +mode LexerCharSet; + +LEXER_CHAR_SET_BODY + : (~ [\]\\] | EscAny)+ -> more + ; + +LEXER_CHAR_SET + : RBrack -> popMode + ; + +UNTERMINATED_CHAR_SET + : EOF -> popMode + ; + +// ------------------------------------------------------------------------------ +// Grammar specific Keywords, Punctuation, etc. +fragment Id + : NameStartChar NameChar* + ; \ No newline at end of file diff --git a/developer/ANTLR/ANTLRv4Parser.g4 b/developer/ANTLR/ANTLRv4Parser.g4 new file mode 100644 index 0000000..a4ff765 --- /dev/null +++ b/developer/ANTLR/ANTLRv4Parser.g4 @@ -0,0 +1,408 @@ +/* + * [The "BSD license"] + * Copyright (c) 2012-2014 Terence Parr + * Copyright (c) 2012-2014 Sam Harwell + * Copyright (c) 2015 Gerald Rosenberg + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* A grammar for ANTLR v4 written in ANTLR v4. + * + * Modified 2015.06.16 gbr + * -- update for compatibility with Antlr v4.5 + * -- add mode for channels + * -- moved members to LexerAdaptor + * -- move fragments to imports + */ + +// $antlr-format alignTrailingComments on, columnLimit 130, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments off +// $antlr-format useTab off, allowShortRulesOnASingleLine off, allowShortBlocksOnASingleLine on, alignSemicolons hanging +// $antlr-format alignColons hanging + +parser grammar ANTLRv4Parser; + +options { + tokenVocab = ANTLRv4Lexer; +} + +// The main entry point for parsing a v4 grammar. +grammarSpec + : grammarDecl prequelConstruct* rules modeSpec* EOF + ; + +grammarDecl + : grammarType identifier SEMI + ; + +grammarType + : LEXER GRAMMAR + | PARSER GRAMMAR + | GRAMMAR + ; + +// This is the list of all constructs that can be declared before +// the set of rules that compose the grammar, and is invoked 0..n +// times by the grammarPrequel rule. + +prequelConstruct + : optionsSpec + | delegateGrammars + | tokensSpec + | channelsSpec + | action_ + ; + +// ------------ +// Options - things that affect analysis and/or code generation + +optionsSpec + : OPTIONS (option SEMI)* RBRACE + ; + +option + : identifier ASSIGN optionValue + ; + +optionValue + : identifier (DOT identifier)* + | STRING_LITERAL + | actionBlock + | INT + ; + +// ------------ +// Delegates + +delegateGrammars + : IMPORT delegateGrammar (COMMA delegateGrammar)* SEMI + ; + +delegateGrammar + : identifier ASSIGN identifier + | identifier + ; + +// ------------ +// Tokens & Channels + +tokensSpec + : TOKENS idList? RBRACE + ; + +channelsSpec + : CHANNELS idList? RBRACE + ; + +idList + : identifier (COMMA identifier)* COMMA? + ; + +// Match stuff like @parser::members {int i;} + +action_ + : AT (actionScopeName COLONCOLON)? identifier actionBlock + ; + +// Scope names could collide with keywords; allow them as ids for action scopes + +actionScopeName + : identifier + | LEXER + | PARSER + ; + +actionBlock + : BEGIN_ACTION ACTION_CONTENT* END_ACTION + ; + +argActionBlock + : BEGIN_ARGUMENT ARGUMENT_CONTENT* END_ARGUMENT + ; + +modeSpec + : MODE identifier SEMI lexerRuleSpec* + ; + +rules + : ruleSpec* + ; + +ruleSpec + : parserRuleSpec + | lexerRuleSpec + ; + +parserRuleSpec + : ruleModifiers? RULE_REF argActionBlock? ruleReturns? throwsSpec? localsSpec? rulePrequel* COLON ruleBlock SEMI + exceptionGroup + ; + +exceptionGroup + : exceptionHandler* finallyClause? + ; + +exceptionHandler + : CATCH argActionBlock actionBlock + ; + +finallyClause + : FINALLY actionBlock + ; + +rulePrequel + : optionsSpec + | ruleAction + ; + +ruleReturns + : RETURNS argActionBlock + ; + +// -------------- +// Exception spec +throwsSpec + : THROWS identifier (COMMA identifier)* + ; + +localsSpec + : LOCALS argActionBlock + ; + +/** Match stuff like @init {int i;} */ +ruleAction + : AT identifier actionBlock + ; + +ruleModifiers + : ruleModifier+ + ; + +// An individual access modifier for a rule. The 'fragment' modifier +// is an internal indication for lexer rules that they do not match +// from the input but are like subroutines for other lexer rules to +// reuse for certain lexical patterns. The other modifiers are passed +// to the code generation templates and may be ignored by the template +// if they are of no use in that language. + +ruleModifier + : PUBLIC + | PRIVATE + | PROTECTED + | FRAGMENT + ; + +ruleBlock + : ruleAltList + ; + +ruleAltList + : labeledAlt (OR labeledAlt)* + ; + +labeledAlt + : alternative (POUND identifier)? + ; + +// -------------------- +// Lexer rules + +lexerRuleSpec + : FRAGMENT? TOKEN_REF optionsSpec? COLON lexerRuleBlock SEMI + ; + +lexerRuleBlock + : lexerAltList + ; + +lexerAltList + : lexerAlt (OR lexerAlt)* + ; + +lexerAlt + : lexerElements lexerCommands? + | + // explicitly allow empty alts + ; + +lexerElements + : lexerElement+ + | + ; + +lexerElement + : lexerAtom ebnfSuffix? + | lexerBlock ebnfSuffix? + | actionBlock QUESTION? + ; + +// but preds can be anywhere + +lexerBlock + : LPAREN lexerAltList RPAREN + ; + +// E.g., channel(HIDDEN), skip, more, mode(INSIDE), push(INSIDE), pop + +lexerCommands + : RARROW lexerCommand (COMMA lexerCommand)* + ; + +lexerCommand + : lexerCommandName LPAREN lexerCommandExpr RPAREN + | lexerCommandName + ; + +lexerCommandName + : identifier + | MODE + ; + +lexerCommandExpr + : identifier + | INT + ; + +// -------------------- +// Rule Alts + +altList + : alternative (OR alternative)* + ; + +alternative + : elementOptions? element+ + | + // explicitly allow empty alts + ; + +element + : labeledElement (ebnfSuffix |) + | atom (ebnfSuffix |) + | ebnf + | actionBlock (QUESTION predicateOptions?)? + ; + +predicateOptions + : LT predicateOption (COMMA predicateOption)* GT + ; + +predicateOption + : elementOption + | identifier ASSIGN actionBlock + ; + +labeledElement + : identifier (ASSIGN | PLUS_ASSIGN) (atom | block) + ; + +// -------------------- +// EBNF and blocks + +ebnf + : block blockSuffix? + ; + +blockSuffix + : ebnfSuffix + ; + +ebnfSuffix + : QUESTION QUESTION? + | STAR QUESTION? + | PLUS QUESTION? + ; + +lexerAtom + : characterRange + | terminalDef + | notSet + | LEXER_CHAR_SET + | DOT elementOptions? + ; + +atom + : terminalDef + | ruleref + | notSet + | DOT elementOptions? + ; + +// -------------------- +// Inverted element set +notSet + : NOT setElement + | NOT blockSet + ; + +blockSet + : LPAREN setElement (OR setElement)* RPAREN + ; + +setElement + : TOKEN_REF elementOptions? + | STRING_LITERAL elementOptions? + | characterRange + | LEXER_CHAR_SET + ; + +// ------------- +// Grammar Block +block + : LPAREN (optionsSpec? ruleAction* COLON)? altList RPAREN + ; + +// ---------------- +// Parser rule ref +ruleref + : RULE_REF argActionBlock? elementOptions? + ; + +// --------------- +// Character Range +characterRange + : STRING_LITERAL RANGE STRING_LITERAL + ; + +terminalDef + : TOKEN_REF elementOptions? + | STRING_LITERAL elementOptions? + ; + +// Terminals may be adorned with certain options when +// reference in the grammar: TOK<,,,> +elementOptions + : LT elementOption (COMMA elementOption)* GT + ; + +elementOption + : identifier + | identifier ASSIGN (identifier | STRING_LITERAL) + ; + +identifier + : RULE_REF + | TOKEN_REF + ; \ No newline at end of file diff --git a/developer/ANTLR/GQL_20240412_rf1_literals.g4 b/developer/ANTLR/GQL_20240412_rf1_literals.g4 new file mode 100644 index 0000000..e9ac41e --- /dev/null +++ b/developer/ANTLR/GQL_20240412_rf1_literals.g4 @@ -0,0 +1,66 @@ +// Define tokens for each category + +// Data Types +DATA_TYPE: BOOL | BOOLEAN | BYTE_STRING_LITERAL | CHAR | DATETIME | DECIMAL | FLOAT | + INTEGER | INT | REAL | SMALLINT | STRING | TIME | TIMESTAMP | UBIGINT | + UNSIGNED_BINARY_INTEGER | UNSIGNED_DECIMAL_INTEGER | UNSIGNED_HEXADECIMAL_INTEGER | + UNSIGNED_OCTAL_INTEGER | VARBINARY | VARCHAR | INT8 | INT16 | INT32 | INT64 | + INT128 | INT256 | BIGINT | UINT8 | UINT16 | UINT32 | UINT64 | UINT128 | UINT256 | + BYTE_LENGTH | BYTES | CARDINALITY | DATE | DAY | DEC | DOUBLE | DURATION | + DURATION_BETWEEN | ELEMENT | ELEMENT_ID | FLOAT | INSTANT | INTERVAL | MAX | MIN | + MINUTE | MODULUS | MONTH | NUMERIC | SIZE | TEMP | TEMPORAL | TIME | UINT | + VALUE | VALUES | YEAR | ZONED | ZONED_DATETIME | ZONED_TIME | USMALLINT ; + +// Functions +FUNCTION: ABS | ACOS | ASIN | ATAN | AVG | CEIL | CEILING | COS | COSH | EXP | FLOOR | + LOG | LOG10 | MOD | POWER | RADIANS | SIN | SINH | SQRT | TAN | TANH | TRIM | + LTRIM | RTRIM | BTRIM | CONCATENATION_OPERATOR | CHARACTER_LENGTH | OCTET_LENGTH | + POSITION | SUBSTRING | UPPER | LOWER | AGGREGATE | AGGREGATES | ALL_DIFFERENT | + CAST | COT | COUNT | STDDEV_POP | STDDEV_SAMP | SUM ; + +// Punctuation and Operators +PUNCTUATION_OPERATOR: AMPERSAND | ASTERISK | COLON | COMMA | CONCATENATION_OPERATOR | + DOLLAR_SIGN | DOUBLE_COLON | DOUBLE_PERIOD | DOUBLE_QUOTE | + DOUBLE_DOLLAR_SIGN | EQUALS_OPERATOR | EXCLAMATION_MARK | + GREATER_THAN_OR_EQUALS_OPERATOR | LEFT_ANGLE_BRACKET | LEFT_ARROW | + LEFT_BRACE | LEFT_BRACKET | LEFT_MINUS_RIGHT | LEFT_MINUS_SLASH | + LEFT_PAREN | LEFT_TILDE_SLASH | LESS_THAN_OR_EQUALS_OPERATOR | + MINUS_LEFT_BRACKET | MINUS_SIGN | PERIOD | PLUS_SIGN | RIGHT_ANGLE_BRACKET | + RIGHT_ARROW | RIGHT_BRACE | RIGHT_BRACKET | RIGHT_BRACKET_MINUS | + RIGHT_BRACKET_TILDE | RIGHT_DOUBLE_ARROW | RIGHT_PAREN | SOLIDUS | + TILDE | TILDE_LEFT_BRACKET | TILDE_RIGHT_ARROW | TILDE_SLASH | VERTICAL_BAR | + BRACKETED_COMMENT | BRACKET_RIGHT_ARROW | BRACKET_TILDE_RIGHT_ARROW | + COMMERCIAL_AT | DOUBLE_QUOTED_CHARACTER_SEQUENCE | SINGLE_QUOTED_CHARACTER_SEQUENCE | + SLASH_MINUS | SLASH_MINUS_RIGHT | SLASH_TILDE | SLASH_TILDE_RIGHT | + REVERSE_SOLIDUS | UNDERSCORE ; + +// Keywords +KEYWORD: ALL | AND | ANY | ARRAY | AS | ASC | DESC | DISTINCT | EXISTS | FALSE | FROM | + GROUP | HAVING | IN | IS | LIKE | MATCH | NOT | NULL | ON | OR | ORDER | + RETURN | SELECT | TRUE | UNION | USING | WHERE | WITH | ABSTRACT | ALTER | + ASCENDING | AT | BIG | BINARY | BINDING | BINDINGS | BOTH | CALL | CATALOG | + CLEAR | CLONE | CLOSE | COMMIT | CONSTRAINT | CREATE | CURRENT_PROPERTY_GRAPH | + CURRENT_SCHEMA | DELETE | DESCENDING | DETACH | DIFFERENT | DIRECTED | DIRECTORY | + DROP | DRYRUN | ELEMENTS | EXCEPT | EXISTING | FILTER | FINISH | FIRST | FUNCTION | + GENERAL_PARAMETER_REFERENCE | GRANT | GROUPS | HOME_GRAPH | HOME_PROPERTY_GRAPH | + HOME_SCHEMA | INSERT | INTERSECT | KEEP | LABELED | LAST | LEADING | LEFT | + LEFT_ARROW_BRACKET | LEFT_ARROW_TILDE | LIST | NOTHING | NULLIF | OF | ONLY | + OPEN | OPTIONAL | ORDINALITY | OTHERWISE | PARENT | PARENTHESIZED | PATH | + PATHS | PRECISION | PRIMARY | PRIORITY | PROCEDURE | PRODUCT | PROPERTIES | + PROPERTY | PROPERTY_EXISTS | QUANTIFIER | REFERENCE | REFERENCES | REFLECT | + REGULAR | REMOVE | RENAME | REPEATABLE | REPLACE | RESET | REVOKE | RIGHT | + ROLLBACK | SAME | SCHEMA | SESSION | SET | SHORTEST | SIGNED | SIMPLE | + SIMPLE_COMMENT_MINUS | SIMPLE_COMMENT_SOLIDUS | SOURCE | SP | START | + SUBSTITUTED_PARAMETER_REFERENCE | TABLE | TO | TRAIL | TRAILING | TRANSACTION | + TYPED | UNDIRECTED | UNIQUE | UNIT | UNSIGNED | USE | VERTEX | WALK | WHITESPACE | + WITHOUT | WRITE | XOR | YIELD | ZONE ; + +// Literals +LITERAL: NULL | TRUE | FALSE | NUMBER | BOOLEAN_LITERAL ; + +// Control Flow +CONTROL_FLOW: CASE | WHEN | THEN | ELSE | END | IF | FOR | WHILE | DO | LOOP | + BREAK | CONTINUE | RETURN | IMPLIES ; + +// Miscellaneous +MISC: ACCENT_QUOTED_CHARACTER_SEQUENCE | ACYCLIC | GRAVE_ACCENT ; diff --git a/developer/ANTLR/GQL_20240412_substituted.g4 b/developer/ANTLR/GQL_20240412_substituted.g4 new file mode 100644 index 0000000..25de3e2 --- /dev/null +++ b/developer/ANTLR/GQL_20240412_substituted.g4 @@ -0,0 +1,5783 @@ +// Original: grammar GQL_20240412; +CONTROL_FLOWgrammarCONTROL_FLOW CONTROL_FLOWGQL_20240412CONTROL_FLOW; + +// Original: options { caseInsensitive = true; } +CONTROL_FLOWoptionsCONTROL_FLOW { CONTROL_FLOWcaseInsensitiveCONTROL_FLOW = CONTROL_FLOWtrueCONTROL_FLOW; } + +// 6 + +// Original: gqlProgram +CONTROL_FLOWgqlProgramCONTROL_FLOW +// Original: : programActivity sessionCloseCommand? EOF +: CONTROL_FLOWprogramActivityCONTROL_FLOW CONTROL_FLOWsessionCloseCommandCONTROL_FLOW? CONTROL_FLOWEOFCONTROL_FLOW +// Original: | sessionCloseCommand EOF +| CONTROL_FLOWsessionCloseCommandCONTROL_FLOW CONTROL_FLOWEOFCONTROL_FLOW +; + +// Original: programActivity +CONTROL_FLOWprogramActivityCONTROL_FLOW +// Original: : sessionActivity +: CONTROL_FLOWsessionActivityCONTROL_FLOW +// Original: | transactionActivity +| CONTROL_FLOWtransactionActivityCONTROL_FLOW +; + +// Original: sessionActivity +CONTROL_FLOWsessionActivityCONTROL_FLOW +: sessionResetCommand+ +| sessionSetCommand+ sessionResetCommand* +; + +// Original: transactionActivity +CONTROL_FLOWtransactionActivityCONTROL_FLOW +: startTransactionCommand (procedureSpecification endTransactionCommand?)? +| procedureSpecification endTransactionCommand? +// Original: | endTransactionCommand +| CONTROL_FLOWendTransactionCommandCONTROL_FLOW +; + +// Original: endTransactionCommand +CONTROL_FLOWendTransactionCommandCONTROL_FLOW +// Original: : rollbackCommand +: CONTROL_FLOWrollbackCommandCONTROL_FLOW +// Original: | commitCommand +| CONTROL_FLOWcommitCommandCONTROL_FLOW +; + +// 7.1 + +// Original: sessionSetCommand +CONTROL_FLOWsessionSetCommandCONTROL_FLOW +// Original: : SESSION SET (sessionSetSchemaClause | sessionSetGraphClause | sessionSetTimeZoneClause | sessionSetParameterClause) +// Original: : SESSION KEYWORD (sessionSetSchemaClause | sessionSetGraphClause | sessionSetTimeZoneClause | sessionSetParameterClause) +: KEYWORD KEYWORD (sessionSetSchemaClause | sessionSetGraphClause | sessionSetTimeZoneClause | sessionSetParameterClause) +; + +// Original: sessionSetSchemaClause +CONTROL_FLOWsessionSetSchemaClauseCONTROL_FLOW +// Original: : SCHEMA schemaReference +: CONTROL_FLOWSCHEMACONTROL_FLOW CONTROL_FLOWschemaReferenceCONTROL_FLOW +; + +// Original: sessionSetGraphClause +CONTROL_FLOWsessionSetGraphClauseCONTROL_FLOW +// Original: : PROPERTY? GRAPH graphExpression +: CONTROL_FLOWPROPERTYCONTROL_FLOW? CONTROL_FLOWGRAPHCONTROL_FLOW CONTROL_FLOWgraphExpressionCONTROL_FLOW +; + +// Original: sessionSetTimeZoneClause +CONTROL_FLOWsessionSetTimeZoneClauseCONTROL_FLOW +// Original: : TIME ZONE setTimeZoneValue +: CONTROL_FLOWTIMECONTROL_FLOW CONTROL_FLOWZONECONTROL_FLOW CONTROL_FLOWsetTimeZoneValueCONTROL_FLOW +; + +// Original: setTimeZoneValue +CONTROL_FLOWsetTimeZoneValueCONTROL_FLOW +// Original: : timeZoneString +: CONTROL_FLOWtimeZoneStringCONTROL_FLOW +; + +// Original: sessionSetParameterClause +CONTROL_FLOWsessionSetParameterClauseCONTROL_FLOW +// Original: : sessionSetGraphParameterClause +: CONTROL_FLOWsessionSetGraphParameterClauseCONTROL_FLOW +// Original: | sessionSetBindingTableParameterClause +| CONTROL_FLOWsessionSetBindingTableParameterClauseCONTROL_FLOW +// Original: | sessionSetValueParameterClause +| CONTROL_FLOWsessionSetValueParameterClauseCONTROL_FLOW +; + +// Original: sessionSetGraphParameterClause +CONTROL_FLOWsessionSetGraphParameterClauseCONTROL_FLOW +// Original: : PROPERTY? GRAPH sessionSetParameterName optTypedGraphInitializer +: CONTROL_FLOWPROPERTYCONTROL_FLOW? CONTROL_FLOWGRAPHCONTROL_FLOW CONTROL_FLOWsessionSetParameterNameCONTROL_FLOW CONTROL_FLOWoptTypedGraphInitializerCONTROL_FLOW +; + +// Original: sessionSetBindingTableParameterClause +CONTROL_FLOWsessionSetBindingTableParameterClauseCONTROL_FLOW +// Original: : BINDING? TABLE sessionSetParameterName optTypedBindingTableInitializer +// Original: : KEYWORD? TABLE sessionSetParameterName optTypedBindingTableInitializer +: CONTROL_FLOWKEYWORDCONTROL_FLOW? CONTROL_FLOWTABLECONTROL_FLOW CONTROL_FLOWsessionSetParameterNameCONTROL_FLOW CONTROL_FLOWoptTypedBindingTableInitializerCONTROL_FLOW +; + +// Original: sessionSetValueParameterClause +CONTROL_FLOWsessionSetValueParameterClauseCONTROL_FLOW +// Original: : VALUE sessionSetParameterName optTypedValueInitializer +: CONTROL_FLOWVALUECONTROL_FLOW CONTROL_FLOWsessionSetParameterNameCONTROL_FLOW CONTROL_FLOWoptTypedValueInitializerCONTROL_FLOW +; + +// Original: sessionSetParameterName +CONTROL_FLOWsessionSetParameterNameCONTROL_FLOW +// Original: : (IF NOT EXISTS)? sessionParameterSpecification +: (CONTROL_FLOWIFCONTROL_FLOW CONTROL_FLOWNOTCONTROL_FLOW CONTROL_FLOWEXISTSCONTROL_FLOW)? CONTROL_FLOWsessionParameterSpecificationCONTROL_FLOW +; + +// 7.2 + +// Original: sessionResetCommand +CONTROL_FLOWsessionResetCommandCONTROL_FLOW +// Original: : SESSION RESET sessionResetArguments? +// Original: : KEYWORD RESET sessionResetArguments? +: KEYWORD KEYWORD sessionResetArguments? +; + +// Original: sessionResetArguments +CONTROL_FLOWsessionResetArgumentsCONTROL_FLOW +// Original: : ALL? (PARAMETERS | CHARACTERISTICS) +: KEYWORD? (PARAMETERS | CHARACTERISTICS) +// Original: | SCHEMA +| CONTROL_FLOWSCHEMACONTROL_FLOW +// Original: | PROPERTY? GRAPH +| CONTROL_FLOWPROPERTYCONTROL_FLOW? CONTROL_FLOWGRAPHCONTROL_FLOW +// Original: | TIME ZONE +| CONTROL_FLOWTIMECONTROL_FLOW CONTROL_FLOWZONECONTROL_FLOW +// Original: | PARAMETER? sessionParameterSpecification +| CONTROL_FLOWPARAMETERCONTROL_FLOW? CONTROL_FLOWsessionParameterSpecificationCONTROL_FLOW +; + +// 7.3 + +// Original: sessionCloseCommand +CONTROL_FLOWsessionCloseCommandCONTROL_FLOW +// Original: : SESSION CLOSE +// Original: : SESSION KEYWORD +: CONTROL_FLOWSESSIONCONTROL_FLOW CONTROL_FLOWKEYWORDCONTROL_FLOW +; + +// 7.4 + +// Original: sessionParameterSpecification +CONTROL_FLOWsessionParameterSpecificationCONTROL_FLOW +// Original: : GENERAL_PARAMETER_REFERENCE +: CONTROL_FLOWGENERAL_PARAMETER_REFERENCECONTROL_FLOW +; + +// 8.1 + +// Original: startTransactionCommand +CONTROL_FLOWstartTransactionCommandCONTROL_FLOW +// Original: : START TRANSACTION transactionCharacteristics? +// Original: : KEYWORD TRANSACTION transactionCharacteristics? +: KEYWORD KEYWORD transactionCharacteristics? +; + +// 8.2 + +// Original: transactionCharacteristics +CONTROL_FLOWtransactionCharacteristicsCONTROL_FLOW +// Original: : transactionMode (COMMA transactionMode)* +: transactionMode (PUNCTUATION_OPERATOR transactionMode)* +; + +// Original: transactionMode +CONTROL_FLOWtransactionModeCONTROL_FLOW +// Original: : transactionAccessMode +: CONTROL_FLOWtransactionAccessModeCONTROL_FLOW +; + +// Original: transactionAccessMode +CONTROL_FLOWtransactionAccessModeCONTROL_FLOW +// Original: : READ ONLY +: CONTROL_FLOWREADCONTROL_FLOW CONTROL_FLOWONLYCONTROL_FLOW +// Original: | READ WRITE +| CONTROL_FLOWREADCONTROL_FLOW CONTROL_FLOWWRITECONTROL_FLOW +; + +// 8.3 + +// Original: rollbackCommand +CONTROL_FLOWrollbackCommandCONTROL_FLOW +// Original: : ROLLBACK +: CONTROL_FLOWROLLBACKCONTROL_FLOW +; + +// 8.4 + +// Original: commitCommand +CONTROL_FLOWcommitCommandCONTROL_FLOW +// Original: : COMMIT +: CONTROL_FLOWCOMMITCONTROL_FLOW +; + +// 9.1 + +// Original: nestedProcedureSpecification +CONTROL_FLOWnestedProcedureSpecificationCONTROL_FLOW +// Original: : LEFT_BRACE procedureSpecification RIGHT_BRACE +: CONTROL_FLOWLEFT_BRACECONTROL_FLOW CONTROL_FLOWprocedureSpecificationCONTROL_FLOW CONTROL_FLOWRIGHT_BRACECONTROL_FLOW +; + +// Original: // , and are +// , CONTROL_FLOWandCONTROL_FLOW CONTROL_FLOWareCONTROL_FLOW +// Original: // identical productions. The specification distinguishes them in the BNF, but in the implementation, the distinction +// CONTROL_FLOWidenticalCONTROL_FLOW CONTROL_FLOWproductionsCONTROL_FLOW. CONTROL_FLOWTheCONTROL_FLOW CONTROL_FLOWspecificationCONTROL_FLOW CONTROL_FLOWdistinguishesCONTROL_FLOW CONTROL_FLOWthemCONTROL_FLOW CONTROL_FLOWinCONTROL_FLOW CONTROL_FLOWtheCONTROL_FLOW CONTROL_FLOWBNFCONTROL_FLOW, CONTROL_FLOWbutCONTROL_FLOW CONTROL_FLOWinCONTROL_FLOW CONTROL_FLOWtheCONTROL_FLOW CONTROL_FLOWimplementationCONTROL_FLOW, CONTROL_FLOWtheCONTROL_FLOW CONTROL_FLOWdistinctionCONTROL_FLOW +// has to be made sematically, in code, based on the kind of statements contained in the . +// Original: procedureSpecification +CONTROL_FLOWprocedureSpecificationCONTROL_FLOW +// Original: : procedureBody +: CONTROL_FLOWprocedureBodyCONTROL_FLOW +// Original: // : catalogModifyingProcedureSpecification +// : CONTROL_FLOWcatalogModifyingProcedureSpecificationCONTROL_FLOW +// Original: // | dataModifyingProcedureSpecification +// | CONTROL_FLOWdataModifyingProcedureSpecificationCONTROL_FLOW +// Original: // | querySpecification +// | CONTROL_FLOWquerySpecificationCONTROL_FLOW +; + +// Original: //catalogModifyingProcedureSpecification +//CONTROL_FLOWcatalogModifyingProcedureSpecificationCONTROL_FLOW +// Original: // : procedureBody +// : CONTROL_FLOWprocedureBodyCONTROL_FLOW +// ; + +// Original: nestedDataModifyingProcedureSpecification +CONTROL_FLOWnestedDataModifyingProcedureSpecificationCONTROL_FLOW +// Original: : LEFT_BRACE procedureBody RIGHT_BRACE +: CONTROL_FLOWLEFT_BRACECONTROL_FLOW CONTROL_FLOWprocedureBodyCONTROL_FLOW CONTROL_FLOWRIGHT_BRACECONTROL_FLOW +; + +// Original: //dataModifyingProcedureSpecification +//CONTROL_FLOWdataModifyingProcedureSpecificationCONTROL_FLOW +// Original: // : procedureBody +// : CONTROL_FLOWprocedureBodyCONTROL_FLOW +// ; + +// Original: nestedQuerySpecification +CONTROL_FLOWnestedQuerySpecificationCONTROL_FLOW +// Original: : LEFT_BRACE procedureBody RIGHT_BRACE +: CONTROL_FLOWLEFT_BRACECONTROL_FLOW CONTROL_FLOWprocedureBodyCONTROL_FLOW CONTROL_FLOWRIGHT_BRACECONTROL_FLOW +; + +// Original: //querySpecification +//CONTROL_FLOWquerySpecificationCONTROL_FLOW +// Original: // : procedureBody +// : CONTROL_FLOWprocedureBodyCONTROL_FLOW +// ; + +// 9.2 + +// Original: procedureBody +CONTROL_FLOWprocedureBodyCONTROL_FLOW +// Original: : atSchemaClause? bindingVariableDefinitionBlock? statementBlock +: CONTROL_FLOWatSchemaClauseCONTROL_FLOW? CONTROL_FLOWbindingVariableDefinitionBlockCONTROL_FLOW? CONTROL_FLOWstatementBlockCONTROL_FLOW +; + +// Original: bindingVariableDefinitionBlock +CONTROL_FLOWbindingVariableDefinitionBlockCONTROL_FLOW +: bindingVariableDefinition+ +; + +// Original: bindingVariableDefinition +CONTROL_FLOWbindingVariableDefinitionCONTROL_FLOW +// Original: : graphVariableDefinition +: CONTROL_FLOWgraphVariableDefinitionCONTROL_FLOW +// Original: | bindingTableVariableDefinition +| CONTROL_FLOWbindingTableVariableDefinitionCONTROL_FLOW +// Original: | valueVariableDefinition +| CONTROL_FLOWvalueVariableDefinitionCONTROL_FLOW +; + +// Original: statementBlock +CONTROL_FLOWstatementBlockCONTROL_FLOW +: statement nextStatement* +; + +// Original: statement +CONTROL_FLOWstatementCONTROL_FLOW +// Original: : linearCatalogModifyingStatement +: CONTROL_FLOWlinearCatalogModifyingStatementCONTROL_FLOW +// Original: | linearDataModifyingStatement +| CONTROL_FLOWlinearDataModifyingStatementCONTROL_FLOW +// Original: | compositeQueryStatement +| CONTROL_FLOWcompositeQueryStatementCONTROL_FLOW +; + +// Original: nextStatement +CONTROL_FLOWnextStatementCONTROL_FLOW +// Original: : NEXT yieldClause? statement +: CONTROL_FLOWNEXTCONTROL_FLOW CONTROL_FLOWyieldClauseCONTROL_FLOW? CONTROL_FLOWstatementCONTROL_FLOW +; + +// 10.1 + +// Original: graphVariableDefinition +CONTROL_FLOWgraphVariableDefinitionCONTROL_FLOW +// Original: : PROPERTY? GRAPH bindingVariable optTypedGraphInitializer +: CONTROL_FLOWPROPERTYCONTROL_FLOW? CONTROL_FLOWGRAPHCONTROL_FLOW CONTROL_FLOWbindingVariableCONTROL_FLOW CONTROL_FLOWoptTypedGraphInitializerCONTROL_FLOW +; + +// Original: optTypedGraphInitializer +CONTROL_FLOWoptTypedGraphInitializerCONTROL_FLOW +// Original: : (typed? graphReferenceValueType)? graphInitializer +: (CONTROL_FLOWtypedCONTROL_FLOW? CONTROL_FLOWgraphReferenceValueTypeCONTROL_FLOW)? CONTROL_FLOWgraphInitializerCONTROL_FLOW +; + +// Original: graphInitializer +CONTROL_FLOWgraphInitializerCONTROL_FLOW +// Original: : EQUALS_OPERATOR graphExpression +: CONTROL_FLOWEQUALS_OPERATORCONTROL_FLOW CONTROL_FLOWgraphExpressionCONTROL_FLOW +; + +// 10.2 + +// Original: bindingTableVariableDefinition +CONTROL_FLOWbindingTableVariableDefinitionCONTROL_FLOW +// Original: : BINDING? TABLE bindingVariable optTypedBindingTableInitializer +// Original: : KEYWORD? TABLE bindingVariable optTypedBindingTableInitializer +: CONTROL_FLOWKEYWORDCONTROL_FLOW? CONTROL_FLOWTABLECONTROL_FLOW CONTROL_FLOWbindingVariableCONTROL_FLOW CONTROL_FLOWoptTypedBindingTableInitializerCONTROL_FLOW +; + +// Original: optTypedBindingTableInitializer +CONTROL_FLOWoptTypedBindingTableInitializerCONTROL_FLOW +// Original: : (typed? bindingTableReferenceValueType)? bindingTableInitializer +: (CONTROL_FLOWtypedCONTROL_FLOW? CONTROL_FLOWbindingTableReferenceValueTypeCONTROL_FLOW)? CONTROL_FLOWbindingTableInitializerCONTROL_FLOW +; + +// Original: bindingTableInitializer +CONTROL_FLOWbindingTableInitializerCONTROL_FLOW +// Original: : EQUALS_OPERATOR bindingTableExpression +: CONTROL_FLOWEQUALS_OPERATORCONTROL_FLOW CONTROL_FLOWbindingTableExpressionCONTROL_FLOW +; + +// 10.3 + +// Original: valueVariableDefinition +CONTROL_FLOWvalueVariableDefinitionCONTROL_FLOW +// Original: : VALUE bindingVariable optTypedValueInitializer +: CONTROL_FLOWVALUECONTROL_FLOW CONTROL_FLOWbindingVariableCONTROL_FLOW CONTROL_FLOWoptTypedValueInitializerCONTROL_FLOW +; + +// Original: optTypedValueInitializer +CONTROL_FLOWoptTypedValueInitializerCONTROL_FLOW +// Original: : (typed? valueType)? valueInitializer +: (CONTROL_FLOWtypedCONTROL_FLOW? CONTROL_FLOWvalueTypeCONTROL_FLOW)? CONTROL_FLOWvalueInitializerCONTROL_FLOW +; + +// Original: valueInitializer +CONTROL_FLOWvalueInitializerCONTROL_FLOW +// Original: : EQUALS_OPERATOR valueExpression +: CONTROL_FLOWEQUALS_OPERATORCONTROL_FLOW CONTROL_FLOWvalueExpressionCONTROL_FLOW +; + +// 11.1 + +// Original: graphExpression +CONTROL_FLOWgraphExpressionCONTROL_FLOW +// Original: : objectExpressionPrimary +: CONTROL_FLOWobjectExpressionPrimaryCONTROL_FLOW +// Original: | graphReference +| CONTROL_FLOWgraphReferenceCONTROL_FLOW +// Original: | objectNameOrBindingVariable +| CONTROL_FLOWobjectNameOrBindingVariableCONTROL_FLOW +// Original: | currentGraph +| CONTROL_FLOWcurrentGraphCONTROL_FLOW +; + +// Original: currentGraph +CONTROL_FLOWcurrentGraphCONTROL_FLOW +// Original: : CURRENT_PROPERTY_GRAPH +// Original: : KEYWORD +: CONTROL_FLOWKEYWORDCONTROL_FLOW +// Original: | CURRENT_GRAPH +| CONTROL_FLOWCURRENT_GRAPHCONTROL_FLOW +; + +// 11.2 + +// Original: bindingTableExpression +CONTROL_FLOWbindingTableExpressionCONTROL_FLOW +// Original: : nestedBindingTableQuerySpecification +: CONTROL_FLOWnestedBindingTableQuerySpecificationCONTROL_FLOW +// Original: | objectExpressionPrimary +| CONTROL_FLOWobjectExpressionPrimaryCONTROL_FLOW +// Original: | bindingTableReference +| CONTROL_FLOWbindingTableReferenceCONTROL_FLOW +// Original: | objectNameOrBindingVariable +| CONTROL_FLOWobjectNameOrBindingVariableCONTROL_FLOW +; + +// Original: nestedBindingTableQuerySpecification +CONTROL_FLOWnestedBindingTableQuerySpecificationCONTROL_FLOW +// Original: : nestedQuerySpecification +: CONTROL_FLOWnestedQuerySpecificationCONTROL_FLOW +; + +// 11.3 + +// Original: objectExpressionPrimary +CONTROL_FLOWobjectExpressionPrimaryCONTROL_FLOW +// Original: : VARIABLE valueExpressionPrimary +: CONTROL_FLOWVARIABLECONTROL_FLOW CONTROL_FLOWvalueExpressionPrimaryCONTROL_FLOW +// Original: | parenthesizedValueExpression +| CONTROL_FLOWparenthesizedValueExpressionCONTROL_FLOW +// Original: | nonParenthesizedValueExpressionPrimarySpecialCase +| CONTROL_FLOWnonParenthesizedValueExpressionPrimarySpecialCaseCONTROL_FLOW +; + +// 12.1 + +// Original: linearCatalogModifyingStatement +CONTROL_FLOWlinearCatalogModifyingStatementCONTROL_FLOW +: simpleCatalogModifyingStatement+ +; + +// Original: simpleCatalogModifyingStatement +CONTROL_FLOWsimpleCatalogModifyingStatementCONTROL_FLOW +// Original: : primitiveCatalogModifyingStatement +: CONTROL_FLOWprimitiveCatalogModifyingStatementCONTROL_FLOW +// Original: | callCatalogModifyingProcedureStatement +| CONTROL_FLOWcallCatalogModifyingProcedureStatementCONTROL_FLOW +; + +// Original: primitiveCatalogModifyingStatement +CONTROL_FLOWprimitiveCatalogModifyingStatementCONTROL_FLOW +// Original: : createSchemaStatement +: CONTROL_FLOWcreateSchemaStatementCONTROL_FLOW +// Original: | dropSchemaStatement +| CONTROL_FLOWdropSchemaStatementCONTROL_FLOW +// Original: | createGraphStatement +| CONTROL_FLOWcreateGraphStatementCONTROL_FLOW +// Original: | dropGraphStatement +| CONTROL_FLOWdropGraphStatementCONTROL_FLOW +// Original: | createGraphTypeStatement +| CONTROL_FLOWcreateGraphTypeStatementCONTROL_FLOW +// Original: | dropGraphTypeStatement +| CONTROL_FLOWdropGraphTypeStatementCONTROL_FLOW +; + +// 12.2 + +// Original: createSchemaStatement +CONTROL_FLOWcreateSchemaStatementCONTROL_FLOW +// Original: : CREATE SCHEMA (IF NOT EXISTS)? catalogSchemaParentAndName +// Original: : KEYWORD SCHEMA (IF NOT EXISTS)? catalogSchemaParentAndName +: CONTROL_FLOWKEYWORDCONTROL_FLOW CONTROL_FLOWSCHEMACONTROL_FLOW (CONTROL_FLOWIFCONTROL_FLOW CONTROL_FLOWNOTCONTROL_FLOW CONTROL_FLOWEXISTSCONTROL_FLOW)? CONTROL_FLOWcatalogSchemaParentAndNameCONTROL_FLOW +; + +// 12.3 + +// Original: dropSchemaStatement +CONTROL_FLOWdropSchemaStatementCONTROL_FLOW +// Original: : DROP SCHEMA (IF EXISTS)? catalogSchemaParentAndName +: CONTROL_FLOWDROPCONTROL_FLOW CONTROL_FLOWSCHEMACONTROL_FLOW (CONTROL_FLOWIFCONTROL_FLOW CONTROL_FLOWEXISTSCONTROL_FLOW)? CONTROL_FLOWcatalogSchemaParentAndNameCONTROL_FLOW +; + +// 12.4 + +// Original: createGraphStatement +CONTROL_FLOWcreateGraphStatementCONTROL_FLOW +// Original: : CREATE (PROPERTY? GRAPH (IF NOT EXISTS)? | OR REPLACE PROPERTY? GRAPH) catalogGraphParentAndName (openGraphType | ofGraphType) graphSource? +// Original: : KEYWORD (PROPERTY? GRAPH (IF NOT EXISTS)? | OR REPLACE PROPERTY? GRAPH) catalogGraphParentAndName (openGraphType | ofGraphType) graphSource? +// Original: : KEYWORD (PROPERTY? GRAPH (IF NOT EXISTS)? | OR KEYWORD PROPERTY? GRAPH) catalogGraphParentAndName (openGraphType | ofGraphType) graphSource? +// Original: : KEYWORD (KEYWORD? GRAPH (IF NOT EXISTS)? | OR KEYWORD KEYWORD? GRAPH) catalogGraphParentAndName (openGraphType | ofGraphType) graphSource? +// Original: : KEYWORD (KEYWORD? GRAPH (IF KEYWORD EXISTS)? | OR KEYWORD KEYWORD? GRAPH) catalogGraphParentAndName (openGraphType | ofGraphType) graphSource? +// Original: : KEYWORD (KEYWORD? GRAPH (IF KEYWORD KEYWORD)? | OR KEYWORD KEYWORD? GRAPH) catalogGraphParentAndName (openGraphType | ofGraphType) graphSource? +// Original: : KEYWORD (KEYWORD? GRAPH (CONTROL_FLOW KEYWORD KEYWORD)? | OR KEYWORD KEYWORD? GRAPH) catalogGraphParentAndName (openGraphType | ofGraphType) graphSource? +: KEYWORD (KEYWORD? GRAPH (CONTROL_FLOW KEYWORD KEYWORD)? | KEYWORD KEYWORD KEYWORD? GRAPH) catalogGraphParentAndName (openGraphType | ofGraphType) graphSource? +; + +// Original: openGraphType +CONTROL_FLOWopenGraphTypeCONTROL_FLOW +// Original: : typed? ANY (PROPERTY? GRAPH)? +// Original: : typed? ANY (KEYWORD? GRAPH)? +: typed? KEYWORD (KEYWORD? GRAPH)? +; + +// Original: ofGraphType +CONTROL_FLOWofGraphTypeCONTROL_FLOW +// Original: : graphTypeLikeGraph +: CONTROL_FLOWgraphTypeLikeGraphCONTROL_FLOW +// Original: | typed? graphTypeReference +| CONTROL_FLOWtypedCONTROL_FLOW? CONTROL_FLOWgraphTypeReferenceCONTROL_FLOW +// Original: | typed? (PROPERTY? GRAPH)? nestedGraphTypeSpecification +| CONTROL_FLOWtypedCONTROL_FLOW? (CONTROL_FLOWPROPERTYCONTROL_FLOW? CONTROL_FLOWGRAPHCONTROL_FLOW)? CONTROL_FLOWnestedGraphTypeSpecificationCONTROL_FLOW +; + +// Original: graphTypeLikeGraph +CONTROL_FLOWgraphTypeLikeGraphCONTROL_FLOW +// Original: : LIKE graphExpression +: CONTROL_FLOWLIKECONTROL_FLOW CONTROL_FLOWgraphExpressionCONTROL_FLOW +; + +// Original: graphSource +CONTROL_FLOWgraphSourceCONTROL_FLOW +// Original: : AS COPY OF graphExpression +// Original: : KEYWORD COPY OF graphExpression +: CONTROL_FLOWKEYWORDCONTROL_FLOW CONTROL_FLOWCOPYCONTROL_FLOW CONTROL_FLOWOFCONTROL_FLOW CONTROL_FLOWgraphExpressionCONTROL_FLOW +; + +// 12.5 + +// Original: dropGraphStatement +CONTROL_FLOWdropGraphStatementCONTROL_FLOW +// Original: : DROP PROPERTY? GRAPH (IF EXISTS)? catalogGraphParentAndName +: CONTROL_FLOWDROPCONTROL_FLOW CONTROL_FLOWPROPERTYCONTROL_FLOW? CONTROL_FLOWGRAPHCONTROL_FLOW (CONTROL_FLOWIFCONTROL_FLOW CONTROL_FLOWEXISTSCONTROL_FLOW)? CONTROL_FLOWcatalogGraphParentAndNameCONTROL_FLOW +; + +// 12.6 + +// Original: createGraphTypeStatement +CONTROL_FLOWcreateGraphTypeStatementCONTROL_FLOW +// Original: : CREATE (PROPERTY? GRAPH TYPE (IF NOT EXISTS)? | OR REPLACE PROPERTY? GRAPH TYPE) catalogGraphTypeParentAndName graphTypeSource +// Original: : KEYWORD (PROPERTY? GRAPH TYPE (IF NOT EXISTS)? | OR REPLACE PROPERTY? GRAPH TYPE) catalogGraphTypeParentAndName graphTypeSource +: CONTROL_FLOWKEYWORDCONTROL_FLOW (CONTROL_FLOWPROPERTYCONTROL_FLOW? CONTROL_FLOWGRAPHCONTROL_FLOW CONTROL_FLOWTYPECONTROL_FLOW (CONTROL_FLOWIFCONTROL_FLOW CONTROL_FLOWNOTCONTROL_FLOW CONTROL_FLOWEXISTSCONTROL_FLOW)? | CONTROL_FLOWORCONTROL_FLOW CONTROL_FLOWREPLACECONTROL_FLOW CONTROL_FLOWPROPERTYCONTROL_FLOW? CONTROL_FLOWGRAPHCONTROL_FLOW CONTROL_FLOWTYPECONTROL_FLOW) CONTROL_FLOWcatalogGraphTypeParentAndNameCONTROL_FLOW CONTROL_FLOWgraphTypeSourceCONTROL_FLOW +; + +// Original: graphTypeSource +CONTROL_FLOWgraphTypeSourceCONTROL_FLOW +// Original: : AS? copyOfGraphType +// Original: : KEYWORD? copyOfGraphType +: CONTROL_FLOWKEYWORDCONTROL_FLOW? CONTROL_FLOWcopyOfGraphTypeCONTROL_FLOW +// Original: | graphTypeLikeGraph +| CONTROL_FLOWgraphTypeLikeGraphCONTROL_FLOW +// Original: | AS? nestedGraphTypeSpecification +// Original: | KEYWORD? nestedGraphTypeSpecification +| CONTROL_FLOWKEYWORDCONTROL_FLOW? CONTROL_FLOWnestedGraphTypeSpecificationCONTROL_FLOW +; + +// Original: copyOfGraphType +CONTROL_FLOWcopyOfGraphTypeCONTROL_FLOW +// Original: : COPY OF graphTypeReference +: CONTROL_FLOWCOPYCONTROL_FLOW CONTROL_FLOWOFCONTROL_FLOW CONTROL_FLOWgraphTypeReferenceCONTROL_FLOW +; + +// 12.7 + +// Original: dropGraphTypeStatement +CONTROL_FLOWdropGraphTypeStatementCONTROL_FLOW +// Original: : DROP PROPERTY? GRAPH TYPE (IF EXISTS)? catalogGraphTypeParentAndName +: CONTROL_FLOWDROPCONTROL_FLOW CONTROL_FLOWPROPERTYCONTROL_FLOW? CONTROL_FLOWGRAPHCONTROL_FLOW CONTROL_FLOWTYPECONTROL_FLOW (CONTROL_FLOWIFCONTROL_FLOW CONTROL_FLOWEXISTSCONTROL_FLOW)? CONTROL_FLOWcatalogGraphTypeParentAndNameCONTROL_FLOW +; + +// 12.8 + +// Original: callCatalogModifyingProcedureStatement +CONTROL_FLOWcallCatalogModifyingProcedureStatementCONTROL_FLOW +// Original: : callProcedureStatement +: CONTROL_FLOWcallProcedureStatementCONTROL_FLOW +; + +// 13.1 + +// Original: linearDataModifyingStatement +CONTROL_FLOWlinearDataModifyingStatementCONTROL_FLOW +// Original: : focusedLinearDataModifyingStatement +: CONTROL_FLOWfocusedLinearDataModifyingStatementCONTROL_FLOW +// Original: | ambientLinearDataModifyingStatement +| CONTROL_FLOWambientLinearDataModifyingStatementCONTROL_FLOW +; + +// Original: focusedLinearDataModifyingStatement +CONTROL_FLOWfocusedLinearDataModifyingStatementCONTROL_FLOW +// Original: : focusedLinearDataModifyingStatementBody +: CONTROL_FLOWfocusedLinearDataModifyingStatementBodyCONTROL_FLOW +// Original: | focusedNestedDataModifyingProcedureSpecification +| CONTROL_FLOWfocusedNestedDataModifyingProcedureSpecificationCONTROL_FLOW +; + +// Original: focusedLinearDataModifyingStatementBody +CONTROL_FLOWfocusedLinearDataModifyingStatementBodyCONTROL_FLOW +: useGraphClause simpleLinearDataAccessingStatement primitiveResultStatement? +; + +// Original: focusedNestedDataModifyingProcedureSpecification +CONTROL_FLOWfocusedNestedDataModifyingProcedureSpecificationCONTROL_FLOW +// Original: : useGraphClause nestedDataModifyingProcedureSpecification +: CONTROL_FLOWuseGraphClauseCONTROL_FLOW CONTROL_FLOWnestedDataModifyingProcedureSpecificationCONTROL_FLOW +; + +// Original: ambientLinearDataModifyingStatement +CONTROL_FLOWambientLinearDataModifyingStatementCONTROL_FLOW +// Original: : ambientLinearDataModifyingStatementBody +: CONTROL_FLOWambientLinearDataModifyingStatementBodyCONTROL_FLOW +// Original: | nestedDataModifyingProcedureSpecification +| CONTROL_FLOWnestedDataModifyingProcedureSpecificationCONTROL_FLOW +; + +// Original: ambientLinearDataModifyingStatementBody +CONTROL_FLOWambientLinearDataModifyingStatementBodyCONTROL_FLOW +: simpleLinearDataAccessingStatement primitiveResultStatement? +; + +// Original: simpleLinearDataAccessingStatement +CONTROL_FLOWsimpleLinearDataAccessingStatementCONTROL_FLOW +: simpleQueryStatement* simpleDataModifyingStatement+ +; + +// Original: // Subsumed by previous rule to enforce 13.1 SR 5 +// CONTROL_FLOWSubsumedCONTROL_FLOW CONTROL_FLOWbyCONTROL_FLOW CONTROL_FLOWpreviousCONTROL_FLOW CONTROL_FLOWruleCONTROL_FLOW CONTROL_FLOWtoCONTROL_FLOW CONTROL_FLOWenforceCONTROL_FLOW CONTROL_FLOW13CONTROL_FLOW.CONTROL_FLOW1CONTROL_FLOW CONTROL_FLOWSRCONTROL_FLOW CONTROL_FLOW5CONTROL_FLOW +// Original: //simpleDataAccessingStatement +//CONTROL_FLOWsimpleDataAccessingStatementCONTROL_FLOW +// Original: // : simpleQueryStatement +// : CONTROL_FLOWsimpleQueryStatementCONTROL_FLOW +// Original: // | simpleDataModifyingStatement +// | CONTROL_FLOWsimpleDataModifyingStatementCONTROL_FLOW +// ; + +// Original: simpleDataModifyingStatement +CONTROL_FLOWsimpleDataModifyingStatementCONTROL_FLOW +// Original: : primitiveDataModifyingStatement +: CONTROL_FLOWprimitiveDataModifyingStatementCONTROL_FLOW +// Original: | callDataModifyingProcedureStatement +| CONTROL_FLOWcallDataModifyingProcedureStatementCONTROL_FLOW +; + +// Original: primitiveDataModifyingStatement +CONTROL_FLOWprimitiveDataModifyingStatementCONTROL_FLOW +// Original: : insertStatement +: CONTROL_FLOWinsertStatementCONTROL_FLOW +// Original: | setStatement +| CONTROL_FLOWsetStatementCONTROL_FLOW +// Original: | removeStatement +| CONTROL_FLOWremoveStatementCONTROL_FLOW +// Original: | deleteStatement +| CONTROL_FLOWdeleteStatementCONTROL_FLOW +; + +// 13.2 + +// Original: insertStatement +CONTROL_FLOWinsertStatementCONTROL_FLOW +// Original: : INSERT insertGraphPattern +: CONTROL_FLOWINSERTCONTROL_FLOW CONTROL_FLOWinsertGraphPatternCONTROL_FLOW +; + +// 13.3 + +// Original: setStatement +CONTROL_FLOWsetStatementCONTROL_FLOW +// Original: : SET setItemList +// Original: : KEYWORD setItemList +: CONTROL_FLOWKEYWORDCONTROL_FLOW CONTROL_FLOWsetItemListCONTROL_FLOW +; + +// Original: setItemList +CONTROL_FLOWsetItemListCONTROL_FLOW +// Original: : setItem (COMMA setItem)* +: setItem (PUNCTUATION_OPERATOR setItem)* +; + +// Original: setItem +CONTROL_FLOWsetItemCONTROL_FLOW +// Original: : setPropertyItem +: CONTROL_FLOWsetPropertyItemCONTROL_FLOW +// Original: | setAllPropertiesItem +| CONTROL_FLOWsetAllPropertiesItemCONTROL_FLOW +// Original: | setLabelItem +| CONTROL_FLOWsetLabelItemCONTROL_FLOW +; + +// Original: setPropertyItem +CONTROL_FLOWsetPropertyItemCONTROL_FLOW +// Original: : bindingVariableReference PERIOD propertyName EQUALS_OPERATOR valueExpression +: CONTROL_FLOWbindingVariableReferenceCONTROL_FLOW CONTROL_FLOWPERIODCONTROL_FLOW CONTROL_FLOWpropertyNameCONTROL_FLOW CONTROL_FLOWEQUALS_OPERATORCONTROL_FLOW CONTROL_FLOWvalueExpressionCONTROL_FLOW +; + +// Original: setAllPropertiesItem +CONTROL_FLOWsetAllPropertiesItemCONTROL_FLOW +// Original: : bindingVariableReference EQUALS_OPERATOR LEFT_BRACE propertyKeyValuePairList? RIGHT_BRACE +: CONTROL_FLOWbindingVariableReferenceCONTROL_FLOW CONTROL_FLOWEQUALS_OPERATORCONTROL_FLOW CONTROL_FLOWLEFT_BRACECONTROL_FLOW CONTROL_FLOWpropertyKeyValuePairListCONTROL_FLOW? CONTROL_FLOWRIGHT_BRACECONTROL_FLOW +; + +// Original: setLabelItem +CONTROL_FLOWsetLabelItemCONTROL_FLOW +// Original: : bindingVariableReference isOrColon labelName +: CONTROL_FLOWbindingVariableReferenceCONTROL_FLOW CONTROL_FLOWisOrColonCONTROL_FLOW CONTROL_FLOWlabelNameCONTROL_FLOW +; + +// 13.4 + +// Original: removeStatement +CONTROL_FLOWremoveStatementCONTROL_FLOW +// Original: : REMOVE removeItemList +: CONTROL_FLOWREMOVECONTROL_FLOW CONTROL_FLOWremoveItemListCONTROL_FLOW +; + +// Original: removeItemList +CONTROL_FLOWremoveItemListCONTROL_FLOW +// Original: : removeItem (COMMA removeItem)* +: removeItem (PUNCTUATION_OPERATOR removeItem)* +; + +// Original: removeItem +CONTROL_FLOWremoveItemCONTROL_FLOW +// Original: : removePropertyItem +: CONTROL_FLOWremovePropertyItemCONTROL_FLOW +// Original: | removeLabelItem +| CONTROL_FLOWremoveLabelItemCONTROL_FLOW +; + +// Original: removePropertyItem +CONTROL_FLOWremovePropertyItemCONTROL_FLOW +// Original: : bindingVariableReference PERIOD propertyName +: CONTROL_FLOWbindingVariableReferenceCONTROL_FLOW CONTROL_FLOWPERIODCONTROL_FLOW CONTROL_FLOWpropertyNameCONTROL_FLOW +; + +// Original: removeLabelItem +CONTROL_FLOWremoveLabelItemCONTROL_FLOW +// Original: : bindingVariableReference isOrColon labelName +: CONTROL_FLOWbindingVariableReferenceCONTROL_FLOW CONTROL_FLOWisOrColonCONTROL_FLOW CONTROL_FLOWlabelNameCONTROL_FLOW +; + +// 13.5 + +// Original: deleteStatement +CONTROL_FLOWdeleteStatementCONTROL_FLOW +// Original: : (DETACH | NODETACH)? DELETE deleteItemList +// Original: : (DETACH | NODETACH)? KEYWORD deleteItemList +// Original: : (KEYWORD | NODETACH)? KEYWORD deleteItemList +: (CONTROL_FLOWKEYWORDCONTROL_FLOW | CONTROL_FLOWNODETACHCONTROL_FLOW)? CONTROL_FLOWKEYWORDCONTROL_FLOW CONTROL_FLOWdeleteItemListCONTROL_FLOW +; + +// Original: deleteItemList +CONTROL_FLOWdeleteItemListCONTROL_FLOW +// Original: : deleteItem (COMMA deleteItem)* +: deleteItem (PUNCTUATION_OPERATOR deleteItem)* +; + +// Original: deleteItem +CONTROL_FLOWdeleteItemCONTROL_FLOW +// Original: : valueExpression +: CONTROL_FLOWvalueExpressionCONTROL_FLOW +; + +// 13.6 + +// Original: callDataModifyingProcedureStatement +CONTROL_FLOWcallDataModifyingProcedureStatementCONTROL_FLOW +// Original: : callProcedureStatement +: CONTROL_FLOWcallProcedureStatementCONTROL_FLOW +; + +// 14.1 + +// Original: compositeQueryStatement +CONTROL_FLOWcompositeQueryStatementCONTROL_FLOW +// Original: : compositeQueryExpression +: CONTROL_FLOWcompositeQueryExpressionCONTROL_FLOW +; + +// 14.2 + +// Original: compositeQueryExpression +CONTROL_FLOWcompositeQueryExpressionCONTROL_FLOW +// Original: : compositeQueryExpression queryConjunction compositeQueryPrimary +: CONTROL_FLOWcompositeQueryExpressionCONTROL_FLOW CONTROL_FLOWqueryConjunctionCONTROL_FLOW CONTROL_FLOWcompositeQueryPrimaryCONTROL_FLOW +// Original: | compositeQueryPrimary +| CONTROL_FLOWcompositeQueryPrimaryCONTROL_FLOW +; + +// Original: queryConjunction +CONTROL_FLOWqueryConjunctionCONTROL_FLOW +// Original: : setOperator +: CONTROL_FLOWsetOperatorCONTROL_FLOW +// Original: | OTHERWISE +| CONTROL_FLOWOTHERWISECONTROL_FLOW +; + +// Original: setOperator +CONTROL_FLOWsetOperatorCONTROL_FLOW +// Original: : UNION setQuantifier? +: KEYWORD setQuantifier? +// Original: | EXCEPT setQuantifier? +| KEYWORD setQuantifier? +// Original: | INTERSECT setQuantifier? +| KEYWORD setQuantifier? +; + +// Original: compositeQueryPrimary +CONTROL_FLOWcompositeQueryPrimaryCONTROL_FLOW +// Original: : linearQueryStatement +: CONTROL_FLOWlinearQueryStatementCONTROL_FLOW +; + +// 14.3 and + +// Original: linearQueryStatement +CONTROL_FLOWlinearQueryStatementCONTROL_FLOW +// Original: : focusedLinearQueryStatement +: CONTROL_FLOWfocusedLinearQueryStatementCONTROL_FLOW +// Original: | ambientLinearQueryStatement +| CONTROL_FLOWambientLinearQueryStatementCONTROL_FLOW +; + +// Original: focusedLinearQueryStatement +CONTROL_FLOWfocusedLinearQueryStatementCONTROL_FLOW +// Original: : focusedLinearQueryStatementPart* focusedLinearQueryAndPrimitiveResultStatementPart +: CONTROL_FLOWfocusedLinearQueryStatementPartCONTROL_FLOW* CONTROL_FLOWfocusedLinearQueryAndPrimitiveResultStatementPartCONTROL_FLOW +// Original: | focusedPrimitiveResultStatement +| CONTROL_FLOWfocusedPrimitiveResultStatementCONTROL_FLOW +// Original: | focusedNestedQuerySpecification +| CONTROL_FLOWfocusedNestedQuerySpecificationCONTROL_FLOW +// Original: | selectStatement +| CONTROL_FLOWselectStatementCONTROL_FLOW +; + +// Original: focusedLinearQueryStatementPart +CONTROL_FLOWfocusedLinearQueryStatementPartCONTROL_FLOW +// Original: : useGraphClause simpleLinearQueryStatement +: CONTROL_FLOWuseGraphClauseCONTROL_FLOW CONTROL_FLOWsimpleLinearQueryStatementCONTROL_FLOW +; + +// Original: focusedLinearQueryAndPrimitiveResultStatementPart +CONTROL_FLOWfocusedLinearQueryAndPrimitiveResultStatementPartCONTROL_FLOW +// Original: : useGraphClause simpleLinearQueryStatement primitiveResultStatement +: CONTROL_FLOWuseGraphClauseCONTROL_FLOW CONTROL_FLOWsimpleLinearQueryStatementCONTROL_FLOW CONTROL_FLOWprimitiveResultStatementCONTROL_FLOW +; + +// Original: focusedPrimitiveResultStatement +CONTROL_FLOWfocusedPrimitiveResultStatementCONTROL_FLOW +// Original: : useGraphClause primitiveResultStatement +: CONTROL_FLOWuseGraphClauseCONTROL_FLOW CONTROL_FLOWprimitiveResultStatementCONTROL_FLOW +; + +// Original: focusedNestedQuerySpecification +CONTROL_FLOWfocusedNestedQuerySpecificationCONTROL_FLOW +// Original: : useGraphClause nestedQuerySpecification +: CONTROL_FLOWuseGraphClauseCONTROL_FLOW CONTROL_FLOWnestedQuerySpecificationCONTROL_FLOW +; + +// Original: ambientLinearQueryStatement +CONTROL_FLOWambientLinearQueryStatementCONTROL_FLOW +// Original: : simpleLinearQueryStatement? primitiveResultStatement +: CONTROL_FLOWsimpleLinearQueryStatementCONTROL_FLOW? CONTROL_FLOWprimitiveResultStatementCONTROL_FLOW +// Original: | nestedQuerySpecification +| CONTROL_FLOWnestedQuerySpecificationCONTROL_FLOW +; + +// Original: simpleLinearQueryStatement +CONTROL_FLOWsimpleLinearQueryStatementCONTROL_FLOW +: simpleQueryStatement+ +; + +// Original: simpleQueryStatement +CONTROL_FLOWsimpleQueryStatementCONTROL_FLOW +// Original: : primitiveQueryStatement +: CONTROL_FLOWprimitiveQueryStatementCONTROL_FLOW +// Original: | callQueryStatement +| CONTROL_FLOWcallQueryStatementCONTROL_FLOW +; + +// Original: primitiveQueryStatement +CONTROL_FLOWprimitiveQueryStatementCONTROL_FLOW +// Original: : matchStatement +: CONTROL_FLOWmatchStatementCONTROL_FLOW +// Original: | letStatement +| CONTROL_FLOWletStatementCONTROL_FLOW +// Original: | forStatement +| CONTROL_FLOWforStatementCONTROL_FLOW +// Original: | filterStatement +| CONTROL_FLOWfilterStatementCONTROL_FLOW +// Original: | orderByAndPageStatement +| CONTROL_FLOWorderByAndPageStatementCONTROL_FLOW +; + +// 14.4 + +// Original: matchStatement +CONTROL_FLOWmatchStatementCONTROL_FLOW +// Original: : simpleMatchStatement +: CONTROL_FLOWsimpleMatchStatementCONTROL_FLOW +// Original: | optionalMatchStatement +| CONTROL_FLOWoptionalMatchStatementCONTROL_FLOW +; + +// Original: simpleMatchStatement +CONTROL_FLOWsimpleMatchStatementCONTROL_FLOW +// Original: : MATCH graphPatternBindingTable +: CONTROL_FLOWMATCHCONTROL_FLOW CONTROL_FLOWgraphPatternBindingTableCONTROL_FLOW +; + +// Original: optionalMatchStatement +CONTROL_FLOWoptionalMatchStatementCONTROL_FLOW +// Original: : OPTIONAL optionalOperand +: CONTROL_FLOWOPTIONALCONTROL_FLOW CONTROL_FLOWoptionalOperandCONTROL_FLOW +; + +// Original: optionalOperand +CONTROL_FLOWoptionalOperandCONTROL_FLOW +// Original: : simpleMatchStatement +: CONTROL_FLOWsimpleMatchStatementCONTROL_FLOW +// Original: | LEFT_BRACE matchStatementBlock RIGHT_BRACE +| CONTROL_FLOWLEFT_BRACECONTROL_FLOW CONTROL_FLOWmatchStatementBlockCONTROL_FLOW CONTROL_FLOWRIGHT_BRACECONTROL_FLOW +// Original: | LEFT_PAREN matchStatementBlock RIGHT_PAREN +// Original: | LEFT_PAREN matchStatementBlock PUNCTUATION_OPERATOR +| CONTROL_FLOWLEFT_PARENCONTROL_FLOW CONTROL_FLOWmatchStatementBlockCONTROL_FLOW CONTROL_FLOWPUNCTUATION_OPERATORCONTROL_FLOW +; + +// Original: matchStatementBlock +CONTROL_FLOWmatchStatementBlockCONTROL_FLOW +: matchStatement+ +; + +// 14.5 + +// Original: callQueryStatement +CONTROL_FLOWcallQueryStatementCONTROL_FLOW +// Original: : callProcedureStatement +: CONTROL_FLOWcallProcedureStatementCONTROL_FLOW +; + +// 14.6 + +// Original: filterStatement +CONTROL_FLOWfilterStatementCONTROL_FLOW +// Original: : FILTER (whereClause | searchCondition) +: KEYWORD (whereClause | searchCondition) +; + +// 14.7 + +// Original: letStatement +CONTROL_FLOWletStatementCONTROL_FLOW +// Original: : LET letVariableDefinitionList +: CONTROL_FLOWLETCONTROL_FLOW CONTROL_FLOWletVariableDefinitionListCONTROL_FLOW +; + +// Original: letVariableDefinitionList +CONTROL_FLOWletVariableDefinitionListCONTROL_FLOW +// Original: : letVariableDefinition (COMMA letVariableDefinition)* +: letVariableDefinition (PUNCTUATION_OPERATOR letVariableDefinition)* +; + +// Original: letVariableDefinition +CONTROL_FLOWletVariableDefinitionCONTROL_FLOW +// Original: : valueVariableDefinition +: CONTROL_FLOWvalueVariableDefinitionCONTROL_FLOW +// Original: | bindingVariable EQUALS_OPERATOR valueExpression +| CONTROL_FLOWbindingVariableCONTROL_FLOW CONTROL_FLOWEQUALS_OPERATORCONTROL_FLOW CONTROL_FLOWvalueExpressionCONTROL_FLOW +; + +// 14.8 + +// Original: forStatement +CONTROL_FLOWforStatementCONTROL_FLOW +// Original: : FOR forItem forOrdinalityOrOffset? +: CONTROL_FLOW forItem forOrdinalityOrOffset? +; + +// Original: forItem +CONTROL_FLOWforItemCONTROL_FLOW +// Original: : forItemAlias forItemSource +: CONTROL_FLOWforItemAliasCONTROL_FLOW CONTROL_FLOWforItemSourceCONTROL_FLOW +; + +// Original: forItemAlias +CONTROL_FLOWforItemAliasCONTROL_FLOW +// Original: : bindingVariable IN +: CONTROL_FLOWbindingVariableCONTROL_FLOW CONTROL_FLOWINCONTROL_FLOW +; + +// Original: forItemSource +CONTROL_FLOWforItemSourceCONTROL_FLOW +// Original: : valueExpression +: CONTROL_FLOWvalueExpressionCONTROL_FLOW +; + +// Original: forOrdinalityOrOffset +CONTROL_FLOWforOrdinalityOrOffsetCONTROL_FLOW +// Original: : WITH (ORDINALITY | OFFSET) bindingVariable +// Original: : WITH (KEYWORD | OFFSET) bindingVariable +: CONTROL_FLOWWITHCONTROL_FLOW (CONTROL_FLOWKEYWORDCONTROL_FLOW | CONTROL_FLOWOFFSETCONTROL_FLOW) CONTROL_FLOWbindingVariableCONTROL_FLOW +; + +// 14.9 + +// Original: orderByAndPageStatement +CONTROL_FLOWorderByAndPageStatementCONTROL_FLOW +: orderByClause offsetClause? limitClause? +| offsetClause limitClause? +// Original: | limitClause +| CONTROL_FLOWlimitClauseCONTROL_FLOW +; + +// 14.10 + +// Original: primitiveResultStatement +CONTROL_FLOWprimitiveResultStatementCONTROL_FLOW +: returnStatement orderByAndPageStatement? +// Original: | FINISH +| CONTROL_FLOWFINISHCONTROL_FLOW +; + +// 14.11 + +// Original: returnStatement +CONTROL_FLOWreturnStatementCONTROL_FLOW +// Original: : RETURN returnStatementBody +: CONTROL_FLOWRETURNCONTROL_FLOW CONTROL_FLOWreturnStatementBodyCONTROL_FLOW +; + +// Original: returnStatementBody +CONTROL_FLOWreturnStatementBodyCONTROL_FLOW +// Original: : setQuantifier? (ASTERISK | returnItemList) groupByClause? +: setQuantifier? (PUNCTUATION_OPERATOR | returnItemList) groupByClause? +// Original: | NO BINDINGS +// Original: | NO KEYWORD +| CONTROL_FLOWNOCONTROL_FLOW CONTROL_FLOWKEYWORDCONTROL_FLOW +; + +// Original: returnItemList +CONTROL_FLOWreturnItemListCONTROL_FLOW +// Original: : returnItem (COMMA returnItem)* +: returnItem (PUNCTUATION_OPERATOR returnItem)* +; + +// Original: returnItem +CONTROL_FLOWreturnItemCONTROL_FLOW +: aggregatingValueExpression returnItemAlias? +; + +// Original: returnItemAlias +CONTROL_FLOWreturnItemAliasCONTROL_FLOW +// Original: : AS identifier +// Original: : KEYWORD identifier +: CONTROL_FLOWKEYWORDCONTROL_FLOW CONTROL_FLOWidentifierCONTROL_FLOW +; + +// 14.12 + +selectStatement +: SELECT setQuantifier? (ASTERISK | selectItemList) (selectStatementBody whereClause? groupByClause? havingClause? orderByClause? offsetClause? limitClause?)? +; + +selectItemList +: selectItem (COMMA selectItem)* +; + +selectItem +: aggregatingValueExpression selectItemAlias? +; + +selectItemAlias +: AS identifier +; + +havingClause +: HAVING searchCondition +; + +selectStatementBody +: FROM (selectGraphMatchList | selectQuerySpecification) +; + +selectGraphMatchList +: selectGraphMatch (COMMA selectGraphMatch)* +; + +selectGraphMatch +: graphExpression matchStatement +; + +selectQuerySpecification +: nestedQuerySpecification +| graphExpression nestedQuerySpecification +; + +// 15.1 and + +callProcedureStatement +: OPTIONAL? CALL procedureCall +; + +procedureCall +: inlineProcedureCall +| namedProcedureCall +; + +// 15.2 + +inlineProcedureCall +: variableScopeClause? nestedProcedureSpecification +; + +variableScopeClause +: LEFT_PAREN bindingVariableReferenceList? RIGHT_PAREN +; + +bindingVariableReferenceList +: bindingVariableReference (COMMA bindingVariableReference)* +; + +// 15.3 + +namedProcedureCall +: procedureReference LEFT_PAREN procedureArgumentList? RIGHT_PAREN yieldClause? +; + +procedureArgumentList +: procedureArgument (COMMA procedureArgument)* +; + +procedureArgument +: valueExpression +; + +// 16.1 + +atSchemaClause +: AT schemaReference +; + +// 16.2 + +useGraphClause +: USE graphExpression +; + +// 16.3 + +graphPatternBindingTable +: graphPattern graphPatternYieldClause? +; + +graphPatternYieldClause +: YIELD graphPatternYieldItemList +; + +graphPatternYieldItemList +: graphPatternYieldItem (COMMA graphPatternYieldItem)* +| NO BINDINGS +; + +// and are identical productions, both consisting +// of a single non-terminal . Thus is ambiguous +// from a parsing standpoint. So here we simply use bindingVariableReference. Post parsing code must +// apply the semantics assocaited with each type of . +graphPatternYieldItem +: bindingVariableReference +// : elementVariableReference +// | pathVariableReference +; + +// 16.4 + +graphPattern +: matchMode? pathPatternList keepClause? graphPatternWhereClause? +; + +matchMode +: repeatableElementsMatchMode +| differentEdgesMatchMode +; + +repeatableElementsMatchMode +: REPEATABLE elementBindingsOrElements +; + +differentEdgesMatchMode +: DIFFERENT edgeBindingsOrEdges +; + +elementBindingsOrElements +: ELEMENT BINDINGS? +| ELEMENTS +; + +edgeBindingsOrEdges +: edgeSynonym BINDINGS? +| edgesSynonym +; + +pathPatternList +: pathPattern (COMMA pathPattern)* +; + +pathPattern +: pathVariableDeclaration? pathPatternPrefix? pathPatternExpression +; + +pathVariableDeclaration +: pathVariable EQUALS_OPERATOR +; + +keepClause +: KEEP pathPatternPrefix +; + +graphPatternWhereClause +: WHERE searchCondition +; + +// 16.5 + +insertGraphPattern +: insertPathPatternList +; + +insertPathPatternList +: insertPathPattern (COMMA insertPathPattern)* +; + +insertPathPattern +: insertNodePattern (insertEdgePattern insertNodePattern)* +; + +insertNodePattern +: LEFT_PAREN insertElementPatternFiller? RIGHT_PAREN +; + +insertEdgePattern +: insertEdgePointingLeft +| insertEdgePointingRight +| insertEdgeUndirected +; + +insertEdgePointingLeft +: LEFT_ARROW_BRACKET insertElementPatternFiller? RIGHT_BRACKET_MINUS +; + +insertEdgePointingRight +: MINUS_LEFT_BRACKET insertElementPatternFiller? BRACKET_RIGHT_ARROW +; + +insertEdgeUndirected +: TILDE_LEFT_BRACKET insertElementPatternFiller? RIGHT_BRACKET_TILDE +; + +insertElementPatternFiller +: elementVariableDeclaration labelAndPropertySetSpecification? +| elementVariableDeclaration? labelAndPropertySetSpecification +; + +labelAndPropertySetSpecification +: isOrColon labelSetSpecification elementPropertySpecification? +| (isOrColon labelSetSpecification)? elementPropertySpecification +; + +// 16.6 + +pathPatternPrefix +: pathModePrefix +| pathSearchPrefix +; + +pathModePrefix +: pathMode pathOrPaths? +; + +pathMode +: WALK +| TRAIL +| SIMPLE +| ACYCLIC +; + +pathSearchPrefix +: allPathSearch +| anyPathSearch +| shortestPathSearch +; + +allPathSearch +: ALL pathMode? pathOrPaths? +; + +pathOrPaths +: PATH +| PATHS +; + +anyPathSearch +: ANY numberOfPaths? pathMode? pathOrPaths? +; + +numberOfPaths +: nonNegativeIntegerSpecification +; + +shortestPathSearch +: allShortestPathSearch +| anyShortestPathSearch +| countedShortestPathSearch +| countedShortestGroupSearch +; + +allShortestPathSearch +: ALL SHORTEST pathMode? pathOrPaths? +; + +anyShortestPathSearch +: ANY SHORTEST pathMode? pathOrPaths? +; + +countedShortestPathSearch +: SHORTEST numberOfPaths pathMode? pathOrPaths? +; + +countedShortestGroupSearch +: SHORTEST numberOfGroups? pathMode? pathOrPaths? (GROUP | GROUPS) +; + +numberOfGroups +: nonNegativeIntegerSpecification +; + +// 16.7 + +pathPatternExpression +: pathTerm #ppePathTerm +| pathTerm (MULTISET_ALTERNATION_OPERATOR pathTerm)+ #ppeMultisetAlternation +| pathTerm (VERTICAL_BAR pathTerm)+ #ppePatternUnion +; + +pathTerm +: pathFactor+ +; + +pathFactor +: pathPrimary #pfPathPrimary +| pathPrimary graphPatternQuantifier #pfQuantifiedPathPrimary +| pathPrimary QUESTION_MARK #pfQuestionedPathPrimary +; + +pathPrimary +: elementPattern #ppElementPattern +| parenthesizedPathPatternExpression #ppParenthesizedPathPatternExpression +| simplifiedPathPatternExpression #ppSimplifiedPathPatternExpression +; + +elementPattern +: nodePattern +| edgePattern +; + +nodePattern +: LEFT_PAREN elementPatternFiller RIGHT_PAREN +; + +elementPatternFiller +: elementVariableDeclaration? isLabelExpression? elementPatternPredicate? +; + +elementVariableDeclaration +: TEMP? elementVariable +; + +isLabelExpression +: isOrColon labelExpression +; + +isOrColon +: IS +| COLON +; + +elementPatternPredicate +: elementPatternWhereClause +| elementPropertySpecification +; + +elementPatternWhereClause +: WHERE searchCondition +; + +elementPropertySpecification +: LEFT_BRACE propertyKeyValuePairList RIGHT_BRACE +; + +propertyKeyValuePairList +: propertyKeyValuePair (COMMA propertyKeyValuePair)* +; + +propertyKeyValuePair +: propertyName COLON valueExpression +; + +edgePattern +: fullEdgePattern +| abbreviatedEdgePattern +; + +fullEdgePattern +: fullEdgePointingLeft +| fullEdgeUndirected +| fullEdgePointingRight +| fullEdgeLeftOrUndirected +| fullEdgeUndirectedOrRight +| fullEdgeLeftOrRight +| fullEdgeAnyDirection +; + +fullEdgePointingLeft +: LEFT_ARROW_BRACKET elementPatternFiller RIGHT_BRACKET_MINUS +; + +fullEdgeUndirected +: TILDE_LEFT_BRACKET elementPatternFiller RIGHT_BRACKET_TILDE +; + +fullEdgePointingRight +: MINUS_LEFT_BRACKET elementPatternFiller BRACKET_RIGHT_ARROW +; + +fullEdgeLeftOrUndirected +: LEFT_ARROW_TILDE_BRACKET elementPatternFiller RIGHT_BRACKET_TILDE +; + +fullEdgeUndirectedOrRight +: TILDE_LEFT_BRACKET elementPatternFiller BRACKET_TILDE_RIGHT_ARROW +; + +fullEdgeLeftOrRight +: LEFT_ARROW_BRACKET elementPatternFiller BRACKET_RIGHT_ARROW +; + +fullEdgeAnyDirection +: MINUS_LEFT_BRACKET elementPatternFiller RIGHT_BRACKET_MINUS +; + +abbreviatedEdgePattern +: LEFT_ARROW +| TILDE +| RIGHT_ARROW +| LEFT_ARROW_TILDE +| TILDE_RIGHT_ARROW +| LEFT_MINUS_RIGHT +| MINUS_SIGN +; + +parenthesizedPathPatternExpression +: LEFT_PAREN subpathVariableDeclaration? pathModePrefix? pathPatternExpression parenthesizedPathPatternWhereClause? RIGHT_PAREN +; + +subpathVariableDeclaration +: subpathVariable EQUALS_OPERATOR +; + +parenthesizedPathPatternWhereClause +: WHERE searchCondition +; + +// 16.8