gen

package

Go to main page

Versions in this module

v0

v0.11.0

Aug 13, 2026

Changes in this version

type ISubqueryCountContext

+ AllReadingStatement func() []IReadingStatementContext

+ ReadingStatement func(i int) IReadingStatementContext

type ISubqueryExistContext

+ AllReadingStatement func() []IReadingStatementContext

+ ReadingStatement func(i int) IReadingStatementContext

type SubqueryCountContext

+ func (s *SubqueryCountContext) AllReadingStatement() []IReadingStatementContext

+ func (s *SubqueryCountContext) ReadingStatement(i int) IReadingStatementContext

type SubqueryExistContext

+ func (s *SubqueryExistContext) AllReadingStatement() []IReadingStatementContext

+ func (s *SubqueryExistContext) ReadingStatement(i int) IReadingStatementContext

v0.10.0

Jul 24, 2026

v0.9.0

Jul 19, 2026

Changes in this version

+ const CypherLexerFOREACH

+ const CypherParserFOREACH

+ const CypherParserRULE_foreachSt

+ func InitEmptyForeachStContext(p *ForeachStContext)

type BaseCypherParserListener

+ func (s *BaseCypherParserListener) EnterForeachSt(ctx *ForeachStContext)

+ func (s *BaseCypherParserListener) ExitForeachSt(ctx *ForeachStContext)

type BaseCypherParserVisitor

+ func (v *BaseCypherParserVisitor) VisitForeachSt(ctx *ForeachStContext) interface{}

type CypherParser

+ func (p *CypherParser) ForeachSt() (localctx IForeachStContext)

type CypherParserListener

+ EnterForeachSt func(c *ForeachStContext)

+ ExitForeachSt func(c *ForeachStContext)

type CypherParserVisitor

+ VisitForeachSt func(ctx *ForeachStContext) interface{}

+ type ForeachStContext struct

+ func NewEmptyForeachStContext() *ForeachStContext

+ func NewForeachStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForeachStContext

+ func (*ForeachStContext) IsForeachStContext()

+ func (s *ForeachStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ForeachStContext) AllUpdatingStatement() []IUpdatingStatementContext

+ func (s *ForeachStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ForeachStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ForeachStContext) Expression() IExpressionContext

+ func (s *ForeachStContext) FOREACH() antlr.TerminalNode

+ func (s *ForeachStContext) GetParser() antlr.Parser

+ func (s *ForeachStContext) GetRuleContext() antlr.RuleContext

+ func (s *ForeachStContext) IN() antlr.TerminalNode

+ func (s *ForeachStContext) LPAREN() antlr.TerminalNode

+ func (s *ForeachStContext) RPAREN() antlr.TerminalNode

+ func (s *ForeachStContext) STICK() antlr.TerminalNode

+ func (s *ForeachStContext) Symbol() ISymbolContext

+ func (s *ForeachStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *ForeachStContext) UpdatingStatement(i int) IUpdatingStatementContext

+ type IForeachStContext interface

+ AllUpdatingStatement func() []IUpdatingStatementContext

+ Expression func() IExpressionContext

+ FOREACH func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IN func() antlr.TerminalNode

+ IsForeachStContext func()

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ STICK func() antlr.TerminalNode

+ Symbol func() ISymbolContext

+ UpdatingStatement func(i int) IUpdatingStatementContext

type ISetItemContext

+ AllDOT func() []antlr.TerminalNode

+ AllName func() []INameContext

+ Atom func() IAtomContext

+ DOT func(i int) antlr.TerminalNode

+ Name func(i int) INameContext

type IUpdatingStatementContext

+ ForeachSt func() IForeachStContext

type SetItemContext

+ func (s *SetItemContext) AllDOT() []antlr.TerminalNode

+ func (s *SetItemContext) AllName() []INameContext

+ func (s *SetItemContext) Atom() IAtomContext

+ func (s *SetItemContext) DOT(i int) antlr.TerminalNode

+ func (s *SetItemContext) Name(i int) INameContext

type UpdatingStatementContext

+ func (s *UpdatingStatementContext) ForeachSt() IForeachStContext

v0.8.1

Jul 14, 2026

v0.8.0

Jul 14, 2026

v0.7.0

Jul 3, 2026

v0.6.0

Jun 28, 2026

Changes in this version

+ const CypherParserRULE_mapProjection

+ const CypherParserRULE_mapProjectionItem

+ func InitEmptyMapProjectionContext(p *MapProjectionContext)

+ func InitEmptyMapProjectionItemContext(p *MapProjectionItemContext)

type AtomContext

+ func (s *AtomContext) MapProjection() IMapProjectionContext

type BaseCypherParserListener

+ func (s *BaseCypherParserListener) EnterMapProjection(ctx *MapProjectionContext)

+ func (s *BaseCypherParserListener) EnterMapProjectionItem(ctx *MapProjectionItemContext)

+ func (s *BaseCypherParserListener) ExitMapProjection(ctx *MapProjectionContext)

+ func (s *BaseCypherParserListener) ExitMapProjectionItem(ctx *MapProjectionItemContext)

type BaseCypherParserVisitor

