grammar.ebnf

(*
 * THE CYPHER GRAPH QUERY LANGUAGE GRAMMAR (Draft, 2016-01-29)
 *
 * (c) Copyright 2015-2016 Neo Technology, Inc.
 *
 * Network Engine for Objects in Lund AB [http://neotechnology.com]
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *)

Cypher = WS, AllOptions, WS, Statements ;

AllOptions = {AnyCypherOption} ;

AnyCypherOption = CypherOption
                | Explain
                | Profile
                ;

CypherOption = 'CYPHER', [VersionNumber], {ConfigurationOption} ;

VersionNumber = DigitString, '.', DigitString ;

Explain = 'EXPLAIN' ;

Profile = 'PROFILE' ;

ConfigurationOption = SymbolicNameString, '=', SymbolicNameString ;

Statements = WS, Statement, WS, {';', WS, Statement, WS}, [';'] ;

Statement = Command
          | Query
          ;

Query = RegularQuery
      | BulkImportQuery
      ;

RegularQuery = SingleQuery, {WS, Union} ;

BulkImportQuery = PeriodicCommitHint, WS, LoadCSVQuery ;

SingleQuery = {Clause}- ;

PeriodicCommitHint = 'USING', SP, 'PERIODIC', SP, 'COMMIT', [SP, SignedIntegerLiteral] ;

LoadCSVQuery = LoadCSV, {WS, Clause} ;

Union = ('UNION', SP, 'ALL', SingleQuery)
      | ('UNION', SingleQuery)
      ;

Clause = LoadCSV
       | Start
       | Match
       | Unwind
       | Merge
       | Create
       | SetClause
       | Delete
       | Remove
       | Foreach
       | With
       | Return
       | Pragma
       ;

Command = CreateUniqueConstraint
        | CreateNodePropertyExistenceConstraint
        | CreateRelationshipPropertyExistenceConstraint
        | CreateIndex
        | DropUniqueConstraint
        | DropNodePropertyExistenceConstraint
        | DropRelationshipPropertyExistenceConstraint
        | DropIndex
        ;

CreateUniqueConstraint = 'CREATE', UniqueConstraintSyntax ;

CreateNodePropertyExistenceConstraint = 'CREATE', NodePropertyExistenceConstraintSyntax ;

CreateRelationshipPropertyExistenceConstraint = 'CREATE', RelationshipPropertyExistenceConstraintSyntax ;

CreateIndex = 'CREATE', SP, 'INDEX', SP, 'ON', NodeLabel, '(', PropertyKeyName, ')' ;

DropUniqueConstraint = 'DROP', UniqueConstraintSyntax ;

DropNodePropertyExistenceConstraint = 'DROP', NodePropertyExistenceConstraintSyntax ;

DropRelationshipPropertyExistenceConstraint = 'DROP', RelationshipPropertyExistenceConstraintSyntax ;

DropIndex = 'DROP', SP, 'INDEX', SP, 'ON', NodeLabel, '(', PropertyKeyName, ')' ;

UniqueConstraintSyntax = 'CONSTRAINT', SP, 'ON', '(', Variable, NodeLabel, ')', 'ASSERT', PropertyExpression, 'IS', SP, 'UNIQUE' ;

NodePropertyExistenceConstraintSyntax = 'CONSTRAINT', SP, 'ON', '(', Variable, NodeLabel, ')', 'ASSERT', SP, 'EXISTS', '(', PropertyExpression, ')' ;

RelationshipPropertyExistenceConstraintSyntax = 'CONSTRAINT', SP, 'ON', RelationshipPatternSyntax, 'ASSERT', SP, 'EXISTS', '(', PropertyExpression, ')' ;

RelationshipPatternSyntax = ('(', WS, ')', Dash, '[', Variable, RelType, ']', Dash, '(', WS, ')')
                          | ('(', WS, ')', Dash, '[', Variable, RelType, ']', RightArrowHead, Dash, '(', WS, ')')
                          | ('(', WS, ')', LeftArrowHead, Dash, '[', Variable, RelType, ']', Dash, '(', WS, ')')
                          ;

LoadCSV = 'LOAD', SP, 'CSV', SP, ['WITH', SP, 'HEADERS', SP], 'FROM', SP, Expression, SP, 'AS', Variable, SP, ['FIELDTERMINATOR', SP, StringLiteral] ;

Match = ['OPTIONAL', SP], 'MATCH', SP, Pattern, {Hint}, [Where] ;

Unwind = 'UNWIND', SP, Expression, SP, 'AS', SP, Variable ;

Merge = 'MERGE', SP, PatternPart, {SP, MergeAction} ;

MergeAction = ('ON', SP, 'MATCH', SP, SetClause)
            | ('ON', SP, 'CREATE', SP, SetClause)
            ;

Create = ('CREATE', 'UNIQUE', SP, Pattern)
       | ('CREATE', SP, Pattern)
       ;

SetClause = 'SET', SetItem, {',', SetItem} ;

SetItem = (PropertyExpression, '=', Expression)
        | (Variable, '=', Expression)
        | (Variable, '+=', Expression)
        | (Variable, NodeLabels)
        ;

Delete = ('DELETE', Expression, {',', Expression})
       | ('DETACH', SP, 'DELETE', Expression, {',', Expression})
       ;

Remove = 'REMOVE', SP, RemoveItem, {WS, ',', WS, RemoveItem} ;

RemoveItem = (Variable, NodeLabels)
           | PropertyExpression
           ;

Foreach = 'FOREACH', WS, '(', WS, Variable, SP, 'IN', SP, Expression, '|', {SP, Clause}-, WS, ')' ;

With = ('WITH', 'DISTINCT', ReturnBody, [Where])
     | ('WITH', ReturnBody, [Where])
     ;

Return = ('RETURN', 'DISTINCT', ReturnBody)
       | ('RETURN', ReturnBody)
       ;

ReturnBody = ReturnItems, [Order], [Skip], [Limit] ;

ReturnItems = ('*', {',', ReturnItem})
            | (ReturnItem, {',', ReturnItem})
            ;

ReturnItem = (Expression, 'AS', Variable)
           | Expression
           ;

Order = 'ORDER', 'BY', SortItem, {',', SortItem} ;

Skip = 'SKIP', Expression ;

Limit = 'LIMIT', Expression ;

SortItem = (Expression, ('DESCENDING' | 'DESC'))
         | (Expression, ['ASCENDING' | 'ASC'])
         ;

Pragma = '_PRAGMA', (('WITH', 'NONE', [Skip], [Limit], [Where]) | ('WITHOUT', Variable, {',', Variable})) ;

Hint = ('USING', SP, 'INDEX', SP, Variable, NodeLabel, '(', PropertyKeyName, ')')
     | ('USING', SP, 'JOIN', SP, 'ON', SP, Variable, {WS, ',', WS, Variable})
     | ('USING', SP, 'SCAN', SP, Variable, NodeLabel)
     ;

Start = 'START', SP, StartPoint, {WS, ',', WS, StartPoint}, [Where] ;

StartPoint = Variable, WS, '=', WS, Lookup ;

Lookup = NodeLookup
       | RelationshipLookup
       ;

NodeLookup = 'NODE', (IdentifiedIndexLookup | IndexQuery | IdLookup) ;

RelationshipLookup = ('RELATIONSHIP' | 'REL'), (IdentifiedIndexLookup | IndexQuery | IdLookup) ;

IdentifiedIndexLookup = ':', SymbolicNameString, '(', SymbolicNameString, '=', (StringLiteral | Parameter), ')' ;

IndexQuery = ':', SymbolicNameString, '(', (StringLiteral | Parameter), ')' ;

IdLookup = '(', (LiteralIds | Parameter | '*'), ')' ;

LiteralIds = UnsignedIntegerLiteral, {WS, ',', WS, UnsignedIntegerLiteral} ;

Where = 'WHERE', Expression ;

Pattern = PatternPart, {',', PatternPart} ;

PatternPart = (Variable, '=', AnonymousPatternPart)
            | AnonymousPatternPart
            ;

AnonymousPatternPart = ShortestPathPattern
                     | PatternElement
                     ;

ShortestPathPattern = ('shortestPath', '(', PatternElement, ')')
                    | ('allShortestPath', '(', PatternElement, ')')
                    ;

PatternElement = (NodePattern, {WS, PatternElementChain})
               | ('(', PatternElement, ')')
               ;

NodePattern = '(', [Variable], [NodeLabels], [Properties], ')' ;

PatternElementChain = RelationshipPattern, NodePattern ;

RelationshipPattern = (LeftArrowHead, Dash, RelationshipDetail, Dash, RightArrowHead)
                    | (LeftArrowHead, Dash, RelationshipDetail, Dash)
                    | (Dash, RelationshipDetail, Dash, RightArrowHead)
                    | (Dash, RelationshipDetail, Dash)
                    ;

RelationshipDetail = '[', [Variable], ['?'], [RelationshipTypes], ['*', [RangeLiteral]], [Properties], ']' ;

Properties = MapLiteral
           | Parameter
           ;

RelType = ':', RelTypeName ;

RelationshipTypes = ':', RelTypeName, {WS, '|', [':'], WS, RelTypeName} ;

NodeLabels = NodeLabel, {WS, NodeLabel} ;

NodeLabel = ':', LabelName ;

RangeLiteral = [UnsignedIntegerLiteral, WS], '..', [WS, UnsignedIntegerLiteral] ;

LabelName = SymbolicNameString ;

RelTypeName = SymbolicNameString ;

Expression = Expression12 ;

Expression12 = Expression11, {'OR', Expression11} ;

Expression11 = Expression10, {'XOR', Expression10} ;

Expression10 = Expression9, {'AND', Expression9} ;

Expression9 = ('NOT', Expression9)
            | Expression8
            ;

Expression8 = Expression7, {WS, PartialComparisonExpression} ;

Expression7 = Expression6, {('+', Expression6) | ('-', Expression6)} ;

Expression6 = Expression5, {('*', Expression5) | ('/', Expression5) | ('%', Expression5)} ;

Expression5 = Expression4, {'^', Expression4} ;

Expression4 = Expression3
            | ('+', Expression3)
            | ('-', Expression3)
            ;

Expression3 = Expression2, {
                ('[', Expression, ']')
              | ('[', [Expression], '..', [Expression], ']')
              | ('=~', Expression2) | ('IN', Expression2)
              | ('STARTS', 'WITH', Expression2)
              | ('ENDS', 'WITH', Expression2)
              | ('CONTAINS', Expression2)
              | ('IS', 'NULL')
              | ('IS', 'NOT', 'NULL')
            } ;

Expression2 = Expression1, {PropertyLookup | NodeLabels} ;

Expression1 = NumberLiteral
            | StringLiteral
            | Parameter
            | 'TRUE'
            | 'FALSE'
            | 'NULL'
            | CaseExpression
            | ('COUNT', '(', '*', ')')
            | MapLiteral
            | ListComprehension
            | ('[', Expression, {',', Expression}, ']')
            | ('FILTER', '(', FilterExpression, ')')
            | ('EXTRACT', '(', FilterExpression, [WS, '|', Expression], ')')
            | Reduce
            | ('ALL', '(', FilterExpression, ')')
            | ('ANY', '(', FilterExpression, ')')
            | ('NONE', '(', FilterExpression, ')')
            | ('SINGLE', '(', FilterExpression, ')')
            | ShortestPathPattern
            | RelationshipsPattern
            | parenthesizedExpression
            | FunctionInvocation
            | Variable
            ;

Reduce = 'REDUCE', '(', Variable, '=', Expression, ',', IdInColl, '|', Expression, ')' ;

PartialComparisonExpression = ('=', Expression7)
                            | ('<>', Expression7)
                            | ('!=', Expression7)
                            | ('<', Expression7)
                            | ('>', Expression7)
                            | ('<=', Expression7)
                            | ('>=', Expression7)
                            ;

parenthesizedExpression = '(', Expression, ')' ;

RelationshipsPattern = NodePattern, {WS, PatternElementChain}- ;

FilterExpression = IdInColl, [WS, Where] ;

IdInColl = Variable, 'IN', Expression ;

FunctionInvocation = FunctionName, '(', ['DISTINCT'], [Expression, {',', Expression}], ')' ;

FunctionName = SymbolicNameString ;

ListComprehension = '[', FilterExpression, [WS, '|', Expression], ']' ;

PropertyLookup = '.', ((PropertyKeyName, ('?' | '!')) | PropertyKeyName) ;

CaseExpression = (('CASE', {CaseAlternatives}-) | ('CASE', Expression, {CaseAlternatives}-)), [WS, 'ELSE', Expression], 'END' ;

CaseAlternatives = 'WHEN', Expression, 'THEN', Expression ;

Variable = SymbolicNameString ;

StringLiteral = ('"', {ANY | EscapedChar}, '"')
              | ("'", {ANY | EscapedChar}, "'")
              ;

EscapedChar = '\', (
                '\'
              | "'"
              | '"'
              | 'b'
              | 'f'
              | 'n'
              | 'r'
              | 't'
              | '_'
              | '%'
              | ('u', 4 * HexDigit)
              | ('U', 8 * HexDigit)
            ) ;

NumberLiteral = DoubleLiteral
              | SignedIntegerLiteral
              ;

MapLiteral = '{', [PropertyKeyName, ':', Expression, {',', PropertyKeyName, ':', Expression}], '}' ;

Parameter = '{', (UnescapedSymbolicNameString | EscapedSymbolicNameString | UnsignedDecimalInteger), '}' ;

PropertyExpression = Expression1, {WS, PropertyLookup}- ;

PropertyKeyName = SymbolicNameString ;

SignedIntegerLiteral = HexInteger
                     | OctalInteger
                     | DecimalInteger
                     ;

UnsignedIntegerLiteral = UnsignedDecimalInteger ;

HexInteger = ['-'], UnsignedHexInteger ;

DecimalInteger = ['-'], UnsignedDecimalInteger ;

OctalInteger = ['-'], UnsignedOctalInteger ;

UnsignedHexInteger = '0x', HexString ;

UnsignedDecimalInteger = (('1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'), [DigitString])
                       | '0'
                       ;

UnsignedOctalInteger = '0', OctalString ;

HexString = {HexDigit}- ;

DigitString = {Digit}- ;

OctalString = {OctDigit}- ;

HexDigit = '0'
         | '1'
         | '2'
         | '3'
         | '4'
         | '5'
         | '6'
         | '7'
         | '8'
         | '9'
         | 'a'
         | 'b'
         | 'c'
         | 'd'
         | 'e'
         | 'f'
         ;

Digit = '0'
      | '1'
      | '2'
      | '3'
      | '4'
      | '5'
      | '6'
      | '7'
      | '8'
      | '9'
      ;

OctDigit = '0'
         | '1'
         | '2'
         | '3'
         | '4'
         | '5'
         | '6'
         | '7'
         ;

DoubleLiteral = ExponentDecimalReal
              | RegularDecimalReal
              ;

ExponentDecimalReal = ['-'], {Digit | '.'}-, ('e' | 'E'), ['-'], DigitString ;

RegularDecimalReal = ['-'], {Digit}, '.', DigitString ;

SymbolicNameString = UnescapedSymbolicNameString
                   | EscapedSymbolicNameString
                   ;

UnescapedSymbolicNameString = IdentifierStart, {IdentifierPart} ;

(* Defined using Character.isJavaIdentifierStart(...) in Java. *)
IdentifierStart = JavaIdentifierStart) ;

(* Defined using Character.isJavaIdentifierPart(...) in Java. *)
IdentifierPart = JavaIdentifierPart) ;

(* Any character except "`", enclosed within `backticks`. *)
EscapedSymbolicNameString = '`', {ANY}, '`' ;

WS = {whitespace} ;

SP = {whitespace}- ;

whitespace = SPACE)
           | TAB)
           | LF)
           | VT)
           | FF)
           | CR)
           | FS)
           | GS)
           | RS)
           | US)
           | Comment
           ;

Comment = ('/*', ANY, '*/')
        | ('//', ANY, [CR)], (LF) | EOI)))
        ;

LeftArrowHead = '<' ;

RightArrowHead = '>' ;

Dash = '-' ;