+ func (v *BaseCypherParserVisitor) VisitMapProjection(ctx *MapProjectionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitMapProjectionItem(ctx *MapProjectionItemContext) interface{}

type CypherParser

+ func (p *CypherParser) MapProjection() (localctx IMapProjectionContext)

+ func (p *CypherParser) MapProjectionItem() (localctx IMapProjectionItemContext)

type CypherParserListener

+ EnterMapProjection func(c *MapProjectionContext)

+ EnterMapProjectionItem func(c *MapProjectionItemContext)

+ ExitMapProjection func(c *MapProjectionContext)

+ ExitMapProjectionItem func(c *MapProjectionItemContext)

type CypherParserVisitor

+ VisitMapProjection func(ctx *MapProjectionContext) interface{}

+ VisitMapProjectionItem func(ctx *MapProjectionItemContext) interface{}

type IAtomContext

+ MapProjection func() IMapProjectionContext

+ type IMapProjectionContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllMapProjectionItem func() []IMapProjectionItemContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsMapProjectionContext func()

+ LBRACE func() antlr.TerminalNode

+ MapProjectionItem func(i int) IMapProjectionItemContext

+ RBRACE func() antlr.TerminalNode

+ Symbol func() ISymbolContext

+ type IMapProjectionItemContext interface

+ COLON func() antlr.TerminalNode

+ DOT func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsMapProjectionItemContext func()

+ MULT func() antlr.TerminalNode

+ Name func() INameContext

+ Symbol func() ISymbolContext

+ type MapProjectionContext struct

+ func NewEmptyMapProjectionContext() *MapProjectionContext

+ func NewMapProjectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MapProjectionContext

+ func (*MapProjectionContext) IsMapProjectionContext()

+ func (s *MapProjectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *MapProjectionContext) AllCOMMA() []antlr.TerminalNode

+ func (s *MapProjectionContext) AllMapProjectionItem() []IMapProjectionItemContext

+ func (s *MapProjectionContext) COMMA(i int) antlr.TerminalNode

+ func (s *MapProjectionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *MapProjectionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *MapProjectionContext) GetParser() antlr.Parser

+ func (s *MapProjectionContext) GetRuleContext() antlr.RuleContext

+ func (s *MapProjectionContext) LBRACE() antlr.TerminalNode

+ func (s *MapProjectionContext) MapProjectionItem(i int) IMapProjectionItemContext

+ func (s *MapProjectionContext) RBRACE() antlr.TerminalNode

+ func (s *MapProjectionContext) Symbol() ISymbolContext

+ func (s *MapProjectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type MapProjectionItemContext struct

+ func NewEmptyMapProjectionItemContext() *MapProjectionItemContext

+ func NewMapProjectionItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MapProjectionItemContext

+ func (*MapProjectionItemContext) IsMapProjectionItemContext()

+ func (s *MapProjectionItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *MapProjectionItemContext) COLON() antlr.TerminalNode

+ func (s *MapProjectionItemContext) DOT() antlr.TerminalNode

+ func (s *MapProjectionItemContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *MapProjectionItemContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *MapProjectionItemContext) Expression() IExpressionContext

+ func (s *MapProjectionItemContext) GetParser() antlr.Parser

+ func (s *MapProjectionItemContext) GetRuleContext() antlr.RuleContext

+ func (s *MapProjectionItemContext) MULT() antlr.TerminalNode

+ func (s *MapProjectionItemContext) Name() INameContext

+ func (s *MapProjectionItemContext) Symbol() ISymbolContext

+ func (s *MapProjectionItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

v0.5.0

Jun 17, 2026

v0.4.0

Jun 17, 2026

v0.3.2

Jun 15, 2026

v0.3.1

Jun 15, 2026

v0.3.0

Jun 14, 2026

Changes in this version

+ const CypherParserRULE_reduceExpression

+ func InitEmptyReduceExpressionContext(p *ReduceExpressionContext)

type AtomContext

+ func (s *AtomContext) ReduceExpression() IReduceExpressionContext

type BaseCypherParserListener

+ func (s *BaseCypherParserListener) EnterReduceExpression(ctx *ReduceExpressionContext)

+ func (s *BaseCypherParserListener) ExitReduceExpression(ctx *ReduceExpressionContext)

type BaseCypherParserVisitor

+ func (v *BaseCypherParserVisitor) VisitReduceExpression(ctx *ReduceExpressionContext) interface{}

type CypherParser

+ func (p *CypherParser) ReduceExpression() (localctx IReduceExpressionContext)

type CypherParserListener

+ EnterReduceExpression func(c *ReduceExpressionContext)

+ ExitReduceExpression func(c *ReduceExpressionContext)

type CypherParserVisitor

+ VisitReduceExpression func(ctx *ReduceExpressionContext) interface{}

type IAtomContext

+ ReduceExpression func() IReduceExpressionContext

+ type IReduceExpressionContext interface

+ ASSIGN func() antlr.TerminalNode

+ AllExpression func() []IExpressionContext

+ COMMA func() antlr.TerminalNode

+ Expression func(i int) IExpressionContext

+ FilterExpression func() IFilterExpressionContext

+ GetParser func() antlr.Parser

+ IsReduceExpressionContext func()

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ STICK func() antlr.TerminalNode

+ Symbol func() ISymbolContext

+ type ReduceExpressionContext struct

+ func NewEmptyReduceExpressionContext() *ReduceExpressionContext

+ func NewReduceExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReduceExpressionContext

+ func (*ReduceExpressionContext) IsReduceExpressionContext()

+ func (s *ReduceExpressionContext) ASSIGN() antlr.TerminalNode

+ func (s *ReduceExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ReduceExpressionContext) AllExpression() []IExpressionContext

+ func (s *ReduceExpressionContext) COMMA() antlr.TerminalNode

+ func (s *ReduceExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ReduceExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ReduceExpressionContext) Expression(i int) IExpressionContext

+ func (s *ReduceExpressionContext) FilterExpression() IFilterExpressionContext

+ func (s *ReduceExpressionContext) GetParser() antlr.Parser

+ func (s *ReduceExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *ReduceExpressionContext) LPAREN() antlr.TerminalNode

+ func (s *ReduceExpressionContext) RPAREN() antlr.TerminalNode

+ func (s *ReduceExpressionContext) STICK() antlr.TerminalNode

+ func (s *ReduceExpressionContext) Symbol() ISymbolContext

+ func (s *ReduceExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

v0.2.0

Jun 5, 2026

v0.1.0

Jun 2, 2026

Changes in this version

+ const CypherLexerADD

+ const CypherLexerADD_ASSIGN

+ const CypherLexerALL

+ const CypherLexerAND

+ const CypherLexerANY

+ const CypherLexerAS

+ const CypherLexerASC

+ const CypherLexerASCENDING

+ const CypherLexerASSIGN

+ const CypherLexerBY

+ const CypherLexerCALL

+ const CypherLexerCARET

+ const CypherLexerCASE

+ const CypherLexerCHAR_LITERAL

+ const CypherLexerCOLON

+ const CypherLexerCOMMA

+ const CypherLexerCOMMENT

+ const CypherLexerCOMMENTS

+ const CypherLexerCONSTRAINT

+ const CypherLexerCONTAINS

+ const CypherLexerCOUNT

+ const CypherLexerCREATE

+ const CypherLexerDELETE

+ const CypherLexerDESC

+ const CypherLexerDESCENDING

+ const CypherLexerDETACH

+ const CypherLexerDIGIT

+ const CypherLexerDISTINCT

+ const CypherLexerDIV

+ const CypherLexerDO

+ const CypherLexerDOLLAR

+ const CypherLexerDOT

+ const CypherLexerDROP

+ const CypherLexerELSE

+ const CypherLexerEND

+ const CypherLexerENDS

+ const CypherLexerERRCHAR

+ const CypherLexerESC

+ const CypherLexerESC_LITERAL

+ const CypherLexerEXISTS

+ const CypherLexerEXTRACT

+ const CypherLexerFALSE

+ const CypherLexerFILTER

+ const CypherLexerFLOAT

+ const CypherLexerFOR

+ const CypherLexerGE

+ const CypherLexerGT

+ const CypherLexerID

+ const CypherLexerIN

+ const CypherLexerIS

+ const CypherLexerLBRACE

+ const CypherLexerLBRACK

+ const CypherLexerLE

+ const CypherLexerLIMIT

+ const CypherLexerLINE_COMMENT

+ const CypherLexerLPAREN

+ const CypherLexerLT

+ const CypherLexerLetter

+ const CypherLexerMANDATORY

+ const CypherLexerMATCH

+ const CypherLexerMERGE

+ const CypherLexerMOD

+ const CypherLexerMULT

+ const CypherLexerNONE

+ const CypherLexerNOT

+ const CypherLexerNOT_EQUAL

+ const CypherLexerNULL_W

+ const CypherLexerOF

+ const CypherLexerON

+ const CypherLexerOPTIONAL

+ const CypherLexerOR

+ const CypherLexerORDER

+ const CypherLexerPLUS

+ const CypherLexerRANGE

+ const CypherLexerRBRACE

+ const CypherLexerRBRACK

+ const CypherLexerREMOVE

+ const CypherLexerREQUIRE

+ const CypherLexerRETURN

+ const CypherLexerRPAREN

+ const CypherLexerSCALAR

+ const CypherLexerSEMI

+ const CypherLexerSET

+ const CypherLexerSINGLE

+ const CypherLexerSKIP_W

+ const CypherLexerSTARTS

+ const CypherLexerSTICK

+ const CypherLexerSTRING_LITERAL

+ const CypherLexerSUB

+ const CypherLexerTHEN

+ const CypherLexerTRUE

+ const CypherLexerUNION

+ const CypherLexerUNIQUE

+ const CypherLexerUNWIND

+ const CypherLexerWHEN

+ const CypherLexerWHERE

+ const CypherLexerWITH

+ const CypherLexerWS

+ const CypherLexerXOR

+ const CypherLexerYIELD

+ const CypherParserADD

+ const CypherParserADD_ASSIGN

+ const CypherParserALL

+ const CypherParserAND

+ const CypherParserANY

+ const CypherParserAS

+ const CypherParserASC

+ const CypherParserASCENDING

+ const CypherParserASSIGN

+ const CypherParserBY

+ const CypherParserCALL

+ const CypherParserCARET

+ const CypherParserCASE

+ const CypherParserCHAR_LITERAL

+ const CypherParserCOLON

+ const CypherParserCOMMA

+ const CypherParserCOMMENT

+ const CypherParserCONSTRAINT

+ const CypherParserCONTAINS

+ const CypherParserCOUNT

+ const CypherParserCREATE

+ const CypherParserDELETE

+ const CypherParserDESC

+ const CypherParserDESCENDING

+ const CypherParserDETACH

+ const CypherParserDIGIT

+ const CypherParserDISTINCT

+ const CypherParserDIV

+ const CypherParserDO

+ const CypherParserDOLLAR

+ const CypherParserDOT

+ const CypherParserDROP

+ const CypherParserELSE

+ const CypherParserEND

+ const CypherParserENDS

+ const CypherParserEOF

+ const CypherParserERRCHAR

+ const CypherParserESC

+ const CypherParserESC_LITERAL

+ const CypherParserEXISTS

+ const CypherParserEXTRACT

+ const CypherParserFALSE

+ const CypherParserFILTER

+ const CypherParserFLOAT

+ const CypherParserFOR

+ const CypherParserGE

+ const CypherParserGT

+ const CypherParserID

+ const CypherParserIN

+ const CypherParserIS

+ const CypherParserLBRACE

+ const CypherParserLBRACK

+ const CypherParserLE

+ const CypherParserLIMIT

+ const CypherParserLINE_COMMENT

+ const CypherParserLPAREN

+ const CypherParserLT

+ const CypherParserLetter

+ const CypherParserMANDATORY

+ const CypherParserMATCH

+ const CypherParserMERGE

+ const CypherParserMOD

+ const CypherParserMULT

+ const CypherParserNONE

+ const CypherParserNOT

+ const CypherParserNOT_EQUAL

+ const CypherParserNULL_W

+ const CypherParserOF

+ const CypherParserON

+ const CypherParserOPTIONAL

+ const CypherParserOR

+ const CypherParserORDER

+ const CypherParserPLUS

+ const CypherParserRANGE

+ const CypherParserRBRACE

+ const CypherParserRBRACK

+ const CypherParserREMOVE

+ const CypherParserREQUIRE

+ const CypherParserRETURN

+ const CypherParserRPAREN

+ const CypherParserRULE_addSubExpression

+ const CypherParserRULE_andExpression

+ const CypherParserRULE_atom

+ const CypherParserRULE_atomicExpression

+ const CypherParserRULE_boolLit

+ const CypherParserRULE_caseExpression

+ const CypherParserRULE_charLit

+ const CypherParserRULE_comparisonExpression

+ const CypherParserRULE_comparisonSigns

+ const CypherParserRULE_countAll

+ const CypherParserRULE_createSt

+ const CypherParserRULE_deleteSt

+ const CypherParserRULE_expression

+ const CypherParserRULE_expressionChain

+ const CypherParserRULE_filterExpression

+ const CypherParserRULE_filterWith

+ const CypherParserRULE_functionInvocation

+ const CypherParserRULE_invocationName

+ const CypherParserRULE_lhs

+ const CypherParserRULE_limitSt

+ const CypherParserRULE_listComprehension

+ const CypherParserRULE_listExpression

+ const CypherParserRULE_listLit

+ const CypherParserRULE_literal

+ const CypherParserRULE_mapLit

+ const CypherParserRULE_mapPair

+ const CypherParserRULE_matchSt

+ const CypherParserRULE_mergeAction

+ const CypherParserRULE_mergeSt

+ const CypherParserRULE_multDivExpression

+ const CypherParserRULE_multiPartQ

+ const CypherParserRULE_name

+ const CypherParserRULE_nodeLabels

+ const CypherParserRULE_nodePattern

+ const CypherParserRULE_notExpression

+ const CypherParserRULE_nullExpression

+ const CypherParserRULE_numLit

+ const CypherParserRULE_orderItem

+ const CypherParserRULE_orderSt

+ const CypherParserRULE_parameter

+ const CypherParserRULE_parenExpressionChain

+ const CypherParserRULE_parenthesizedExpression

+ const CypherParserRULE_pattern

+ const CypherParserRULE_patternComprehension

+ const CypherParserRULE_patternElem

+ const CypherParserRULE_patternElemChain

+ const CypherParserRULE_patternPart

+ const CypherParserRULE_patternWhere

+ const CypherParserRULE_powerExpression

+ const CypherParserRULE_projectionBody

+ const CypherParserRULE_projectionItem

+ const CypherParserRULE_projectionItems

+ const CypherParserRULE_properties

+ const CypherParserRULE_propertyExpression

+ const CypherParserRULE_propertyOrLabelExpression

+ const CypherParserRULE_query

+ const CypherParserRULE_queryCallSt

+ const CypherParserRULE_rangeLit

+ const CypherParserRULE_readingStatement

+ const CypherParserRULE_regularQuery

+ const CypherParserRULE_relationDetail

+ const CypherParserRULE_relationshipPattern

+ const CypherParserRULE_relationshipTypes

+ const CypherParserRULE_relationshipsChainPattern

+ const CypherParserRULE_removeItem

+ const CypherParserRULE_removeSt

+ const CypherParserRULE_reservedWord

+ const CypherParserRULE_returnSt

+ const CypherParserRULE_script

+ const CypherParserRULE_setItem

+ const CypherParserRULE_setSt

+ const CypherParserRULE_singlePartQ

+ const CypherParserRULE_singleQuery

+ const CypherParserRULE_skipSt

+ const CypherParserRULE_standaloneCall

+ const CypherParserRULE_stringExpPrefix

+ const CypherParserRULE_stringExpression

+ const CypherParserRULE_stringLit

+ const CypherParserRULE_subqueryCount

+ const CypherParserRULE_subqueryExist

+ const CypherParserRULE_symbol

+ const CypherParserRULE_unaryAddSubExpression

+ const CypherParserRULE_unionSt

+ const CypherParserRULE_unwindSt

+ const CypherParserRULE_updatingStatement

+ const CypherParserRULE_where

+ const CypherParserRULE_withSt

+ const CypherParserRULE_xorExpression

+ const CypherParserRULE_yieldItem

+ const CypherParserRULE_yieldItems

+ const CypherParserSCALAR

+ const CypherParserSEMI

+ const CypherParserSET

+ const CypherParserSINGLE

+ const CypherParserSKIP_W

+ const CypherParserSTARTS

+ const CypherParserSTICK

+ const CypherParserSTRING_LITERAL

+ const CypherParserSUB

+ const CypherParserTHEN

+ const CypherParserTRUE

+ const CypherParserUNION

+ const CypherParserUNIQUE

+ const CypherParserUNWIND

+ const CypherParserWHEN

+ const CypherParserWHERE

+ const CypherParserWITH

+ const CypherParserWS

+ const CypherParserXOR

+ const CypherParserYIELD

+ var CypherLexerLexerStaticData struct

+ var CypherParserParserStaticData struct

+ func CypherLexerInit()

+ func CypherParserInit()

+ func InitEmptyAddSubExpressionContext(p *AddSubExpressionContext)

+ func InitEmptyAndExpressionContext(p *AndExpressionContext)

+ func InitEmptyAtomContext(p *AtomContext)

+ func InitEmptyAtomicExpressionContext(p *AtomicExpressionContext)

+ func InitEmptyBoolLitContext(p *BoolLitContext)

+ func InitEmptyCaseExpressionContext(p *CaseExpressionContext)

+ func InitEmptyCharLitContext(p *CharLitContext)

+ func InitEmptyComparisonExpressionContext(p *ComparisonExpressionContext)

+ func InitEmptyComparisonSignsContext(p *ComparisonSignsContext)

+ func InitEmptyCountAllContext(p *CountAllContext)

+ func InitEmptyCreateStContext(p *CreateStContext)

+ func InitEmptyDeleteStContext(p *DeleteStContext)

+ func InitEmptyExpressionChainContext(p *ExpressionChainContext)

+ func InitEmptyExpressionContext(p *ExpressionContext)

+ func InitEmptyFilterExpressionContext(p *FilterExpressionContext)

+ func InitEmptyFilterWithContext(p *FilterWithContext)

+ func InitEmptyFunctionInvocationContext(p *FunctionInvocationContext)

+ func InitEmptyInvocationNameContext(p *InvocationNameContext)

+ func InitEmptyLhsContext(p *LhsContext)

+ func InitEmptyLimitStContext(p *LimitStContext)

+ func InitEmptyListComprehensionContext(p *ListComprehensionContext)

+ func InitEmptyListExpressionContext(p *ListExpressionContext)

+ func InitEmptyListLitContext(p *ListLitContext)

+ func InitEmptyLiteralContext(p *LiteralContext)

+ func InitEmptyMapLitContext(p *MapLitContext)

+ func InitEmptyMapPairContext(p *MapPairContext)

+ func InitEmptyMatchStContext(p *MatchStContext)

+ func InitEmptyMergeActionContext(p *MergeActionContext)

+ func InitEmptyMergeStContext(p *MergeStContext)

+ func InitEmptyMultDivExpressionContext(p *MultDivExpressionContext)

+ func InitEmptyMultiPartQContext(p *MultiPartQContext)

+ func InitEmptyNameContext(p *NameContext)

+ func InitEmptyNodeLabelsContext(p *NodeLabelsContext)

+ func InitEmptyNodePatternContext(p *NodePatternContext)

+ func InitEmptyNotExpressionContext(p *NotExpressionContext)

+ func InitEmptyNullExpressionContext(p *NullExpressionContext)

+ func InitEmptyNumLitContext(p *NumLitContext)

+ func InitEmptyOrderItemContext(p *OrderItemContext)

+ func InitEmptyOrderStContext(p *OrderStContext)

+ func InitEmptyParameterContext(p *ParameterContext)

+ func InitEmptyParenExpressionChainContext(p *ParenExpressionChainContext)

+ func InitEmptyParenthesizedExpressionContext(p *ParenthesizedExpressionContext)

+ func InitEmptyPatternComprehensionContext(p *PatternComprehensionContext)

+ func InitEmptyPatternContext(p *PatternContext)

+ func InitEmptyPatternElemChainContext(p *PatternElemChainContext)

+ func InitEmptyPatternElemContext(p *PatternElemContext)

+ func InitEmptyPatternPartContext(p *PatternPartContext)

+ func InitEmptyPatternWhereContext(p *PatternWhereContext)

+ func InitEmptyPowerExpressionContext(p *PowerExpressionContext)

+ func InitEmptyProjectionBodyContext(p *ProjectionBodyContext)

+ func InitEmptyProjectionItemContext(p *ProjectionItemContext)

+ func InitEmptyProjectionItemsContext(p *ProjectionItemsContext)

+ func InitEmptyPropertiesContext(p *PropertiesContext)

+ func InitEmptyPropertyExpressionContext(p *PropertyExpressionContext)

+ func InitEmptyPropertyOrLabelExpressionContext(p *PropertyOrLabelExpressionContext)

+ func InitEmptyQueryCallStContext(p *QueryCallStContext)

+ func InitEmptyQueryContext(p *QueryContext)

+ func InitEmptyRangeLitContext(p *RangeLitContext)

+ func InitEmptyReadingStatementContext(p *ReadingStatementContext)

+ func InitEmptyRegularQueryContext(p *RegularQueryContext)

+ func InitEmptyRelationDetailContext(p *RelationDetailContext)

+ func InitEmptyRelationshipPatternContext(p *RelationshipPatternContext)

+ func InitEmptyRelationshipTypesContext(p *RelationshipTypesContext)

+ func InitEmptyRelationshipsChainPatternContext(p *RelationshipsChainPatternContext)

+ func InitEmptyRemoveItemContext(p *RemoveItemContext)

+ func InitEmptyRemoveStContext(p *RemoveStContext)

+ func InitEmptyReservedWordContext(p *ReservedWordContext)

+ func InitEmptyReturnStContext(p *ReturnStContext)

+ func InitEmptyScriptContext(p *ScriptContext)

+ func InitEmptySetItemContext(p *SetItemContext)

+ func InitEmptySetStContext(p *SetStContext)

+ func InitEmptySinglePartQContext(p *SinglePartQContext)

+ func InitEmptySingleQueryContext(p *SingleQueryContext)

+ func InitEmptySkipStContext(p *SkipStContext)

+ func InitEmptyStandaloneCallContext(p *StandaloneCallContext)

+ func InitEmptyStringExpPrefixContext(p *StringExpPrefixContext)

+ func InitEmptyStringExpressionContext(p *StringExpressionContext)

+ func InitEmptyStringLitContext(p *StringLitContext)

+ func InitEmptySubqueryCountContext(p *SubqueryCountContext)

+ func InitEmptySubqueryExistContext(p *SubqueryExistContext)

+ func InitEmptySymbolContext(p *SymbolContext)

+ func InitEmptyUnaryAddSubExpressionContext(p *UnaryAddSubExpressionContext)

+ func InitEmptyUnionStContext(p *UnionStContext)

+ func InitEmptyUnwindStContext(p *UnwindStContext)

+ func InitEmptyUpdatingStatementContext(p *UpdatingStatementContext)

+ func InitEmptyWhereContext(p *WhereContext)

+ func InitEmptyWithStContext(p *WithStContext)

+ func InitEmptyXorExpressionContext(p *XorExpressionContext)

+ func InitEmptyYieldItemContext(p *YieldItemContext)

+ func InitEmptyYieldItemsContext(p *YieldItemsContext)

+ type AddSubExpressionContext struct

+ func NewAddSubExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AddSubExpressionContext

+ func NewEmptyAddSubExpressionContext() *AddSubExpressionContext

+ func (*AddSubExpressionContext) IsAddSubExpressionContext()

+ func (s *AddSubExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *AddSubExpressionContext) AllMultDivExpression() []IMultDivExpressionContext

+ func (s *AddSubExpressionContext) AllPLUS() []antlr.TerminalNode

+ func (s *AddSubExpressionContext) AllSUB() []antlr.TerminalNode

+ func (s *AddSubExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *AddSubExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *AddSubExpressionContext) GetParser() antlr.Parser

+ func (s *AddSubExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *AddSubExpressionContext) MultDivExpression(i int) IMultDivExpressionContext

+ func (s *AddSubExpressionContext) PLUS(i int) antlr.TerminalNode

+ func (s *AddSubExpressionContext) SUB(i int) antlr.TerminalNode

+ func (s *AddSubExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type AndExpressionContext struct

+ func NewAndExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AndExpressionContext

+ func NewEmptyAndExpressionContext() *AndExpressionContext

+ func (*AndExpressionContext) IsAndExpressionContext()

+ func (s *AndExpressionContext) AND(i int) antlr.TerminalNode

+ func (s *AndExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *AndExpressionContext) AllAND() []antlr.TerminalNode

+ func (s *AndExpressionContext) AllNotExpression() []INotExpressionContext

+ func (s *AndExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *AndExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *AndExpressionContext) GetParser() antlr.Parser

+ func (s *AndExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *AndExpressionContext) NotExpression(i int) INotExpressionContext

+ func (s *AndExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type AtomContext struct

+ func NewAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtomContext

+ func NewEmptyAtomContext() *AtomContext

+ func (*AtomContext) IsAtomContext()

+ func (s *AtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *AtomContext) CaseExpression() ICaseExpressionContext

+ func (s *AtomContext) CountAll() ICountAllContext

+ func (s *AtomContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *AtomContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *AtomContext) FilterWith() IFilterWithContext

+ func (s *AtomContext) FunctionInvocation() IFunctionInvocationContext

+ func (s *AtomContext) GetParser() antlr.Parser

+ func (s *AtomContext) GetRuleContext() antlr.RuleContext

+ func (s *AtomContext) ListComprehension() IListComprehensionContext

+ func (s *AtomContext) Literal() ILiteralContext

+ func (s *AtomContext) Parameter() IParameterContext

+ func (s *AtomContext) ParenthesizedExpression() IParenthesizedExpressionContext

+ func (s *AtomContext) PatternComprehension() IPatternComprehensionContext

+ func (s *AtomContext) RelationshipsChainPattern() IRelationshipsChainPatternContext

+ func (s *AtomContext) SubqueryCount() ISubqueryCountContext

+ func (s *AtomContext) SubqueryExist() ISubqueryExistContext

+ func (s *AtomContext) Symbol() ISymbolContext

+ func (s *AtomContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type AtomicExpressionContext struct

+ func NewAtomicExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtomicExpressionContext

+ func NewEmptyAtomicExpressionContext() *AtomicExpressionContext

+ func (*AtomicExpressionContext) IsAtomicExpressionContext()

+ func (s *AtomicExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *AtomicExpressionContext) AllListExpression() []IListExpressionContext

+ func (s *AtomicExpressionContext) AllNullExpression() []INullExpressionContext

+ func (s *AtomicExpressionContext) AllStringExpression() []IStringExpressionContext

+ func (s *AtomicExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *AtomicExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *AtomicExpressionContext) GetParser() antlr.Parser

+ func (s *AtomicExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *AtomicExpressionContext) ListExpression(i int) IListExpressionContext

+ func (s *AtomicExpressionContext) NullExpression(i int) INullExpressionContext

+ func (s *AtomicExpressionContext) PropertyOrLabelExpression() IPropertyOrLabelExpressionContext

+ func (s *AtomicExpressionContext) StringExpression(i int) IStringExpressionContext

+ func (s *AtomicExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type BaseCypherParserListener struct

+ func (s *BaseCypherParserListener) EnterAddSubExpression(ctx *AddSubExpressionContext)

+ func (s *BaseCypherParserListener) EnterAndExpression(ctx *AndExpressionContext)

+ func (s *BaseCypherParserListener) EnterAtom(ctx *AtomContext)

+ func (s *BaseCypherParserListener) EnterAtomicExpression(ctx *AtomicExpressionContext)

+ func (s *BaseCypherParserListener) EnterBoolLit(ctx *BoolLitContext)

+ func (s *BaseCypherParserListener) EnterCaseExpression(ctx *CaseExpressionContext)

+ func (s *BaseCypherParserListener) EnterCharLit(ctx *CharLitContext)

+ func (s *BaseCypherParserListener) EnterComparisonExpression(ctx *ComparisonExpressionContext)

+ func (s *BaseCypherParserListener) EnterComparisonSigns(ctx *ComparisonSignsContext)

+ func (s *BaseCypherParserListener) EnterCountAll(ctx *CountAllContext)

+ func (s *BaseCypherParserListener) EnterCreateSt(ctx *CreateStContext)

+ func (s *BaseCypherParserListener) EnterDeleteSt(ctx *DeleteStContext)

+ func (s *BaseCypherParserListener) EnterEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseCypherParserListener) EnterExpression(ctx *ExpressionContext)

+ func (s *BaseCypherParserListener) EnterExpressionChain(ctx *ExpressionChainContext)

+ func (s *BaseCypherParserListener) EnterFilterExpression(ctx *FilterExpressionContext)

+ func (s *BaseCypherParserListener) EnterFilterWith(ctx *FilterWithContext)

+ func (s *BaseCypherParserListener) EnterFunctionInvocation(ctx *FunctionInvocationContext)

+ func (s *BaseCypherParserListener) EnterInvocationName(ctx *InvocationNameContext)

+ func (s *BaseCypherParserListener) EnterLhs(ctx *LhsContext)

+ func (s *BaseCypherParserListener) EnterLimitSt(ctx *LimitStContext)

+ func (s *BaseCypherParserListener) EnterListComprehension(ctx *ListComprehensionContext)

+ func (s *BaseCypherParserListener) EnterListExpression(ctx *ListExpressionContext)

+ func (s *BaseCypherParserListener) EnterListLit(ctx *ListLitContext)

+ func (s *BaseCypherParserListener) EnterLiteral(ctx *LiteralContext)

+ func (s *BaseCypherParserListener) EnterMapLit(ctx *MapLitContext)

+ func (s *BaseCypherParserListener) EnterMapPair(ctx *MapPairContext)

+ func (s *BaseCypherParserListener) EnterMatchSt(ctx *MatchStContext)

+ func (s *BaseCypherParserListener) EnterMergeAction(ctx *MergeActionContext)

+ func (s *BaseCypherParserListener) EnterMergeSt(ctx *MergeStContext)

+ func (s *BaseCypherParserListener) EnterMultDivExpression(ctx *MultDivExpressionContext)

+ func (s *BaseCypherParserListener) EnterMultiPartQ(ctx *MultiPartQContext)

+ func (s *BaseCypherParserListener) EnterName(ctx *NameContext)

+ func (s *BaseCypherParserListener) EnterNodeLabels(ctx *NodeLabelsContext)

+ func (s *BaseCypherParserListener) EnterNodePattern(ctx *NodePatternContext)

+ func (s *BaseCypherParserListener) EnterNotExpression(ctx *NotExpressionContext)

+ func (s *BaseCypherParserListener) EnterNullExpression(ctx *NullExpressionContext)

+ func (s *BaseCypherParserListener) EnterNumLit(ctx *NumLitContext)

+ func (s *BaseCypherParserListener) EnterOrderItem(ctx *OrderItemContext)

+ func (s *BaseCypherParserListener) EnterOrderSt(ctx *OrderStContext)

+ func (s *BaseCypherParserListener) EnterParameter(ctx *ParameterContext)

+ func (s *BaseCypherParserListener) EnterParenExpressionChain(ctx *ParenExpressionChainContext)

+ func (s *BaseCypherParserListener) EnterParenthesizedExpression(ctx *ParenthesizedExpressionContext)

+ func (s *BaseCypherParserListener) EnterPattern(ctx *PatternContext)

+ func (s *BaseCypherParserListener) EnterPatternComprehension(ctx *PatternComprehensionContext)

+ func (s *BaseCypherParserListener) EnterPatternElem(ctx *PatternElemContext)

+ func (s *BaseCypherParserListener) EnterPatternElemChain(ctx *PatternElemChainContext)

+ func (s *BaseCypherParserListener) EnterPatternPart(ctx *PatternPartContext)

+ func (s *BaseCypherParserListener) EnterPatternWhere(ctx *PatternWhereContext)

+ func (s *BaseCypherParserListener) EnterPowerExpression(ctx *PowerExpressionContext)

+ func (s *BaseCypherParserListener) EnterProjectionBody(ctx *ProjectionBodyContext)

+ func (s *BaseCypherParserListener) EnterProjectionItem(ctx *ProjectionItemContext)

+ func (s *BaseCypherParserListener) EnterProjectionItems(ctx *ProjectionItemsContext)

+ func (s *BaseCypherParserListener) EnterProperties(ctx *PropertiesContext)

+ func (s *BaseCypherParserListener) EnterPropertyExpression(ctx *PropertyExpressionContext)

+ func (s *BaseCypherParserListener) EnterPropertyOrLabelExpression(ctx *PropertyOrLabelExpressionContext)

+ func (s *BaseCypherParserListener) EnterQuery(ctx *QueryContext)

+ func (s *BaseCypherParserListener) EnterQueryCallSt(ctx *QueryCallStContext)

+ func (s *BaseCypherParserListener) EnterRangeLit(ctx *RangeLitContext)

+ func (s *BaseCypherParserListener) EnterReadingStatement(ctx *ReadingStatementContext)

+ func (s *BaseCypherParserListener) EnterRegularQuery(ctx *RegularQueryContext)

+ func (s *BaseCypherParserListener) EnterRelationDetail(ctx *RelationDetailContext)

+ func (s *BaseCypherParserListener) EnterRelationshipPattern(ctx *RelationshipPatternContext)

+ func (s *BaseCypherParserListener) EnterRelationshipTypes(ctx *RelationshipTypesContext)

+ func (s *BaseCypherParserListener) EnterRelationshipsChainPattern(ctx *RelationshipsChainPatternContext)

+ func (s *BaseCypherParserListener) EnterRemoveItem(ctx *RemoveItemContext)

+ func (s *BaseCypherParserListener) EnterRemoveSt(ctx *RemoveStContext)

+ func (s *BaseCypherParserListener) EnterReservedWord(ctx *ReservedWordContext)

+ func (s *BaseCypherParserListener) EnterReturnSt(ctx *ReturnStContext)

+ func (s *BaseCypherParserListener) EnterScript(ctx *ScriptContext)

+ func (s *BaseCypherParserListener) EnterSetItem(ctx *SetItemContext)

+ func (s *BaseCypherParserListener) EnterSetSt(ctx *SetStContext)

+ func (s *BaseCypherParserListener) EnterSinglePartQ(ctx *SinglePartQContext)

+ func (s *BaseCypherParserListener) EnterSingleQuery(ctx *SingleQueryContext)

+ func (s *BaseCypherParserListener) EnterSkipSt(ctx *SkipStContext)

+ func (s *BaseCypherParserListener) EnterStandaloneCall(ctx *StandaloneCallContext)

+ func (s *BaseCypherParserListener) EnterStringExpPrefix(ctx *StringExpPrefixContext)

+ func (s *BaseCypherParserListener) EnterStringExpression(ctx *StringExpressionContext)

+ func (s *BaseCypherParserListener) EnterStringLit(ctx *StringLitContext)

+ func (s *BaseCypherParserListener) EnterSubqueryCount(ctx *SubqueryCountContext)

+ func (s *BaseCypherParserListener) EnterSubqueryExist(ctx *SubqueryExistContext)

+ func (s *BaseCypherParserListener) EnterSymbol(ctx *SymbolContext)

+ func (s *BaseCypherParserListener) EnterUnaryAddSubExpression(ctx *UnaryAddSubExpressionContext)

+ func (s *BaseCypherParserListener) EnterUnionSt(ctx *UnionStContext)

+ func (s *BaseCypherParserListener) EnterUnwindSt(ctx *UnwindStContext)

+ func (s *BaseCypherParserListener) EnterUpdatingStatement(ctx *UpdatingStatementContext)

+ func (s *BaseCypherParserListener) EnterWhere(ctx *WhereContext)

+ func (s *BaseCypherParserListener) EnterWithSt(ctx *WithStContext)

+ func (s *BaseCypherParserListener) EnterXorExpression(ctx *XorExpressionContext)

+ func (s *BaseCypherParserListener) EnterYieldItem(ctx *YieldItemContext)

+ func (s *BaseCypherParserListener) EnterYieldItems(ctx *YieldItemsContext)

+ func (s *BaseCypherParserListener) ExitAddSubExpression(ctx *AddSubExpressionContext)

+ func (s *BaseCypherParserListener) ExitAndExpression(ctx *AndExpressionContext)

+ func (s *BaseCypherParserListener) ExitAtom(ctx *AtomContext)

+ func (s *BaseCypherParserListener) ExitAtomicExpression(ctx *AtomicExpressionContext)

+ func (s *BaseCypherParserListener) ExitBoolLit(ctx *BoolLitContext)

+ func (s *BaseCypherParserListener) ExitCaseExpression(ctx *CaseExpressionContext)

+ func (s *BaseCypherParserListener) ExitCharLit(ctx *CharLitContext)

+ func (s *BaseCypherParserListener) ExitComparisonExpression(ctx *ComparisonExpressionContext)

+ func (s *BaseCypherParserListener) ExitComparisonSigns(ctx *ComparisonSignsContext)

+ func (s *BaseCypherParserListener) ExitCountAll(ctx *CountAllContext)

+ func (s *BaseCypherParserListener) ExitCreateSt(ctx *CreateStContext)

+ func (s *BaseCypherParserListener) ExitDeleteSt(ctx *DeleteStContext)

+ func (s *BaseCypherParserListener) ExitEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseCypherParserListener) ExitExpression(ctx *ExpressionContext)

+ func (s *BaseCypherParserListener) ExitExpressionChain(ctx *ExpressionChainContext)

+ func (s *BaseCypherParserListener) ExitFilterExpression(ctx *FilterExpressionContext)

+ func (s *BaseCypherParserListener) ExitFilterWith(ctx *FilterWithContext)

+ func (s *BaseCypherParserListener) ExitFunctionInvocation(ctx *FunctionInvocationContext)

+ func (s *BaseCypherParserListener) ExitInvocationName(ctx *InvocationNameContext)

+ func (s *BaseCypherParserListener) ExitLhs(ctx *LhsContext)

+ func (s *BaseCypherParserListener) ExitLimitSt(ctx *LimitStContext)

+ func (s *BaseCypherParserListener) ExitListComprehension(ctx *ListComprehensionContext)

+ func (s *BaseCypherParserListener) ExitListExpression(ctx *ListExpressionContext)

+ func (s *BaseCypherParserListener) ExitListLit(ctx *ListLitContext)

+ func (s *BaseCypherParserListener) ExitLiteral(ctx *LiteralContext)

+ func (s *BaseCypherParserListener) ExitMapLit(ctx *MapLitContext)

+ func (s *BaseCypherParserListener) ExitMapPair(ctx *MapPairContext)

+ func (s *BaseCypherParserListener) ExitMatchSt(ctx *MatchStContext)

+ func (s *BaseCypherParserListener) ExitMergeAction(ctx *MergeActionContext)

+ func (s *BaseCypherParserListener) ExitMergeSt(ctx *MergeStContext)

+ func (s *BaseCypherParserListener) ExitMultDivExpression(ctx *MultDivExpressionContext)

+ func (s *BaseCypherParserListener) ExitMultiPartQ(ctx *MultiPartQContext)

+ func (s *BaseCypherParserListener) ExitName(ctx *NameContext)

+ func (s *BaseCypherParserListener) ExitNodeLabels(ctx *NodeLabelsContext)

+ func (s *BaseCypherParserListener) ExitNodePattern(ctx *NodePatternContext)

+ func (s *BaseCypherParserListener) ExitNotExpression(ctx *NotExpressionContext)

+ func (s *BaseCypherParserListener) ExitNullExpression(ctx *NullExpressionContext)

+ func (s *BaseCypherParserListener) ExitNumLit(ctx *NumLitContext)

+ func (s *BaseCypherParserListener) ExitOrderItem(ctx *OrderItemContext)

+ func (s *BaseCypherParserListener) ExitOrderSt(ctx *OrderStContext)

+ func (s *BaseCypherParserListener) ExitParameter(ctx *ParameterContext)

+ func (s *BaseCypherParserListener) ExitParenExpressionChain(ctx *ParenExpressionChainContext)

+ func (s *BaseCypherParserListener) ExitParenthesizedExpression(ctx *ParenthesizedExpressionContext)

+ func (s *BaseCypherParserListener) ExitPattern(ctx *PatternContext)

+ func (s *BaseCypherParserListener) ExitPatternComprehension(ctx *PatternComprehensionContext)

+ func (s *BaseCypherParserListener) ExitPatternElem(ctx *PatternElemContext)

+ func (s *BaseCypherParserListener) ExitPatternElemChain(ctx *PatternElemChainContext)

+ func (s *BaseCypherParserListener) ExitPatternPart(ctx *PatternPartContext)

+ func (s *BaseCypherParserListener) ExitPatternWhere(ctx *PatternWhereContext)

+ func (s *BaseCypherParserListener) ExitPowerExpression(ctx *PowerExpressionContext)

+ func (s *BaseCypherParserListener) ExitProjectionBody(ctx *ProjectionBodyContext)

+ func (s *BaseCypherParserListener) ExitProjectionItem(ctx *ProjectionItemContext)

+ func (s *BaseCypherParserListener) ExitProjectionItems(ctx *ProjectionItemsContext)

+ func (s *BaseCypherParserListener) ExitProperties(ctx *PropertiesContext)

+ func (s *BaseCypherParserListener) ExitPropertyExpression(ctx *PropertyExpressionContext)

+ func (s *BaseCypherParserListener) ExitPropertyOrLabelExpression(ctx *PropertyOrLabelExpressionContext)

+ func (s *BaseCypherParserListener) ExitQuery(ctx *QueryContext)

+ func (s *BaseCypherParserListener) ExitQueryCallSt(ctx *QueryCallStContext)

+ func (s *BaseCypherParserListener) ExitRangeLit(ctx *RangeLitContext)

+ func (s *BaseCypherParserListener) ExitReadingStatement(ctx *ReadingStatementContext)

+ func (s *BaseCypherParserListener) ExitRegularQuery(ctx *RegularQueryContext)

+ func (s *BaseCypherParserListener) ExitRelationDetail(ctx *RelationDetailContext)

+ func (s *BaseCypherParserListener) ExitRelationshipPattern(ctx *RelationshipPatternContext)

+ func (s *BaseCypherParserListener) ExitRelationshipTypes(ctx *RelationshipTypesContext)

+ func (s *BaseCypherParserListener) ExitRelationshipsChainPattern(ctx *RelationshipsChainPatternContext)

+ func (s *BaseCypherParserListener) ExitRemoveItem(ctx *RemoveItemContext)

+ func (s *BaseCypherParserListener) ExitRemoveSt(ctx *RemoveStContext)

+ func (s *BaseCypherParserListener) ExitReservedWord(ctx *ReservedWordContext)

+ func (s *BaseCypherParserListener) ExitReturnSt(ctx *ReturnStContext)

+ func (s *BaseCypherParserListener) ExitScript(ctx *ScriptContext)

+ func (s *BaseCypherParserListener) ExitSetItem(ctx *SetItemContext)

+ func (s *BaseCypherParserListener) ExitSetSt(ctx *SetStContext)

+ func (s *BaseCypherParserListener) ExitSinglePartQ(ctx *SinglePartQContext)

+ func (s *BaseCypherParserListener) ExitSingleQuery(ctx *SingleQueryContext)

+ func (s *BaseCypherParserListener) ExitSkipSt(ctx *SkipStContext)

+ func (s *BaseCypherParserListener) ExitStandaloneCall(ctx *StandaloneCallContext)

+ func (s *BaseCypherParserListener) ExitStringExpPrefix(ctx *StringExpPrefixContext)

+ func (s *BaseCypherParserListener) ExitStringExpression(ctx *StringExpressionContext)

+ func (s *BaseCypherParserListener) ExitStringLit(ctx *StringLitContext)

+ func (s *BaseCypherParserListener) ExitSubqueryCount(ctx *SubqueryCountContext)

+ func (s *BaseCypherParserListener) ExitSubqueryExist(ctx *SubqueryExistContext)

+ func (s *BaseCypherParserListener) ExitSymbol(ctx *SymbolContext)

+ func (s *BaseCypherParserListener) ExitUnaryAddSubExpression(ctx *UnaryAddSubExpressionContext)

+ func (s *BaseCypherParserListener) ExitUnionSt(ctx *UnionStContext)

+ func (s *BaseCypherParserListener) ExitUnwindSt(ctx *UnwindStContext)

+ func (s *BaseCypherParserListener) ExitUpdatingStatement(ctx *UpdatingStatementContext)

+ func (s *BaseCypherParserListener) ExitWhere(ctx *WhereContext)

+ func (s *BaseCypherParserListener) ExitWithSt(ctx *WithStContext)

+ func (s *BaseCypherParserListener) ExitXorExpression(ctx *XorExpressionContext)

+ func (s *BaseCypherParserListener) ExitYieldItem(ctx *YieldItemContext)

+ func (s *BaseCypherParserListener) ExitYieldItems(ctx *YieldItemsContext)

+ func (s *BaseCypherParserListener) VisitErrorNode(node antlr.ErrorNode)

+ func (s *BaseCypherParserListener) VisitTerminal(node antlr.TerminalNode)

+ type BaseCypherParserVisitor struct

+ func (v *BaseCypherParserVisitor) VisitAddSubExpression(ctx *AddSubExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitAndExpression(ctx *AndExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitAtom(ctx *AtomContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitAtomicExpression(ctx *AtomicExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitBoolLit(ctx *BoolLitContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitCaseExpression(ctx *CaseExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitCharLit(ctx *CharLitContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitComparisonExpression(ctx *ComparisonExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitComparisonSigns(ctx *ComparisonSignsContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitCountAll(ctx *CountAllContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitCreateSt(ctx *CreateStContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitDeleteSt(ctx *DeleteStContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitExpression(ctx *ExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitExpressionChain(ctx *ExpressionChainContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitFilterExpression(ctx *FilterExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitFilterWith(ctx *FilterWithContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitFunctionInvocation(ctx *FunctionInvocationContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitInvocationName(ctx *InvocationNameContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitLhs(ctx *LhsContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitLimitSt(ctx *LimitStContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitListComprehension(ctx *ListComprehensionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitListExpression(ctx *ListExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitListLit(ctx *ListLitContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitLiteral(ctx *LiteralContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitMapLit(ctx *MapLitContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitMapPair(ctx *MapPairContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitMatchSt(ctx *MatchStContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitMergeAction(ctx *MergeActionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitMergeSt(ctx *MergeStContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitMultDivExpression(ctx *MultDivExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitMultiPartQ(ctx *MultiPartQContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitName(ctx *NameContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitNodeLabels(ctx *NodeLabelsContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitNodePattern(ctx *NodePatternContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitNotExpression(ctx *NotExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitNullExpression(ctx *NullExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitNumLit(ctx *NumLitContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitOrderItem(ctx *OrderItemContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitOrderSt(ctx *OrderStContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitParameter(ctx *ParameterContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitParenExpressionChain(ctx *ParenExpressionChainContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitParenthesizedExpression(ctx *ParenthesizedExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitPattern(ctx *PatternContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitPatternComprehension(ctx *PatternComprehensionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitPatternElem(ctx *PatternElemContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitPatternElemChain(ctx *PatternElemChainContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitPatternPart(ctx *PatternPartContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitPatternWhere(ctx *PatternWhereContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitPowerExpression(ctx *PowerExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitProjectionBody(ctx *ProjectionBodyContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitProjectionItem(ctx *ProjectionItemContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitProjectionItems(ctx *ProjectionItemsContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitProperties(ctx *PropertiesContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitPropertyExpression(ctx *PropertyExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitPropertyOrLabelExpression(ctx *PropertyOrLabelExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitQuery(ctx *QueryContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitQueryCallSt(ctx *QueryCallStContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitRangeLit(ctx *RangeLitContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitReadingStatement(ctx *ReadingStatementContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitRegularQuery(ctx *RegularQueryContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitRelationDetail(ctx *RelationDetailContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitRelationshipPattern(ctx *RelationshipPatternContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitRelationshipTypes(ctx *RelationshipTypesContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitRelationshipsChainPattern(ctx *RelationshipsChainPatternContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitRemoveItem(ctx *RemoveItemContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitRemoveSt(ctx *RemoveStContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitReservedWord(ctx *ReservedWordContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitReturnSt(ctx *ReturnStContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitScript(ctx *ScriptContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitSetItem(ctx *SetItemContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitSetSt(ctx *SetStContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitSinglePartQ(ctx *SinglePartQContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitSingleQuery(ctx *SingleQueryContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitSkipSt(ctx *SkipStContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitStandaloneCall(ctx *StandaloneCallContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitStringExpPrefix(ctx *StringExpPrefixContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitStringExpression(ctx *StringExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitStringLit(ctx *StringLitContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitSubqueryCount(ctx *SubqueryCountContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitSubqueryExist(ctx *SubqueryExistContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitSymbol(ctx *SymbolContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitUnaryAddSubExpression(ctx *UnaryAddSubExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitUnionSt(ctx *UnionStContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitUnwindSt(ctx *UnwindStContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitUpdatingStatement(ctx *UpdatingStatementContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitWhere(ctx *WhereContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitWithSt(ctx *WithStContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitXorExpression(ctx *XorExpressionContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitYieldItem(ctx *YieldItemContext) interface{}

+ func (v *BaseCypherParserVisitor) VisitYieldItems(ctx *YieldItemsContext) interface{}

+ type BoolLitContext struct

+ func NewBoolLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BoolLitContext

+ func NewEmptyBoolLitContext() *BoolLitContext

+ func (*BoolLitContext) IsBoolLitContext()

+ func (s *BoolLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *BoolLitContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *BoolLitContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *BoolLitContext) FALSE() antlr.TerminalNode

+ func (s *BoolLitContext) GetParser() antlr.Parser

+ func (s *BoolLitContext) GetRuleContext() antlr.RuleContext

+ func (s *BoolLitContext) TRUE() antlr.TerminalNode

+ func (s *BoolLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type CaseExpressionContext struct

+ func NewCaseExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseExpressionContext

+ func NewEmptyCaseExpressionContext() *CaseExpressionContext

+ func (*CaseExpressionContext) IsCaseExpressionContext()

+ func (s *CaseExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *CaseExpressionContext) AllExpression() []IExpressionContext

+ func (s *CaseExpressionContext) AllTHEN() []antlr.TerminalNode

+ func (s *CaseExpressionContext) AllWHEN() []antlr.TerminalNode

+ func (s *CaseExpressionContext) CASE() antlr.TerminalNode

+ func (s *CaseExpressionContext) ELSE() antlr.TerminalNode

+ func (s *CaseExpressionContext) END() antlr.TerminalNode

+ func (s *CaseExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *CaseExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *CaseExpressionContext) Expression(i int) IExpressionContext

+ func (s *CaseExpressionContext) GetParser() antlr.Parser

+ func (s *CaseExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *CaseExpressionContext) THEN(i int) antlr.TerminalNode

+ func (s *CaseExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *CaseExpressionContext) WHEN(i int) antlr.TerminalNode

+ type CharLitContext struct

+ func NewCharLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CharLitContext

+ func NewEmptyCharLitContext() *CharLitContext

+ func (*CharLitContext) IsCharLitContext()

+ func (s *CharLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *CharLitContext) CHAR_LITERAL() antlr.TerminalNode

+ func (s *CharLitContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *CharLitContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *CharLitContext) GetParser() antlr.Parser

+ func (s *CharLitContext) GetRuleContext() antlr.RuleContext

+ func (s *CharLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ComparisonExpressionContext struct

+ func NewComparisonExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComparisonExpressionContext

+ func NewEmptyComparisonExpressionContext() *ComparisonExpressionContext

+ func (*ComparisonExpressionContext) IsComparisonExpressionContext()

+ func (s *ComparisonExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ComparisonExpressionContext) AddSubExpression(i int) IAddSubExpressionContext

+ func (s *ComparisonExpressionContext) AllAddSubExpression() []IAddSubExpressionContext

+ func (s *ComparisonExpressionContext) AllComparisonSigns() []IComparisonSignsContext

+ func (s *ComparisonExpressionContext) ComparisonSigns(i int) IComparisonSignsContext

+ func (s *ComparisonExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ComparisonExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ComparisonExpressionContext) GetParser() antlr.Parser

+ func (s *ComparisonExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *ComparisonExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ComparisonSignsContext struct

+ func NewComparisonSignsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComparisonSignsContext

+ func NewEmptyComparisonSignsContext() *ComparisonSignsContext

+ func (*ComparisonSignsContext) IsComparisonSignsContext()

+ func (s *ComparisonSignsContext) ASSIGN() antlr.TerminalNode

+ func (s *ComparisonSignsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ComparisonSignsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ComparisonSignsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ComparisonSignsContext) GE() antlr.TerminalNode

+ func (s *ComparisonSignsContext) GT() antlr.TerminalNode

+ func (s *ComparisonSignsContext) GetParser() antlr.Parser

+ func (s *ComparisonSignsContext) GetRuleContext() antlr.RuleContext

+ func (s *ComparisonSignsContext) LE() antlr.TerminalNode

+ func (s *ComparisonSignsContext) LT() antlr.TerminalNode

+ func (s *ComparisonSignsContext) NOT_EQUAL() antlr.TerminalNode

+ func (s *ComparisonSignsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type CountAllContext struct

+ func NewCountAllContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CountAllContext

+ func NewEmptyCountAllContext() *CountAllContext

+ func (*CountAllContext) IsCountAllContext()

+ func (s *CountAllContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *CountAllContext) COUNT() antlr.TerminalNode

+ func (s *CountAllContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *CountAllContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *CountAllContext) GetParser() antlr.Parser

+ func (s *CountAllContext) GetRuleContext() antlr.RuleContext

+ func (s *CountAllContext) LPAREN() antlr.TerminalNode

+ func (s *CountAllContext) MULT() antlr.TerminalNode

+ func (s *CountAllContext) RPAREN() antlr.TerminalNode

+ func (s *CountAllContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type CreateStContext struct

+ func NewCreateStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateStContext

+ func NewEmptyCreateStContext() *CreateStContext

+ func (*CreateStContext) IsCreateStContext()

+ func (s *CreateStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *CreateStContext) CREATE() antlr.TerminalNode

+ func (s *CreateStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *CreateStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *CreateStContext) GetParser() antlr.Parser

+ func (s *CreateStContext) GetRuleContext() antlr.RuleContext

+ func (s *CreateStContext) Pattern() IPatternContext

+ func (s *CreateStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type CypherLexer struct

+ func NewCypherLexer(input antlr.CharStream) *CypherLexer

+ type CypherParser struct

+ func NewCypherParser(input antlr.TokenStream) *CypherParser

+ func (p *CypherParser) AddSubExpression() (localctx IAddSubExpressionContext)

+ func (p *CypherParser) AndExpression() (localctx IAndExpressionContext)

+ func (p *CypherParser) Atom() (localctx IAtomContext)

+ func (p *CypherParser) AtomicExpression() (localctx IAtomicExpressionContext)

+ func (p *CypherParser) BoolLit() (localctx IBoolLitContext)

+ func (p *CypherParser) CaseExpression() (localctx ICaseExpressionContext)

+ func (p *CypherParser) CharLit() (localctx ICharLitContext)

+ func (p *CypherParser) ComparisonExpression() (localctx IComparisonExpressionContext)

+ func (p *CypherParser) ComparisonSigns() (localctx IComparisonSignsContext)

+ func (p *CypherParser) CountAll() (localctx ICountAllContext)

+ func (p *CypherParser) CreateSt() (localctx ICreateStContext)

+ func (p *CypherParser) DeleteSt() (localctx IDeleteStContext)

+ func (p *CypherParser) Expression() (localctx IExpressionContext)

+ func (p *CypherParser) ExpressionChain() (localctx IExpressionChainContext)

+ func (p *CypherParser) FilterExpression() (localctx IFilterExpressionContext)

+ func (p *CypherParser) FilterWith() (localctx IFilterWithContext)

+ func (p *CypherParser) FunctionInvocation() (localctx IFunctionInvocationContext)

+ func (p *CypherParser) InvocationName() (localctx IInvocationNameContext)

+ func (p *CypherParser) Lhs() (localctx ILhsContext)

+ func (p *CypherParser) LimitSt() (localctx ILimitStContext)

+ func (p *CypherParser) ListComprehension() (localctx IListComprehensionContext)

+ func (p *CypherParser) ListExpression() (localctx IListExpressionContext)

+ func (p *CypherParser) ListLit() (localctx IListLitContext)

+ func (p *CypherParser) Literal() (localctx ILiteralContext)

+ func (p *CypherParser) MapLit() (localctx IMapLitContext)

+ func (p *CypherParser) MapPair() (localctx IMapPairContext)

+ func (p *CypherParser) MatchSt() (localctx IMatchStContext)

+ func (p *CypherParser) MergeAction() (localctx IMergeActionContext)

+ func (p *CypherParser) MergeSt() (localctx IMergeStContext)

+ func (p *CypherParser) MultDivExpression() (localctx IMultDivExpressionContext)

+ func (p *CypherParser) MultiPartQ() (localctx IMultiPartQContext)

+ func (p *CypherParser) Name() (localctx INameContext)

+ func (p *CypherParser) NodeLabels() (localctx INodeLabelsContext)

+ func (p *CypherParser) NodePattern() (localctx INodePatternContext)

+ func (p *CypherParser) NotExpression() (localctx INotExpressionContext)

+ func (p *CypherParser) NullExpression() (localctx INullExpressionContext)

+ func (p *CypherParser) NumLit() (localctx INumLitContext)

+ func (p *CypherParser) OrderItem() (localctx IOrderItemContext)

+ func (p *CypherParser) OrderSt() (localctx IOrderStContext)

+ func (p *CypherParser) Parameter() (localctx IParameterContext)

+ func (p *CypherParser) ParenExpressionChain() (localctx IParenExpressionChainContext)

+ func (p *CypherParser) ParenthesizedExpression() (localctx IParenthesizedExpressionContext)

+ func (p *CypherParser) Pattern() (localctx IPatternContext)

+ func (p *CypherParser) PatternComprehension() (localctx IPatternComprehensionContext)

+ func (p *CypherParser) PatternElem() (localctx IPatternElemContext)

+ func (p *CypherParser) PatternElemChain() (localctx IPatternElemChainContext)

+ func (p *CypherParser) PatternPart() (localctx IPatternPartContext)

+ func (p *CypherParser) PatternWhere() (localctx IPatternWhereContext)

+ func (p *CypherParser) PowerExpression() (localctx IPowerExpressionContext)

+ func (p *CypherParser) ProjectionBody() (localctx IProjectionBodyContext)

+ func (p *CypherParser) ProjectionItem() (localctx IProjectionItemContext)

+ func (p *CypherParser) ProjectionItems() (localctx IProjectionItemsContext)

+ func (p *CypherParser) Properties() (localctx IPropertiesContext)

+ func (p *CypherParser) PropertyExpression() (localctx IPropertyExpressionContext)

+ func (p *CypherParser) PropertyOrLabelExpression() (localctx IPropertyOrLabelExpressionContext)

+ func (p *CypherParser) Query() (localctx IQueryContext)

+ func (p *CypherParser) QueryCallSt() (localctx IQueryCallStContext)

+ func (p *CypherParser) RangeLit() (localctx IRangeLitContext)

+ func (p *CypherParser) ReadingStatement() (localctx IReadingStatementContext)

+ func (p *CypherParser) RegularQuery() (localctx IRegularQueryContext)

+ func (p *CypherParser) RelationDetail() (localctx IRelationDetailContext)

+ func (p *CypherParser) RelationshipPattern() (localctx IRelationshipPatternContext)

+ func (p *CypherParser) RelationshipTypes() (localctx IRelationshipTypesContext)

+ func (p *CypherParser) RelationshipsChainPattern() (localctx IRelationshipsChainPatternContext)

+ func (p *CypherParser) RemoveItem() (localctx IRemoveItemContext)

+ func (p *CypherParser) RemoveSt() (localctx IRemoveStContext)

+ func (p *CypherParser) ReservedWord() (localctx IReservedWordContext)

+ func (p *CypherParser) ReturnSt() (localctx IReturnStContext)

+ func (p *CypherParser) Script() (localctx IScriptContext)

+ func (p *CypherParser) SetItem() (localctx ISetItemContext)

+ func (p *CypherParser) SetSt() (localctx ISetStContext)

+ func (p *CypherParser) SinglePartQ() (localctx ISinglePartQContext)

+ func (p *CypherParser) SingleQuery() (localctx ISingleQueryContext)

+ func (p *CypherParser) SkipSt() (localctx ISkipStContext)

+ func (p *CypherParser) StandaloneCall() (localctx IStandaloneCallContext)

+ func (p *CypherParser) StringExpPrefix() (localctx IStringExpPrefixContext)

+ func (p *CypherParser) StringExpression() (localctx IStringExpressionContext)

+ func (p *CypherParser) StringLit() (localctx IStringLitContext)

+ func (p *CypherParser) SubqueryCount() (localctx ISubqueryCountContext)

+ func (p *CypherParser) SubqueryExist() (localctx ISubqueryExistContext)

+ func (p *CypherParser) Symbol() (localctx ISymbolContext)

+ func (p *CypherParser) UnaryAddSubExpression() (localctx IUnaryAddSubExpressionContext)

+ func (p *CypherParser) UnionSt() (localctx IUnionStContext)

+ func (p *CypherParser) UnwindSt() (localctx IUnwindStContext)

+ func (p *CypherParser) UpdatingStatement() (localctx IUpdatingStatementContext)

+ func (p *CypherParser) Where() (localctx IWhereContext)

+ func (p *CypherParser) WithSt() (localctx IWithStContext)

+ func (p *CypherParser) XorExpression() (localctx IXorExpressionContext)

+ func (p *CypherParser) YieldItem() (localctx IYieldItemContext)

+ func (p *CypherParser) YieldItems() (localctx IYieldItemsContext)

+ type CypherParserListener interface

+ EnterAddSubExpression func(c *AddSubExpressionContext)

+ EnterAndExpression func(c *AndExpressionContext)

+ EnterAtom func(c *AtomContext)

+ EnterAtomicExpression func(c *AtomicExpressionContext)

+ EnterBoolLit func(c *BoolLitContext)

+ EnterCaseExpression func(c *CaseExpressionContext)

+ EnterCharLit func(c *CharLitContext)

+ EnterComparisonExpression func(c *ComparisonExpressionContext)

+ EnterComparisonSigns func(c *ComparisonSignsContext)

+ EnterCountAll func(c *CountAllContext)

+ EnterCreateSt func(c *CreateStContext)

+ EnterDeleteSt func(c *DeleteStContext)

+ EnterExpression func(c *ExpressionContext)

+ EnterExpressionChain func(c *ExpressionChainContext)

+ EnterFilterExpression func(c *FilterExpressionContext)

+ EnterFilterWith func(c *FilterWithContext)

+ EnterFunctionInvocation func(c *FunctionInvocationContext)

+ EnterInvocationName func(c *InvocationNameContext)

+ EnterLhs func(c *LhsContext)

+ EnterLimitSt func(c *LimitStContext)

+ EnterListComprehension func(c *ListComprehensionContext)

+ EnterListExpression func(c *ListExpressionContext)

+ EnterListLit func(c *ListLitContext)

+ EnterLiteral func(c *LiteralContext)

+ EnterMapLit func(c *MapLitContext)

+ EnterMapPair func(c *MapPairContext)

+ EnterMatchSt func(c *MatchStContext)

+ EnterMergeAction func(c *MergeActionContext)

+ EnterMergeSt func(c *MergeStContext)

+ EnterMultDivExpression func(c *MultDivExpressionContext)

+ EnterMultiPartQ func(c *MultiPartQContext)

+ EnterName func(c *NameContext)

+ EnterNodeLabels func(c *NodeLabelsContext)

+ EnterNodePattern func(c *NodePatternContext)

+ EnterNotExpression func(c *NotExpressionContext)

+ EnterNullExpression func(c *NullExpressionContext)

+ EnterNumLit func(c *NumLitContext)

+ EnterOrderItem func(c *OrderItemContext)

+ EnterOrderSt func(c *OrderStContext)

+ EnterParameter func(c *ParameterContext)

+ EnterParenExpressionChain func(c *ParenExpressionChainContext)

+ EnterParenthesizedExpression func(c *ParenthesizedExpressionContext)

+ EnterPattern func(c *PatternContext)

+ EnterPatternComprehension func(c *PatternComprehensionContext)

+ EnterPatternElem func(c *PatternElemContext)

+ EnterPatternElemChain func(c *PatternElemChainContext)

+ EnterPatternPart func(c *PatternPartContext)

+ EnterPatternWhere func(c *PatternWhereContext)

+ EnterPowerExpression func(c *PowerExpressionContext)

+ EnterProjectionBody func(c *ProjectionBodyContext)

+ EnterProjectionItem func(c *ProjectionItemContext)

+ EnterProjectionItems func(c *ProjectionItemsContext)

+ EnterProperties func(c *PropertiesContext)

+ EnterPropertyExpression func(c *PropertyExpressionContext)

+ EnterPropertyOrLabelExpression func(c *PropertyOrLabelExpressionContext)

+ EnterQuery func(c *QueryContext)

+ EnterQueryCallSt func(c *QueryCallStContext)

+ EnterRangeLit func(c *RangeLitContext)

+ EnterReadingStatement func(c *ReadingStatementContext)

+ EnterRegularQuery func(c *RegularQueryContext)

+ EnterRelationDetail func(c *RelationDetailContext)

+ EnterRelationshipPattern func(c *RelationshipPatternContext)

+ EnterRelationshipTypes func(c *RelationshipTypesContext)

+ EnterRelationshipsChainPattern func(c *RelationshipsChainPatternContext)

+ EnterRemoveItem func(c *RemoveItemContext)

+ EnterRemoveSt func(c *RemoveStContext)

+ EnterReservedWord func(c *ReservedWordContext)

+ EnterReturnSt func(c *ReturnStContext)

+ EnterScript func(c *ScriptContext)

+ EnterSetItem func(c *SetItemContext)

+ EnterSetSt func(c *SetStContext)

+ EnterSinglePartQ func(c *SinglePartQContext)

+ EnterSingleQuery func(c *SingleQueryContext)

+ EnterSkipSt func(c *SkipStContext)

+ EnterStandaloneCall func(c *StandaloneCallContext)

+ EnterStringExpPrefix func(c *StringExpPrefixContext)

+ EnterStringExpression func(c *StringExpressionContext)

+ EnterStringLit func(c *StringLitContext)

+ EnterSubqueryCount func(c *SubqueryCountContext)

+ EnterSubqueryExist func(c *SubqueryExistContext)

+ EnterSymbol func(c *SymbolContext)

+ EnterUnaryAddSubExpression func(c *UnaryAddSubExpressionContext)

+ EnterUnionSt func(c *UnionStContext)

+ EnterUnwindSt func(c *UnwindStContext)

+ EnterUpdatingStatement func(c *UpdatingStatementContext)

+ EnterWhere func(c *WhereContext)

+ EnterWithSt func(c *WithStContext)

+ EnterXorExpression func(c *XorExpressionContext)

+ EnterYieldItem func(c *YieldItemContext)

+ EnterYieldItems func(c *YieldItemsContext)

+ ExitAddSubExpression func(c *AddSubExpressionContext)

+ ExitAndExpression func(c *AndExpressionContext)

+ ExitAtom func(c *AtomContext)

+ ExitAtomicExpression func(c *AtomicExpressionContext)

+ ExitBoolLit func(c *BoolLitContext)

+ ExitCaseExpression func(c *CaseExpressionContext)

+ ExitCharLit func(c *CharLitContext)

+ ExitComparisonExpression func(c *ComparisonExpressionContext)

+ ExitComparisonSigns func(c *ComparisonSignsContext)

+ ExitCountAll func(c *CountAllContext)

+ ExitCreateSt func(c *CreateStContext)

+ ExitDeleteSt func(c *DeleteStContext)

+ ExitExpression func(c *ExpressionContext)

+ ExitExpressionChain func(c *ExpressionChainContext)

+ ExitFilterExpression func(c *FilterExpressionContext)

+ ExitFilterWith func(c *FilterWithContext)

+ ExitFunctionInvocation func(c *FunctionInvocationContext)

+ ExitInvocationName func(c *InvocationNameContext)

+ ExitLhs func(c *LhsContext)

+ ExitLimitSt func(c *LimitStContext)

+ ExitListComprehension func(c *ListComprehensionContext)

+ ExitListExpression func(c *ListExpressionContext)

+ ExitListLit func(c *ListLitContext)

+ ExitLiteral func(c *LiteralContext)

+ ExitMapLit func(c *MapLitContext)

+ ExitMapPair func(c *MapPairContext)

+ ExitMatchSt func(c *MatchStContext)

+ ExitMergeAction func(c *MergeActionContext)

+ ExitMergeSt func(c *MergeStContext)

+ ExitMultDivExpression func(c *MultDivExpressionContext)

+ ExitMultiPartQ func(c *MultiPartQContext)

+ ExitName func(c *NameContext)

+ ExitNodeLabels func(c *NodeLabelsContext)

+ ExitNodePattern func(c *NodePatternContext)

+ ExitNotExpression func(c *NotExpressionContext)

+ ExitNullExpression func(c *NullExpressionContext)

+ ExitNumLit func(c *NumLitContext)

+ ExitOrderItem func(c *OrderItemContext)

+ ExitOrderSt func(c *OrderStContext)

+ ExitParameter func(c *ParameterContext)

+ ExitParenExpressionChain func(c *ParenExpressionChainContext)

+ ExitParenthesizedExpression func(c *ParenthesizedExpressionContext)

+ ExitPattern func(c *PatternContext)

+ ExitPatternComprehension func(c *PatternComprehensionContext)

+ ExitPatternElem func(c *PatternElemContext)

+ ExitPatternElemChain func(c *PatternElemChainContext)

+ ExitPatternPart func(c *PatternPartContext)

+ ExitPatternWhere func(c *PatternWhereContext)

+ ExitPowerExpression func(c *PowerExpressionContext)

+ ExitProjectionBody func(c *ProjectionBodyContext)

+ ExitProjectionItem func(c *ProjectionItemContext)

+ ExitProjectionItems func(c *ProjectionItemsContext)

+ ExitProperties func(c *PropertiesContext)

+ ExitPropertyExpression func(c *PropertyExpressionContext)

+ ExitPropertyOrLabelExpression func(c *PropertyOrLabelExpressionContext)

+ ExitQuery func(c *QueryContext)

+ ExitQueryCallSt func(c *QueryCallStContext)

+ ExitRangeLit func(c *RangeLitContext)

+ ExitReadingStatement func(c *ReadingStatementContext)

+ ExitRegularQuery func(c *RegularQueryContext)

+ ExitRelationDetail func(c *RelationDetailContext)

+ ExitRelationshipPattern func(c *RelationshipPatternContext)

+ ExitRelationshipTypes func(c *RelationshipTypesContext)

+ ExitRelationshipsChainPattern func(c *RelationshipsChainPatternContext)

+ ExitRemoveItem func(c *RemoveItemContext)

+ ExitRemoveSt func(c *RemoveStContext)

+ ExitReservedWord func(c *ReservedWordContext)

+ ExitReturnSt func(c *ReturnStContext)

+ ExitScript func(c *ScriptContext)

+ ExitSetItem func(c *SetItemContext)

+ ExitSetSt func(c *SetStContext)

+ ExitSinglePartQ func(c *SinglePartQContext)

+ ExitSingleQuery func(c *SingleQueryContext)

+ ExitSkipSt func(c *SkipStContext)

+ ExitStandaloneCall func(c *StandaloneCallContext)

+ ExitStringExpPrefix func(c *StringExpPrefixContext)

+ ExitStringExpression func(c *StringExpressionContext)

+ ExitStringLit func(c *StringLitContext)

+ ExitSubqueryCount func(c *SubqueryCountContext)

+ ExitSubqueryExist func(c *SubqueryExistContext)

+ ExitSymbol func(c *SymbolContext)

+ ExitUnaryAddSubExpression func(c *UnaryAddSubExpressionContext)

+ ExitUnionSt func(c *UnionStContext)

+ ExitUnwindSt func(c *UnwindStContext)

+ ExitUpdatingStatement func(c *UpdatingStatementContext)

+ ExitWhere func(c *WhereContext)

+ ExitWithSt func(c *WithStContext)

+ ExitXorExpression func(c *XorExpressionContext)

+ ExitYieldItem func(c *YieldItemContext)

+ ExitYieldItems func(c *YieldItemsContext)

+ type CypherParserVisitor interface

+ VisitAddSubExpression func(ctx *AddSubExpressionContext) interface{}

+ VisitAndExpression func(ctx *AndExpressionContext) interface{}

+ VisitAtom func(ctx *AtomContext) interface{}

+ VisitAtomicExpression func(ctx *AtomicExpressionContext) interface{}

+ VisitBoolLit func(ctx *BoolLitContext) interface{}

+ VisitCaseExpression func(ctx *CaseExpressionContext) interface{}

+ VisitCharLit func(ctx *CharLitContext) interface{}

+ VisitComparisonExpression func(ctx *ComparisonExpressionContext) interface{}

+ VisitComparisonSigns func(ctx *ComparisonSignsContext) interface{}

+ VisitCountAll func(ctx *CountAllContext) interface{}

+ VisitCreateSt func(ctx *CreateStContext) interface{}

+ VisitDeleteSt func(ctx *DeleteStContext) interface{}

+ VisitExpression func(ctx *ExpressionContext) interface{}

+ VisitExpressionChain func(ctx *ExpressionChainContext) interface{}

+ VisitFilterExpression func(ctx *FilterExpressionContext) interface{}

+ VisitFilterWith func(ctx *FilterWithContext) interface{}

+ VisitFunctionInvocation func(ctx *FunctionInvocationContext) interface{}

+ VisitInvocationName func(ctx *InvocationNameContext) interface{}

+ VisitLhs func(ctx *LhsContext) interface{}

+ VisitLimitSt func(ctx *LimitStContext) interface{}

+ VisitListComprehension func(ctx *ListComprehensionContext) interface{}

+ VisitListExpression func(ctx *ListExpressionContext) interface{}

+ VisitListLit func(ctx *ListLitContext) interface{}

+ VisitLiteral func(ctx *LiteralContext) interface{}

+ VisitMapLit func(ctx *MapLitContext) interface{}

+ VisitMapPair func(ctx *MapPairContext) interface{}

+ VisitMatchSt func(ctx *MatchStContext) interface{}

+ VisitMergeAction func(ctx *MergeActionContext) interface{}

+ VisitMergeSt func(ctx *MergeStContext) interface{}

+ VisitMultDivExpression func(ctx *MultDivExpressionContext) interface{}

+ VisitMultiPartQ func(ctx *MultiPartQContext) interface{}

+ VisitName func(ctx *NameContext) interface{}

+ VisitNodeLabels func(ctx *NodeLabelsContext) interface{}

+ VisitNodePattern func(ctx *NodePatternContext) interface{}

+ VisitNotExpression func(ctx *NotExpressionContext) interface{}

+ VisitNullExpression func(ctx *NullExpressionContext) interface{}

+ VisitNumLit func(ctx *NumLitContext) interface{}

+ VisitOrderItem func(ctx *OrderItemContext) interface{}

+ VisitOrderSt func(ctx *OrderStContext) interface{}

+ VisitParameter func(ctx *ParameterContext) interface{}

+ VisitParenExpressionChain func(ctx *ParenExpressionChainContext) interface{}

+ VisitParenthesizedExpression func(ctx *ParenthesizedExpressionContext) interface{}

+ VisitPattern func(ctx *PatternContext) interface{}

+ VisitPatternComprehension func(ctx *PatternComprehensionContext) interface{}

+ VisitPatternElem func(ctx *PatternElemContext) interface{}

+ VisitPatternElemChain func(ctx *PatternElemChainContext) interface{}

+ VisitPatternPart func(ctx *PatternPartContext) interface{}

+ VisitPatternWhere func(ctx *PatternWhereContext) interface{}

+ VisitPowerExpression func(ctx *PowerExpressionContext) interface{}

+ VisitProjectionBody func(ctx *ProjectionBodyContext) interface{}

+ VisitProjectionItem func(ctx *ProjectionItemContext) interface{}

+ VisitProjectionItems func(ctx *ProjectionItemsContext) interface{}

+ VisitProperties func(ctx *PropertiesContext) interface{}

+ VisitPropertyExpression func(ctx *PropertyExpressionContext) interface{}

+ VisitPropertyOrLabelExpression func(ctx *PropertyOrLabelExpressionContext) interface{}

+ VisitQuery func(ctx *QueryContext) interface{}

+ VisitQueryCallSt func(ctx *QueryCallStContext) interface{}

+ VisitRangeLit func(ctx *RangeLitContext) interface{}

+ VisitReadingStatement func(ctx *ReadingStatementContext) interface{}

+ VisitRegularQuery func(ctx *RegularQueryContext) interface{}

+ VisitRelationDetail func(ctx *RelationDetailContext) interface{}

+ VisitRelationshipPattern func(ctx *RelationshipPatternContext) interface{}

+ VisitRelationshipTypes func(ctx *RelationshipTypesContext) interface{}

+ VisitRelationshipsChainPattern func(ctx *RelationshipsChainPatternContext) interface{}

+ VisitRemoveItem func(ctx *RemoveItemContext) interface{}

+ VisitRemoveSt func(ctx *RemoveStContext) interface{}

+ VisitReservedWord func(ctx *ReservedWordContext) interface{}

+ VisitReturnSt func(ctx *ReturnStContext) interface{}

+ VisitScript func(ctx *ScriptContext) interface{}

+ VisitSetItem func(ctx *SetItemContext) interface{}

+ VisitSetSt func(ctx *SetStContext) interface{}

+ VisitSinglePartQ func(ctx *SinglePartQContext) interface{}

+ VisitSingleQuery func(ctx *SingleQueryContext) interface{}

+ VisitSkipSt func(ctx *SkipStContext) interface{}

+ VisitStandaloneCall func(ctx *StandaloneCallContext) interface{}

+ VisitStringExpPrefix func(ctx *StringExpPrefixContext) interface{}

+ VisitStringExpression func(ctx *StringExpressionContext) interface{}

+ VisitStringLit func(ctx *StringLitContext) interface{}

+ VisitSubqueryCount func(ctx *SubqueryCountContext) interface{}

+ VisitSubqueryExist func(ctx *SubqueryExistContext) interface{}

+ VisitSymbol func(ctx *SymbolContext) interface{}

+ VisitUnaryAddSubExpression func(ctx *UnaryAddSubExpressionContext) interface{}

+ VisitUnionSt func(ctx *UnionStContext) interface{}

+ VisitUnwindSt func(ctx *UnwindStContext) interface{}

+ VisitUpdatingStatement func(ctx *UpdatingStatementContext) interface{}

+ VisitWhere func(ctx *WhereContext) interface{}

+ VisitWithSt func(ctx *WithStContext) interface{}

+ VisitXorExpression func(ctx *XorExpressionContext) interface{}

+ VisitYieldItem func(ctx *YieldItemContext) interface{}

+ VisitYieldItems func(ctx *YieldItemsContext) interface{}

+ type DeleteStContext struct

+ func NewDeleteStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeleteStContext

+ func NewEmptyDeleteStContext() *DeleteStContext

+ func (*DeleteStContext) IsDeleteStContext()

+ func (s *DeleteStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *DeleteStContext) DELETE() antlr.TerminalNode

+ func (s *DeleteStContext) DETACH() antlr.TerminalNode

+ func (s *DeleteStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *DeleteStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *DeleteStContext) ExpressionChain() IExpressionChainContext

+ func (s *DeleteStContext) GetParser() antlr.Parser

+ func (s *DeleteStContext) GetRuleContext() antlr.RuleContext

+ func (s *DeleteStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ExpressionChainContext struct

+ func NewEmptyExpressionChainContext() *ExpressionChainContext

+ func NewExpressionChainContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionChainContext

+ func (*ExpressionChainContext) IsExpressionChainContext()

+ func (s *ExpressionChainContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ExpressionChainContext) AllCOMMA() []antlr.TerminalNode

+ func (s *ExpressionChainContext) AllExpression() []IExpressionContext

+ func (s *ExpressionChainContext) COMMA(i int) antlr.TerminalNode

+ func (s *ExpressionChainContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ExpressionChainContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ExpressionChainContext) Expression(i int) IExpressionContext

+ func (s *ExpressionChainContext) GetParser() antlr.Parser

+ func (s *ExpressionChainContext) GetRuleContext() antlr.RuleContext

+ func (s *ExpressionChainContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ExpressionContext struct

+ func NewEmptyExpressionContext() *ExpressionContext

+ func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext

+ func (*ExpressionContext) IsExpressionContext()

+ func (s *ExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ExpressionContext) AllOR() []antlr.TerminalNode

+ func (s *ExpressionContext) AllXorExpression() []IXorExpressionContext

+ func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ExpressionContext) GetParser() antlr.Parser

+ func (s *ExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *ExpressionContext) OR(i int) antlr.TerminalNode

+ func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *ExpressionContext) XorExpression(i int) IXorExpressionContext

+ type FilterExpressionContext struct

+ func NewEmptyFilterExpressionContext() *FilterExpressionContext

+ func NewFilterExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterExpressionContext

+ func (*FilterExpressionContext) IsFilterExpressionContext()

+ func (s *FilterExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *FilterExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *FilterExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *FilterExpressionContext) Expression() IExpressionContext

+ func (s *FilterExpressionContext) GetParser() antlr.Parser

+ func (s *FilterExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *FilterExpressionContext) IN() antlr.TerminalNode

+ func (s *FilterExpressionContext) Symbol() ISymbolContext

+ func (s *FilterExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *FilterExpressionContext) Where() IWhereContext

+ type FilterWithContext struct

+ func NewEmptyFilterWithContext() *FilterWithContext

+ func NewFilterWithContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterWithContext

+ func (*FilterWithContext) IsFilterWithContext()

+ func (s *FilterWithContext) ALL() antlr.TerminalNode

+ func (s *FilterWithContext) ANY() antlr.TerminalNode

+ func (s *FilterWithContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *FilterWithContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *FilterWithContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *FilterWithContext) FilterExpression() IFilterExpressionContext

+ func (s *FilterWithContext) GetParser() antlr.Parser

+ func (s *FilterWithContext) GetRuleContext() antlr.RuleContext

+ func (s *FilterWithContext) LPAREN() antlr.TerminalNode

+ func (s *FilterWithContext) NONE() antlr.TerminalNode

+ func (s *FilterWithContext) RPAREN() antlr.TerminalNode

+ func (s *FilterWithContext) SINGLE() antlr.TerminalNode

+ func (s *FilterWithContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type FunctionInvocationContext struct

+ func NewEmptyFunctionInvocationContext() *FunctionInvocationContext

+ func NewFunctionInvocationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionInvocationContext

+ func (*FunctionInvocationContext) IsFunctionInvocationContext()

+ func (s *FunctionInvocationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *FunctionInvocationContext) DISTINCT() antlr.TerminalNode

+ func (s *FunctionInvocationContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *FunctionInvocationContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *FunctionInvocationContext) ExpressionChain() IExpressionChainContext

+ func (s *FunctionInvocationContext) GetParser() antlr.Parser

+ func (s *FunctionInvocationContext) GetRuleContext() antlr.RuleContext

+ func (s *FunctionInvocationContext) InvocationName() IInvocationNameContext

+ func (s *FunctionInvocationContext) LPAREN() antlr.TerminalNode

+ func (s *FunctionInvocationContext) RPAREN() antlr.TerminalNode

+ func (s *FunctionInvocationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type IAddSubExpressionContext interface

+ AllMultDivExpression func() []IMultDivExpressionContext

+ AllPLUS func() []antlr.TerminalNode

+ AllSUB func() []antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsAddSubExpressionContext func()

+ MultDivExpression func(i int) IMultDivExpressionContext

+ PLUS func(i int) antlr.TerminalNode

+ SUB func(i int) antlr.TerminalNode

+ type IAndExpressionContext interface

+ AND func(i int) antlr.TerminalNode

+ AllAND func() []antlr.TerminalNode

+ AllNotExpression func() []INotExpressionContext

+ GetParser func() antlr.Parser

+ IsAndExpressionContext func()

+ NotExpression func(i int) INotExpressionContext

+ type IAtomContext interface

+ CaseExpression func() ICaseExpressionContext

+ CountAll func() ICountAllContext

+ FilterWith func() IFilterWithContext

+ FunctionInvocation func() IFunctionInvocationContext

+ GetParser func() antlr.Parser

+ IsAtomContext func()

+ ListComprehension func() IListComprehensionContext

+ Literal func() ILiteralContext

+ Parameter func() IParameterContext

+ ParenthesizedExpression func() IParenthesizedExpressionContext

+ PatternComprehension func() IPatternComprehensionContext

+ RelationshipsChainPattern func() IRelationshipsChainPatternContext

+ SubqueryCount func() ISubqueryCountContext

+ SubqueryExist func() ISubqueryExistContext

+ Symbol func() ISymbolContext

+ type IAtomicExpressionContext interface

+ AllListExpression func() []IListExpressionContext

+ AllNullExpression func() []INullExpressionContext

+ AllStringExpression func() []IStringExpressionContext

+ GetParser func() antlr.Parser

+ IsAtomicExpressionContext func()

+ ListExpression func(i int) IListExpressionContext

+ NullExpression func(i int) INullExpressionContext

+ PropertyOrLabelExpression func() IPropertyOrLabelExpressionContext

+ StringExpression func(i int) IStringExpressionContext

+ type IBoolLitContext interface

+ FALSE func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsBoolLitContext func()

+ TRUE func() antlr.TerminalNode

+ type ICaseExpressionContext interface

+ AllExpression func() []IExpressionContext

+ AllTHEN func() []antlr.TerminalNode

+ AllWHEN func() []antlr.TerminalNode

+ CASE func() antlr.TerminalNode

+ ELSE func() antlr.TerminalNode

+ END func() antlr.TerminalNode

+ Expression func(i int) IExpressionContext

+ GetParser func() antlr.Parser

+ IsCaseExpressionContext func()

+ THEN func(i int) antlr.TerminalNode

+ WHEN func(i int) antlr.TerminalNode

+ type ICharLitContext interface

+ CHAR_LITERAL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsCharLitContext func()

+ type IComparisonExpressionContext interface

+ AddSubExpression func(i int) IAddSubExpressionContext

+ AllAddSubExpression func() []IAddSubExpressionContext

+ AllComparisonSigns func() []IComparisonSignsContext

+ ComparisonSigns func(i int) IComparisonSignsContext

+ GetParser func() antlr.Parser

+ IsComparisonExpressionContext func()

+ type IComparisonSignsContext interface

+ ASSIGN func() antlr.TerminalNode

+ GE func() antlr.TerminalNode

+ GT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsComparisonSignsContext func()

+ LE func() antlr.TerminalNode

+ LT func() antlr.TerminalNode

+ NOT_EQUAL func() antlr.TerminalNode

+ type ICountAllContext interface

+ COUNT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsCountAllContext func()

+ LPAREN func() antlr.TerminalNode

+ MULT func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ type ICreateStContext interface

+ CREATE func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsCreateStContext func()

+ Pattern func() IPatternContext

+ type IDeleteStContext interface

+ DELETE func() antlr.TerminalNode

+ DETACH func() antlr.TerminalNode

+ ExpressionChain func() IExpressionChainContext

+ GetParser func() antlr.Parser

+ IsDeleteStContext func()

+ type IExpressionChainContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpression func() []IExpressionContext

+ COMMA func(i int) antlr.TerminalNode

+ Expression func(i int) IExpressionContext

+ GetParser func() antlr.Parser

+ IsExpressionChainContext func()

+ type IExpressionContext interface

+ AllOR func() []antlr.TerminalNode

+ AllXorExpression func() []IXorExpressionContext

+ GetParser func() antlr.Parser

+ IsExpressionContext func()

+ OR func(i int) antlr.TerminalNode

+ XorExpression func(i int) IXorExpressionContext

+ type IFilterExpressionContext interface

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IN func() antlr.TerminalNode

+ IsFilterExpressionContext func()

+ Symbol func() ISymbolContext

+ Where func() IWhereContext

+ type IFilterWithContext interface

+ ALL func() antlr.TerminalNode

+ ANY func() antlr.TerminalNode

+ FilterExpression func() IFilterExpressionContext

+ GetParser func() antlr.Parser

+ IsFilterWithContext func()

+ LPAREN func() antlr.TerminalNode

+ NONE func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ SINGLE func() antlr.TerminalNode

+ type IFunctionInvocationContext interface

+ DISTINCT func() antlr.TerminalNode

+ ExpressionChain func() IExpressionChainContext

+ GetParser func() antlr.Parser

+ InvocationName func() IInvocationNameContext

+ IsFunctionInvocationContext func()

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ type IInvocationNameContext interface

+ AllDOT func() []antlr.TerminalNode

+ AllSymbol func() []ISymbolContext

+ DOT func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsInvocationNameContext func()

+ Symbol func(i int) ISymbolContext

+ type ILhsContext interface

+ ASSIGN func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsLhsContext func()

+ Symbol func() ISymbolContext

+ type ILimitStContext interface

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsLimitStContext func()

+ LIMIT func() antlr.TerminalNode

+ type IListComprehensionContext interface

+ Expression func() IExpressionContext

+ FilterExpression func() IFilterExpressionContext

+ GetParser func() antlr.Parser

+ IsListComprehensionContext func()

+ LBRACK func() antlr.TerminalNode

+ RBRACK func() antlr.TerminalNode

+ STICK func() antlr.TerminalNode

+ type IListExpressionContext interface

+ AllExpression func() []IExpressionContext

+ Expression func(i int) IExpressionContext

+ GetParser func() antlr.Parser

+ IN func() antlr.TerminalNode

+ IsListExpressionContext func()

+ LBRACK func() antlr.TerminalNode

+ PropertyOrLabelExpression func() IPropertyOrLabelExpressionContext

+ RANGE func() antlr.TerminalNode

+ RBRACK func() antlr.TerminalNode

+ type IListLitContext interface

+ ExpressionChain func() IExpressionChainContext

+ GetParser func() antlr.Parser

+ IsListLitContext func()

+ LBRACK func() antlr.TerminalNode

+ RBRACK func() antlr.TerminalNode

+ type ILiteralContext interface

+ BoolLit func() IBoolLitContext

+ CharLit func() ICharLitContext

+ GetParser func() antlr.Parser

+ IsLiteralContext func()

+ ListLit func() IListLitContext

+ MapLit func() IMapLitContext

+ NULL_W func() antlr.TerminalNode

+ NumLit func() INumLitContext

+ StringLit func() IStringLitContext

+ type IMapLitContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllMapPair func() []IMapPairContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsMapLitContext func()

+ LBRACE func() antlr.TerminalNode

+ MapPair func(i int) IMapPairContext

+ RBRACE func() antlr.TerminalNode

+ type IMapPairContext interface

+ COLON func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsMapPairContext func()

+ Name func() INameContext

+ type IMatchStContext interface

+ GetParser func() antlr.Parser

+ IsMatchStContext func()

+ MATCH func() antlr.TerminalNode

+ OPTIONAL func() antlr.TerminalNode

+ PatternWhere func() IPatternWhereContext

+ type IMergeActionContext interface

+ CREATE func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsMergeActionContext func()

+ MATCH func() antlr.TerminalNode

+ ON func() antlr.TerminalNode

+ SetSt func() ISetStContext

+ type IMergeStContext interface

+ AllMergeAction func() []IMergeActionContext

+ GetParser func() antlr.Parser

+ IsMergeStContext func()

+ MERGE func() antlr.TerminalNode

+ MergeAction func(i int) IMergeActionContext

+ PatternPart func() IPatternPartContext

+ type IMultDivExpressionContext interface

+ AllDIV func() []antlr.TerminalNode

+ AllMOD func() []antlr.TerminalNode

+ AllMULT func() []antlr.TerminalNode

+ AllPowerExpression func() []IPowerExpressionContext

+ DIV func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsMultDivExpressionContext func()

+ MOD func(i int) antlr.TerminalNode

+ MULT func(i int) antlr.TerminalNode

+ PowerExpression func(i int) IPowerExpressionContext

+ type IMultiPartQContext interface

+ AllReadingStatement func() []IReadingStatementContext

+ AllUpdatingStatement func() []IUpdatingStatementContext

+ AllWithSt func() []IWithStContext

+ GetParser func() antlr.Parser

+ IsMultiPartQContext func()

+ ReadingStatement func(i int) IReadingStatementContext

+ SinglePartQ func() ISinglePartQContext

+ UpdatingStatement func(i int) IUpdatingStatementContext

+ WithSt func(i int) IWithStContext

+ type INameContext interface

+ GetParser func() antlr.Parser

+ IsNameContext func()

+ ReservedWord func() IReservedWordContext

+ Symbol func() ISymbolContext

+ type INodeLabelsContext interface

+ AllCOLON func() []antlr.TerminalNode

+ AllName func() []INameContext

+ COLON func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsNodeLabelsContext func()

+ Name func(i int) INameContext

+ type INodePatternContext interface

+ GetParser func() antlr.Parser

+ IsNodePatternContext func()

+ LPAREN func() antlr.TerminalNode

+ NodeLabels func() INodeLabelsContext

+ Properties func() IPropertiesContext

+ RPAREN func() antlr.TerminalNode

+ Symbol func() ISymbolContext

+ type INotExpressionContext interface

+ ComparisonExpression func() IComparisonExpressionContext

+ GetParser func() antlr.Parser

+ IsNotExpressionContext func()

+ NOT func() antlr.TerminalNode

+ type INullExpressionContext interface

+ GetParser func() antlr.Parser

+ IS func() antlr.TerminalNode

+ IsNullExpressionContext func()

+ NOT func() antlr.TerminalNode

+ NULL_W func() antlr.TerminalNode

+ type INumLitContext interface

+ DIGIT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsNumLitContext func()

+ type IOrderItemContext interface

+ ASC func() antlr.TerminalNode

+ ASCENDING func() antlr.TerminalNode

+ DESC func() antlr.TerminalNode

+ DESCENDING func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsOrderItemContext func()

+ type IOrderStContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllOrderItem func() []IOrderItemContext

+ BY func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsOrderStContext func()

+ ORDER func() antlr.TerminalNode

+ OrderItem func(i int) IOrderItemContext

+ type IParameterContext interface

+ DOLLAR func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsParameterContext func()

+ NumLit func() INumLitContext

+ Symbol func() ISymbolContext

+ type IParenExpressionChainContext interface

+ ExpressionChain func() IExpressionChainContext

+ GetParser func() antlr.Parser

+ IsParenExpressionChainContext func()

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ type IParenthesizedExpressionContext interface

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsParenthesizedExpressionContext func()

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ type IPatternComprehensionContext interface

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsPatternComprehensionContext func()

+ LBRACK func() antlr.TerminalNode

+ Lhs func() ILhsContext

+ RBRACK func() antlr.TerminalNode

+ RelationshipsChainPattern func() IRelationshipsChainPatternContext

+ STICK func() antlr.TerminalNode

+ Where func() IWhereContext

+ type IPatternContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllPatternPart func() []IPatternPartContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsPatternContext func()

+ PatternPart func(i int) IPatternPartContext

+ type IPatternElemChainContext interface

+ GetParser func() antlr.Parser

+ IsPatternElemChainContext func()

+ NodePattern func() INodePatternContext

+ RelationshipPattern func() IRelationshipPatternContext

+ type IPatternElemContext interface

+ AllPatternElemChain func() []IPatternElemChainContext

+ GetParser func() antlr.Parser

+ IsPatternElemContext func()

+ LPAREN func() antlr.TerminalNode

+ NodePattern func() INodePatternContext

+ PatternElem func() IPatternElemContext

+ PatternElemChain func(i int) IPatternElemChainContext

+ RPAREN func() antlr.TerminalNode

+ type IPatternPartContext interface

+ ASSIGN func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsPatternPartContext func()

+ PatternElem func() IPatternElemContext

+ Symbol func() ISymbolContext

+ type IPatternWhereContext interface

+ GetParser func() antlr.Parser

+ IsPatternWhereContext func()

+ Pattern func() IPatternContext

+ Where func() IWhereContext

+ type IPowerExpressionContext interface

+ AllCARET func() []antlr.TerminalNode

+ AllUnaryAddSubExpression func() []IUnaryAddSubExpressionContext

+ CARET func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsPowerExpressionContext func()

+ UnaryAddSubExpression func(i int) IUnaryAddSubExpressionContext

+ type IProjectionBodyContext interface

+ DISTINCT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsProjectionBodyContext func()

+ LimitSt func() ILimitStContext

+ OrderSt func() IOrderStContext

+ ProjectionItems func() IProjectionItemsContext

+ SkipSt func() ISkipStContext

+ type IProjectionItemContext interface

+ AS func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsProjectionItemContext func()

+ Symbol func() ISymbolContext

+ type IProjectionItemsContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllProjectionItem func() []IProjectionItemContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsProjectionItemsContext func()

+ MULT func() antlr.TerminalNode

+ ProjectionItem func(i int) IProjectionItemContext

+ type IPropertiesContext interface

+ GetParser func() antlr.Parser

+ IsPropertiesContext func()

+ MapLit func() IMapLitContext

+ Parameter func() IParameterContext

+ type IPropertyExpressionContext interface

+ AllDOT func() []antlr.TerminalNode

+ AllName func() []INameContext

+ Atom func() IAtomContext

+ DOT func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsPropertyExpressionContext func()

+ Name func(i int) INameContext

+ type IPropertyOrLabelExpressionContext interface

+ GetParser func() antlr.Parser

+ IsPropertyOrLabelExpressionContext func()

+ NodeLabels func() INodeLabelsContext

+ PropertyExpression func() IPropertyExpressionContext

+ type IQueryCallStContext interface

+ CALL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ InvocationName func() IInvocationNameContext

+ IsQueryCallStContext func()

+ ParenExpressionChain func() IParenExpressionChainContext

+ YIELD func() antlr.TerminalNode

+ YieldItems func() IYieldItemsContext

+ type IQueryContext interface

+ GetParser func() antlr.Parser

+ IsQueryContext func()

+ RegularQuery func() IRegularQueryContext

+ StandaloneCall func() IStandaloneCallContext

+ type IRangeLitContext interface

+ AllNumLit func() []INumLitContext

+ GetParser func() antlr.Parser

+ IsRangeLitContext func()

+ MULT func() antlr.TerminalNode

+ NumLit func(i int) INumLitContext

+ RANGE func() antlr.TerminalNode

+ type IReadingStatementContext interface

+ GetParser func() antlr.Parser

+ IsReadingStatementContext func()

+ MatchSt func() IMatchStContext

+ QueryCallSt func() IQueryCallStContext

+ UnwindSt func() IUnwindStContext

+ type IRegularQueryContext interface

+ AllUnionSt func() []IUnionStContext

+ GetParser func() antlr.Parser

+ IsRegularQueryContext func()

+ SingleQuery func() ISingleQueryContext

+ UnionSt func(i int) IUnionStContext

+ type IRelationDetailContext interface

+ GetParser func() antlr.Parser

+ IsRelationDetailContext func()

+ LBRACK func() antlr.TerminalNode

+ Properties func() IPropertiesContext

+ RBRACK func() antlr.TerminalNode

+ RangeLit func() IRangeLitContext

+ RelationshipTypes func() IRelationshipTypesContext

+ Symbol func() ISymbolContext

+ type IRelationshipPatternContext interface

+ AllSUB func() []antlr.TerminalNode

+ GT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsRelationshipPatternContext func()

+ LT func() antlr.TerminalNode

+ RelationDetail func() IRelationDetailContext

+ SUB func(i int) antlr.TerminalNode

+ type IRelationshipTypesContext interface

+ AllCOLON func() []antlr.TerminalNode

+ AllName func() []INameContext

+ AllSTICK func() []antlr.TerminalNode

+ COLON func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsRelationshipTypesContext func()

+ Name func(i int) INameContext

+ STICK func(i int) antlr.TerminalNode

+ type IRelationshipsChainPatternContext interface

+ AllPatternElemChain func() []IPatternElemChainContext

+ GetParser func() antlr.Parser

+ IsRelationshipsChainPatternContext func()

+ NodePattern func() INodePatternContext

+ PatternElemChain func(i int) IPatternElemChainContext

+ type IRemoveItemContext interface

+ GetParser func() antlr.Parser

+ IsRemoveItemContext func()

+ NodeLabels func() INodeLabelsContext

+ PropertyExpression func() IPropertyExpressionContext

+ Symbol func() ISymbolContext

+ type IRemoveStContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllRemoveItem func() []IRemoveItemContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsRemoveStContext func()

+ REMOVE func() antlr.TerminalNode

+ RemoveItem func(i int) IRemoveItemContext

+ type IReservedWordContext interface

+ ADD func() antlr.TerminalNode

+ ALL func() antlr.TerminalNode

+ AND func() antlr.TerminalNode

+ AS func() antlr.TerminalNode

+ ASC func() antlr.TerminalNode

+ ASCENDING func() antlr.TerminalNode

+ BY func() antlr.TerminalNode

+ CASE func() antlr.TerminalNode

+ CONSTRAINT func() antlr.TerminalNode

+ CONTAINS func() antlr.TerminalNode

+ CREATE func() antlr.TerminalNode

+ DELETE func() antlr.TerminalNode

+ DESC func() antlr.TerminalNode

+ DESCENDING func() antlr.TerminalNode

+ DETACH func() antlr.TerminalNode

+ DISTINCT func() antlr.TerminalNode

+ DO func() antlr.TerminalNode

+ DROP func() antlr.TerminalNode

+ ELSE func() antlr.TerminalNode

+ END func() antlr.TerminalNode

+ ENDS func() antlr.TerminalNode

+ EXISTS func() antlr.TerminalNode

+ FALSE func() antlr.TerminalNode

+ FOR func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IN func() antlr.TerminalNode

+ IS func() antlr.TerminalNode

+ IsReservedWordContext func()

+ LIMIT func() antlr.TerminalNode

+ MANDATORY func() antlr.TerminalNode

+ MATCH func() antlr.TerminalNode

+ MERGE func() antlr.TerminalNode

+ NOT func() antlr.TerminalNode

+ NULL_W func() antlr.TerminalNode

+ OF func() antlr.TerminalNode

+ ON func() antlr.TerminalNode

+ OPTIONAL func() antlr.TerminalNode

+ OR func() antlr.TerminalNode

+ ORDER func() antlr.TerminalNode

+ REMOVE func() antlr.TerminalNode

+ REQUIRE func() antlr.TerminalNode

+ RETURN func() antlr.TerminalNode

+ SCALAR func() antlr.TerminalNode

+ SET func() antlr.TerminalNode

+ SKIP_W func() antlr.TerminalNode

+ STARTS func() antlr.TerminalNode

+ THEN func() antlr.TerminalNode

+ TRUE func() antlr.TerminalNode

+ UNION func() antlr.TerminalNode

+ UNIQUE func() antlr.TerminalNode

+ UNWIND func() antlr.TerminalNode

+ WHEN func() antlr.TerminalNode

+ WHERE func() antlr.TerminalNode

+ WITH func() antlr.TerminalNode

+ XOR func() antlr.TerminalNode

+ type IReturnStContext interface

+ GetParser func() antlr.Parser

+ IsReturnStContext func()

+ ProjectionBody func() IProjectionBodyContext

+ RETURN func() antlr.TerminalNode

+ type IScriptContext interface

+ EOF func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsScriptContext func()

+ Query func() IQueryContext

+ SEMI func() antlr.TerminalNode

+ type ISetItemContext interface

+ ADD_ASSIGN func() antlr.TerminalNode

+ ASSIGN func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsSetItemContext func()

+ NodeLabels func() INodeLabelsContext

+ PropertyExpression func() IPropertyExpressionContext

+ Symbol func() ISymbolContext

+ type ISetStContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllSetItem func() []ISetItemContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsSetStContext func()

+ SET func() antlr.TerminalNode

+ SetItem func(i int) ISetItemContext

+ type ISinglePartQContext interface

+ AllReadingStatement func() []IReadingStatementContext

+ AllUpdatingStatement func() []IUpdatingStatementContext

+ GetParser func() antlr.Parser

+ IsSinglePartQContext func()

+ ReadingStatement func(i int) IReadingStatementContext

+ ReturnSt func() IReturnStContext

+ UpdatingStatement func(i int) IUpdatingStatementContext

+ type ISingleQueryContext interface

+ GetParser func() antlr.Parser

+ IsSingleQueryContext func()

+ MultiPartQ func() IMultiPartQContext

+ SinglePartQ func() ISinglePartQContext

+ type ISkipStContext interface

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsSkipStContext func()

+ SKIP_W func() antlr.TerminalNode

+ type IStandaloneCallContext interface

+ CALL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ InvocationName func() IInvocationNameContext

+ IsStandaloneCallContext func()

+ MULT func() antlr.TerminalNode

+ ParenExpressionChain func() IParenExpressionChainContext

+ YIELD func() antlr.TerminalNode

+ YieldItems func() IYieldItemsContext

+ type IStringExpPrefixContext interface

+ CONTAINS func() antlr.TerminalNode

+ ENDS func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsStringExpPrefixContext func()

+ STARTS func() antlr.TerminalNode

+ WITH func() antlr.TerminalNode

+ type IStringExpressionContext interface

+ GetParser func() antlr.Parser

+ IsStringExpressionContext func()

+ PropertyOrLabelExpression func() IPropertyOrLabelExpressionContext

+ StringExpPrefix func() IStringExpPrefixContext

+ type IStringLitContext interface

+ GetParser func() antlr.Parser

+ IsStringLitContext func()

+ STRING_LITERAL func() antlr.TerminalNode

+ type ISubqueryCountContext interface

+ COUNT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsSubqueryCountContext func()

+ LBRACE func() antlr.TerminalNode

+ PatternWhere func() IPatternWhereContext

+ RBRACE func() antlr.TerminalNode

+ RegularQuery func() IRegularQueryContext

+ type ISubqueryExistContext interface

+ EXISTS func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsSubqueryExistContext func()

+ LBRACE func() antlr.TerminalNode

+ PatternWhere func() IPatternWhereContext

+ RBRACE func() antlr.TerminalNode

+ RegularQuery func() IRegularQueryContext

+ type ISymbolContext interface

+ ANY func() antlr.TerminalNode

+ COUNT func() antlr.TerminalNode

+ ESC_LITERAL func() antlr.TerminalNode

+ EXTRACT func() antlr.TerminalNode

+ FILTER func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ ID func() antlr.TerminalNode

+ IsSymbolContext func()

+ NONE func() antlr.TerminalNode

+ SINGLE func() antlr.TerminalNode

+ type IUnaryAddSubExpressionContext interface

+ AtomicExpression func() IAtomicExpressionContext

+ GetParser func() antlr.Parser

+ IsUnaryAddSubExpressionContext func()

+ PLUS func() antlr.TerminalNode

+ SUB func() antlr.TerminalNode

+ type IUnionStContext interface

+ ALL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsUnionStContext func()

+ SingleQuery func() ISingleQueryContext

+ UNION func() antlr.TerminalNode

+ type IUnwindStContext interface

+ AS func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsUnwindStContext func()

+ Symbol func() ISymbolContext

+ UNWIND func() antlr.TerminalNode

+ type IUpdatingStatementContext interface

+ CreateSt func() ICreateStContext

+ DeleteSt func() IDeleteStContext

+ GetParser func() antlr.Parser

+ IsUpdatingStatementContext func()

+ MergeSt func() IMergeStContext

+ RemoveSt func() IRemoveStContext

+ SetSt func() ISetStContext

+ type IWhereContext interface

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsWhereContext func()

+ WHERE func() antlr.TerminalNode

+ type IWithStContext interface

+ GetParser func() antlr.Parser

+ IsWithStContext func()

+ ProjectionBody func() IProjectionBodyContext

+ WITH func() antlr.TerminalNode

+ Where func() IWhereContext

+ type IXorExpressionContext interface

+ AllAndExpression func() []IAndExpressionContext

+ AllXOR func() []antlr.TerminalNode

+ AndExpression func(i int) IAndExpressionContext

+ GetParser func() antlr.Parser

+ IsXorExpressionContext func()

+ XOR func(i int) antlr.TerminalNode

+ type IYieldItemContext interface

+ AS func() antlr.TerminalNode

+ AllSymbol func() []ISymbolContext

+ GetParser func() antlr.Parser

+ IsYieldItemContext func()

+ Symbol func(i int) ISymbolContext

+ type IYieldItemsContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllYieldItem func() []IYieldItemContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsYieldItemsContext func()

+ Where func() IWhereContext

+ YieldItem func(i int) IYieldItemContext

+ type InvocationNameContext struct

+ func NewEmptyInvocationNameContext() *InvocationNameContext

+ func NewInvocationNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InvocationNameContext

+ func (*InvocationNameContext) IsInvocationNameContext()

+ func (s *InvocationNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *InvocationNameContext) AllDOT() []antlr.TerminalNode

+ func (s *InvocationNameContext) AllSymbol() []ISymbolContext

+ func (s *InvocationNameContext) DOT(i int) antlr.TerminalNode

+ func (s *InvocationNameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *InvocationNameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *InvocationNameContext) GetParser() antlr.Parser

+ func (s *InvocationNameContext) GetRuleContext() antlr.RuleContext

+ func (s *InvocationNameContext) Symbol(i int) ISymbolContext

+ func (s *InvocationNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type LhsContext struct

+ func NewEmptyLhsContext() *LhsContext

+ func NewLhsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LhsContext

+ func (*LhsContext) IsLhsContext()

+ func (s *LhsContext) ASSIGN() antlr.TerminalNode

+ func (s *LhsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *LhsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *LhsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *LhsContext) GetParser() antlr.Parser

+ func (s *LhsContext) GetRuleContext() antlr.RuleContext

+ func (s *LhsContext) Symbol() ISymbolContext

+ func (s *LhsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type LimitStContext struct

+ func NewEmptyLimitStContext() *LimitStContext

+ func NewLimitStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitStContext

+ func (*LimitStContext) IsLimitStContext()

+ func (s *LimitStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *LimitStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *LimitStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *LimitStContext) Expression() IExpressionContext

+ func (s *LimitStContext) GetParser() antlr.Parser

+ func (s *LimitStContext) GetRuleContext() antlr.RuleContext

+ func (s *LimitStContext) LIMIT() antlr.TerminalNode

+ func (s *LimitStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ListComprehensionContext struct

+ func NewEmptyListComprehensionContext() *ListComprehensionContext

+ func NewListComprehensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ListComprehensionContext

+ func (*ListComprehensionContext) IsListComprehensionContext()

+ func (s *ListComprehensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ListComprehensionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ListComprehensionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ListComprehensionContext) Expression() IExpressionContext

+ func (s *ListComprehensionContext) FilterExpression() IFilterExpressionContext

+ func (s *ListComprehensionContext) GetParser() antlr.Parser

+ func (s *ListComprehensionContext) GetRuleContext() antlr.RuleContext

+ func (s *ListComprehensionContext) LBRACK() antlr.TerminalNode

+ func (s *ListComprehensionContext) RBRACK() antlr.TerminalNode

+ func (s *ListComprehensionContext) STICK() antlr.TerminalNode

+ func (s *ListComprehensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ListExpressionContext struct

+ func NewEmptyListExpressionContext() *ListExpressionContext

+ func NewListExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ListExpressionContext

+ func (*ListExpressionContext) IsListExpressionContext()

+ func (s *ListExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ListExpressionContext) AllExpression() []IExpressionContext

+ func (s *ListExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ListExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ListExpressionContext) Expression(i int) IExpressionContext

+ func (s *ListExpressionContext) GetParser() antlr.Parser

+ func (s *ListExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *ListExpressionContext) IN() antlr.TerminalNode

+ func (s *ListExpressionContext) LBRACK() antlr.TerminalNode

+ func (s *ListExpressionContext) PropertyOrLabelExpression() IPropertyOrLabelExpressionContext

+ func (s *ListExpressionContext) RANGE() antlr.TerminalNode

+ func (s *ListExpressionContext) RBRACK() antlr.TerminalNode

+ func (s *ListExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ListLitContext struct

+ func NewEmptyListLitContext() *ListLitContext

+ func NewListLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ListLitContext

+ func (*ListLitContext) IsListLitContext()

+ func (s *ListLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ListLitContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ListLitContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ListLitContext) ExpressionChain() IExpressionChainContext

+ func (s *ListLitContext) GetParser() antlr.Parser

+ func (s *ListLitContext) GetRuleContext() antlr.RuleContext

+ func (s *ListLitContext) LBRACK() antlr.TerminalNode

+ func (s *ListLitContext) RBRACK() antlr.TerminalNode

+ func (s *ListLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type LiteralContext struct

+ func NewEmptyLiteralContext() *LiteralContext

+ func NewLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralContext

+ func (*LiteralContext) IsLiteralContext()

+ func (s *LiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *LiteralContext) BoolLit() IBoolLitContext

+ func (s *LiteralContext) CharLit() ICharLitContext

+ func (s *LiteralContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *LiteralContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *LiteralContext) GetParser() antlr.Parser

+ func (s *LiteralContext) GetRuleContext() antlr.RuleContext

+ func (s *LiteralContext) ListLit() IListLitContext

+ func (s *LiteralContext) MapLit() IMapLitContext

+ func (s *LiteralContext) NULL_W() antlr.TerminalNode

+ func (s *LiteralContext) NumLit() INumLitContext

+ func (s *LiteralContext) StringLit() IStringLitContext

+ func (s *LiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type MapLitContext struct

+ func NewEmptyMapLitContext() *MapLitContext

+ func NewMapLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MapLitContext

+ func (*MapLitContext) IsMapLitContext()

+ func (s *MapLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *MapLitContext) AllCOMMA() []antlr.TerminalNode

+ func (s *MapLitContext) AllMapPair() []IMapPairContext

+ func (s *MapLitContext) COMMA(i int) antlr.TerminalNode

+ func (s *MapLitContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *MapLitContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *MapLitContext) GetParser() antlr.Parser

+ func (s *MapLitContext) GetRuleContext() antlr.RuleContext

+ func (s *MapLitContext) LBRACE() antlr.TerminalNode

+ func (s *MapLitContext) MapPair(i int) IMapPairContext

+ func (s *MapLitContext) RBRACE() antlr.TerminalNode

+ func (s *MapLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type MapPairContext struct

+ func NewEmptyMapPairContext() *MapPairContext

+ func NewMapPairContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MapPairContext

+ func (*MapPairContext) IsMapPairContext()

+ func (s *MapPairContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *MapPairContext) COLON() antlr.TerminalNode

+ func (s *MapPairContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *MapPairContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *MapPairContext) Expression() IExpressionContext

+ func (s *MapPairContext) GetParser() antlr.Parser

+ func (s *MapPairContext) GetRuleContext() antlr.RuleContext

+ func (s *MapPairContext) Name() INameContext

+ func (s *MapPairContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type MatchStContext struct

+ func NewEmptyMatchStContext() *MatchStContext

+ func NewMatchStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MatchStContext

+ func (*MatchStContext) IsMatchStContext()

+ func (s *MatchStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *MatchStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *MatchStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *MatchStContext) GetParser() antlr.Parser

+ func (s *MatchStContext) GetRuleContext() antlr.RuleContext

+ func (s *MatchStContext) MATCH() antlr.TerminalNode

+ func (s *MatchStContext) OPTIONAL() antlr.TerminalNode

+ func (s *MatchStContext) PatternWhere() IPatternWhereContext

+ func (s *MatchStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type MergeActionContext struct

+ func NewEmptyMergeActionContext() *MergeActionContext

+ func NewMergeActionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MergeActionContext

+ func (*MergeActionContext) IsMergeActionContext()

+ func (s *MergeActionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *MergeActionContext) CREATE() antlr.TerminalNode

+ func (s *MergeActionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *MergeActionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *MergeActionContext) GetParser() antlr.Parser

+ func (s *MergeActionContext) GetRuleContext() antlr.RuleContext

+ func (s *MergeActionContext) MATCH() antlr.TerminalNode

+ func (s *MergeActionContext) ON() antlr.TerminalNode

+ func (s *MergeActionContext) SetSt() ISetStContext

+ func (s *MergeActionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type MergeStContext struct

+ func NewEmptyMergeStContext() *MergeStContext

+ func NewMergeStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MergeStContext

+ func (*MergeStContext) IsMergeStContext()

+ func (s *MergeStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *MergeStContext) AllMergeAction() []IMergeActionContext

+ func (s *MergeStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *MergeStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *MergeStContext) GetParser() antlr.Parser

+ func (s *MergeStContext) GetRuleContext() antlr.RuleContext

+ func (s *MergeStContext) MERGE() antlr.TerminalNode

+ func (s *MergeStContext) MergeAction(i int) IMergeActionContext

+ func (s *MergeStContext) PatternPart() IPatternPartContext

+ func (s *MergeStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type MultDivExpressionContext struct

+ func NewEmptyMultDivExpressionContext() *MultDivExpressionContext

+ func NewMultDivExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultDivExpressionContext

+ func (*MultDivExpressionContext) IsMultDivExpressionContext()

+ func (s *MultDivExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *MultDivExpressionContext) AllDIV() []antlr.TerminalNode

+ func (s *MultDivExpressionContext) AllMOD() []antlr.TerminalNode

+ func (s *MultDivExpressionContext) AllMULT() []antlr.TerminalNode

+ func (s *MultDivExpressionContext) AllPowerExpression() []IPowerExpressionContext

+ func (s *MultDivExpressionContext) DIV(i int) antlr.TerminalNode

+ func (s *MultDivExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *MultDivExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *MultDivExpressionContext) GetParser() antlr.Parser

+ func (s *MultDivExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *MultDivExpressionContext) MOD(i int) antlr.TerminalNode

+ func (s *MultDivExpressionContext) MULT(i int) antlr.TerminalNode

+ func (s *MultDivExpressionContext) PowerExpression(i int) IPowerExpressionContext

+ func (s *MultDivExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type MultiPartQContext struct

+ func NewEmptyMultiPartQContext() *MultiPartQContext

+ func NewMultiPartQContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultiPartQContext

+ func (*MultiPartQContext) IsMultiPartQContext()

+ func (s *MultiPartQContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *MultiPartQContext) AllReadingStatement() []IReadingStatementContext

+ func (s *MultiPartQContext) AllUpdatingStatement() []IUpdatingStatementContext

+ func (s *MultiPartQContext) AllWithSt() []IWithStContext

+ func (s *MultiPartQContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *MultiPartQContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *MultiPartQContext) GetParser() antlr.Parser

+ func (s *MultiPartQContext) GetRuleContext() antlr.RuleContext

+ func (s *MultiPartQContext) ReadingStatement(i int) IReadingStatementContext

+ func (s *MultiPartQContext) SinglePartQ() ISinglePartQContext

+ func (s *MultiPartQContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *MultiPartQContext) UpdatingStatement(i int) IUpdatingStatementContext

+ func (s *MultiPartQContext) WithSt(i int) IWithStContext

+ type NameContext struct

+ func NewEmptyNameContext() *NameContext

+ func NewNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NameContext

+ func (*NameContext) IsNameContext()

+ func (s *NameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *NameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *NameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *NameContext) GetParser() antlr.Parser

+ func (s *NameContext) GetRuleContext() antlr.RuleContext

+ func (s *NameContext) ReservedWord() IReservedWordContext

+ func (s *NameContext) Symbol() ISymbolContext

+ func (s *NameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type NodeLabelsContext struct

+ func NewEmptyNodeLabelsContext() *NodeLabelsContext

+ func NewNodeLabelsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NodeLabelsContext

+ func (*NodeLabelsContext) IsNodeLabelsContext()

+ func (s *NodeLabelsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *NodeLabelsContext) AllCOLON() []antlr.TerminalNode

+ func (s *NodeLabelsContext) AllName() []INameContext

+ func (s *NodeLabelsContext) COLON(i int) antlr.TerminalNode

+ func (s *NodeLabelsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *NodeLabelsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *NodeLabelsContext) GetParser() antlr.Parser

+ func (s *NodeLabelsContext) GetRuleContext() antlr.RuleContext

+ func (s *NodeLabelsContext) Name(i int) INameContext

+ func (s *NodeLabelsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type NodePatternContext struct

+ func NewEmptyNodePatternContext() *NodePatternContext

+ func NewNodePatternContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NodePatternContext

+ func (*NodePatternContext) IsNodePatternContext()

+ func (s *NodePatternContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *NodePatternContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *NodePatternContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *NodePatternContext) GetParser() antlr.Parser

+ func (s *NodePatternContext) GetRuleContext() antlr.RuleContext

+ func (s *NodePatternContext) LPAREN() antlr.TerminalNode

+ func (s *NodePatternContext) NodeLabels() INodeLabelsContext

+ func (s *NodePatternContext) Properties() IPropertiesContext

+ func (s *NodePatternContext) RPAREN() antlr.TerminalNode

+ func (s *NodePatternContext) Symbol() ISymbolContext

+ func (s *NodePatternContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type NotExpressionContext struct

+ func NewEmptyNotExpressionContext() *NotExpressionContext

+ func NewNotExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NotExpressionContext

+ func (*NotExpressionContext) IsNotExpressionContext()

+ func (s *NotExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *NotExpressionContext) ComparisonExpression() IComparisonExpressionContext

+ func (s *NotExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *NotExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *NotExpressionContext) GetParser() antlr.Parser

+ func (s *NotExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *NotExpressionContext) NOT() antlr.TerminalNode

+ func (s *NotExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type NullExpressionContext struct

+ func NewEmptyNullExpressionContext() *NullExpressionContext

+ func NewNullExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NullExpressionContext

+ func (*NullExpressionContext) IsNullExpressionContext()

+ func (s *NullExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *NullExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *NullExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *NullExpressionContext) GetParser() antlr.Parser

+ func (s *NullExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *NullExpressionContext) IS() antlr.TerminalNode

+ func (s *NullExpressionContext) NOT() antlr.TerminalNode

+ func (s *NullExpressionContext) NULL_W() antlr.TerminalNode

+ func (s *NullExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type NumLitContext struct

+ func NewEmptyNumLitContext() *NumLitContext

+ func NewNumLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumLitContext

+ func (*NumLitContext) IsNumLitContext()

+ func (s *NumLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *NumLitContext) DIGIT() antlr.TerminalNode

+ func (s *NumLitContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *NumLitContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *NumLitContext) GetParser() antlr.Parser

+ func (s *NumLitContext) GetRuleContext() antlr.RuleContext

+ func (s *NumLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type OrderItemContext struct

+ func NewEmptyOrderItemContext() *OrderItemContext

+ func NewOrderItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderItemContext

+ func (*OrderItemContext) IsOrderItemContext()

+ func (s *OrderItemContext) ASC() antlr.TerminalNode

+ func (s *OrderItemContext) ASCENDING() antlr.TerminalNode

+ func (s *OrderItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *OrderItemContext) DESC() antlr.TerminalNode

+ func (s *OrderItemContext) DESCENDING() antlr.TerminalNode

+ func (s *OrderItemContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *OrderItemContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *OrderItemContext) Expression() IExpressionContext

+ func (s *OrderItemContext) GetParser() antlr.Parser

+ func (s *OrderItemContext) GetRuleContext() antlr.RuleContext

+ func (s *OrderItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type OrderStContext struct

+ func NewEmptyOrderStContext() *OrderStContext

+ func NewOrderStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderStContext

+ func (*OrderStContext) IsOrderStContext()

+ func (s *OrderStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *OrderStContext) AllCOMMA() []antlr.TerminalNode

+ func (s *OrderStContext) AllOrderItem() []IOrderItemContext

+ func (s *OrderStContext) BY() antlr.TerminalNode

+ func (s *OrderStContext) COMMA(i int) antlr.TerminalNode

+ func (s *OrderStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *OrderStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *OrderStContext) GetParser() antlr.Parser

+ func (s *OrderStContext) GetRuleContext() antlr.RuleContext

+ func (s *OrderStContext) ORDER() antlr.TerminalNode

+ func (s *OrderStContext) OrderItem(i int) IOrderItemContext

+ func (s *OrderStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ParameterContext struct

+ func NewEmptyParameterContext() *ParameterContext

+ func NewParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParameterContext

+ func (*ParameterContext) IsParameterContext()

+ func (s *ParameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ParameterContext) DOLLAR() antlr.TerminalNode

+ func (s *ParameterContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ParameterContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ParameterContext) GetParser() antlr.Parser

+ func (s *ParameterContext) GetRuleContext() antlr.RuleContext

+ func (s *ParameterContext) NumLit() INumLitContext

+ func (s *ParameterContext) Symbol() ISymbolContext

+ func (s *ParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ParenExpressionChainContext struct

+ func NewEmptyParenExpressionChainContext() *ParenExpressionChainContext

+ func NewParenExpressionChainContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParenExpressionChainContext

+ func (*ParenExpressionChainContext) IsParenExpressionChainContext()

+ func (s *ParenExpressionChainContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ParenExpressionChainContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ParenExpressionChainContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ParenExpressionChainContext) ExpressionChain() IExpressionChainContext

+ func (s *ParenExpressionChainContext) GetParser() antlr.Parser

+ func (s *ParenExpressionChainContext) GetRuleContext() antlr.RuleContext

+ func (s *ParenExpressionChainContext) LPAREN() antlr.TerminalNode

+ func (s *ParenExpressionChainContext) RPAREN() antlr.TerminalNode

+ func (s *ParenExpressionChainContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ParenthesizedExpressionContext struct

+ func NewEmptyParenthesizedExpressionContext() *ParenthesizedExpressionContext

+ func NewParenthesizedExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParenthesizedExpressionContext

+ func (*ParenthesizedExpressionContext) IsParenthesizedExpressionContext()

+ func (s *ParenthesizedExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ParenthesizedExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ParenthesizedExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ParenthesizedExpressionContext) Expression() IExpressionContext

+ func (s *ParenthesizedExpressionContext) GetParser() antlr.Parser

+ func (s *ParenthesizedExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *ParenthesizedExpressionContext) LPAREN() antlr.TerminalNode

+ func (s *ParenthesizedExpressionContext) RPAREN() antlr.TerminalNode

+ func (s *ParenthesizedExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type PatternComprehensionContext struct

+ func NewEmptyPatternComprehensionContext() *PatternComprehensionContext

+ func NewPatternComprehensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PatternComprehensionContext

+ func (*PatternComprehensionContext) IsPatternComprehensionContext()

+ func (s *PatternComprehensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *PatternComprehensionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PatternComprehensionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PatternComprehensionContext) Expression() IExpressionContext

+ func (s *PatternComprehensionContext) GetParser() antlr.Parser

+ func (s *PatternComprehensionContext) GetRuleContext() antlr.RuleContext

+ func (s *PatternComprehensionContext) LBRACK() antlr.TerminalNode

+ func (s *PatternComprehensionContext) Lhs() ILhsContext

+ func (s *PatternComprehensionContext) RBRACK() antlr.TerminalNode

+ func (s *PatternComprehensionContext) RelationshipsChainPattern() IRelationshipsChainPatternContext

+ func (s *PatternComprehensionContext) STICK() antlr.TerminalNode

+ func (s *PatternComprehensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *PatternComprehensionContext) Where() IWhereContext

+ type PatternContext struct

+ func NewEmptyPatternContext() *PatternContext

+ func NewPatternContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PatternContext

+ func (*PatternContext) IsPatternContext()

+ func (s *PatternContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *PatternContext) AllCOMMA() []antlr.TerminalNode

+ func (s *PatternContext) AllPatternPart() []IPatternPartContext

+ func (s *PatternContext) COMMA(i int) antlr.TerminalNode

+ func (s *PatternContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PatternContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PatternContext) GetParser() antlr.Parser

+ func (s *PatternContext) GetRuleContext() antlr.RuleContext

+ func (s *PatternContext) PatternPart(i int) IPatternPartContext

+ func (s *PatternContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type PatternElemChainContext struct

+ func NewEmptyPatternElemChainContext() *PatternElemChainContext

+ func NewPatternElemChainContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PatternElemChainContext

+ func (*PatternElemChainContext) IsPatternElemChainContext()

+ func (s *PatternElemChainContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *PatternElemChainContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PatternElemChainContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PatternElemChainContext) GetParser() antlr.Parser

+ func (s *PatternElemChainContext) GetRuleContext() antlr.RuleContext

+ func (s *PatternElemChainContext) NodePattern() INodePatternContext

+ func (s *PatternElemChainContext) RelationshipPattern() IRelationshipPatternContext

+ func (s *PatternElemChainContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type PatternElemContext struct

+ func NewEmptyPatternElemContext() *PatternElemContext

+ func NewPatternElemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PatternElemContext

+ func (*PatternElemContext) IsPatternElemContext()

+ func (s *PatternElemContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *PatternElemContext) AllPatternElemChain() []IPatternElemChainContext

+ func (s *PatternElemContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PatternElemContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PatternElemContext) GetParser() antlr.Parser

+ func (s *PatternElemContext) GetRuleContext() antlr.RuleContext

+ func (s *PatternElemContext) LPAREN() antlr.TerminalNode

+ func (s *PatternElemContext) NodePattern() INodePatternContext

+ func (s *PatternElemContext) PatternElem() IPatternElemContext

+ func (s *PatternElemContext) PatternElemChain(i int) IPatternElemChainContext

+ func (s *PatternElemContext) RPAREN() antlr.TerminalNode

+ func (s *PatternElemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type PatternPartContext struct

+ func NewEmptyPatternPartContext() *PatternPartContext

+ func NewPatternPartContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PatternPartContext

+ func (*PatternPartContext) IsPatternPartContext()

+ func (s *PatternPartContext) ASSIGN() antlr.TerminalNode

+ func (s *PatternPartContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *PatternPartContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PatternPartContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PatternPartContext) GetParser() antlr.Parser

+ func (s *PatternPartContext) GetRuleContext() antlr.RuleContext

+ func (s *PatternPartContext) PatternElem() IPatternElemContext

+ func (s *PatternPartContext) Symbol() ISymbolContext

+ func (s *PatternPartContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type PatternWhereContext struct

+ func NewEmptyPatternWhereContext() *PatternWhereContext

+ func NewPatternWhereContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PatternWhereContext

+ func (*PatternWhereContext) IsPatternWhereContext()

+ func (s *PatternWhereContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *PatternWhereContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PatternWhereContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PatternWhereContext) GetParser() antlr.Parser

+ func (s *PatternWhereContext) GetRuleContext() antlr.RuleContext

+ func (s *PatternWhereContext) Pattern() IPatternContext

+ func (s *PatternWhereContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *PatternWhereContext) Where() IWhereContext

+ type PowerExpressionContext struct

+ func NewEmptyPowerExpressionContext() *PowerExpressionContext

+ func NewPowerExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PowerExpressionContext

+ func (*PowerExpressionContext) IsPowerExpressionContext()

+ func (s *PowerExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *PowerExpressionContext) AllCARET() []antlr.TerminalNode

+ func (s *PowerExpressionContext) AllUnaryAddSubExpression() []IUnaryAddSubExpressionContext

+ func (s *PowerExpressionContext) CARET(i int) antlr.TerminalNode

+ func (s *PowerExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PowerExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PowerExpressionContext) GetParser() antlr.Parser

+ func (s *PowerExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *PowerExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *PowerExpressionContext) UnaryAddSubExpression(i int) IUnaryAddSubExpressionContext

+ type ProjectionBodyContext struct

+ func NewEmptyProjectionBodyContext() *ProjectionBodyContext

+ func NewProjectionBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProjectionBodyContext

+ func (*ProjectionBodyContext) IsProjectionBodyContext()

+ func (s *ProjectionBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ProjectionBodyContext) DISTINCT() antlr.TerminalNode

+ func (s *ProjectionBodyContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ProjectionBodyContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ProjectionBodyContext) GetParser() antlr.Parser

+ func (s *ProjectionBodyContext) GetRuleContext() antlr.RuleContext

+ func (s *ProjectionBodyContext) LimitSt() ILimitStContext

+ func (s *ProjectionBodyContext) OrderSt() IOrderStContext

+ func (s *ProjectionBodyContext) ProjectionItems() IProjectionItemsContext

+ func (s *ProjectionBodyContext) SkipSt() ISkipStContext

+ func (s *ProjectionBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ProjectionItemContext struct

+ func NewEmptyProjectionItemContext() *ProjectionItemContext

+ func NewProjectionItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProjectionItemContext

+ func (*ProjectionItemContext) IsProjectionItemContext()

+ func (s *ProjectionItemContext) AS() antlr.TerminalNode

+ func (s *ProjectionItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ProjectionItemContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ProjectionItemContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ProjectionItemContext) Expression() IExpressionContext

+ func (s *ProjectionItemContext) GetParser() antlr.Parser

+ func (s *ProjectionItemContext) GetRuleContext() antlr.RuleContext

+ func (s *ProjectionItemContext) Symbol() ISymbolContext

+ func (s *ProjectionItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ProjectionItemsContext struct

+ func NewEmptyProjectionItemsContext() *ProjectionItemsContext

+ func NewProjectionItemsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProjectionItemsContext

+ func (*ProjectionItemsContext) IsProjectionItemsContext()

+ func (s *ProjectionItemsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ProjectionItemsContext) AllCOMMA() []antlr.TerminalNode

+ func (s *ProjectionItemsContext) AllProjectionItem() []IProjectionItemContext

+ func (s *ProjectionItemsContext) COMMA(i int) antlr.TerminalNode

+ func (s *ProjectionItemsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ProjectionItemsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ProjectionItemsContext) GetParser() antlr.Parser

+ func (s *ProjectionItemsContext) GetRuleContext() antlr.RuleContext

+ func (s *ProjectionItemsContext) MULT() antlr.TerminalNode

+ func (s *ProjectionItemsContext) ProjectionItem(i int) IProjectionItemContext

+ func (s *ProjectionItemsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type PropertiesContext struct

+ func NewEmptyPropertiesContext() *PropertiesContext

+ func NewPropertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertiesContext

+ func (*PropertiesContext) IsPropertiesContext()

+ func (s *PropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *PropertiesContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PropertiesContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PropertiesContext) GetParser() antlr.Parser

+ func (s *PropertiesContext) GetRuleContext() antlr.RuleContext

+ func (s *PropertiesContext) MapLit() IMapLitContext

+ func (s *PropertiesContext) Parameter() IParameterContext

+ func (s *PropertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type PropertyExpressionContext struct

+ func NewEmptyPropertyExpressionContext() *PropertyExpressionContext

+ func NewPropertyExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyExpressionContext

+ func (*PropertyExpressionContext) IsPropertyExpressionContext()

+ func (s *PropertyExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *PropertyExpressionContext) AllDOT() []antlr.TerminalNode

+ func (s *PropertyExpressionContext) AllName() []INameContext

+ func (s *PropertyExpressionContext) Atom() IAtomContext

+ func (s *PropertyExpressionContext) DOT(i int) antlr.TerminalNode

+ func (s *PropertyExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PropertyExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PropertyExpressionContext) GetParser() antlr.Parser

+ func (s *PropertyExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *PropertyExpressionContext) Name(i int) INameContext

+ func (s *PropertyExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type PropertyOrLabelExpressionContext struct

+ func NewEmptyPropertyOrLabelExpressionContext() *PropertyOrLabelExpressionContext

+ func NewPropertyOrLabelExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyOrLabelExpressionContext

+ func (*PropertyOrLabelExpressionContext) IsPropertyOrLabelExpressionContext()

+ func (s *PropertyOrLabelExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *PropertyOrLabelExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PropertyOrLabelExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PropertyOrLabelExpressionContext) GetParser() antlr.Parser

+ func (s *PropertyOrLabelExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *PropertyOrLabelExpressionContext) NodeLabels() INodeLabelsContext

+ func (s *PropertyOrLabelExpressionContext) PropertyExpression() IPropertyExpressionContext

+ func (s *PropertyOrLabelExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type QueryCallStContext struct

+ func NewEmptyQueryCallStContext() *QueryCallStContext

+ func NewQueryCallStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryCallStContext

+ func (*QueryCallStContext) IsQueryCallStContext()

+ func (s *QueryCallStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *QueryCallStContext) CALL() antlr.TerminalNode

+ func (s *QueryCallStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *QueryCallStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *QueryCallStContext) GetParser() antlr.Parser

+ func (s *QueryCallStContext) GetRuleContext() antlr.RuleContext

+ func (s *QueryCallStContext) InvocationName() IInvocationNameContext

+ func (s *QueryCallStContext) ParenExpressionChain() IParenExpressionChainContext

+ func (s *QueryCallStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *QueryCallStContext) YIELD() antlr.TerminalNode

+ func (s *QueryCallStContext) YieldItems() IYieldItemsContext

+ type QueryContext struct

+ func NewEmptyQueryContext() *QueryContext

+ func NewQueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryContext

+ func (*QueryContext) IsQueryContext()

+ func (s *QueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *QueryContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *QueryContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *QueryContext) GetParser() antlr.Parser

+ func (s *QueryContext) GetRuleContext() antlr.RuleContext

+ func (s *QueryContext) RegularQuery() IRegularQueryContext

+ func (s *QueryContext) StandaloneCall() IStandaloneCallContext

+ func (s *QueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type RangeLitContext struct

+ func NewEmptyRangeLitContext() *RangeLitContext

+ func NewRangeLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RangeLitContext

+ func (*RangeLitContext) IsRangeLitContext()

+ func (s *RangeLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *RangeLitContext) AllNumLit() []INumLitContext

+ func (s *RangeLitContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *RangeLitContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *RangeLitContext) GetParser() antlr.Parser

+ func (s *RangeLitContext) GetRuleContext() antlr.RuleContext

+ func (s *RangeLitContext) MULT() antlr.TerminalNode

+ func (s *RangeLitContext) NumLit(i int) INumLitContext

+ func (s *RangeLitContext) RANGE() antlr.TerminalNode

+ func (s *RangeLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ReadingStatementContext struct

+ func NewEmptyReadingStatementContext() *ReadingStatementContext

+ func NewReadingStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReadingStatementContext

+ func (*ReadingStatementContext) IsReadingStatementContext()

+ func (s *ReadingStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ReadingStatementContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ReadingStatementContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ReadingStatementContext) GetParser() antlr.Parser

+ func (s *ReadingStatementContext) GetRuleContext() antlr.RuleContext

+ func (s *ReadingStatementContext) MatchSt() IMatchStContext

+ func (s *ReadingStatementContext) QueryCallSt() IQueryCallStContext

+ func (s *ReadingStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *ReadingStatementContext) UnwindSt() IUnwindStContext

+ type RegularQueryContext struct

+ func NewEmptyRegularQueryContext() *RegularQueryContext

+ func NewRegularQueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RegularQueryContext

+ func (*RegularQueryContext) IsRegularQueryContext()

+ func (s *RegularQueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *RegularQueryContext) AllUnionSt() []IUnionStContext

+ func (s *RegularQueryContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *RegularQueryContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *RegularQueryContext) GetParser() antlr.Parser

+ func (s *RegularQueryContext) GetRuleContext() antlr.RuleContext

+ func (s *RegularQueryContext) SingleQuery() ISingleQueryContext

+ func (s *RegularQueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *RegularQueryContext) UnionSt(i int) IUnionStContext

+ type RelationDetailContext struct

+ func NewEmptyRelationDetailContext() *RelationDetailContext

+ func NewRelationDetailContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationDetailContext

+ func (*RelationDetailContext) IsRelationDetailContext()

+ func (s *RelationDetailContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *RelationDetailContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *RelationDetailContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *RelationDetailContext) GetParser() antlr.Parser

+ func (s *RelationDetailContext) GetRuleContext() antlr.RuleContext

+ func (s *RelationDetailContext) LBRACK() antlr.TerminalNode

+ func (s *RelationDetailContext) Properties() IPropertiesContext

+ func (s *RelationDetailContext) RBRACK() antlr.TerminalNode

+ func (s *RelationDetailContext) RangeLit() IRangeLitContext

+ func (s *RelationDetailContext) RelationshipTypes() IRelationshipTypesContext

+ func (s *RelationDetailContext) Symbol() ISymbolContext

+ func (s *RelationDetailContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type RelationshipPatternContext struct

+ func NewEmptyRelationshipPatternContext() *RelationshipPatternContext

+ func NewRelationshipPatternContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationshipPatternContext

+ func (*RelationshipPatternContext) IsRelationshipPatternContext()

+ func (s *RelationshipPatternContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *RelationshipPatternContext) AllSUB() []antlr.TerminalNode

+ func (s *RelationshipPatternContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *RelationshipPatternContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *RelationshipPatternContext) GT() antlr.TerminalNode

+ func (s *RelationshipPatternContext) GetParser() antlr.Parser

+ func (s *RelationshipPatternContext) GetRuleContext() antlr.RuleContext

+ func (s *RelationshipPatternContext) LT() antlr.TerminalNode

+ func (s *RelationshipPatternContext) RelationDetail() IRelationDetailContext

+ func (s *RelationshipPatternContext) SUB(i int) antlr.TerminalNode

+ func (s *RelationshipPatternContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type RelationshipTypesContext struct

+ func NewEmptyRelationshipTypesContext() *RelationshipTypesContext

+ func NewRelationshipTypesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationshipTypesContext

+ func (*RelationshipTypesContext) IsRelationshipTypesContext()

+ func (s *RelationshipTypesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *RelationshipTypesContext) AllCOLON() []antlr.TerminalNode

+ func (s *RelationshipTypesContext) AllName() []INameContext

+ func (s *RelationshipTypesContext) AllSTICK() []antlr.TerminalNode

+ func (s *RelationshipTypesContext) COLON(i int) antlr.TerminalNode

+ func (s *RelationshipTypesContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *RelationshipTypesContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *RelationshipTypesContext) GetParser() antlr.Parser

+ func (s *RelationshipTypesContext) GetRuleContext() antlr.RuleContext

+ func (s *RelationshipTypesContext) Name(i int) INameContext

+ func (s *RelationshipTypesContext) STICK(i int) antlr.TerminalNode

+ func (s *RelationshipTypesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type RelationshipsChainPatternContext struct

+ func NewEmptyRelationshipsChainPatternContext() *RelationshipsChainPatternContext

+ func NewRelationshipsChainPatternContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationshipsChainPatternContext

+ func (*RelationshipsChainPatternContext) IsRelationshipsChainPatternContext()

+ func (s *RelationshipsChainPatternContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *RelationshipsChainPatternContext) AllPatternElemChain() []IPatternElemChainContext

+ func (s *RelationshipsChainPatternContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *RelationshipsChainPatternContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *RelationshipsChainPatternContext) GetParser() antlr.Parser

+ func (s *RelationshipsChainPatternContext) GetRuleContext() antlr.RuleContext

+ func (s *RelationshipsChainPatternContext) NodePattern() INodePatternContext

+ func (s *RelationshipsChainPatternContext) PatternElemChain(i int) IPatternElemChainContext

+ func (s *RelationshipsChainPatternContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type RemoveItemContext struct

+ func NewEmptyRemoveItemContext() *RemoveItemContext

+ func NewRemoveItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RemoveItemContext

+ func (*RemoveItemContext) IsRemoveItemContext()

+ func (s *RemoveItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *RemoveItemContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *RemoveItemContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *RemoveItemContext) GetParser() antlr.Parser

+ func (s *RemoveItemContext) GetRuleContext() antlr.RuleContext

+ func (s *RemoveItemContext) NodeLabels() INodeLabelsContext

+ func (s *RemoveItemContext) PropertyExpression() IPropertyExpressionContext

+ func (s *RemoveItemContext) Symbol() ISymbolContext

+ func (s *RemoveItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type RemoveStContext struct

+ func NewEmptyRemoveStContext() *RemoveStContext

+ func NewRemoveStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RemoveStContext

+ func (*RemoveStContext) IsRemoveStContext()

+ func (s *RemoveStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *RemoveStContext) AllCOMMA() []antlr.TerminalNode

+ func (s *RemoveStContext) AllRemoveItem() []IRemoveItemContext

+ func (s *RemoveStContext) COMMA(i int) antlr.TerminalNode

+ func (s *RemoveStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *RemoveStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *RemoveStContext) GetParser() antlr.Parser

+ func (s *RemoveStContext) GetRuleContext() antlr.RuleContext

+ func (s *RemoveStContext) REMOVE() antlr.TerminalNode

+ func (s *RemoveStContext) RemoveItem(i int) IRemoveItemContext

+ func (s *RemoveStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ReservedWordContext struct

+ func NewEmptyReservedWordContext() *ReservedWordContext

+ func NewReservedWordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReservedWordContext

+ func (*ReservedWordContext) IsReservedWordContext()

+ func (s *ReservedWordContext) ADD() antlr.TerminalNode

+ func (s *ReservedWordContext) ALL() antlr.TerminalNode

+ func (s *ReservedWordContext) AND() antlr.TerminalNode

+ func (s *ReservedWordContext) AS() antlr.TerminalNode

+ func (s *ReservedWordContext) ASC() antlr.TerminalNode

+ func (s *ReservedWordContext) ASCENDING() antlr.TerminalNode

+ func (s *ReservedWordContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ReservedWordContext) BY() antlr.TerminalNode

+ func (s *ReservedWordContext) CASE() antlr.TerminalNode

+ func (s *ReservedWordContext) CONSTRAINT() antlr.TerminalNode

+ func (s *ReservedWordContext) CONTAINS() antlr.TerminalNode

+ func (s *ReservedWordContext) CREATE() antlr.TerminalNode

+ func (s *ReservedWordContext) DELETE() antlr.TerminalNode

+ func (s *ReservedWordContext) DESC() antlr.TerminalNode

+ func (s *ReservedWordContext) DESCENDING() antlr.TerminalNode

+ func (s *ReservedWordContext) DETACH() antlr.TerminalNode

+ func (s *ReservedWordContext) DISTINCT() antlr.TerminalNode

+ func (s *ReservedWordContext) DO() antlr.TerminalNode

+ func (s *ReservedWordContext) DROP() antlr.TerminalNode

+ func (s *ReservedWordContext) ELSE() antlr.TerminalNode

+ func (s *ReservedWordContext) END() antlr.TerminalNode

+ func (s *ReservedWordContext) ENDS() antlr.TerminalNode

+ func (s *ReservedWordContext) EXISTS() antlr.TerminalNode

+ func (s *ReservedWordContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ReservedWordContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ReservedWordContext) FALSE() antlr.TerminalNode

+ func (s *ReservedWordContext) FOR() antlr.TerminalNode

+ func (s *ReservedWordContext) GetParser() antlr.Parser

+ func (s *ReservedWordContext) GetRuleContext() antlr.RuleContext

+ func (s *ReservedWordContext) IN() antlr.TerminalNode

+ func (s *ReservedWordContext) IS() antlr.TerminalNode

+ func (s *ReservedWordContext) LIMIT() antlr.TerminalNode

+ func (s *ReservedWordContext) MANDATORY() antlr.TerminalNode

+ func (s *ReservedWordContext) MATCH() antlr.TerminalNode

+ func (s *ReservedWordContext) MERGE() antlr.TerminalNode

+ func (s *ReservedWordContext) NOT() antlr.TerminalNode

+ func (s *ReservedWordContext) NULL_W() antlr.TerminalNode

+ func (s *ReservedWordContext) OF() antlr.TerminalNode

+ func (s *ReservedWordContext) ON() antlr.TerminalNode

+ func (s *ReservedWordContext) OPTIONAL() antlr.TerminalNode

+ func (s *ReservedWordContext) OR() antlr.TerminalNode

+ func (s *ReservedWordContext) ORDER() antlr.TerminalNode

+ func (s *ReservedWordContext) REMOVE() antlr.TerminalNode

+ func (s *ReservedWordContext) REQUIRE() antlr.TerminalNode

+ func (s *ReservedWordContext) RETURN() antlr.TerminalNode

+ func (s *ReservedWordContext) SCALAR() antlr.TerminalNode

+ func (s *ReservedWordContext) SET() antlr.TerminalNode

+ func (s *ReservedWordContext) SKIP_W() antlr.TerminalNode

+ func (s *ReservedWordContext) STARTS() antlr.TerminalNode

+ func (s *ReservedWordContext) THEN() antlr.TerminalNode

+ func (s *ReservedWordContext) TRUE() antlr.TerminalNode

+ func (s *ReservedWordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *ReservedWordContext) UNION() antlr.TerminalNode

+ func (s *ReservedWordContext) UNIQUE() antlr.TerminalNode

+ func (s *ReservedWordContext) UNWIND() antlr.TerminalNode

+ func (s *ReservedWordContext) WHEN() antlr.TerminalNode

+ func (s *ReservedWordContext) WHERE() antlr.TerminalNode

+ func (s *ReservedWordContext) WITH() antlr.TerminalNode

+ func (s *ReservedWordContext) XOR() antlr.TerminalNode

+ type ReturnStContext struct

+ func NewEmptyReturnStContext() *ReturnStContext

+ func NewReturnStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnStContext

+ func (*ReturnStContext) IsReturnStContext()

+ func (s *ReturnStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ReturnStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ReturnStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ReturnStContext) GetParser() antlr.Parser

+ func (s *ReturnStContext) GetRuleContext() antlr.RuleContext

+ func (s *ReturnStContext) ProjectionBody() IProjectionBodyContext

+ func (s *ReturnStContext) RETURN() antlr.TerminalNode

+ func (s *ReturnStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ScriptContext struct

+ func NewEmptyScriptContext() *ScriptContext

+ func NewScriptContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ScriptContext

+ func (*ScriptContext) IsScriptContext()

+ func (s *ScriptContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ScriptContext) EOF() antlr.TerminalNode

+ func (s *ScriptContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ScriptContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ScriptContext) GetParser() antlr.Parser

+ func (s *ScriptContext) GetRuleContext() antlr.RuleContext

+ func (s *ScriptContext) Query() IQueryContext

+ func (s *ScriptContext) SEMI() antlr.TerminalNode

+ func (s *ScriptContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type SetItemContext struct

+ func NewEmptySetItemContext() *SetItemContext

+ func NewSetItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetItemContext

+ func (*SetItemContext) IsSetItemContext()

+ func (s *SetItemContext) ADD_ASSIGN() antlr.TerminalNode

+ func (s *SetItemContext) ASSIGN() antlr.TerminalNode

+ func (s *SetItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *SetItemContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *SetItemContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *SetItemContext) Expression() IExpressionContext

+ func (s *SetItemContext) GetParser() antlr.Parser

+ func (s *SetItemContext) GetRuleContext() antlr.RuleContext

+ func (s *SetItemContext) NodeLabels() INodeLabelsContext

+ func (s *SetItemContext) PropertyExpression() IPropertyExpressionContext

+ func (s *SetItemContext) Symbol() ISymbolContext

+ func (s *SetItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type SetStContext struct

+ func NewEmptySetStContext() *SetStContext

+ func NewSetStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetStContext

+ func (*SetStContext) IsSetStContext()

+ func (s *SetStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *SetStContext) AllCOMMA() []antlr.TerminalNode

+ func (s *SetStContext) AllSetItem() []ISetItemContext

+ func (s *SetStContext) COMMA(i int) antlr.TerminalNode

+ func (s *SetStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *SetStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *SetStContext) GetParser() antlr.Parser

+ func (s *SetStContext) GetRuleContext() antlr.RuleContext

+ func (s *SetStContext) SET() antlr.TerminalNode

+ func (s *SetStContext) SetItem(i int) ISetItemContext

+ func (s *SetStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type SinglePartQContext struct

+ func NewEmptySinglePartQContext() *SinglePartQContext

+ func NewSinglePartQContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SinglePartQContext

+ func (*SinglePartQContext) IsSinglePartQContext()

+ func (s *SinglePartQContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *SinglePartQContext) AllReadingStatement() []IReadingStatementContext

+ func (s *SinglePartQContext) AllUpdatingStatement() []IUpdatingStatementContext

+ func (s *SinglePartQContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *SinglePartQContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *SinglePartQContext) GetParser() antlr.Parser

+ func (s *SinglePartQContext) GetRuleContext() antlr.RuleContext

+ func (s *SinglePartQContext) ReadingStatement(i int) IReadingStatementContext

+ func (s *SinglePartQContext) ReturnSt() IReturnStContext

+ func (s *SinglePartQContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *SinglePartQContext) UpdatingStatement(i int) IUpdatingStatementContext

+ type SingleQueryContext struct

+ func NewEmptySingleQueryContext() *SingleQueryContext

+ func NewSingleQueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleQueryContext

+ func (*SingleQueryContext) IsSingleQueryContext()

+ func (s *SingleQueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *SingleQueryContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *SingleQueryContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *SingleQueryContext) GetParser() antlr.Parser

+ func (s *SingleQueryContext) GetRuleContext() antlr.RuleContext

+ func (s *SingleQueryContext) MultiPartQ() IMultiPartQContext

+ func (s *SingleQueryContext) SinglePartQ() ISinglePartQContext

+ func (s *SingleQueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type SkipStContext struct

+ func NewEmptySkipStContext() *SkipStContext

+ func NewSkipStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SkipStContext

+ func (*SkipStContext) IsSkipStContext()

+ func (s *SkipStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *SkipStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *SkipStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *SkipStContext) Expression() IExpressionContext

+ func (s *SkipStContext) GetParser() antlr.Parser

+ func (s *SkipStContext) GetRuleContext() antlr.RuleContext

+ func (s *SkipStContext) SKIP_W() antlr.TerminalNode

+ func (s *SkipStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type StandaloneCallContext struct

+ func NewEmptyStandaloneCallContext() *StandaloneCallContext

+ func NewStandaloneCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StandaloneCallContext

+ func (*StandaloneCallContext) IsStandaloneCallContext()

+ func (s *StandaloneCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *StandaloneCallContext) CALL() antlr.TerminalNode

+ func (s *StandaloneCallContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *StandaloneCallContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *StandaloneCallContext) GetParser() antlr.Parser

+ func (s *StandaloneCallContext) GetRuleContext() antlr.RuleContext

+ func (s *StandaloneCallContext) InvocationName() IInvocationNameContext

+ func (s *StandaloneCallContext) MULT() antlr.TerminalNode

+ func (s *StandaloneCallContext) ParenExpressionChain() IParenExpressionChainContext

+ func (s *StandaloneCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *StandaloneCallContext) YIELD() antlr.TerminalNode

+ func (s *StandaloneCallContext) YieldItems() IYieldItemsContext

+ type StringExpPrefixContext struct

+ func NewEmptyStringExpPrefixContext() *StringExpPrefixContext

+ func NewStringExpPrefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringExpPrefixContext

+ func (*StringExpPrefixContext) IsStringExpPrefixContext()

+ func (s *StringExpPrefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *StringExpPrefixContext) CONTAINS() antlr.TerminalNode

+ func (s *StringExpPrefixContext) ENDS() antlr.TerminalNode

+ func (s *StringExpPrefixContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *StringExpPrefixContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *StringExpPrefixContext) GetParser() antlr.Parser

+ func (s *StringExpPrefixContext) GetRuleContext() antlr.RuleContext

+ func (s *StringExpPrefixContext) STARTS() antlr.TerminalNode

+ func (s *StringExpPrefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *StringExpPrefixContext) WITH() antlr.TerminalNode

+ type StringExpressionContext struct

+ func NewEmptyStringExpressionContext() *StringExpressionContext

+ func NewStringExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringExpressionContext

+ func (*StringExpressionContext) IsStringExpressionContext()

+ func (s *StringExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *StringExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *StringExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *StringExpressionContext) GetParser() antlr.Parser

+ func (s *StringExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *StringExpressionContext) PropertyOrLabelExpression() IPropertyOrLabelExpressionContext

+ func (s *StringExpressionContext) StringExpPrefix() IStringExpPrefixContext

+ func (s *StringExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type StringLitContext struct

+ func NewEmptyStringLitContext() *StringLitContext

+ func NewStringLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringLitContext

+ func (*StringLitContext) IsStringLitContext()

+ func (s *StringLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *StringLitContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *StringLitContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *StringLitContext) GetParser() antlr.Parser

+ func (s *StringLitContext) GetRuleContext() antlr.RuleContext

+ func (s *StringLitContext) STRING_LITERAL() antlr.TerminalNode

+ func (s *StringLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type SubqueryCountContext struct

+ func NewEmptySubqueryCountContext() *SubqueryCountContext

+ func NewSubqueryCountContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SubqueryCountContext

+ func (*SubqueryCountContext) IsSubqueryCountContext()

+ func (s *SubqueryCountContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *SubqueryCountContext) COUNT() antlr.TerminalNode

+ func (s *SubqueryCountContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *SubqueryCountContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *SubqueryCountContext) GetParser() antlr.Parser

+ func (s *SubqueryCountContext) GetRuleContext() antlr.RuleContext

+ func (s *SubqueryCountContext) LBRACE() antlr.TerminalNode

+ func (s *SubqueryCountContext) PatternWhere() IPatternWhereContext

+ func (s *SubqueryCountContext) RBRACE() antlr.TerminalNode

+ func (s *SubqueryCountContext) RegularQuery() IRegularQueryContext

+ func (s *SubqueryCountContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type SubqueryExistContext struct

+ func NewEmptySubqueryExistContext() *SubqueryExistContext

+ func NewSubqueryExistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SubqueryExistContext

+ func (*SubqueryExistContext) IsSubqueryExistContext()

+ func (s *SubqueryExistContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *SubqueryExistContext) EXISTS() antlr.TerminalNode

+ func (s *SubqueryExistContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *SubqueryExistContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *SubqueryExistContext) GetParser() antlr.Parser

+ func (s *SubqueryExistContext) GetRuleContext() antlr.RuleContext

+ func (s *SubqueryExistContext) LBRACE() antlr.TerminalNode

+ func (s *SubqueryExistContext) PatternWhere() IPatternWhereContext

+ func (s *SubqueryExistContext) RBRACE() antlr.TerminalNode

+ func (s *SubqueryExistContext) RegularQuery() IRegularQueryContext

+ func (s *SubqueryExistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type SymbolContext struct

+ func NewEmptySymbolContext() *SymbolContext

+ func NewSymbolContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SymbolContext

+ func (*SymbolContext) IsSymbolContext()

+ func (s *SymbolContext) ANY() antlr.TerminalNode

+ func (s *SymbolContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *SymbolContext) COUNT() antlr.TerminalNode

+ func (s *SymbolContext) ESC_LITERAL() antlr.TerminalNode

+ func (s *SymbolContext) EXTRACT() antlr.TerminalNode

+ func (s *SymbolContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *SymbolContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *SymbolContext) FILTER() antlr.TerminalNode

+ func (s *SymbolContext) GetParser() antlr.Parser

+ func (s *SymbolContext) GetRuleContext() antlr.RuleContext

+ func (s *SymbolContext) ID() antlr.TerminalNode

+ func (s *SymbolContext) NONE() antlr.TerminalNode

+ func (s *SymbolContext) SINGLE() antlr.TerminalNode

+ func (s *SymbolContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type UnaryAddSubExpressionContext struct

+ func NewEmptyUnaryAddSubExpressionContext() *UnaryAddSubExpressionContext

+ func NewUnaryAddSubExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryAddSubExpressionContext

+ func (*UnaryAddSubExpressionContext) IsUnaryAddSubExpressionContext()

+ func (s *UnaryAddSubExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *UnaryAddSubExpressionContext) AtomicExpression() IAtomicExpressionContext

+ func (s *UnaryAddSubExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *UnaryAddSubExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *UnaryAddSubExpressionContext) GetParser() antlr.Parser

+ func (s *UnaryAddSubExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *UnaryAddSubExpressionContext) PLUS() antlr.TerminalNode

+ func (s *UnaryAddSubExpressionContext) SUB() antlr.TerminalNode

+ func (s *UnaryAddSubExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type UnionStContext struct

+ func NewEmptyUnionStContext() *UnionStContext

+ func NewUnionStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnionStContext

+ func (*UnionStContext) IsUnionStContext()

+ func (s *UnionStContext) ALL() antlr.TerminalNode

+ func (s *UnionStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *UnionStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *UnionStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *UnionStContext) GetParser() antlr.Parser

+ func (s *UnionStContext) GetRuleContext() antlr.RuleContext

+ func (s *UnionStContext) SingleQuery() ISingleQueryContext

+ func (s *UnionStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *UnionStContext) UNION() antlr.TerminalNode

+ type UnwindStContext struct

+ func NewEmptyUnwindStContext() *UnwindStContext

+ func NewUnwindStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnwindStContext

+ func (*UnwindStContext) IsUnwindStContext()

+ func (s *UnwindStContext) AS() antlr.TerminalNode

+ func (s *UnwindStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *UnwindStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *UnwindStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *UnwindStContext) Expression() IExpressionContext

+ func (s *UnwindStContext) GetParser() antlr.Parser

+ func (s *UnwindStContext) GetRuleContext() antlr.RuleContext

+ func (s *UnwindStContext) Symbol() ISymbolContext

+ func (s *UnwindStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *UnwindStContext) UNWIND() antlr.TerminalNode

+ type UpdatingStatementContext struct

+ func NewEmptyUpdatingStatementContext() *UpdatingStatementContext

+ func NewUpdatingStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdatingStatementContext

+ func (*UpdatingStatementContext) IsUpdatingStatementContext()

+ func (s *UpdatingStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *UpdatingStatementContext) CreateSt() ICreateStContext

+ func (s *UpdatingStatementContext) DeleteSt() IDeleteStContext

+ func (s *UpdatingStatementContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *UpdatingStatementContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *UpdatingStatementContext) GetParser() antlr.Parser

+ func (s *UpdatingStatementContext) GetRuleContext() antlr.RuleContext

+ func (s *UpdatingStatementContext) MergeSt() IMergeStContext

+ func (s *UpdatingStatementContext) RemoveSt() IRemoveStContext

+ func (s *UpdatingStatementContext) SetSt() ISetStContext

+ func (s *UpdatingStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type WhereContext struct

+ func NewEmptyWhereContext() *WhereContext

+ func NewWhereContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhereContext

+ func (*WhereContext) IsWhereContext()

+ func (s *WhereContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *WhereContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *WhereContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *WhereContext) Expression() IExpressionContext

+ func (s *WhereContext) GetParser() antlr.Parser

+ func (s *WhereContext) GetRuleContext() antlr.RuleContext

+ func (s *WhereContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *WhereContext) WHERE() antlr.TerminalNode

+ type WithStContext struct

+ func NewEmptyWithStContext() *WithStContext

+ func NewWithStContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WithStContext

+ func (*WithStContext) IsWithStContext()

+ func (s *WithStContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *WithStContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *WithStContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *WithStContext) GetParser() antlr.Parser

+ func (s *WithStContext) GetRuleContext() antlr.RuleContext

+ func (s *WithStContext) ProjectionBody() IProjectionBodyContext

+ func (s *WithStContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *WithStContext) WITH() antlr.TerminalNode

+ func (s *WithStContext) Where() IWhereContext

+ type XorExpressionContext struct

+ func NewEmptyXorExpressionContext() *XorExpressionContext

+ func NewXorExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XorExpressionContext

+ func (*XorExpressionContext) IsXorExpressionContext()

+ func (s *XorExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *XorExpressionContext) AllAndExpression() []IAndExpressionContext

+ func (s *XorExpressionContext) AllXOR() []antlr.TerminalNode

+ func (s *XorExpressionContext) AndExpression(i int) IAndExpressionContext

+ func (s *XorExpressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *XorExpressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *XorExpressionContext) GetParser() antlr.Parser

+ func (s *XorExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *XorExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *XorExpressionContext) XOR(i int) antlr.TerminalNode

+ type YieldItemContext struct

+ func NewEmptyYieldItemContext() *YieldItemContext

+ func NewYieldItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *YieldItemContext

+ func (*YieldItemContext) IsYieldItemContext()

+ func (s *YieldItemContext) AS() antlr.TerminalNode

+ func (s *YieldItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *YieldItemContext) AllSymbol() []ISymbolContext

+ func (s *YieldItemContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *YieldItemContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *YieldItemContext) GetParser() antlr.Parser

+ func (s *YieldItemContext) GetRuleContext() antlr.RuleContext

+ func (s *YieldItemContext) Symbol(i int) ISymbolContext

+ func (s *YieldItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type YieldItemsContext struct

+ func NewEmptyYieldItemsContext() *YieldItemsContext

+ func NewYieldItemsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *YieldItemsContext

+ func (*YieldItemsContext) IsYieldItemsContext()

+ func (s *YieldItemsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *YieldItemsContext) AllCOMMA() []antlr.TerminalNode

+ func (s *YieldItemsContext) AllYieldItem() []IYieldItemContext

+ func (s *YieldItemsContext) COMMA(i int) antlr.TerminalNode

+ func (s *YieldItemsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *YieldItemsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *YieldItemsContext) GetParser() antlr.Parser

+ func (s *YieldItemsContext) GetRuleContext() antlr.RuleContext

+ func (s *YieldItemsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *YieldItemsContext) Where() IWhereContext

+ func (s *YieldItemsContext) YieldItem(i int) IYieldItemContext

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL