fql

package

Go to main page

Versions in this module

v0

v0.18.0

Mar 28, 2023

v0.17.0

Feb 7, 2023

Changes in this version

+ func FqlLexerInit()

+ func FqlParserInit()

v0.16.7

Jul 30, 2022

v0.16.6

Feb 11, 2022

v0.16.5

Jan 17, 2022

Changes in this version

+ const FqlParserRULE_unsafeReservedWord

type BaseFqlParserListener

+ func (s *BaseFqlParserListener) EnterUnsafeReservedWord(ctx *UnsafeReservedWordContext)

+ func (s *BaseFqlParserListener) ExitUnsafeReservedWord(ctx *UnsafeReservedWordContext)

type BaseFqlParserVisitor

+ func (v *BaseFqlParserVisitor) VisitUnsafeReservedWord(ctx *UnsafeReservedWordContext) interface{}

type FqlParser

+ func (p *FqlParser) UnsafeReservedWord() (localctx IUnsafeReservedWordContext)

type FqlParserListener

+ EnterUnsafeReservedWord func(c *UnsafeReservedWordContext)

+ ExitUnsafeReservedWord func(c *UnsafeReservedWordContext)

type FqlParserVisitor

+ VisitUnsafeReservedWord func(ctx *UnsafeReservedWordContext) interface{}

type FunctionNameContext

+ func (s *FunctionNameContext) UnsafeReservedWord() IUnsafeReservedWordContext

+ type IUnsafeReservedWordContext interface

+ GetParser func() antlr.Parser

+ IsUnsafeReservedWordContext func()

type ParamContext

+ func (s *ParamContext) SafeReservedWord() ISafeReservedWordContext

type PropertyNameContext

+ func (s *PropertyNameContext) UnsafeReservedWord() IUnsafeReservedWordContext

+ type UnsafeReservedWordContext struct

+ func NewEmptyUnsafeReservedWordContext() *UnsafeReservedWordContext

+ func NewUnsafeReservedWordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnsafeReservedWordContext

+ func (*UnsafeReservedWordContext) IsUnsafeReservedWordContext()

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

+ func (s *UnsafeReservedWordContext) BooleanLiteral() antlr.TerminalNode

+ func (s *UnsafeReservedWordContext) Do() antlr.TerminalNode

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

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

+ func (s *UnsafeReservedWordContext) For() antlr.TerminalNode

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

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

+ func (s *UnsafeReservedWordContext) In() antlr.TerminalNode

+ func (s *UnsafeReservedWordContext) Let() antlr.TerminalNode

+ func (s *UnsafeReservedWordContext) Like() antlr.TerminalNode

+ func (s *UnsafeReservedWordContext) None() antlr.TerminalNode

+ func (s *UnsafeReservedWordContext) Not() antlr.TerminalNode

+ func (s *UnsafeReservedWordContext) Null() antlr.TerminalNode

+ func (s *UnsafeReservedWordContext) Return() antlr.TerminalNode

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

+ func (s *UnsafeReservedWordContext) Use() antlr.TerminalNode

+ func (s *UnsafeReservedWordContext) Waitfor() antlr.TerminalNode

+ func (s *UnsafeReservedWordContext) While() antlr.TerminalNode

v0.16.4

Jan 3, 2022

v0.16.3

Dec 23, 2021

v0.16.2

Dec 13, 2021

Changes in this version

type LimitClauseValueContext

+ func (s *LimitClauseValueContext) FunctionCallExpression() IFunctionCallExpressionContext

+ func (s *LimitClauseValueContext) MemberExpression() IMemberExpressionContext

+ func (s *LimitClauseValueContext) Variable() IVariableContext

v0.16.1

Dec 9, 2021

v0.16.0

Nov 22, 2021

Changes in this version

+ const FqlLexerCurrent

+ const FqlLexerEvent

+ const FqlLexerIgnoreIdentifier

+ const FqlLexerOptions

+ const FqlLexerTimeout

+ const FqlLexerUnknownIdentifier

+ const FqlLexerWaitfor

+ const FqlParserCurrent

+ const FqlParserEvent

+ const FqlParserIgnoreIdentifier

+ const FqlParserOptions

+ const FqlParserRULE_argumentList

+ const FqlParserRULE_errorOperator

+ const FqlParserRULE_expressionAtom

+ const FqlParserRULE_functionCall

+ const FqlParserRULE_functionName

+ const FqlParserRULE_literal

+ const FqlParserRULE_memberExpressionPath

+ const FqlParserRULE_memberExpressionSource

+ const FqlParserRULE_optionsClause

+ const FqlParserRULE_predicate

+ const FqlParserRULE_rangeOperand

+ const FqlParserRULE_safeReservedWord

+ const FqlParserRULE_timeoutClause

+ const FqlParserRULE_unsafReservedWord

+ const FqlParserRULE_waitForEventName

+ const FqlParserRULE_waitForEventSource

+ const FqlParserRULE_waitForExpression

+ const FqlParserTimeout

+ const FqlParserUnknownIdentifier

+ const FqlParserWaitfor

+ type ArgumentListContext struct

+ func NewArgumentListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentListContext

+ func NewEmptyArgumentListContext() *ArgumentListContext

+ func (*ArgumentListContext) IsArgumentListContext()

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

+ func (s *ArgumentListContext) AllComma() []antlr.TerminalNode

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

+ func (s *ArgumentListContext) Comma(i int) antlr.TerminalNode

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

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

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

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

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

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

type ArrayLiteralContext

+ func (s *ArrayLiteralContext) ArgumentList() IArgumentListContext

type ArrayOperatorContext

+ func (s *ArrayOperatorContext) EqualityOperator() IEqualityOperatorContext

+ func (s *ArrayOperatorContext) GetOperator() antlr.Token

+ func (s *ArrayOperatorContext) InOperator() IInOperatorContext

+ func (s *ArrayOperatorContext) SetOperator(v antlr.Token)

type BaseFqlParserListener

+ func (s *BaseFqlParserListener) EnterArgumentList(ctx *ArgumentListContext)

+ func (s *BaseFqlParserListener) EnterErrorOperator(ctx *ErrorOperatorContext)

+ func (s *BaseFqlParserListener) EnterExpressionAtom(ctx *ExpressionAtomContext)

+ func (s *BaseFqlParserListener) EnterFunctionCall(ctx *FunctionCallContext)

+ func (s *BaseFqlParserListener) EnterFunctionName(ctx *FunctionNameContext)

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

+ func (s *BaseFqlParserListener) EnterMemberExpressionPath(ctx *MemberExpressionPathContext)

+ func (s *BaseFqlParserListener) EnterMemberExpressionSource(ctx *MemberExpressionSourceContext)

+ func (s *BaseFqlParserListener) EnterOptionsClause(ctx *OptionsClauseContext)

+ func (s *BaseFqlParserListener) EnterPredicate(ctx *PredicateContext)

+ func (s *BaseFqlParserListener) EnterRangeOperand(ctx *RangeOperandContext)

+ func (s *BaseFqlParserListener) EnterSafeReservedWord(ctx *SafeReservedWordContext)

+ func (s *BaseFqlParserListener) EnterTimeoutClause(ctx *TimeoutClauseContext)

+ func (s *BaseFqlParserListener) EnterUnsafReservedWord(ctx *UnsafReservedWordContext)

+ func (s *BaseFqlParserListener) EnterWaitForEventName(ctx *WaitForEventNameContext)

+ func (s *BaseFqlParserListener) EnterWaitForEventSource(ctx *WaitForEventSourceContext)

+ func (s *BaseFqlParserListener) EnterWaitForExpression(ctx *WaitForExpressionContext)

+ func (s *BaseFqlParserListener) ExitArgumentList(ctx *ArgumentListContext)

+ func (s *BaseFqlParserListener) ExitErrorOperator(ctx *ErrorOperatorContext)

+ func (s *BaseFqlParserListener) ExitExpressionAtom(ctx *ExpressionAtomContext)

+ func (s *BaseFqlParserListener) ExitFunctionCall(ctx *FunctionCallContext)

+ func (s *BaseFqlParserListener) ExitFunctionName(ctx *FunctionNameContext)

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

+ func (s *BaseFqlParserListener) ExitMemberExpressionPath(ctx *MemberExpressionPathContext)

+ func (s *BaseFqlParserListener) ExitMemberExpressionSource(ctx *MemberExpressionSourceContext)

+ func (s *BaseFqlParserListener) ExitOptionsClause(ctx *OptionsClauseContext)

+ func (s *BaseFqlParserListener) ExitPredicate(ctx *PredicateContext)

+ func (s *BaseFqlParserListener) ExitRangeOperand(ctx *RangeOperandContext)

+ func (s *BaseFqlParserListener) ExitSafeReservedWord(ctx *SafeReservedWordContext)

+ func (s *BaseFqlParserListener) ExitTimeoutClause(ctx *TimeoutClauseContext)

+ func (s *BaseFqlParserListener) ExitUnsafReservedWord(ctx *UnsafReservedWordContext)

+ func (s *BaseFqlParserListener) ExitWaitForEventName(ctx *WaitForEventNameContext)

+ func (s *BaseFqlParserListener) ExitWaitForEventSource(ctx *WaitForEventSourceContext)

+ func (s *BaseFqlParserListener) ExitWaitForExpression(ctx *WaitForExpressionContext)

type BaseFqlParserVisitor

+ func (v *BaseFqlParserVisitor) VisitArgumentList(ctx *ArgumentListContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitErrorOperator(ctx *ErrorOperatorContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitExpressionAtom(ctx *ExpressionAtomContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitFunctionCall(ctx *FunctionCallContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitFunctionName(ctx *FunctionNameContext) interface{}

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

+ func (v *BaseFqlParserVisitor) VisitMemberExpressionPath(ctx *MemberExpressionPathContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitMemberExpressionSource(ctx *MemberExpressionSourceContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitOptionsClause(ctx *OptionsClauseContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitPredicate(ctx *PredicateContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitRangeOperand(ctx *RangeOperandContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitSafeReservedWord(ctx *SafeReservedWordContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitTimeoutClause(ctx *TimeoutClauseContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitUnsafReservedWord(ctx *UnsafReservedWordContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitWaitForEventName(ctx *WaitForEventNameContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitWaitForEventSource(ctx *WaitForEventSourceContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitWaitForExpression(ctx *WaitForExpressionContext) interface{}

type BodyStatementContext

+ func (s *BodyStatementContext) WaitForExpression() IWaitForExpressionContext

+ type ErrorOperatorContext struct

+ func NewEmptyErrorOperatorContext() *ErrorOperatorContext

+ func NewErrorOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ErrorOperatorContext

+ func (*ErrorOperatorContext) IsErrorOperatorContext()

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

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

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

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

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

+ func (s *ErrorOperatorContext) QuestionMark() antlr.TerminalNode

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

+ type ExpressionAtomContext struct

+ func NewEmptyExpressionAtomContext() *ExpressionAtomContext

+ func NewExpressionAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionAtomContext

+ func (*ExpressionAtomContext) IsExpressionAtomContext()

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

+ func (s *ExpressionAtomContext) AdditiveOperator() IAdditiveOperatorContext

+ func (s *ExpressionAtomContext) AllExpressionAtom() []IExpressionAtomContext

+ func (s *ExpressionAtomContext) CloseParen() antlr.TerminalNode

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

+ func (s *ExpressionAtomContext) ErrorOperator() IErrorOperatorContext

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

+ func (s *ExpressionAtomContext) Expression() IExpressionContext

+ func (s *ExpressionAtomContext) ExpressionAtom(i int) IExpressionAtomContext

+ func (s *ExpressionAtomContext) ForExpression() IForExpressionContext

+ func (s *ExpressionAtomContext) FunctionCallExpression() IFunctionCallExpressionContext

+ func (s *ExpressionAtomContext) GetLeft() IExpressionAtomContext

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

+ func (s *ExpressionAtomContext) GetRight() IExpressionAtomContext

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

+ func (s *ExpressionAtomContext) Literal() ILiteralContext

+ func (s *ExpressionAtomContext) MemberExpression() IMemberExpressionContext

+ func (s *ExpressionAtomContext) MultiplicativeOperator() IMultiplicativeOperatorContext

+ func (s *ExpressionAtomContext) OpenParen() antlr.TerminalNode

+ func (s *ExpressionAtomContext) Param() IParamContext

+ func (s *ExpressionAtomContext) RangeOperator() IRangeOperatorContext

+ func (s *ExpressionAtomContext) RegexpOperator() IRegexpOperatorContext

+ func (s *ExpressionAtomContext) SetLeft(v IExpressionAtomContext)

+ func (s *ExpressionAtomContext) SetRight(v IExpressionAtomContext)

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

+ func (s *ExpressionAtomContext) Variable() IVariableContext

+ func (s *ExpressionAtomContext) WaitForExpression() IWaitForExpressionContext

type ExpressionContext

+ func (s *ExpressionContext) GetCondition() IExpressionContext

+ func (s *ExpressionContext) GetLeft() IExpressionContext

+ func (s *ExpressionContext) GetOnFalse() IExpressionContext

+ func (s *ExpressionContext) GetOnTrue() IExpressionContext

+ func (s *ExpressionContext) GetRight() IExpressionContext

+ func (s *ExpressionContext) GetTernaryOperator() antlr.Token

+ func (s *ExpressionContext) Predicate() IPredicateContext

+ func (s *ExpressionContext) SetCondition(v IExpressionContext)

+ func (s *ExpressionContext) SetLeft(v IExpressionContext)

+ func (s *ExpressionContext) SetOnFalse(v IExpressionContext)

+ func (s *ExpressionContext) SetOnTrue(v IExpressionContext)

+ func (s *ExpressionContext) SetRight(v IExpressionContext)

+ func (s *ExpressionContext) SetTernaryOperator(v antlr.Token)

type ForExpressionContext

+ func (s *ForExpressionContext) AllIdentifier() []antlr.TerminalNode

+ func (s *ForExpressionContext) GetCounterVariable() antlr.Token

+ func (s *ForExpressionContext) GetValueVariable() antlr.Token

+ func (s *ForExpressionContext) Identifier(i int) antlr.TerminalNode

+ func (s *ForExpressionContext) IgnoreIdentifier() antlr.TerminalNode

+ func (s *ForExpressionContext) SetCounterVariable(v antlr.Token)

+ func (s *ForExpressionContext) SetValueVariable(v antlr.Token)

type FqlParser

+ func (p *FqlParser) ArgumentList() (localctx IArgumentListContext)

+ func (p *FqlParser) ErrorOperator() (localctx IErrorOperatorContext)

+ func (p *FqlParser) ExpressionAtom() (localctx IExpressionAtomContext)

+ func (p *FqlParser) ExpressionAtom_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *FqlParser) FunctionCall() (localctx IFunctionCallContext)

+ func (p *FqlParser) FunctionName() (localctx IFunctionNameContext)

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

+ func (p *FqlParser) MemberExpressionPath() (localctx IMemberExpressionPathContext)

+ func (p *FqlParser) MemberExpressionSource() (localctx IMemberExpressionSourceContext)

+ func (p *FqlParser) OptionsClause() (localctx IOptionsClauseContext)

+ func (p *FqlParser) Predicate() (localctx IPredicateContext)

+ func (p *FqlParser) Predicate_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *FqlParser) RangeOperand() (localctx IRangeOperandContext)

+ func (p *FqlParser) SafeReservedWord() (localctx ISafeReservedWordContext)

+ func (p *FqlParser) TimeoutClause() (localctx ITimeoutClauseContext)

+ func (p *FqlParser) UnsafReservedWord() (localctx IUnsafReservedWordContext)

+ func (p *FqlParser) WaitForEventName() (localctx IWaitForEventNameContext)

+ func (p *FqlParser) WaitForEventSource() (localctx IWaitForEventSourceContext)

+ func (p *FqlParser) WaitForExpression() (localctx IWaitForExpressionContext)

type FqlParserListener

+ EnterArgumentList func(c *ArgumentListContext)

+ EnterErrorOperator func(c *ErrorOperatorContext)

+ EnterExpressionAtom func(c *ExpressionAtomContext)

+ EnterFunctionCall func(c *FunctionCallContext)

+ EnterFunctionName func(c *FunctionNameContext)

+ EnterLiteral func(c *LiteralContext)

+ EnterMemberExpressionPath func(c *MemberExpressionPathContext)

+ EnterMemberExpressionSource func(c *MemberExpressionSourceContext)

+ EnterOptionsClause func(c *OptionsClauseContext)

+ EnterPredicate func(c *PredicateContext)

+ EnterRangeOperand func(c *RangeOperandContext)

+ EnterSafeReservedWord func(c *SafeReservedWordContext)

+ EnterTimeoutClause func(c *TimeoutClauseContext)

+ EnterUnsafReservedWord func(c *UnsafReservedWordContext)

+ EnterWaitForEventName func(c *WaitForEventNameContext)

+ EnterWaitForEventSource func(c *WaitForEventSourceContext)

+ EnterWaitForExpression func(c *WaitForExpressionContext)

+ ExitArgumentList func(c *ArgumentListContext)

+ ExitErrorOperator func(c *ErrorOperatorContext)

+ ExitExpressionAtom func(c *ExpressionAtomContext)

+ ExitFunctionCall func(c *FunctionCallContext)

+ ExitFunctionName func(c *FunctionNameContext)

+ ExitLiteral func(c *LiteralContext)

+ ExitMemberExpressionPath func(c *MemberExpressionPathContext)

+ ExitMemberExpressionSource func(c *MemberExpressionSourceContext)

+ ExitOptionsClause func(c *OptionsClauseContext)

+ ExitPredicate func(c *PredicateContext)

+ ExitRangeOperand func(c *RangeOperandContext)

+ ExitSafeReservedWord func(c *SafeReservedWordContext)

+ ExitTimeoutClause func(c *TimeoutClauseContext)

+ ExitUnsafReservedWord func(c *UnsafReservedWordContext)

+ ExitWaitForEventName func(c *WaitForEventNameContext)

+ ExitWaitForEventSource func(c *WaitForEventSourceContext)

+ ExitWaitForExpression func(c *WaitForExpressionContext)

type FqlParserVisitor

+ VisitArgumentList func(ctx *ArgumentListContext) interface{}

+ VisitErrorOperator func(ctx *ErrorOperatorContext) interface{}

+ VisitExpressionAtom func(ctx *ExpressionAtomContext) interface{}

+ VisitFunctionCall func(ctx *FunctionCallContext) interface{}

+ VisitFunctionName func(ctx *FunctionNameContext) interface{}

+ VisitLiteral func(ctx *LiteralContext) interface{}

+ VisitMemberExpressionPath func(ctx *MemberExpressionPathContext) interface{}

+ VisitMemberExpressionSource func(ctx *MemberExpressionSourceContext) interface{}

+ VisitOptionsClause func(ctx *OptionsClauseContext) interface{}

+ VisitPredicate func(ctx *PredicateContext) interface{}

+ VisitRangeOperand func(ctx *RangeOperandContext) interface{}

+ VisitSafeReservedWord func(ctx *SafeReservedWordContext) interface{}

+ VisitTimeoutClause func(ctx *TimeoutClauseContext) interface{}

+ VisitUnsafReservedWord func(ctx *UnsafReservedWordContext) interface{}

+ VisitWaitForEventName func(ctx *WaitForEventNameContext) interface{}

+ VisitWaitForEventSource func(ctx *WaitForEventSourceContext) interface{}

+ VisitWaitForExpression func(ctx *WaitForExpressionContext) interface{}

+ type FunctionCallContext struct

+ func NewEmptyFunctionCallContext() *FunctionCallContext

+ func NewFunctionCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallContext

+ func (*FunctionCallContext) IsFunctionCallContext()

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

+ func (s *FunctionCallContext) ArgumentList() IArgumentListContext

+ func (s *FunctionCallContext) CloseParen() antlr.TerminalNode

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

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

+ func (s *FunctionCallContext) FunctionName() IFunctionNameContext

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

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

+ func (s *FunctionCallContext) Namespace() INamespaceContext

+ func (s *FunctionCallContext) OpenParen() antlr.TerminalNode

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

type FunctionCallExpressionContext

+ func (s *FunctionCallExpressionContext) ErrorOperator() IErrorOperatorContext

+ func (s *FunctionCallExpressionContext) FunctionCall() IFunctionCallContext

+ type FunctionNameContext struct

+ func NewEmptyFunctionNameContext() *FunctionNameContext

+ func NewFunctionNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionNameContext

+ func (*FunctionNameContext) IsFunctionNameContext()

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

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

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

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

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

+ func (s *FunctionNameContext) Identifier() antlr.TerminalNode

+ func (s *FunctionNameContext) SafeReservedWord() ISafeReservedWordContext

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

+ func (s *FunctionNameContext) UnsafReservedWord() IUnsafReservedWordContext

+ type IArgumentListContext interface

+ GetParser func() antlr.Parser

+ IsArgumentListContext func()

type IArrayOperatorContext

+ GetOperator func() antlr.Token

+ SetOperator func(antlr.Token)

+ type IErrorOperatorContext interface

+ GetParser func() antlr.Parser

+ IsErrorOperatorContext func()

+ type IExpressionAtomContext interface

+ GetLeft func() IExpressionAtomContext

+ GetParser func() antlr.Parser

+ GetRight func() IExpressionAtomContext

+ IsExpressionAtomContext func()

+ SetLeft func(IExpressionAtomContext)

+ SetRight func(IExpressionAtomContext)

type IExpressionContext

+ GetCondition func() IExpressionContext

+ GetLeft func() IExpressionContext

+ GetOnFalse func() IExpressionContext

+ GetOnTrue func() IExpressionContext

+ GetRight func() IExpressionContext

+ GetTernaryOperator func() antlr.Token

+ SetCondition func(IExpressionContext)

+ SetLeft func(IExpressionContext)

+ SetOnFalse func(IExpressionContext)

+ SetOnTrue func(IExpressionContext)

+ SetRight func(IExpressionContext)

+ SetTernaryOperator func(antlr.Token)

type IForExpressionContext

+ GetCounterVariable func() antlr.Token

+ GetValueVariable func() antlr.Token

+ SetCounterVariable func(antlr.Token)

+ SetValueVariable func(antlr.Token)

+ type IFunctionCallContext interface

+ GetParser func() antlr.Parser

+ IsFunctionCallContext func()

+ type IFunctionNameContext interface

+ GetParser func() antlr.Parser

+ IsFunctionNameContext func()

+ type ILiteralContext interface

+ GetParser func() antlr.Parser

+ IsLiteralContext func()

+ type IMemberExpressionPathContext interface

+ GetParser func() antlr.Parser

+ IsMemberExpressionPathContext func()

+ type IMemberExpressionSourceContext interface

+ GetParser func() antlr.Parser

+ IsMemberExpressionSourceContext func()

+ type IOptionsClauseContext interface

+ GetParser func() antlr.Parser

+ IsOptionsClauseContext func()

+ type IPredicateContext interface

+ GetLeft func() IPredicateContext

+ GetParser func() antlr.Parser

+ GetRight func() IPredicateContext

+ IsPredicateContext func()

+ SetLeft func(IPredicateContext)

+ SetRight func(IPredicateContext)

+ type IRangeOperandContext interface

+ GetParser func() antlr.Parser

+ IsRangeOperandContext func()

type IRangeOperatorContext

+ GetLeft func() IRangeOperandContext

+ GetRight func() IRangeOperandContext

+ SetLeft func(IRangeOperandContext)

+ SetRight func(IRangeOperandContext)

+ type ISafeReservedWordContext interface

+ GetParser func() antlr.Parser

+ IsSafeReservedWordContext func()

+ type ITimeoutClauseContext interface

+ GetParser func() antlr.Parser

+ IsTimeoutClauseContext func()

+ type IUnsafReservedWordContext interface

+ GetParser func() antlr.Parser

+ IsUnsafReservedWordContext func()

type IVariableDeclarationContext

+ GetId func() antlr.Token

+ SetId func(antlr.Token)

+ type IWaitForEventNameContext interface

+ GetParser func() antlr.Parser

+ IsWaitForEventNameContext func()

+ type IWaitForEventSourceContext interface

+ GetParser func() antlr.Parser

+ IsWaitForEventSourceContext func()

+ type IWaitForExpressionContext interface

+ GetParser func() antlr.Parser

+ IsWaitForExpressionContext func()

+ 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) ArrayLiteral() IArrayLiteralContext

+ func (s *LiteralContext) BooleanLiteral() IBooleanLiteralContext

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

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

+ func (s *LiteralContext) FloatLiteral() IFloatLiteralContext

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

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

+ func (s *LiteralContext) IntegerLiteral() IIntegerLiteralContext

+ func (s *LiteralContext) NoneLiteral() INoneLiteralContext

+ func (s *LiteralContext) ObjectLiteral() IObjectLiteralContext

+ func (s *LiteralContext) StringLiteral() IStringLiteralContext

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

type MemberExpressionContext

+ func (s *MemberExpressionContext) AllMemberExpressionPath() []IMemberExpressionPathContext

+ func (s *MemberExpressionContext) MemberExpressionPath(i int) IMemberExpressionPathContext

+ func (s *MemberExpressionContext) MemberExpressionSource() IMemberExpressionSourceContext

+ type MemberExpressionPathContext struct

+ func NewEmptyMemberExpressionPathContext() *MemberExpressionPathContext

+ func NewMemberExpressionPathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberExpressionPathContext

+ func (*MemberExpressionPathContext) IsMemberExpressionPathContext()

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

+ func (s *MemberExpressionPathContext) ComputedPropertyName() IComputedPropertyNameContext

+ func (s *MemberExpressionPathContext) Dot() antlr.TerminalNode

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

+ func (s *MemberExpressionPathContext) ErrorOperator() IErrorOperatorContext

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

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

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

+ func (s *MemberExpressionPathContext) PropertyName() IPropertyNameContext

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

+ type MemberExpressionSourceContext struct

+ func NewEmptyMemberExpressionSourceContext() *MemberExpressionSourceContext

+ func NewMemberExpressionSourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberExpressionSourceContext

+ func (*MemberExpressionSourceContext) IsMemberExpressionSourceContext()

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

+ func (s *MemberExpressionSourceContext) ArrayLiteral() IArrayLiteralContext

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

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

+ func (s *MemberExpressionSourceContext) FunctionCall() IFunctionCallContext

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

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

+ func (s *MemberExpressionSourceContext) ObjectLiteral() IObjectLiteralContext

+ func (s *MemberExpressionSourceContext) Param() IParamContext

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

+ func (s *MemberExpressionSourceContext) Variable() IVariableContext

+ type OptionsClauseContext struct

+ func NewEmptyOptionsClauseContext() *OptionsClauseContext

+ func NewOptionsClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionsClauseContext

+ func (*OptionsClauseContext) IsOptionsClauseContext()

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

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

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

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

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

+ func (s *OptionsClauseContext) ObjectLiteral() IObjectLiteralContext

+ func (s *OptionsClauseContext) Options() antlr.TerminalNode

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

+ type PredicateContext struct

+ func NewEmptyPredicateContext() *PredicateContext

+ func NewPredicateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PredicateContext

+ func (*PredicateContext) IsPredicateContext()

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

+ func (s *PredicateContext) AllPredicate() []IPredicateContext

+ func (s *PredicateContext) ArrayOperator() IArrayOperatorContext

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

+ func (s *PredicateContext) EqualityOperator() IEqualityOperatorContext

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

+ func (s *PredicateContext) ExpressionAtom() IExpressionAtomContext

+ func (s *PredicateContext) GetLeft() IPredicateContext

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

+ func (s *PredicateContext) GetRight() IPredicateContext

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

+ func (s *PredicateContext) InOperator() IInOperatorContext

+ func (s *PredicateContext) LikeOperator() ILikeOperatorContext

+ func (s *PredicateContext) Predicate(i int) IPredicateContext

+ func (s *PredicateContext) SetLeft(v IPredicateContext)

+ func (s *PredicateContext) SetRight(v IPredicateContext)

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

type PropertyAssignmentContext

+ func (s *PropertyAssignmentContext) Variable() IVariableContext

type PropertyNameContext

+ func (s *PropertyNameContext) SafeReservedWord() ISafeReservedWordContext

+ func (s *PropertyNameContext) UnsafReservedWord() IUnsafReservedWordContext

+ type RangeOperandContext struct

+ func NewEmptyRangeOperandContext() *RangeOperandContext

+ func NewRangeOperandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RangeOperandContext

+ func (*RangeOperandContext) IsRangeOperandContext()

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

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

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

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

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

+ func (s *RangeOperandContext) IntegerLiteral() IIntegerLiteralContext

+ func (s *RangeOperandContext) Param() IParamContext

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

+ func (s *RangeOperandContext) Variable() IVariableContext

type RangeOperatorContext

+ func (s *RangeOperatorContext) AllRangeOperand() []IRangeOperandContext

+ func (s *RangeOperatorContext) GetLeft() IRangeOperandContext

+ func (s *RangeOperatorContext) GetRight() IRangeOperandContext

+ func (s *RangeOperatorContext) RangeOperand(i int) IRangeOperandContext

+ func (s *RangeOperatorContext) SetLeft(v IRangeOperandContext)

+ func (s *RangeOperatorContext) SetRight(v IRangeOperandContext)

+ type SafeReservedWordContext struct

+ func NewEmptySafeReservedWordContext() *SafeReservedWordContext

+ func NewSafeReservedWordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SafeReservedWordContext

+ func (*SafeReservedWordContext) IsSafeReservedWordContext()

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

+ func (s *SafeReservedWordContext) Aggregate() antlr.TerminalNode

+ func (s *SafeReservedWordContext) All() antlr.TerminalNode

+ func (s *SafeReservedWordContext) And() antlr.TerminalNode

+ func (s *SafeReservedWordContext) Any() antlr.TerminalNode

+ func (s *SafeReservedWordContext) Collect() antlr.TerminalNode

+ func (s *SafeReservedWordContext) Count() antlr.TerminalNode

+ func (s *SafeReservedWordContext) Current() antlr.TerminalNode

+ func (s *SafeReservedWordContext) Distinct() antlr.TerminalNode

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

+ func (s *SafeReservedWordContext) Event() antlr.TerminalNode

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

+ func (s *SafeReservedWordContext) Filter() antlr.TerminalNode

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

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

+ func (s *SafeReservedWordContext) Into() antlr.TerminalNode

+ func (s *SafeReservedWordContext) Keep() antlr.TerminalNode

+ func (s *SafeReservedWordContext) Limit() antlr.TerminalNode

+ func (s *SafeReservedWordContext) Options() antlr.TerminalNode

+ func (s *SafeReservedWordContext) Or() antlr.TerminalNode

+ func (s *SafeReservedWordContext) Sort() antlr.TerminalNode

+ func (s *SafeReservedWordContext) SortDirection() antlr.TerminalNode

+ func (s *SafeReservedWordContext) Timeout() antlr.TerminalNode

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

+ func (s *SafeReservedWordContext) With() antlr.TerminalNode

+ type TimeoutClauseContext struct

+ func NewEmptyTimeoutClauseContext() *TimeoutClauseContext

+ func NewTimeoutClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TimeoutClauseContext

+ func (*TimeoutClauseContext) IsTimeoutClauseContext()

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

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

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

+ func (s *TimeoutClauseContext) FunctionCall() IFunctionCallContext

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

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

+ func (s *TimeoutClauseContext) IntegerLiteral() IIntegerLiteralContext

+ func (s *TimeoutClauseContext) MemberExpression() IMemberExpressionContext

+ func (s *TimeoutClauseContext) Param() IParamContext

+ func (s *TimeoutClauseContext) Timeout() antlr.TerminalNode

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

+ func (s *TimeoutClauseContext) Variable() IVariableContext

+ type UnsafReservedWordContext struct

+ func NewEmptyUnsafReservedWordContext() *UnsafReservedWordContext

+ func NewUnsafReservedWordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnsafReservedWordContext

+ func (*UnsafReservedWordContext) IsUnsafReservedWordContext()

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

+ func (s *UnsafReservedWordContext) BooleanLiteral() antlr.TerminalNode

+ func (s *UnsafReservedWordContext) Do() antlr.TerminalNode

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

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

+ func (s *UnsafReservedWordContext) For() antlr.TerminalNode

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

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

+ func (s *UnsafReservedWordContext) In() antlr.TerminalNode

+ func (s *UnsafReservedWordContext) Let() antlr.TerminalNode

+ func (s *UnsafReservedWordContext) Like() antlr.TerminalNode

+ func (s *UnsafReservedWordContext) None() antlr.TerminalNode

+ func (s *UnsafReservedWordContext) Not() antlr.TerminalNode

+ func (s *UnsafReservedWordContext) Null() antlr.TerminalNode

+ func (s *UnsafReservedWordContext) Return() antlr.TerminalNode

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

+ func (s *UnsafReservedWordContext) Use() antlr.TerminalNode

+ func (s *UnsafReservedWordContext) Waitfor() antlr.TerminalNode

+ func (s *UnsafReservedWordContext) While() antlr.TerminalNode

type VariableContext

+ func (s *VariableContext) SafeReservedWord() ISafeReservedWordContext

type VariableDeclarationContext

+ func (s *VariableDeclarationContext) GetId() antlr.Token

+ func (s *VariableDeclarationContext) IgnoreIdentifier() antlr.TerminalNode

+ func (s *VariableDeclarationContext) SafeReservedWord() ISafeReservedWordContext

+ func (s *VariableDeclarationContext) SetId(v antlr.Token)

+ type WaitForEventNameContext struct

+ func NewEmptyWaitForEventNameContext() *WaitForEventNameContext

+ func NewWaitForEventNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WaitForEventNameContext

+ func (*WaitForEventNameContext) IsWaitForEventNameContext()

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

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

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

+ func (s *WaitForEventNameContext) FunctionCallExpression() IFunctionCallExpressionContext

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

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

+ func (s *WaitForEventNameContext) MemberExpression() IMemberExpressionContext

+ func (s *WaitForEventNameContext) Param() IParamContext

+ func (s *WaitForEventNameContext) StringLiteral() IStringLiteralContext

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

+ func (s *WaitForEventNameContext) Variable() IVariableContext

+ type WaitForEventSourceContext struct

+ func NewEmptyWaitForEventSourceContext() *WaitForEventSourceContext

+ func NewWaitForEventSourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WaitForEventSourceContext

+ func (*WaitForEventSourceContext) IsWaitForEventSourceContext()

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

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

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

+ func (s *WaitForEventSourceContext) FunctionCallExpression() IFunctionCallExpressionContext

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

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

+ func (s *WaitForEventSourceContext) MemberExpression() IMemberExpressionContext

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

+ func (s *WaitForEventSourceContext) Variable() IVariableContext

+ type WaitForExpressionContext struct

+ func NewEmptyWaitForExpressionContext() *WaitForExpressionContext

+ func NewWaitForExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WaitForExpressionContext

+ func (*WaitForExpressionContext) IsWaitForExpressionContext()

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

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

+ func (s *WaitForExpressionContext) Event() antlr.TerminalNode

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

+ func (s *WaitForExpressionContext) FilterClause() IFilterClauseContext

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

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

+ func (s *WaitForExpressionContext) In() antlr.TerminalNode

+ func (s *WaitForExpressionContext) OptionsClause() IOptionsClauseContext

+ func (s *WaitForExpressionContext) TimeoutClause() ITimeoutClauseContext

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

+ func (s *WaitForExpressionContext) WaitForEventName() IWaitForEventNameContext

+ func (s *WaitForExpressionContext) WaitForEventSource() IWaitForEventSourceContext

+ func (s *WaitForExpressionContext) Waitfor() antlr.TerminalNode

v0.16.0-rc.7

Oct 18, 2021

v0.16.0-rc.6

Oct 16, 2021

v0.16.0-rc.5

Sep 20, 2021

v0.16.0-rc.4

Sep 20, 2021

v0.16.0-rc.3

Sep 19, 2021

v0.16.0-rc.2

Sep 17, 2021

v0.16.0-rc.1

Sep 9, 2021

v0.15.0

Apr 23, 2021

Changes in this version

type MemberContext

+ func (s *MemberContext) ArrayLiteral() IArrayLiteralContext

+ func (s *MemberContext) ObjectLiteral() IObjectLiteralContext

v0.14.1

Mar 27, 2021

v0.14.0

Mar 5, 2021

Changes in this version

+ const FqlParserRULE_likeOperator

type BaseFqlParserListener

+ func (s *BaseFqlParserListener) EnterLikeOperator(ctx *LikeOperatorContext)

+ func (s *BaseFqlParserListener) ExitLikeOperator(ctx *LikeOperatorContext)

type BaseFqlParserVisitor

+ func (v *BaseFqlParserVisitor) VisitLikeOperator(ctx *LikeOperatorContext) interface{}

type ExpressionContext

+ func (s *ExpressionContext) LikeOperator() ILikeOperatorContext

type FqlParser

+ func (p *FqlParser) LikeOperator() (localctx ILikeOperatorContext)

type FqlParserListener

+ EnterLikeOperator func(c *LikeOperatorContext)

+ ExitLikeOperator func(c *LikeOperatorContext)

type FqlParserVisitor

+ VisitLikeOperator func(ctx *LikeOperatorContext) interface{}

+ type ILikeOperatorContext interface

+ GetParser func() antlr.Parser

+ IsLikeOperatorContext func()

+ type LikeOperatorContext struct

+ func NewEmptyLikeOperatorContext() *LikeOperatorContext

+ func NewLikeOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LikeOperatorContext

+ func (*LikeOperatorContext) IsLikeOperatorContext()

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

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

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

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

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

+ func (s *LikeOperatorContext) Like() antlr.TerminalNode

+ func (s *LikeOperatorContext) Not() antlr.TerminalNode

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

v0.13.0

Nov 24, 2020

Changes in this version

+ const FqlLexerDo

+ const FqlLexerWhile

+ const FqlParserDo

+ const FqlParserWhile

type ForExpressionContext

+ func (s *ForExpressionContext) Do() antlr.TerminalNode

+ func (s *ForExpressionContext) Expression() IExpressionContext

+ func (s *ForExpressionContext) While() antlr.TerminalNode

v0.12.1

Oct 22, 2020

v0.12.0

Sep 15, 2020

v0.11.1

May 27, 2020

v0.11.0

May 21, 2020

Changes in this version

+ const FqlLexerUse

+ const FqlParserRULE_functionIdentifier

+ const FqlParserRULE_head

+ const FqlParserRULE_namespaceIdentifier

+ const FqlParserRULE_use

+ const FqlParserRULE_useExpression

+ const FqlParserUse

type BaseFqlParserListener

+ func (s *BaseFqlParserListener) EnterFunctionIdentifier(ctx *FunctionIdentifierContext)

+ func (s *BaseFqlParserListener) EnterHead(ctx *HeadContext)

+ func (s *BaseFqlParserListener) EnterNamespaceIdentifier(ctx *NamespaceIdentifierContext)

+ func (s *BaseFqlParserListener) EnterUse(ctx *UseContext)

+ func (s *BaseFqlParserListener) EnterUseExpression(ctx *UseExpressionContext)

+ func (s *BaseFqlParserListener) ExitFunctionIdentifier(ctx *FunctionIdentifierContext)

+ func (s *BaseFqlParserListener) ExitHead(ctx *HeadContext)

+ func (s *BaseFqlParserListener) ExitNamespaceIdentifier(ctx *NamespaceIdentifierContext)

+ func (s *BaseFqlParserListener) ExitUse(ctx *UseContext)

+ func (s *BaseFqlParserListener) ExitUseExpression(ctx *UseExpressionContext)

type BaseFqlParserVisitor

+ func (v *BaseFqlParserVisitor) VisitFunctionIdentifier(ctx *FunctionIdentifierContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitHead(ctx *HeadContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitNamespaceIdentifier(ctx *NamespaceIdentifierContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitUse(ctx *UseContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitUseExpression(ctx *UseExpressionContext) interface{}

type FqlParser

+ func (p *FqlParser) FunctionIdentifier() (localctx IFunctionIdentifierContext)

+ func (p *FqlParser) Head() (localctx IHeadContext)

+ func (p *FqlParser) NamespaceIdentifier() (localctx INamespaceIdentifierContext)

+ func (p *FqlParser) Use() (localctx IUseContext)

+ func (p *FqlParser) UseExpression() (localctx IUseExpressionContext)

type FqlParserListener

+ EnterFunctionIdentifier func(c *FunctionIdentifierContext)

+ EnterHead func(c *HeadContext)

+ EnterNamespaceIdentifier func(c *NamespaceIdentifierContext)

+ EnterUse func(c *UseContext)

+ EnterUseExpression func(c *UseExpressionContext)

+ ExitFunctionIdentifier func(c *FunctionIdentifierContext)

+ ExitHead func(c *HeadContext)

+ ExitNamespaceIdentifier func(c *NamespaceIdentifierContext)

+ ExitUse func(c *UseContext)

+ ExitUseExpression func(c *UseExpressionContext)

type FqlParserVisitor

+ VisitFunctionIdentifier func(ctx *FunctionIdentifierContext) interface{}

+ VisitHead func(ctx *HeadContext) interface{}

+ VisitNamespaceIdentifier func(ctx *NamespaceIdentifierContext) interface{}

+ VisitUse func(ctx *UseContext) interface{}

+ VisitUseExpression func(ctx *UseExpressionContext) interface{}

type FunctionCallExpressionContext

+ func (s *FunctionCallExpressionContext) FunctionIdentifier() IFunctionIdentifierContext

+ type FunctionIdentifierContext struct

+ func NewEmptyFunctionIdentifierContext() *FunctionIdentifierContext

+ func NewFunctionIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionIdentifierContext

+ func (*FunctionIdentifierContext) IsFunctionIdentifierContext()

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

+ func (s *FunctionIdentifierContext) Aggregate() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) All() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) And() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) Any() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) BooleanLiteral() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) Collect() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) Count() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) Distinct() antlr.TerminalNode

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

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

+ func (s *FunctionIdentifierContext) Filter() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) For() antlr.TerminalNode

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

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

+ func (s *FunctionIdentifierContext) Identifier() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) In() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) Into() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) Keep() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) Let() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) Like() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) Limit() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) None() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) Not() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) Null() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) Or() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) Return() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) Sort() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) SortDirection() antlr.TerminalNode

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

+ func (s *FunctionIdentifierContext) Use() antlr.TerminalNode

+ func (s *FunctionIdentifierContext) With() antlr.TerminalNode

+ type HeadContext struct

+ func NewEmptyHeadContext() *HeadContext

+ func NewHeadContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HeadContext

+ func (*HeadContext) IsHeadContext()

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

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

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

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

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

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

+ func (s *HeadContext) UseExpression() IUseExpressionContext

+ type IFunctionIdentifierContext interface

+ GetParser func() antlr.Parser

+ IsFunctionIdentifierContext func()

+ type IHeadContext interface

+ GetParser func() antlr.Parser

+ IsHeadContext func()

+ type INamespaceIdentifierContext interface

+ GetParser func() antlr.Parser

+ IsNamespaceIdentifierContext func()

+ type IUseContext interface

+ GetParser func() antlr.Parser

+ IsUseContext func()

+ type IUseExpressionContext interface

+ GetParser func() antlr.Parser

+ IsUseExpressionContext func()

+ type NamespaceIdentifierContext struct

+ func NewEmptyNamespaceIdentifierContext() *NamespaceIdentifierContext

+ func NewNamespaceIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamespaceIdentifierContext

+ func (*NamespaceIdentifierContext) IsNamespaceIdentifierContext()

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

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

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

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

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

+ func (s *NamespaceIdentifierContext) Identifier() antlr.TerminalNode

+ func (s *NamespaceIdentifierContext) Namespace() INamespaceContext

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

type ProgramContext

+ func (s *ProgramContext) AllHead() []IHeadContext

+ func (s *ProgramContext) Head(i int) IHeadContext

+ type UseContext struct

+ func NewEmptyUseContext() *UseContext

+ func NewUseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UseContext

+ func (*UseContext) IsUseContext()

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

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

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

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

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

+ func (s *UseContext) NamespaceIdentifier() INamespaceIdentifierContext

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

+ func (s *UseContext) Use() antlr.TerminalNode

+ type UseExpressionContext struct

+ func NewEmptyUseExpressionContext() *UseExpressionContext

+ func NewUseExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UseExpressionContext

+ func (*UseExpressionContext) IsUseExpressionContext()

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

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

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

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

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

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

+ func (s *UseExpressionContext) Use() IUseContext

v0.10.2

Apr 20, 2020

v0.10.1

Mar 15, 2020

v0.10.0

Feb 21, 2020

v0.9.0

Sep 10, 2019

Changes in this version

+ const FqlParserRULE_member

+ const FqlParserRULE_memberPath

type BaseFqlParserListener

+ func (s *BaseFqlParserListener) EnterMember(ctx *MemberContext)

+ func (s *BaseFqlParserListener) EnterMemberPath(ctx *MemberPathContext)

+ func (s *BaseFqlParserListener) ExitMember(ctx *MemberContext)

+ func (s *BaseFqlParserListener) ExitMemberPath(ctx *MemberPathContext)

type BaseFqlParserVisitor

+ func (v *BaseFqlParserVisitor) VisitMember(ctx *MemberContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitMemberPath(ctx *MemberPathContext) interface{}

type FqlParser

+ func (p *FqlParser) Member() (localctx IMemberContext)

+ func (p *FqlParser) MemberPath() (localctx IMemberPathContext)

type FqlParserListener

+ EnterMember func(c *MemberContext)

+ EnterMemberPath func(c *MemberPathContext)

+ ExitMember func(c *MemberContext)

+ ExitMemberPath func(c *MemberPathContext)

type FqlParserVisitor

+ VisitMember func(ctx *MemberContext) interface{}

+ VisitMemberPath func(ctx *MemberPathContext) interface{}

+ type IMemberContext interface

+ GetParser func() antlr.Parser

+ IsMemberContext func()

+ type IMemberPathContext interface

+ GetParser func() antlr.Parser

+ IsMemberPathContext func()

+ type MemberContext struct

+ func NewEmptyMemberContext() *MemberContext

+ func NewMemberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberContext

+ func (*MemberContext) IsMemberContext()

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

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

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

+ func (s *MemberContext) FunctionCallExpression() IFunctionCallExpressionContext

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

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

+ func (s *MemberContext) Identifier() antlr.TerminalNode

+ func (s *MemberContext) Param() IParamContext

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

type MemberExpressionContext

+ func (s *MemberExpressionContext) Member() IMemberContext

+ func (s *MemberExpressionContext) MemberPath() IMemberPathContext

+ type MemberPathContext struct

+ func NewEmptyMemberPathContext() *MemberPathContext

+ func NewMemberPathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberPathContext

+ func (*MemberPathContext) IsMemberPathContext()

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

+ func (s *MemberPathContext) AllComputedPropertyName() []IComputedPropertyNameContext

+ func (s *MemberPathContext) AllDot() []antlr.TerminalNode

+ func (s *MemberPathContext) AllPropertyName() []IPropertyNameContext

+ func (s *MemberPathContext) ComputedPropertyName(i int) IComputedPropertyNameContext

+ func (s *MemberPathContext) Dot(i int) antlr.TerminalNode

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

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

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

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

+ func (s *MemberPathContext) PropertyName(i int) IPropertyNameContext

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

type PropertyNameContext

+ func (s *PropertyNameContext) Param() IParamContext

v0.8.2

Aug 5, 2019

v0.8.1

Jul 27, 2019

v0.8.0

Jul 23, 2019

Changes in this version

+ const FqlLexerNamespaceSegment

+ const FqlParserNamespaceSegment

+ const FqlParserRULE_namespace

+ const FqlParserRULE_regexpOperator

type BaseFqlParserListener

+ func (s *BaseFqlParserListener) EnterNamespace(ctx *NamespaceContext)

+ func (s *BaseFqlParserListener) EnterRegexpOperator(ctx *RegexpOperatorContext)

+ func (s *BaseFqlParserListener) ExitNamespace(ctx *NamespaceContext)

+ func (s *BaseFqlParserListener) ExitRegexpOperator(ctx *RegexpOperatorContext)

type BaseFqlParserVisitor

+ func (v *BaseFqlParserVisitor) VisitNamespace(ctx *NamespaceContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitRegexpOperator(ctx *RegexpOperatorContext) interface{}

type ExpressionContext

+ func (s *ExpressionContext) RegexpOperator() IRegexpOperatorContext

type FqlParser

+ func (p *FqlParser) Namespace() (localctx INamespaceContext)

+ func (p *FqlParser) RegexpOperator() (localctx IRegexpOperatorContext)

type FqlParserListener

+ EnterNamespace func(c *NamespaceContext)

+ EnterRegexpOperator func(c *RegexpOperatorContext)

+ ExitNamespace func(c *NamespaceContext)

+ ExitRegexpOperator func(c *RegexpOperatorContext)

type FqlParserVisitor

+ VisitNamespace func(ctx *NamespaceContext) interface{}

+ VisitRegexpOperator func(ctx *RegexpOperatorContext) interface{}

type FunctionCallExpressionContext

+ func (s *FunctionCallExpressionContext) Namespace() INamespaceContext

+ type INamespaceContext interface

+ GetParser func() antlr.Parser

+ IsNamespaceContext func()

+ type IRegexpOperatorContext interface

+ GetParser func() antlr.Parser

+ IsRegexpOperatorContext func()

+ type NamespaceContext struct

+ func NewEmptyNamespaceContext() *NamespaceContext

+ func NewNamespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamespaceContext

+ func (*NamespaceContext) IsNamespaceContext()

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

+ func (s *NamespaceContext) AllNamespaceSegment() []antlr.TerminalNode

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

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

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

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

+ func (s *NamespaceContext) NamespaceSegment(i int) antlr.TerminalNode

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

+ type RegexpOperatorContext struct

+ func NewEmptyRegexpOperatorContext() *RegexpOperatorContext

+ func NewRegexpOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RegexpOperatorContext

+ func (*RegexpOperatorContext) IsRegexpOperatorContext()

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

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

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

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

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

+ func (s *RegexpOperatorContext) RegexMatch() antlr.TerminalNode

+ func (s *RegexpOperatorContext) RegexNotMatch() antlr.TerminalNode

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

v0.7.0

Mar 19, 2019

v0.6.0

Dec 25, 2018

Changes in this version

+ const FqlParserRULE_additiveOperator

+ const FqlParserRULE_expressionGroup

+ const FqlParserRULE_logicalAndOperator

+ const FqlParserRULE_logicalOrOperator

+ const FqlParserRULE_multiplicativeOperator

+ type AdditiveOperatorContext struct

+ func NewAdditiveOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AdditiveOperatorContext

+ func NewEmptyAdditiveOperatorContext() *AdditiveOperatorContext

+ func (*AdditiveOperatorContext) IsAdditiveOperatorContext()

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

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

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

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

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

+ func (s *AdditiveOperatorContext) Minus() antlr.TerminalNode

+ func (s *AdditiveOperatorContext) Plus() antlr.TerminalNode

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

type BaseFqlParserListener

+ func (s *BaseFqlParserListener) EnterAdditiveOperator(ctx *AdditiveOperatorContext)

+ func (s *BaseFqlParserListener) EnterExpressionGroup(ctx *ExpressionGroupContext)

+ func (s *BaseFqlParserListener) EnterLogicalAndOperator(ctx *LogicalAndOperatorContext)

+ func (s *BaseFqlParserListener) EnterLogicalOrOperator(ctx *LogicalOrOperatorContext)

+ func (s *BaseFqlParserListener) EnterMultiplicativeOperator(ctx *MultiplicativeOperatorContext)

+ func (s *BaseFqlParserListener) ExitAdditiveOperator(ctx *AdditiveOperatorContext)

+ func (s *BaseFqlParserListener) ExitExpressionGroup(ctx *ExpressionGroupContext)

+ func (s *BaseFqlParserListener) ExitLogicalAndOperator(ctx *LogicalAndOperatorContext)

+ func (s *BaseFqlParserListener) ExitLogicalOrOperator(ctx *LogicalOrOperatorContext)

+ func (s *BaseFqlParserListener) ExitMultiplicativeOperator(ctx *MultiplicativeOperatorContext)

type BaseFqlParserVisitor

+ func (v *BaseFqlParserVisitor) VisitAdditiveOperator(ctx *AdditiveOperatorContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitExpressionGroup(ctx *ExpressionGroupContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitLogicalAndOperator(ctx *LogicalAndOperatorContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitLogicalOrOperator(ctx *LogicalOrOperatorContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitMultiplicativeOperator(ctx *MultiplicativeOperatorContext) interface{}

type ExpressionContext

+ func (s *ExpressionContext) AdditiveOperator() IAdditiveOperatorContext

+ func (s *ExpressionContext) ExpressionGroup() IExpressionGroupContext

+ func (s *ExpressionContext) LogicalAndOperator() ILogicalAndOperatorContext

+ func (s *ExpressionContext) LogicalOrOperator() ILogicalOrOperatorContext

+ func (s *ExpressionContext) MultiplicativeOperator() IMultiplicativeOperatorContext

+ type ExpressionGroupContext struct

+ func NewEmptyExpressionGroupContext() *ExpressionGroupContext

+ func NewExpressionGroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionGroupContext

+ func (*ExpressionGroupContext) IsExpressionGroupContext()

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

+ func (s *ExpressionGroupContext) CloseParen() antlr.TerminalNode

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

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

+ func (s *ExpressionGroupContext) Expression() IExpressionContext

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

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

+ func (s *ExpressionGroupContext) OpenParen() antlr.TerminalNode

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

type FqlParser

+ func (p *FqlParser) AdditiveOperator() (localctx IAdditiveOperatorContext)

+ func (p *FqlParser) ExpressionGroup() (localctx IExpressionGroupContext)

+ func (p *FqlParser) LogicalAndOperator() (localctx ILogicalAndOperatorContext)

+ func (p *FqlParser) LogicalOrOperator() (localctx ILogicalOrOperatorContext)

+ func (p *FqlParser) MultiplicativeOperator() (localctx IMultiplicativeOperatorContext)

type FqlParserListener

+ EnterAdditiveOperator func(c *AdditiveOperatorContext)

+ EnterExpressionGroup func(c *ExpressionGroupContext)

+ EnterLogicalAndOperator func(c *LogicalAndOperatorContext)

+ EnterLogicalOrOperator func(c *LogicalOrOperatorContext)

+ EnterMultiplicativeOperator func(c *MultiplicativeOperatorContext)

+ ExitAdditiveOperator func(c *AdditiveOperatorContext)

+ ExitExpressionGroup func(c *ExpressionGroupContext)

+ ExitLogicalAndOperator func(c *LogicalAndOperatorContext)

+ ExitLogicalOrOperator func(c *LogicalOrOperatorContext)

+ ExitMultiplicativeOperator func(c *MultiplicativeOperatorContext)

type FqlParserVisitor

+ VisitAdditiveOperator func(ctx *AdditiveOperatorContext) interface{}

+ VisitExpressionGroup func(ctx *ExpressionGroupContext) interface{}

+ VisitLogicalAndOperator func(ctx *LogicalAndOperatorContext) interface{}

+ VisitLogicalOrOperator func(ctx *LogicalOrOperatorContext) interface{}

+ VisitMultiplicativeOperator func(ctx *MultiplicativeOperatorContext) interface{}

+ type IAdditiveOperatorContext interface

+ GetParser func() antlr.Parser

+ IsAdditiveOperatorContext func()

+ type IExpressionGroupContext interface

+ GetParser func() antlr.Parser

+ IsExpressionGroupContext func()

+ type ILogicalAndOperatorContext interface

+ GetParser func() antlr.Parser

+ IsLogicalAndOperatorContext func()

+ type ILogicalOrOperatorContext interface

+ GetParser func() antlr.Parser

+ IsLogicalOrOperatorContext func()

+ type IMultiplicativeOperatorContext interface

+ GetParser func() antlr.Parser

+ IsMultiplicativeOperatorContext func()

+ type LogicalAndOperatorContext struct

+ func NewEmptyLogicalAndOperatorContext() *LogicalAndOperatorContext

+ func NewLogicalAndOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LogicalAndOperatorContext

+ func (*LogicalAndOperatorContext) IsLogicalAndOperatorContext()

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

+ func (s *LogicalAndOperatorContext) And() antlr.TerminalNode

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

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

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

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

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

+ type LogicalOrOperatorContext struct

+ func NewEmptyLogicalOrOperatorContext() *LogicalOrOperatorContext

+ func NewLogicalOrOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LogicalOrOperatorContext

+ func (*LogicalOrOperatorContext) IsLogicalOrOperatorContext()

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

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

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

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

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

+ func (s *LogicalOrOperatorContext) Or() antlr.TerminalNode

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

+ type MultiplicativeOperatorContext struct

+ func NewEmptyMultiplicativeOperatorContext() *MultiplicativeOperatorContext

+ func NewMultiplicativeOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultiplicativeOperatorContext

+ func (*MultiplicativeOperatorContext) IsMultiplicativeOperatorContext()

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

+ func (s *MultiplicativeOperatorContext) Div() antlr.TerminalNode

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

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

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

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

+ func (s *MultiplicativeOperatorContext) Mod() antlr.TerminalNode

+ func (s *MultiplicativeOperatorContext) Multi() antlr.TerminalNode

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

v0.5.2

Nov 30, 2018

v0.5.1

Nov 22, 2018

v0.5.0

Nov 20, 2018

Changes in this version

+ const FqlParserRULE_forExpressionStatement

+ const FqlParserRULE_limitClauseValue

type BaseFqlParserListener

+ func (s *BaseFqlParserListener) EnterForExpressionStatement(ctx *ForExpressionStatementContext)

+ func (s *BaseFqlParserListener) EnterLimitClauseValue(ctx *LimitClauseValueContext)

+ func (s *BaseFqlParserListener) ExitForExpressionStatement(ctx *ForExpressionStatementContext)

+ func (s *BaseFqlParserListener) ExitLimitClauseValue(ctx *LimitClauseValueContext)

type BaseFqlParserVisitor

+ func (v *BaseFqlParserVisitor) VisitForExpressionStatement(ctx *ForExpressionStatementContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitLimitClauseValue(ctx *LimitClauseValueContext) interface{}

type ForExpressionBodyContext

+ func (s *ForExpressionBodyContext) ForExpressionClause() IForExpressionClauseContext

+ func (s *ForExpressionBodyContext) ForExpressionStatement() IForExpressionStatementContext

+ type ForExpressionStatementContext struct

+ func NewEmptyForExpressionStatementContext() *ForExpressionStatementContext

+ func NewForExpressionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionStatementContext

+ func (*ForExpressionStatementContext) IsForExpressionStatementContext()

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

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

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

+ func (s *ForExpressionStatementContext) FunctionCallExpression() IFunctionCallExpressionContext

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

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

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

+ func (s *ForExpressionStatementContext) VariableDeclaration() IVariableDeclarationContext

type FqlParser

+ func (p *FqlParser) ForExpressionStatement() (localctx IForExpressionStatementContext)

+ func (p *FqlParser) LimitClauseValue() (localctx ILimitClauseValueContext)

type FqlParserListener

+ EnterForExpressionStatement func(c *ForExpressionStatementContext)

+ EnterLimitClauseValue func(c *LimitClauseValueContext)

+ ExitForExpressionStatement func(c *ForExpressionStatementContext)

+ ExitLimitClauseValue func(c *LimitClauseValueContext)

type FqlParserVisitor

+ VisitForExpressionStatement func(ctx *ForExpressionStatementContext) interface{}

+ VisitLimitClauseValue func(ctx *LimitClauseValueContext) interface{}

+ type IForExpressionStatementContext interface

+ GetParser func() antlr.Parser

+ IsForExpressionStatementContext func()

+ type ILimitClauseValueContext interface

+ GetParser func() antlr.Parser

+ IsLimitClauseValueContext func()

type LimitClauseContext

+ func (s *LimitClauseContext) AllLimitClauseValue() []ILimitClauseValueContext

+ func (s *LimitClauseContext) LimitClauseValue(i int) ILimitClauseValueContext

+ type LimitClauseValueContext struct

+ func NewEmptyLimitClauseValueContext() *LimitClauseValueContext

+ func NewLimitClauseValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseValueContext

+ func (*LimitClauseValueContext) IsLimitClauseValueContext()

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

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

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

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

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

+ func (s *LimitClauseValueContext) IntegerLiteral() antlr.TerminalNode

+ func (s *LimitClauseValueContext) Param() IParamContext

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

v0.4.0

Oct 25, 2018

Changes in this version

+ const FqlParserRULE_collectAggregateSelector

+ const FqlParserRULE_collectAggregator

+ const FqlParserRULE_collectCounter

+ const FqlParserRULE_collectGrouping

+ const FqlParserRULE_collectSelector

type BaseFqlParserListener

+ func (s *BaseFqlParserListener) EnterCollectAggregateSelector(ctx *CollectAggregateSelectorContext)

+ func (s *BaseFqlParserListener) EnterCollectAggregator(ctx *CollectAggregatorContext)

+ func (s *BaseFqlParserListener) EnterCollectCounter(ctx *CollectCounterContext)

+ func (s *BaseFqlParserListener) EnterCollectGrouping(ctx *CollectGroupingContext)

+ func (s *BaseFqlParserListener) EnterCollectSelector(ctx *CollectSelectorContext)

+ func (s *BaseFqlParserListener) ExitCollectAggregateSelector(ctx *CollectAggregateSelectorContext)

+ func (s *BaseFqlParserListener) ExitCollectAggregator(ctx *CollectAggregatorContext)

+ func (s *BaseFqlParserListener) ExitCollectCounter(ctx *CollectCounterContext)

+ func (s *BaseFqlParserListener) ExitCollectGrouping(ctx *CollectGroupingContext)

+ func (s *BaseFqlParserListener) ExitCollectSelector(ctx *CollectSelectorContext)

type BaseFqlParserVisitor

+ func (v *BaseFqlParserVisitor) VisitCollectAggregateSelector(ctx *CollectAggregateSelectorContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitCollectAggregator(ctx *CollectAggregatorContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitCollectCounter(ctx *CollectCounterContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitCollectGrouping(ctx *CollectGroupingContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitCollectSelector(ctx *CollectSelectorContext) interface{}

+ type CollectAggregateSelectorContext struct

+ func NewCollectAggregateSelectorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectAggregateSelectorContext

+ func NewEmptyCollectAggregateSelectorContext() *CollectAggregateSelectorContext

+ func (*CollectAggregateSelectorContext) IsCollectAggregateSelectorContext()

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

+ func (s *CollectAggregateSelectorContext) Assign() antlr.TerminalNode

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

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

+ func (s *CollectAggregateSelectorContext) FunctionCallExpression() IFunctionCallExpressionContext

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

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

+ func (s *CollectAggregateSelectorContext) Identifier() antlr.TerminalNode

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

+ type CollectAggregatorContext struct

+ func NewCollectAggregatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectAggregatorContext

+ func NewEmptyCollectAggregatorContext() *CollectAggregatorContext

+ func (*CollectAggregatorContext) IsCollectAggregatorContext()

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

+ func (s *CollectAggregatorContext) Aggregate() antlr.TerminalNode

+ func (s *CollectAggregatorContext) AllCollectAggregateSelector() []ICollectAggregateSelectorContext

+ func (s *CollectAggregatorContext) AllComma() []antlr.TerminalNode

+ func (s *CollectAggregatorContext) CollectAggregateSelector(i int) ICollectAggregateSelectorContext

+ func (s *CollectAggregatorContext) Comma(i int) antlr.TerminalNode

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

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

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

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

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

type CollectClauseContext

+ func (s *CollectClauseContext) CollectAggregator() ICollectAggregatorContext

+ func (s *CollectClauseContext) CollectCounter() ICollectCounterContext

+ func (s *CollectClauseContext) CollectGrouping() ICollectGroupingContext

+ type CollectCounterContext struct

+ func NewCollectCounterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectCounterContext

+ func NewEmptyCollectCounterContext() *CollectCounterContext

+ func (*CollectCounterContext) IsCollectCounterContext()

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

+ func (s *CollectCounterContext) Count() antlr.TerminalNode

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

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

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

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

+ func (s *CollectCounterContext) Identifier() antlr.TerminalNode

+ func (s *CollectCounterContext) Into() antlr.TerminalNode

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

+ func (s *CollectCounterContext) With() antlr.TerminalNode

type CollectGroupVariableContext

+ func (s *CollectGroupVariableContext) AllIdentifier() []antlr.TerminalNode

+ func (s *CollectGroupVariableContext) CollectSelector() ICollectSelectorContext

+ func (s *CollectGroupVariableContext) Into() antlr.TerminalNode

+ func (s *CollectGroupVariableContext) Keep() antlr.TerminalNode

+ type CollectGroupingContext struct

+ func NewCollectGroupingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectGroupingContext

+ func NewEmptyCollectGroupingContext() *CollectGroupingContext

+ func (*CollectGroupingContext) IsCollectGroupingContext()

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

+ func (s *CollectGroupingContext) AllCollectSelector() []ICollectSelectorContext

+ func (s *CollectGroupingContext) AllComma() []antlr.TerminalNode

+ func (s *CollectGroupingContext) CollectSelector(i int) ICollectSelectorContext

+ func (s *CollectGroupingContext) Comma(i int) antlr.TerminalNode

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

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

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

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

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

+ type CollectSelectorContext struct

+ func NewCollectSelectorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectSelectorContext

+ func NewEmptyCollectSelectorContext() *CollectSelectorContext

+ func (*CollectSelectorContext) IsCollectSelectorContext()

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

+ func (s *CollectSelectorContext) Assign() antlr.TerminalNode

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

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

+ func (s *CollectSelectorContext) Expression() IExpressionContext

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

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

+ func (s *CollectSelectorContext) Identifier() antlr.TerminalNode

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

type FqlParser

+ func (p *FqlParser) CollectAggregateSelector() (localctx ICollectAggregateSelectorContext)

+ func (p *FqlParser) CollectAggregator() (localctx ICollectAggregatorContext)

+ func (p *FqlParser) CollectCounter() (localctx ICollectCounterContext)

+ func (p *FqlParser) CollectGrouping() (localctx ICollectGroupingContext)

+ func (p *FqlParser) CollectSelector() (localctx ICollectSelectorContext)

type FqlParserListener

+ EnterCollectAggregateSelector func(c *CollectAggregateSelectorContext)

+ EnterCollectAggregator func(c *CollectAggregatorContext)

+ EnterCollectCounter func(c *CollectCounterContext)

+ EnterCollectGrouping func(c *CollectGroupingContext)

+ EnterCollectSelector func(c *CollectSelectorContext)

+ ExitCollectAggregateSelector func(c *CollectAggregateSelectorContext)

+ ExitCollectAggregator func(c *CollectAggregatorContext)

+ ExitCollectCounter func(c *CollectCounterContext)

+ ExitCollectGrouping func(c *CollectGroupingContext)

+ ExitCollectSelector func(c *CollectSelectorContext)

type FqlParserVisitor

+ VisitCollectAggregateSelector func(ctx *CollectAggregateSelectorContext) interface{}

+ VisitCollectAggregator func(ctx *CollectAggregatorContext) interface{}

+ VisitCollectCounter func(ctx *CollectCounterContext) interface{}

+ VisitCollectGrouping func(ctx *CollectGroupingContext) interface{}

+ VisitCollectSelector func(ctx *CollectSelectorContext) interface{}

+ type ICollectAggregateSelectorContext interface

+ GetParser func() antlr.Parser

+ IsCollectAggregateSelectorContext func()

+ type ICollectAggregatorContext interface

+ GetParser func() antlr.Parser

+ IsCollectAggregatorContext func()

+ type ICollectCounterContext interface

+ GetParser func() antlr.Parser

+ IsCollectCounterContext func()

+ type ICollectGroupingContext interface

+ GetParser func() antlr.Parser

+ IsCollectGroupingContext func()

+ type ICollectSelectorContext interface

+ GetParser func() antlr.Parser

+ IsCollectSelectorContext func()

type PropertyNameContext

+ func (s *PropertyNameContext) StringLiteral() IStringLiteralContext

v0.3.0

Oct 17, 2018

Changes in this version

+ const FqlLexerTemplateStringLiteral

+ const FqlParserTemplateStringLiteral

type ExpressionContext

+ func (s *ExpressionContext) UnaryOperator() IUnaryOperatorContext

type InOperatorContext

+ func (s *InOperatorContext) Not() antlr.TerminalNode

type StringLiteralContext

+ func (s *StringLiteralContext) TemplateStringLiteral() antlr.TerminalNode

v0.2.0

Oct 14, 2018

Changes in this version

+ const FqlLexerAggregate

+ const FqlLexerAll

+ const FqlLexerAnd

+ const FqlLexerAny

+ const FqlLexerAssign

+ const FqlLexerBooleanLiteral

+ const FqlLexerCloseBrace

+ const FqlLexerCloseBracket

+ const FqlLexerCloseParen

+ const FqlLexerCollect

+ const FqlLexerColon

+ const FqlLexerComma

+ const FqlLexerCount

+ const FqlLexerDistinct

+ const FqlLexerDiv

+ const FqlLexerDot

+ const FqlLexerEq

+ const FqlLexerFilter

+ const FqlLexerFloatLiteral

+ const FqlLexerFor

+ const FqlLexerGt

+ const FqlLexerGte

+ const FqlLexerIdentifier

+ const FqlLexerIn

+ const FqlLexerIntegerLiteral

+ const FqlLexerInto

+ const FqlLexerKeep

+ const FqlLexerLet

+ const FqlLexerLike

+ const FqlLexerLimit

+ const FqlLexerLineTerminator

+ const FqlLexerLt

+ const FqlLexerLte

+ const FqlLexerMinus

+ const FqlLexerMinusMinus

+ const FqlLexerMod

+ const FqlLexerMulti

+ const FqlLexerMultiLineComment

+ const FqlLexerNeq

+ const FqlLexerNone

+ const FqlLexerNot

+ const FqlLexerNull

+ const FqlLexerOpenBrace

+ const FqlLexerOpenBracket

+ const FqlLexerOpenParen

+ const FqlLexerOr

+ const FqlLexerParam

+ const FqlLexerPlus

+ const FqlLexerPlusPlus

+ const FqlLexerQuestionMark

+ const FqlLexerRange

+ const FqlLexerRegexMatch

+ const FqlLexerRegexNotMatch

+ const FqlLexerReturn

+ const FqlLexerSemiColon

+ const FqlLexerSingleLineComment

+ const FqlLexerSort

+ const FqlLexerSortDirection

+ const FqlLexerStringLiteral

+ const FqlLexerWhiteSpaces

+ const FqlLexerWith

+ const FqlParserAggregate

+ const FqlParserAll

+ const FqlParserAnd

+ const FqlParserAny

+ const FqlParserAssign

+ const FqlParserBooleanLiteral

+ const FqlParserCloseBrace

+ const FqlParserCloseBracket

+ const FqlParserCloseParen

+ const FqlParserCollect

+ const FqlParserColon

+ const FqlParserComma

+ const FqlParserCount

+ const FqlParserDistinct

+ const FqlParserDiv

+ const FqlParserDot

+ const FqlParserEOF

+ const FqlParserEq

+ const FqlParserFilter

+ const FqlParserFloatLiteral

+ const FqlParserFor

+ const FqlParserGt

+ const FqlParserGte

+ const FqlParserIdentifier

+ const FqlParserIn

+ const FqlParserIntegerLiteral

+ const FqlParserInto

+ const FqlParserKeep

+ const FqlParserLet

+ const FqlParserLike

+ const FqlParserLimit

+ const FqlParserLineTerminator

+ const FqlParserLt

+ const FqlParserLte

+ const FqlParserMinus

+ const FqlParserMinusMinus

+ const FqlParserMod

+ const FqlParserMulti

+ const FqlParserMultiLineComment

+ const FqlParserNeq

+ const FqlParserNone

+ const FqlParserNot

+ const FqlParserNull

+ const FqlParserOpenBrace

+ const FqlParserOpenBracket

+ const FqlParserOpenParen

+ const FqlParserOr

+ const FqlParserParam

+ const FqlParserPlus

+ const FqlParserPlusPlus

+ const FqlParserQuestionMark

+ const FqlParserRULE_arguments

+ const FqlParserRULE_arrayElementList

+ const FqlParserRULE_arrayLiteral

+ const FqlParserRULE_arrayOperator

+ const FqlParserRULE_body

+ const FqlParserRULE_bodyExpression

+ const FqlParserRULE_bodyStatement

+ const FqlParserRULE_booleanLiteral

+ const FqlParserRULE_collectAggregateExpression

+ const FqlParserRULE_collectAggregateVariable

+ const FqlParserRULE_collectClause

+ const FqlParserRULE_collectCountVariable

+ const FqlParserRULE_collectGroupVariable

+ const FqlParserRULE_collectKeepVariable

+ const FqlParserRULE_collectOption

+ const FqlParserRULE_collectVariable

+ const FqlParserRULE_computedPropertyName

+ const FqlParserRULE_equalityOperator

+ const FqlParserRULE_expression

+ const FqlParserRULE_expressionSequence

+ const FqlParserRULE_filterClause

+ const FqlParserRULE_floatLiteral

+ const FqlParserRULE_forExpression

+ const FqlParserRULE_forExpressionBody

+ const FqlParserRULE_forExpressionClause

+ const FqlParserRULE_forExpressionKeyVariable

+ const FqlParserRULE_forExpressionReturn

+ const FqlParserRULE_forExpressionSource

+ const FqlParserRULE_forExpressionValueVariable

+ const FqlParserRULE_forTernaryExpression

+ const FqlParserRULE_functionCallExpression

+ const FqlParserRULE_inOperator

+ const FqlParserRULE_integerLiteral

+ const FqlParserRULE_limitClause

+ const FqlParserRULE_logicalOperator

+ const FqlParserRULE_mathOperator

+ const FqlParserRULE_memberExpression

+ const FqlParserRULE_noneLiteral

+ const FqlParserRULE_objectLiteral

+ const FqlParserRULE_param

+ const FqlParserRULE_program

+ const FqlParserRULE_propertyAssignment

+ const FqlParserRULE_propertyName

+ const FqlParserRULE_rangeOperator

+ const FqlParserRULE_returnExpression

+ const FqlParserRULE_shorthandPropertyName

+ const FqlParserRULE_sortClause

+ const FqlParserRULE_sortClauseExpression

+ const FqlParserRULE_stringLiteral

+ const FqlParserRULE_unaryOperator

+ const FqlParserRULE_variable

+ const FqlParserRULE_variableDeclaration

+ const FqlParserRange

+ const FqlParserRegexMatch

+ const FqlParserRegexNotMatch

+ const FqlParserReturn

+ const FqlParserSemiColon

+ const FqlParserSingleLineComment

+ const FqlParserSort

+ const FqlParserSortDirection

+ const FqlParserStringLiteral

+ const FqlParserWhiteSpaces

+ const FqlParserWith

+ type ArgumentsContext struct

+ func NewArgumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentsContext

+ func NewEmptyArgumentsContext() *ArgumentsContext

+ func (*ArgumentsContext) IsArgumentsContext()

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

+ func (s *ArgumentsContext) AllComma() []antlr.TerminalNode

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

+ func (s *ArgumentsContext) CloseParen() antlr.TerminalNode

+ func (s *ArgumentsContext) Comma(i int) antlr.TerminalNode

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

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

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

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

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

+ func (s *ArgumentsContext) OpenParen() antlr.TerminalNode

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

+ type ArrayElementListContext struct

+ func NewArrayElementListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayElementListContext

+ func NewEmptyArrayElementListContext() *ArrayElementListContext

+ func (*ArrayElementListContext) IsArrayElementListContext()

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

+ func (s *ArrayElementListContext) AllComma() []antlr.TerminalNode

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

+ func (s *ArrayElementListContext) Comma(i int) antlr.TerminalNode

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

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

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

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

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

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

+ type ArrayLiteralContext struct

+ func NewArrayLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayLiteralContext

+ func NewEmptyArrayLiteralContext() *ArrayLiteralContext

+ func (*ArrayLiteralContext) IsArrayLiteralContext()

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

+ func (s *ArrayLiteralContext) ArrayElementList() IArrayElementListContext

+ func (s *ArrayLiteralContext) CloseBracket() antlr.TerminalNode

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

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

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

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

+ func (s *ArrayLiteralContext) OpenBracket() antlr.TerminalNode

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

+ type ArrayOperatorContext struct

+ func NewArrayOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayOperatorContext

+ func NewEmptyArrayOperatorContext() *ArrayOperatorContext

+ func (*ArrayOperatorContext) IsArrayOperatorContext()

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

+ func (s *ArrayOperatorContext) All() antlr.TerminalNode

+ func (s *ArrayOperatorContext) Any() antlr.TerminalNode

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

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

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

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

+ func (s *ArrayOperatorContext) None() antlr.TerminalNode

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

+ type BaseFqlParserListener struct

+ func (s *BaseFqlParserListener) EnterArguments(ctx *ArgumentsContext)

+ func (s *BaseFqlParserListener) EnterArrayElementList(ctx *ArrayElementListContext)

+ func (s *BaseFqlParserListener) EnterArrayLiteral(ctx *ArrayLiteralContext)

+ func (s *BaseFqlParserListener) EnterArrayOperator(ctx *ArrayOperatorContext)

+ func (s *BaseFqlParserListener) EnterBody(ctx *BodyContext)

+ func (s *BaseFqlParserListener) EnterBodyExpression(ctx *BodyExpressionContext)

+ func (s *BaseFqlParserListener) EnterBodyStatement(ctx *BodyStatementContext)

+ func (s *BaseFqlParserListener) EnterBooleanLiteral(ctx *BooleanLiteralContext)

+ func (s *BaseFqlParserListener) EnterCollectAggregateExpression(ctx *CollectAggregateExpressionContext)

+ func (s *BaseFqlParserListener) EnterCollectAggregateVariable(ctx *CollectAggregateVariableContext)

+ func (s *BaseFqlParserListener) EnterCollectClause(ctx *CollectClauseContext)

+ func (s *BaseFqlParserListener) EnterCollectCountVariable(ctx *CollectCountVariableContext)

+ func (s *BaseFqlParserListener) EnterCollectGroupVariable(ctx *CollectGroupVariableContext)

+ func (s *BaseFqlParserListener) EnterCollectKeepVariable(ctx *CollectKeepVariableContext)

+ func (s *BaseFqlParserListener) EnterCollectOption(ctx *CollectOptionContext)

+ func (s *BaseFqlParserListener) EnterCollectVariable(ctx *CollectVariableContext)

+ func (s *BaseFqlParserListener) EnterComputedPropertyName(ctx *ComputedPropertyNameContext)

+ func (s *BaseFqlParserListener) EnterEqualityOperator(ctx *EqualityOperatorContext)

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

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

+ func (s *BaseFqlParserListener) EnterExpressionSequence(ctx *ExpressionSequenceContext)

+ func (s *BaseFqlParserListener) EnterFilterClause(ctx *FilterClauseContext)

+ func (s *BaseFqlParserListener) EnterFloatLiteral(ctx *FloatLiteralContext)

+ func (s *BaseFqlParserListener) EnterForExpression(ctx *ForExpressionContext)

+ func (s *BaseFqlParserListener) EnterForExpressionBody(ctx *ForExpressionBodyContext)

+ func (s *BaseFqlParserListener) EnterForExpressionClause(ctx *ForExpressionClauseContext)

+ func (s *BaseFqlParserListener) EnterForExpressionKeyVariable(ctx *ForExpressionKeyVariableContext)

+ func (s *BaseFqlParserListener) EnterForExpressionReturn(ctx *ForExpressionReturnContext)

+ func (s *BaseFqlParserListener) EnterForExpressionSource(ctx *ForExpressionSourceContext)

+ func (s *BaseFqlParserListener) EnterForExpressionValueVariable(ctx *ForExpressionValueVariableContext)

+ func (s *BaseFqlParserListener) EnterForTernaryExpression(ctx *ForTernaryExpressionContext)

+ func (s *BaseFqlParserListener) EnterFunctionCallExpression(ctx *FunctionCallExpressionContext)

+ func (s *BaseFqlParserListener) EnterInOperator(ctx *InOperatorContext)

+ func (s *BaseFqlParserListener) EnterIntegerLiteral(ctx *IntegerLiteralContext)

+ func (s *BaseFqlParserListener) EnterLimitClause(ctx *LimitClauseContext)

+ func (s *BaseFqlParserListener) EnterLogicalOperator(ctx *LogicalOperatorContext)

+ func (s *BaseFqlParserListener) EnterMathOperator(ctx *MathOperatorContext)

+ func (s *BaseFqlParserListener) EnterMemberExpression(ctx *MemberExpressionContext)

+ func (s *BaseFqlParserListener) EnterNoneLiteral(ctx *NoneLiteralContext)

+ func (s *BaseFqlParserListener) EnterObjectLiteral(ctx *ObjectLiteralContext)

+ func (s *BaseFqlParserListener) EnterParam(ctx *ParamContext)

+ func (s *BaseFqlParserListener) EnterProgram(ctx *ProgramContext)

+ func (s *BaseFqlParserListener) EnterPropertyAssignment(ctx *PropertyAssignmentContext)

+ func (s *BaseFqlParserListener) EnterPropertyName(ctx *PropertyNameContext)

+ func (s *BaseFqlParserListener) EnterRangeOperator(ctx *RangeOperatorContext)

+ func (s *BaseFqlParserListener) EnterReturnExpression(ctx *ReturnExpressionContext)

+ func (s *BaseFqlParserListener) EnterShorthandPropertyName(ctx *ShorthandPropertyNameContext)

+ func (s *BaseFqlParserListener) EnterSortClause(ctx *SortClauseContext)

+ func (s *BaseFqlParserListener) EnterSortClauseExpression(ctx *SortClauseExpressionContext)

+ func (s *BaseFqlParserListener) EnterStringLiteral(ctx *StringLiteralContext)

+ func (s *BaseFqlParserListener) EnterUnaryOperator(ctx *UnaryOperatorContext)

+ func (s *BaseFqlParserListener) EnterVariable(ctx *VariableContext)

+ func (s *BaseFqlParserListener) EnterVariableDeclaration(ctx *VariableDeclarationContext)

+ func (s *BaseFqlParserListener) ExitArguments(ctx *ArgumentsContext)

+ func (s *BaseFqlParserListener) ExitArrayElementList(ctx *ArrayElementListContext)

+ func (s *BaseFqlParserListener) ExitArrayLiteral(ctx *ArrayLiteralContext)

+ func (s *BaseFqlParserListener) ExitArrayOperator(ctx *ArrayOperatorContext)

+ func (s *BaseFqlParserListener) ExitBody(ctx *BodyContext)

+ func (s *BaseFqlParserListener) ExitBodyExpression(ctx *BodyExpressionContext)

+ func (s *BaseFqlParserListener) ExitBodyStatement(ctx *BodyStatementContext)

+ func (s *BaseFqlParserListener) ExitBooleanLiteral(ctx *BooleanLiteralContext)

+ func (s *BaseFqlParserListener) ExitCollectAggregateExpression(ctx *CollectAggregateExpressionContext)

+ func (s *BaseFqlParserListener) ExitCollectAggregateVariable(ctx *CollectAggregateVariableContext)

+ func (s *BaseFqlParserListener) ExitCollectClause(ctx *CollectClauseContext)

+ func (s *BaseFqlParserListener) ExitCollectCountVariable(ctx *CollectCountVariableContext)

+ func (s *BaseFqlParserListener) ExitCollectGroupVariable(ctx *CollectGroupVariableContext)

+ func (s *BaseFqlParserListener) ExitCollectKeepVariable(ctx *CollectKeepVariableContext)

+ func (s *BaseFqlParserListener) ExitCollectOption(ctx *CollectOptionContext)

+ func (s *BaseFqlParserListener) ExitCollectVariable(ctx *CollectVariableContext)

+ func (s *BaseFqlParserListener) ExitComputedPropertyName(ctx *ComputedPropertyNameContext)

+ func (s *BaseFqlParserListener) ExitEqualityOperator(ctx *EqualityOperatorContext)

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

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

+ func (s *BaseFqlParserListener) ExitExpressionSequence(ctx *ExpressionSequenceContext)

+ func (s *BaseFqlParserListener) ExitFilterClause(ctx *FilterClauseContext)

+ func (s *BaseFqlParserListener) ExitFloatLiteral(ctx *FloatLiteralContext)

+ func (s *BaseFqlParserListener) ExitForExpression(ctx *ForExpressionContext)

+ func (s *BaseFqlParserListener) ExitForExpressionBody(ctx *ForExpressionBodyContext)

+ func (s *BaseFqlParserListener) ExitForExpressionClause(ctx *ForExpressionClauseContext)

+ func (s *BaseFqlParserListener) ExitForExpressionKeyVariable(ctx *ForExpressionKeyVariableContext)

+ func (s *BaseFqlParserListener) ExitForExpressionReturn(ctx *ForExpressionReturnContext)

+ func (s *BaseFqlParserListener) ExitForExpressionSource(ctx *ForExpressionSourceContext)

+ func (s *BaseFqlParserListener) ExitForExpressionValueVariable(ctx *ForExpressionValueVariableContext)

+ func (s *BaseFqlParserListener) ExitForTernaryExpression(ctx *ForTernaryExpressionContext)

+ func (s *BaseFqlParserListener) ExitFunctionCallExpression(ctx *FunctionCallExpressionContext)

+ func (s *BaseFqlParserListener) ExitInOperator(ctx *InOperatorContext)

+ func (s *BaseFqlParserListener) ExitIntegerLiteral(ctx *IntegerLiteralContext)

+ func (s *BaseFqlParserListener) ExitLimitClause(ctx *LimitClauseContext)

+ func (s *BaseFqlParserListener) ExitLogicalOperator(ctx *LogicalOperatorContext)

+ func (s *BaseFqlParserListener) ExitMathOperator(ctx *MathOperatorContext)

+ func (s *BaseFqlParserListener) ExitMemberExpression(ctx *MemberExpressionContext)

+ func (s *BaseFqlParserListener) ExitNoneLiteral(ctx *NoneLiteralContext)

+ func (s *BaseFqlParserListener) ExitObjectLiteral(ctx *ObjectLiteralContext)

+ func (s *BaseFqlParserListener) ExitParam(ctx *ParamContext)

+ func (s *BaseFqlParserListener) ExitProgram(ctx *ProgramContext)

+ func (s *BaseFqlParserListener) ExitPropertyAssignment(ctx *PropertyAssignmentContext)

+ func (s *BaseFqlParserListener) ExitPropertyName(ctx *PropertyNameContext)

+ func (s *BaseFqlParserListener) ExitRangeOperator(ctx *RangeOperatorContext)

+ func (s *BaseFqlParserListener) ExitReturnExpression(ctx *ReturnExpressionContext)

+ func (s *BaseFqlParserListener) ExitShorthandPropertyName(ctx *ShorthandPropertyNameContext)

+ func (s *BaseFqlParserListener) ExitSortClause(ctx *SortClauseContext)

+ func (s *BaseFqlParserListener) ExitSortClauseExpression(ctx *SortClauseExpressionContext)

+ func (s *BaseFqlParserListener) ExitStringLiteral(ctx *StringLiteralContext)

+ func (s *BaseFqlParserListener) ExitUnaryOperator(ctx *UnaryOperatorContext)

+ func (s *BaseFqlParserListener) ExitVariable(ctx *VariableContext)

+ func (s *BaseFqlParserListener) ExitVariableDeclaration(ctx *VariableDeclarationContext)

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

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

+ type BaseFqlParserVisitor struct

+ func (v *BaseFqlParserVisitor) VisitArguments(ctx *ArgumentsContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitArrayElementList(ctx *ArrayElementListContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitArrayLiteral(ctx *ArrayLiteralContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitArrayOperator(ctx *ArrayOperatorContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitBody(ctx *BodyContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitBodyExpression(ctx *BodyExpressionContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitBodyStatement(ctx *BodyStatementContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitCollectAggregateExpression(ctx *CollectAggregateExpressionContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitCollectAggregateVariable(ctx *CollectAggregateVariableContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitCollectClause(ctx *CollectClauseContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitCollectCountVariable(ctx *CollectCountVariableContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitCollectGroupVariable(ctx *CollectGroupVariableContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitCollectKeepVariable(ctx *CollectKeepVariableContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitCollectOption(ctx *CollectOptionContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitCollectVariable(ctx *CollectVariableContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitComputedPropertyName(ctx *ComputedPropertyNameContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitEqualityOperator(ctx *EqualityOperatorContext) interface{}

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

+ func (v *BaseFqlParserVisitor) VisitExpressionSequence(ctx *ExpressionSequenceContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitFilterClause(ctx *FilterClauseContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitFloatLiteral(ctx *FloatLiteralContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitForExpression(ctx *ForExpressionContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitForExpressionBody(ctx *ForExpressionBodyContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitForExpressionClause(ctx *ForExpressionClauseContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitForExpressionKeyVariable(ctx *ForExpressionKeyVariableContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitForExpressionReturn(ctx *ForExpressionReturnContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitForExpressionSource(ctx *ForExpressionSourceContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitForExpressionValueVariable(ctx *ForExpressionValueVariableContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitForTernaryExpression(ctx *ForTernaryExpressionContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitFunctionCallExpression(ctx *FunctionCallExpressionContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitInOperator(ctx *InOperatorContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitIntegerLiteral(ctx *IntegerLiteralContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitLimitClause(ctx *LimitClauseContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitLogicalOperator(ctx *LogicalOperatorContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitMathOperator(ctx *MathOperatorContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitMemberExpression(ctx *MemberExpressionContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitNoneLiteral(ctx *NoneLiteralContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitObjectLiteral(ctx *ObjectLiteralContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitParam(ctx *ParamContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitProgram(ctx *ProgramContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitPropertyAssignment(ctx *PropertyAssignmentContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitPropertyName(ctx *PropertyNameContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitRangeOperator(ctx *RangeOperatorContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitReturnExpression(ctx *ReturnExpressionContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitShorthandPropertyName(ctx *ShorthandPropertyNameContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitSortClause(ctx *SortClauseContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitSortClauseExpression(ctx *SortClauseExpressionContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitStringLiteral(ctx *StringLiteralContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitUnaryOperator(ctx *UnaryOperatorContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitVariable(ctx *VariableContext) interface{}

+ func (v *BaseFqlParserVisitor) VisitVariableDeclaration(ctx *VariableDeclarationContext) interface{}

+ type BodyContext struct

+ func NewBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyContext

+ func NewEmptyBodyContext() *BodyContext

+ func (*BodyContext) IsBodyContext()

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

+ func (s *BodyContext) AllBodyStatement() []IBodyStatementContext

+ func (s *BodyContext) BodyExpression() IBodyExpressionContext

+ func (s *BodyContext) BodyStatement(i int) IBodyStatementContext

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

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

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

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

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

+ type BodyExpressionContext struct

+ func NewBodyExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyExpressionContext

+ func NewEmptyBodyExpressionContext() *BodyExpressionContext

+ func (*BodyExpressionContext) IsBodyExpressionContext()

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

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

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

+ func (s *BodyExpressionContext) ForExpression() IForExpressionContext

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

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

+ func (s *BodyExpressionContext) ReturnExpression() IReturnExpressionContext

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

+ type BodyStatementContext struct

+ func NewBodyStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyStatementContext

+ func NewEmptyBodyStatementContext() *BodyStatementContext

+ func (*BodyStatementContext) IsBodyStatementContext()

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

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

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

+ func (s *BodyStatementContext) FunctionCallExpression() IFunctionCallExpressionContext

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

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

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

+ func (s *BodyStatementContext) VariableDeclaration() IVariableDeclarationContext

+ type BooleanLiteralContext struct

+ func NewBooleanLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BooleanLiteralContext

+ func NewEmptyBooleanLiteralContext() *BooleanLiteralContext

+ func (*BooleanLiteralContext) IsBooleanLiteralContext()

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

+ func (s *BooleanLiteralContext) BooleanLiteral() antlr.TerminalNode

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

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

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

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

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

+ type CollectAggregateExpressionContext struct

+ func NewCollectAggregateExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectAggregateExpressionContext

+ func NewEmptyCollectAggregateExpressionContext() *CollectAggregateExpressionContext

+ func (*CollectAggregateExpressionContext) IsCollectAggregateExpressionContext()

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

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

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

+ func (s *CollectAggregateExpressionContext) Expression() IExpressionContext

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

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

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

+ type CollectAggregateVariableContext struct

+ func NewCollectAggregateVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectAggregateVariableContext

+ func NewEmptyCollectAggregateVariableContext() *CollectAggregateVariableContext

+ func (*CollectAggregateVariableContext) IsCollectAggregateVariableContext()

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

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

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

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

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

+ func (s *CollectAggregateVariableContext) Identifier() antlr.TerminalNode

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

+ type CollectClauseContext struct

+ func NewCollectClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectClauseContext

+ func NewEmptyCollectClauseContext() *CollectClauseContext

+ func (*CollectClauseContext) IsCollectClauseContext()

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

+ func (s *CollectClauseContext) Aggregate() antlr.TerminalNode

+ func (s *CollectClauseContext) AllAssign() []antlr.TerminalNode

+ func (s *CollectClauseContext) Assign(i int) antlr.TerminalNode

+ func (s *CollectClauseContext) Collect() antlr.TerminalNode

+ func (s *CollectClauseContext) CollectAggregateExpression() ICollectAggregateExpressionContext

+ func (s *CollectClauseContext) CollectAggregateVariable() ICollectAggregateVariableContext

+ func (s *CollectClauseContext) CollectCountVariable() ICollectCountVariableContext

+ func (s *CollectClauseContext) CollectGroupVariable() ICollectGroupVariableContext

+ func (s *CollectClauseContext) CollectKeepVariable() ICollectKeepVariableContext

+ func (s *CollectClauseContext) CollectVariable() ICollectVariableContext

+ func (s *CollectClauseContext) Count() antlr.TerminalNode

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

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

+ func (s *CollectClauseContext) Expression() IExpressionContext

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

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

+ func (s *CollectClauseContext) Into() antlr.TerminalNode

+ func (s *CollectClauseContext) Keep() antlr.TerminalNode

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

+ func (s *CollectClauseContext) With() antlr.TerminalNode

+ type CollectCountVariableContext struct

+ func NewCollectCountVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectCountVariableContext

+ func NewEmptyCollectCountVariableContext() *CollectCountVariableContext

+ func (*CollectCountVariableContext) IsCollectCountVariableContext()

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

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

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

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

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

+ func (s *CollectCountVariableContext) Identifier() antlr.TerminalNode

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

+ type CollectGroupVariableContext struct

+ func NewCollectGroupVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectGroupVariableContext

+ func NewEmptyCollectGroupVariableContext() *CollectGroupVariableContext

+ func (*CollectGroupVariableContext) IsCollectGroupVariableContext()

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

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

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

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

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

+ func (s *CollectGroupVariableContext) Identifier() antlr.TerminalNode

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

+ type CollectKeepVariableContext struct

+ func NewCollectKeepVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectKeepVariableContext

+ func NewEmptyCollectKeepVariableContext() *CollectKeepVariableContext

+ func (*CollectKeepVariableContext) IsCollectKeepVariableContext()

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

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

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

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

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

+ func (s *CollectKeepVariableContext) Identifier() antlr.TerminalNode

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

+ type CollectOptionContext struct

+ func NewCollectOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectOptionContext

+ func NewEmptyCollectOptionContext() *CollectOptionContext

+ func (*CollectOptionContext) IsCollectOptionContext()

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

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

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

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

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

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

+ type CollectVariableContext struct

+ func NewCollectVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectVariableContext

+ func NewEmptyCollectVariableContext() *CollectVariableContext

+ func (*CollectVariableContext) IsCollectVariableContext()

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

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

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

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

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

+ func (s *CollectVariableContext) Identifier() antlr.TerminalNode

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

+ type ComputedPropertyNameContext struct

+ func NewComputedPropertyNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComputedPropertyNameContext

+ func NewEmptyComputedPropertyNameContext() *ComputedPropertyNameContext

+ func (*ComputedPropertyNameContext) IsComputedPropertyNameContext()

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

+ func (s *ComputedPropertyNameContext) CloseBracket() antlr.TerminalNode

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

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

+ func (s *ComputedPropertyNameContext) Expression() IExpressionContext

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

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

+ func (s *ComputedPropertyNameContext) OpenBracket() antlr.TerminalNode

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

+ type EqualityOperatorContext struct

+ func NewEmptyEqualityOperatorContext() *EqualityOperatorContext

+ func NewEqualityOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EqualityOperatorContext

+ func (*EqualityOperatorContext) IsEqualityOperatorContext()

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

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

+ func (s *EqualityOperatorContext) Eq() antlr.TerminalNode

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

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

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

+ func (s *EqualityOperatorContext) Gt() antlr.TerminalNode

+ func (s *EqualityOperatorContext) Gte() antlr.TerminalNode

+ func (s *EqualityOperatorContext) Lt() antlr.TerminalNode

+ func (s *EqualityOperatorContext) Lte() antlr.TerminalNode

+ func (s *EqualityOperatorContext) Neq() antlr.TerminalNode

+ func (s *EqualityOperatorContext) 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) AllExpression() []IExpressionContext

+ func (s *ExpressionContext) ArrayLiteral() IArrayLiteralContext

+ func (s *ExpressionContext) ArrayOperator() IArrayOperatorContext

+ func (s *ExpressionContext) BooleanLiteral() IBooleanLiteralContext

+ func (s *ExpressionContext) CloseParen() antlr.TerminalNode

+ func (s *ExpressionContext) Colon() antlr.TerminalNode

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

+ func (s *ExpressionContext) EqualityOperator() IEqualityOperatorContext

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

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

+ func (s *ExpressionContext) ExpressionSequence() IExpressionSequenceContext

+ func (s *ExpressionContext) FloatLiteral() IFloatLiteralContext

+ func (s *ExpressionContext) FunctionCallExpression() IFunctionCallExpressionContext

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

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

+ func (s *ExpressionContext) InOperator() IInOperatorContext

+ func (s *ExpressionContext) IntegerLiteral() IIntegerLiteralContext

+ func (s *ExpressionContext) LogicalOperator() ILogicalOperatorContext

+ func (s *ExpressionContext) MathOperator() IMathOperatorContext

+ func (s *ExpressionContext) MemberExpression() IMemberExpressionContext

+ func (s *ExpressionContext) Minus() antlr.TerminalNode

+ func (s *ExpressionContext) NoneLiteral() INoneLiteralContext

+ func (s *ExpressionContext) Not() antlr.TerminalNode

+ func (s *ExpressionContext) ObjectLiteral() IObjectLiteralContext

+ func (s *ExpressionContext) OpenParen() antlr.TerminalNode

+ func (s *ExpressionContext) Param() IParamContext

+ func (s *ExpressionContext) Plus() antlr.TerminalNode

+ func (s *ExpressionContext) QuestionMark() antlr.TerminalNode

+ func (s *ExpressionContext) RangeOperator() IRangeOperatorContext

+ func (s *ExpressionContext) StringLiteral() IStringLiteralContext

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

+ func (s *ExpressionContext) Variable() IVariableContext

+ type ExpressionSequenceContext struct

+ func NewEmptyExpressionSequenceContext() *ExpressionSequenceContext

+ func NewExpressionSequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionSequenceContext

+ func (*ExpressionSequenceContext) IsExpressionSequenceContext()

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

+ func (s *ExpressionSequenceContext) AllComma() []antlr.TerminalNode

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

+ func (s *ExpressionSequenceContext) Comma(i int) antlr.TerminalNode

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

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

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

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

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

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

+ type FilterClauseContext struct

+ func NewEmptyFilterClauseContext() *FilterClauseContext

+ func NewFilterClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterClauseContext

+ func (*FilterClauseContext) IsFilterClauseContext()

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

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

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

+ func (s *FilterClauseContext) Expression() IExpressionContext

+ func (s *FilterClauseContext) Filter() antlr.TerminalNode

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

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

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

+ type FloatLiteralContext struct

+ func NewEmptyFloatLiteralContext() *FloatLiteralContext

+ func NewFloatLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FloatLiteralContext

+ func (*FloatLiteralContext) IsFloatLiteralContext()

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

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

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

+ func (s *FloatLiteralContext) FloatLiteral() antlr.TerminalNode

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

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

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

+ type ForExpressionBodyContext struct

+ func NewEmptyForExpressionBodyContext() *ForExpressionBodyContext

+ func NewForExpressionBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionBodyContext

+ func (*ForExpressionBodyContext) IsForExpressionBodyContext()

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

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

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

+ func (s *ForExpressionBodyContext) FunctionCallExpression() IFunctionCallExpressionContext

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

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

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

+ func (s *ForExpressionBodyContext) VariableDeclaration() IVariableDeclarationContext

+ type ForExpressionClauseContext struct

+ func NewEmptyForExpressionClauseContext() *ForExpressionClauseContext

+ func NewForExpressionClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionClauseContext

+ func (*ForExpressionClauseContext) IsForExpressionClauseContext()

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

+ func (s *ForExpressionClauseContext) CollectClause() ICollectClauseContext

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

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

+ func (s *ForExpressionClauseContext) FilterClause() IFilterClauseContext

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

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

+ func (s *ForExpressionClauseContext) LimitClause() ILimitClauseContext

+ func (s *ForExpressionClauseContext) SortClause() ISortClauseContext

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

+ type ForExpressionContext struct

+ func NewEmptyForExpressionContext() *ForExpressionContext

+ func NewForExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionContext

+ func (*ForExpressionContext) IsForExpressionContext()

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

+ func (s *ForExpressionContext) AllForExpressionBody() []IForExpressionBodyContext

+ func (s *ForExpressionContext) AllForExpressionClause() []IForExpressionClauseContext

+ func (s *ForExpressionContext) Comma() antlr.TerminalNode

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

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

+ func (s *ForExpressionContext) For() antlr.TerminalNode

+ func (s *ForExpressionContext) ForExpressionBody(i int) IForExpressionBodyContext

+ func (s *ForExpressionContext) ForExpressionClause(i int) IForExpressionClauseContext

+ func (s *ForExpressionContext) ForExpressionKeyVariable() IForExpressionKeyVariableContext

+ func (s *ForExpressionContext) ForExpressionReturn() IForExpressionReturnContext

+ func (s *ForExpressionContext) ForExpressionSource() IForExpressionSourceContext

+ func (s *ForExpressionContext) ForExpressionValueVariable() IForExpressionValueVariableContext

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

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

+ func (s *ForExpressionContext) In() antlr.TerminalNode

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

+ type ForExpressionKeyVariableContext struct

+ func NewEmptyForExpressionKeyVariableContext() *ForExpressionKeyVariableContext

+ func NewForExpressionKeyVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionKeyVariableContext

+ func (*ForExpressionKeyVariableContext) IsForExpressionKeyVariableContext()

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

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

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

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

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

+ func (s *ForExpressionKeyVariableContext) Identifier() antlr.TerminalNode

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

+ type ForExpressionReturnContext struct

+ func NewEmptyForExpressionReturnContext() *ForExpressionReturnContext

+ func NewForExpressionReturnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionReturnContext

+ func (*ForExpressionReturnContext) IsForExpressionReturnContext()

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

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

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

+ func (s *ForExpressionReturnContext) ForExpression() IForExpressionContext

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

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

+ func (s *ForExpressionReturnContext) ReturnExpression() IReturnExpressionContext

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

+ type ForExpressionSourceContext struct

+ func NewEmptyForExpressionSourceContext() *ForExpressionSourceContext

+ func NewForExpressionSourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionSourceContext

+ func (*ForExpressionSourceContext) IsForExpressionSourceContext()

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

+ func (s *ForExpressionSourceContext) ArrayLiteral() IArrayLiteralContext

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

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

+ func (s *ForExpressionSourceContext) FunctionCallExpression() IFunctionCallExpressionContext

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

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

+ func (s *ForExpressionSourceContext) MemberExpression() IMemberExpressionContext

+ func (s *ForExpressionSourceContext) ObjectLiteral() IObjectLiteralContext

+ func (s *ForExpressionSourceContext) Param() IParamContext

+ func (s *ForExpressionSourceContext) RangeOperator() IRangeOperatorContext

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

+ func (s *ForExpressionSourceContext) Variable() IVariableContext

+ type ForExpressionValueVariableContext struct

+ func NewEmptyForExpressionValueVariableContext() *ForExpressionValueVariableContext

+ func NewForExpressionValueVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionValueVariableContext

+ func (*ForExpressionValueVariableContext) IsForExpressionValueVariableContext()

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

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

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

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

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

+ func (s *ForExpressionValueVariableContext) Identifier() antlr.TerminalNode

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

+ type ForTernaryExpressionContext struct

+ func NewEmptyForTernaryExpressionContext() *ForTernaryExpressionContext

+ func NewForTernaryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForTernaryExpressionContext

+ func (*ForTernaryExpressionContext) IsForTernaryExpressionContext()

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

+ func (s *ForTernaryExpressionContext) AllCloseParen() []antlr.TerminalNode

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

+ func (s *ForTernaryExpressionContext) AllForExpression() []IForExpressionContext

+ func (s *ForTernaryExpressionContext) AllOpenParen() []antlr.TerminalNode

+ func (s *ForTernaryExpressionContext) CloseParen(i int) antlr.TerminalNode

+ func (s *ForTernaryExpressionContext) Colon() antlr.TerminalNode

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

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

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

+ func (s *ForTernaryExpressionContext) ForExpression(i int) IForExpressionContext

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

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

+ func (s *ForTernaryExpressionContext) OpenParen(i int) antlr.TerminalNode

+ func (s *ForTernaryExpressionContext) QuestionMark() antlr.TerminalNode

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

+ type FqlLexer struct

+ func NewFqlLexer(input antlr.CharStream) *FqlLexer

+ type FqlParser struct

+ func NewFqlParser(input antlr.TokenStream) *FqlParser

+ func (p *FqlParser) Arguments() (localctx IArgumentsContext)

+ func (p *FqlParser) ArrayElementList() (localctx IArrayElementListContext)

+ func (p *FqlParser) ArrayLiteral() (localctx IArrayLiteralContext)

+ func (p *FqlParser) ArrayOperator() (localctx IArrayOperatorContext)

+ func (p *FqlParser) Body() (localctx IBodyContext)

+ func (p *FqlParser) BodyExpression() (localctx IBodyExpressionContext)

+ func (p *FqlParser) BodyStatement() (localctx IBodyStatementContext)

+ func (p *FqlParser) BooleanLiteral() (localctx IBooleanLiteralContext)

+ func (p *FqlParser) CollectAggregateExpression() (localctx ICollectAggregateExpressionContext)

+ func (p *FqlParser) CollectAggregateVariable() (localctx ICollectAggregateVariableContext)

+ func (p *FqlParser) CollectClause() (localctx ICollectClauseContext)

+ func (p *FqlParser) CollectCountVariable() (localctx ICollectCountVariableContext)

+ func (p *FqlParser) CollectGroupVariable() (localctx ICollectGroupVariableContext)

+ func (p *FqlParser) CollectKeepVariable() (localctx ICollectKeepVariableContext)

+ func (p *FqlParser) CollectOption() (localctx ICollectOptionContext)

+ func (p *FqlParser) CollectVariable() (localctx ICollectVariableContext)

+ func (p *FqlParser) ComputedPropertyName() (localctx IComputedPropertyNameContext)

+ func (p *FqlParser) EqualityOperator() (localctx IEqualityOperatorContext)

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

+ func (p *FqlParser) ExpressionSequence() (localctx IExpressionSequenceContext)

+ func (p *FqlParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *FqlParser) FilterClause() (localctx IFilterClauseContext)

+ func (p *FqlParser) FloatLiteral() (localctx IFloatLiteralContext)

+ func (p *FqlParser) ForExpression() (localctx IForExpressionContext)

+ func (p *FqlParser) ForExpressionBody() (localctx IForExpressionBodyContext)

+ func (p *FqlParser) ForExpressionClause() (localctx IForExpressionClauseContext)

+ func (p *FqlParser) ForExpressionKeyVariable() (localctx IForExpressionKeyVariableContext)

+ func (p *FqlParser) ForExpressionReturn() (localctx IForExpressionReturnContext)

+ func (p *FqlParser) ForExpressionSource() (localctx IForExpressionSourceContext)

+ func (p *FqlParser) ForExpressionValueVariable() (localctx IForExpressionValueVariableContext)

+ func (p *FqlParser) ForTernaryExpression() (localctx IForTernaryExpressionContext)

+ func (p *FqlParser) FunctionCallExpression() (localctx IFunctionCallExpressionContext)

+ func (p *FqlParser) InOperator() (localctx IInOperatorContext)

+ func (p *FqlParser) IntegerLiteral() (localctx IIntegerLiteralContext)

+ func (p *FqlParser) LimitClause() (localctx ILimitClauseContext)

+ func (p *FqlParser) LogicalOperator() (localctx ILogicalOperatorContext)

+ func (p *FqlParser) MathOperator() (localctx IMathOperatorContext)

+ func (p *FqlParser) MemberExpression() (localctx IMemberExpressionContext)

+ func (p *FqlParser) NoneLiteral() (localctx INoneLiteralContext)

+ func (p *FqlParser) ObjectLiteral() (localctx IObjectLiteralContext)

+ func (p *FqlParser) Param() (localctx IParamContext)

+ func (p *FqlParser) Program() (localctx IProgramContext)

+ func (p *FqlParser) PropertyAssignment() (localctx IPropertyAssignmentContext)

+ func (p *FqlParser) PropertyName() (localctx IPropertyNameContext)

+ func (p *FqlParser) RangeOperator() (localctx IRangeOperatorContext)

+ func (p *FqlParser) ReturnExpression() (localctx IReturnExpressionContext)

+ func (p *FqlParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

+ func (p *FqlParser) ShorthandPropertyName() (localctx IShorthandPropertyNameContext)

+ func (p *FqlParser) SortClause() (localctx ISortClauseContext)

+ func (p *FqlParser) SortClauseExpression() (localctx ISortClauseExpressionContext)

+ func (p *FqlParser) StringLiteral() (localctx IStringLiteralContext)

+ func (p *FqlParser) UnaryOperator() (localctx IUnaryOperatorContext)

+ func (p *FqlParser) Variable() (localctx IVariableContext)

+ func (p *FqlParser) VariableDeclaration() (localctx IVariableDeclarationContext)

+ type FqlParserListener interface

+ EnterArguments func(c *ArgumentsContext)

+ EnterArrayElementList func(c *ArrayElementListContext)

+ EnterArrayLiteral func(c *ArrayLiteralContext)

+ EnterArrayOperator func(c *ArrayOperatorContext)

+ EnterBody func(c *BodyContext)

+ EnterBodyExpression func(c *BodyExpressionContext)

+ EnterBodyStatement func(c *BodyStatementContext)

+ EnterBooleanLiteral func(c *BooleanLiteralContext)

+ EnterCollectAggregateExpression func(c *CollectAggregateExpressionContext)

+ EnterCollectAggregateVariable func(c *CollectAggregateVariableContext)

+ EnterCollectClause func(c *CollectClauseContext)

+ EnterCollectCountVariable func(c *CollectCountVariableContext)

+ EnterCollectGroupVariable func(c *CollectGroupVariableContext)

+ EnterCollectKeepVariable func(c *CollectKeepVariableContext)

+ EnterCollectOption func(c *CollectOptionContext)

+ EnterCollectVariable func(c *CollectVariableContext)

+ EnterComputedPropertyName func(c *ComputedPropertyNameContext)

+ EnterEqualityOperator func(c *EqualityOperatorContext)

+ EnterExpression func(c *ExpressionContext)

+ EnterExpressionSequence func(c *ExpressionSequenceContext)

+ EnterFilterClause func(c *FilterClauseContext)

+ EnterFloatLiteral func(c *FloatLiteralContext)

+ EnterForExpression func(c *ForExpressionContext)

+ EnterForExpressionBody func(c *ForExpressionBodyContext)

+ EnterForExpressionClause func(c *ForExpressionClauseContext)

+ EnterForExpressionKeyVariable func(c *ForExpressionKeyVariableContext)

+ EnterForExpressionReturn func(c *ForExpressionReturnContext)

+ EnterForExpressionSource func(c *ForExpressionSourceContext)

+ EnterForExpressionValueVariable func(c *ForExpressionValueVariableContext)

+ EnterForTernaryExpression func(c *ForTernaryExpressionContext)

+ EnterFunctionCallExpression func(c *FunctionCallExpressionContext)

+ EnterInOperator func(c *InOperatorContext)

+ EnterIntegerLiteral func(c *IntegerLiteralContext)

+ EnterLimitClause func(c *LimitClauseContext)

+ EnterLogicalOperator func(c *LogicalOperatorContext)

+ EnterMathOperator func(c *MathOperatorContext)

+ EnterMemberExpression func(c *MemberExpressionContext)

+ EnterNoneLiteral func(c *NoneLiteralContext)

+ EnterObjectLiteral func(c *ObjectLiteralContext)

+ EnterParam func(c *ParamContext)

+ EnterProgram func(c *ProgramContext)

+ EnterPropertyAssignment func(c *PropertyAssignmentContext)

+ EnterPropertyName func(c *PropertyNameContext)

+ EnterRangeOperator func(c *RangeOperatorContext)

+ EnterReturnExpression func(c *ReturnExpressionContext)

+ EnterShorthandPropertyName func(c *ShorthandPropertyNameContext)

+ EnterSortClause func(c *SortClauseContext)

+ EnterSortClauseExpression func(c *SortClauseExpressionContext)

+ EnterStringLiteral func(c *StringLiteralContext)

+ EnterUnaryOperator func(c *UnaryOperatorContext)

+ EnterVariable func(c *VariableContext)

+ EnterVariableDeclaration func(c *VariableDeclarationContext)

+ ExitArguments func(c *ArgumentsContext)

+ ExitArrayElementList func(c *ArrayElementListContext)

+ ExitArrayLiteral func(c *ArrayLiteralContext)

+ ExitArrayOperator func(c *ArrayOperatorContext)

+ ExitBody func(c *BodyContext)

+ ExitBodyExpression func(c *BodyExpressionContext)

+ ExitBodyStatement func(c *BodyStatementContext)

+ ExitBooleanLiteral func(c *BooleanLiteralContext)

+ ExitCollectAggregateExpression func(c *CollectAggregateExpressionContext)

+ ExitCollectAggregateVariable func(c *CollectAggregateVariableContext)

+ ExitCollectClause func(c *CollectClauseContext)

+ ExitCollectCountVariable func(c *CollectCountVariableContext)

+ ExitCollectGroupVariable func(c *CollectGroupVariableContext)

+ ExitCollectKeepVariable func(c *CollectKeepVariableContext)

+ ExitCollectOption func(c *CollectOptionContext)

+ ExitCollectVariable func(c *CollectVariableContext)

+ ExitComputedPropertyName func(c *ComputedPropertyNameContext)

+ ExitEqualityOperator func(c *EqualityOperatorContext)

+ ExitExpression func(c *ExpressionContext)

+ ExitExpressionSequence func(c *ExpressionSequenceContext)

+ ExitFilterClause func(c *FilterClauseContext)

+ ExitFloatLiteral func(c *FloatLiteralContext)

+ ExitForExpression func(c *ForExpressionContext)

+ ExitForExpressionBody func(c *ForExpressionBodyContext)

+ ExitForExpressionClause func(c *ForExpressionClauseContext)

+ ExitForExpressionKeyVariable func(c *ForExpressionKeyVariableContext)

+ ExitForExpressionReturn func(c *ForExpressionReturnContext)

+ ExitForExpressionSource func(c *ForExpressionSourceContext)

+ ExitForExpressionValueVariable func(c *ForExpressionValueVariableContext)

+ ExitForTernaryExpression func(c *ForTernaryExpressionContext)

+ ExitFunctionCallExpression func(c *FunctionCallExpressionContext)

+ ExitInOperator func(c *InOperatorContext)

+ ExitIntegerLiteral func(c *IntegerLiteralContext)

+ ExitLimitClause func(c *LimitClauseContext)

+ ExitLogicalOperator func(c *LogicalOperatorContext)

+ ExitMathOperator func(c *MathOperatorContext)

+ ExitMemberExpression func(c *MemberExpressionContext)

+ ExitNoneLiteral func(c *NoneLiteralContext)

+ ExitObjectLiteral func(c *ObjectLiteralContext)

+ ExitParam func(c *ParamContext)

+ ExitProgram func(c *ProgramContext)

+ ExitPropertyAssignment func(c *PropertyAssignmentContext)

+ ExitPropertyName func(c *PropertyNameContext)

+ ExitRangeOperator func(c *RangeOperatorContext)

+ ExitReturnExpression func(c *ReturnExpressionContext)

+ ExitShorthandPropertyName func(c *ShorthandPropertyNameContext)

+ ExitSortClause func(c *SortClauseContext)

+ ExitSortClauseExpression func(c *SortClauseExpressionContext)

+ ExitStringLiteral func(c *StringLiteralContext)

+ ExitUnaryOperator func(c *UnaryOperatorContext)

+ ExitVariable func(c *VariableContext)

+ ExitVariableDeclaration func(c *VariableDeclarationContext)

+ type FqlParserVisitor interface

+ VisitArguments func(ctx *ArgumentsContext) interface{}

+ VisitArrayElementList func(ctx *ArrayElementListContext) interface{}

+ VisitArrayLiteral func(ctx *ArrayLiteralContext) interface{}

+ VisitArrayOperator func(ctx *ArrayOperatorContext) interface{}

+ VisitBody func(ctx *BodyContext) interface{}

+ VisitBodyExpression func(ctx *BodyExpressionContext) interface{}

+ VisitBodyStatement func(ctx *BodyStatementContext) interface{}

+ VisitBooleanLiteral func(ctx *BooleanLiteralContext) interface{}

+ VisitCollectAggregateExpression func(ctx *CollectAggregateExpressionContext) interface{}

+ VisitCollectAggregateVariable func(ctx *CollectAggregateVariableContext) interface{}

+ VisitCollectClause func(ctx *CollectClauseContext) interface{}

+ VisitCollectCountVariable func(ctx *CollectCountVariableContext) interface{}

+ VisitCollectGroupVariable func(ctx *CollectGroupVariableContext) interface{}

+ VisitCollectKeepVariable func(ctx *CollectKeepVariableContext) interface{}

+ VisitCollectOption func(ctx *CollectOptionContext) interface{}

+ VisitCollectVariable func(ctx *CollectVariableContext) interface{}

+ VisitComputedPropertyName func(ctx *ComputedPropertyNameContext) interface{}

+ VisitEqualityOperator func(ctx *EqualityOperatorContext) interface{}

+ VisitExpression func(ctx *ExpressionContext) interface{}

+ VisitExpressionSequence func(ctx *ExpressionSequenceContext) interface{}

+ VisitFilterClause func(ctx *FilterClauseContext) interface{}

+ VisitFloatLiteral func(ctx *FloatLiteralContext) interface{}

+ VisitForExpression func(ctx *ForExpressionContext) interface{}

+ VisitForExpressionBody func(ctx *ForExpressionBodyContext) interface{}

+ VisitForExpressionClause func(ctx *ForExpressionClauseContext) interface{}

+ VisitForExpressionKeyVariable func(ctx *ForExpressionKeyVariableContext) interface{}

+ VisitForExpressionReturn func(ctx *ForExpressionReturnContext) interface{}

+ VisitForExpressionSource func(ctx *ForExpressionSourceContext) interface{}

+ VisitForExpressionValueVariable func(ctx *ForExpressionValueVariableContext) interface{}

+ VisitForTernaryExpression func(ctx *ForTernaryExpressionContext) interface{}

+ VisitFunctionCallExpression func(ctx *FunctionCallExpressionContext) interface{}

+ VisitInOperator func(ctx *InOperatorContext) interface{}

+ VisitIntegerLiteral func(ctx *IntegerLiteralContext) interface{}

+ VisitLimitClause func(ctx *LimitClauseContext) interface{}

+ VisitLogicalOperator func(ctx *LogicalOperatorContext) interface{}

+ VisitMathOperator func(ctx *MathOperatorContext) interface{}

+ VisitMemberExpression func(ctx *MemberExpressionContext) interface{}

+ VisitNoneLiteral func(ctx *NoneLiteralContext) interface{}

+ VisitObjectLiteral func(ctx *ObjectLiteralContext) interface{}

+ VisitParam func(ctx *ParamContext) interface{}

+ VisitProgram func(ctx *ProgramContext) interface{}

+ VisitPropertyAssignment func(ctx *PropertyAssignmentContext) interface{}

+ VisitPropertyName func(ctx *PropertyNameContext) interface{}

+ VisitRangeOperator func(ctx *RangeOperatorContext) interface{}

+ VisitReturnExpression func(ctx *ReturnExpressionContext) interface{}

+ VisitShorthandPropertyName func(ctx *ShorthandPropertyNameContext) interface{}

+ VisitSortClause func(ctx *SortClauseContext) interface{}

+ VisitSortClauseExpression func(ctx *SortClauseExpressionContext) interface{}

+ VisitStringLiteral func(ctx *StringLiteralContext) interface{}

+ VisitUnaryOperator func(ctx *UnaryOperatorContext) interface{}

+ VisitVariable func(ctx *VariableContext) interface{}

+ VisitVariableDeclaration func(ctx *VariableDeclarationContext) interface{}

+ type FunctionCallExpressionContext struct

+ func NewEmptyFunctionCallExpressionContext() *FunctionCallExpressionContext

+ func NewFunctionCallExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallExpressionContext

+ func (*FunctionCallExpressionContext) IsFunctionCallExpressionContext()

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

+ func (s *FunctionCallExpressionContext) Arguments() IArgumentsContext

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

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

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

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

+ func (s *FunctionCallExpressionContext) Identifier() antlr.TerminalNode

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

+ type IArgumentsContext interface

+ GetParser func() antlr.Parser

+ IsArgumentsContext func()

+ type IArrayElementListContext interface

+ GetParser func() antlr.Parser

+ IsArrayElementListContext func()

+ type IArrayLiteralContext interface

+ GetParser func() antlr.Parser

+ IsArrayLiteralContext func()

+ type IArrayOperatorContext interface

+ GetParser func() antlr.Parser

+ IsArrayOperatorContext func()

+ type IBodyContext interface

+ GetParser func() antlr.Parser

+ IsBodyContext func()

+ type IBodyExpressionContext interface

+ GetParser func() antlr.Parser

+ IsBodyExpressionContext func()

+ type IBodyStatementContext interface

+ GetParser func() antlr.Parser

+ IsBodyStatementContext func()

+ type IBooleanLiteralContext interface

+ GetParser func() antlr.Parser

+ IsBooleanLiteralContext func()

+ type ICollectAggregateExpressionContext interface

+ GetParser func() antlr.Parser

+ IsCollectAggregateExpressionContext func()

+ type ICollectAggregateVariableContext interface

+ GetParser func() antlr.Parser

+ IsCollectAggregateVariableContext func()

+ type ICollectClauseContext interface

+ GetParser func() antlr.Parser

+ IsCollectClauseContext func()

+ type ICollectCountVariableContext interface

+ GetParser func() antlr.Parser

+ IsCollectCountVariableContext func()

+ type ICollectGroupVariableContext interface

+ GetParser func() antlr.Parser

+ IsCollectGroupVariableContext func()

+ type ICollectKeepVariableContext interface

+ GetParser func() antlr.Parser

+ IsCollectKeepVariableContext func()

+ type ICollectOptionContext interface

+ GetParser func() antlr.Parser

+ IsCollectOptionContext func()

+ type ICollectVariableContext interface

+ GetParser func() antlr.Parser

+ IsCollectVariableContext func()

+ type IComputedPropertyNameContext interface

+ GetParser func() antlr.Parser

+ IsComputedPropertyNameContext func()

+ type IEqualityOperatorContext interface

+ GetParser func() antlr.Parser

+ IsEqualityOperatorContext func()

+ type IExpressionContext interface

+ GetParser func() antlr.Parser

+ IsExpressionContext func()

+ type IExpressionSequenceContext interface

+ GetParser func() antlr.Parser

+ IsExpressionSequenceContext func()

+ type IFilterClauseContext interface

+ GetParser func() antlr.Parser

+ IsFilterClauseContext func()

+ type IFloatLiteralContext interface

+ GetParser func() antlr.Parser

+ IsFloatLiteralContext func()

+ type IForExpressionBodyContext interface

+ GetParser func() antlr.Parser

+ IsForExpressionBodyContext func()

+ type IForExpressionClauseContext interface

+ GetParser func() antlr.Parser

+ IsForExpressionClauseContext func()

+ type IForExpressionContext interface

+ GetParser func() antlr.Parser

+ IsForExpressionContext func()

+ type IForExpressionKeyVariableContext interface

+ GetParser func() antlr.Parser

+ IsForExpressionKeyVariableContext func()

+ type IForExpressionReturnContext interface

+ GetParser func() antlr.Parser

+ IsForExpressionReturnContext func()

+ type IForExpressionSourceContext interface

+ GetParser func() antlr.Parser

+ IsForExpressionSourceContext func()

+ type IForExpressionValueVariableContext interface

+ GetParser func() antlr.Parser

+ IsForExpressionValueVariableContext func()

+ type IForTernaryExpressionContext interface

+ GetParser func() antlr.Parser

+ IsForTernaryExpressionContext func()

+ type IFunctionCallExpressionContext interface

+ GetParser func() antlr.Parser

+ IsFunctionCallExpressionContext func()

+ type IInOperatorContext interface

+ GetParser func() antlr.Parser

+ IsInOperatorContext func()

+ type IIntegerLiteralContext interface

+ GetParser func() antlr.Parser

+ IsIntegerLiteralContext func()

+ type ILimitClauseContext interface

+ GetParser func() antlr.Parser

+ IsLimitClauseContext func()

+ type ILogicalOperatorContext interface

+ GetParser func() antlr.Parser

+ IsLogicalOperatorContext func()

+ type IMathOperatorContext interface

+ GetParser func() antlr.Parser

+ IsMathOperatorContext func()

+ type IMemberExpressionContext interface

+ GetParser func() antlr.Parser

+ IsMemberExpressionContext func()

+ type INoneLiteralContext interface

+ GetParser func() antlr.Parser

+ IsNoneLiteralContext func()

+ type IObjectLiteralContext interface

+ GetParser func() antlr.Parser

+ IsObjectLiteralContext func()

+ type IParamContext interface

+ GetParser func() antlr.Parser

+ IsParamContext func()

+ type IProgramContext interface

+ GetParser func() antlr.Parser

+ IsProgramContext func()

+ type IPropertyAssignmentContext interface

+ GetParser func() antlr.Parser

+ IsPropertyAssignmentContext func()

+ type IPropertyNameContext interface

+ GetParser func() antlr.Parser

+ IsPropertyNameContext func()

+ type IRangeOperatorContext interface

+ GetParser func() antlr.Parser

+ IsRangeOperatorContext func()

+ type IReturnExpressionContext interface

+ GetParser func() antlr.Parser

+ IsReturnExpressionContext func()

+ type IShorthandPropertyNameContext interface

+ GetParser func() antlr.Parser

+ IsShorthandPropertyNameContext func()

+ type ISortClauseContext interface

+ GetParser func() antlr.Parser

+ IsSortClauseContext func()

+ type ISortClauseExpressionContext interface

+ GetParser func() antlr.Parser

+ IsSortClauseExpressionContext func()

+ type IStringLiteralContext interface

+ GetParser func() antlr.Parser

+ IsStringLiteralContext func()

+ type IUnaryOperatorContext interface

+ GetParser func() antlr.Parser

+ IsUnaryOperatorContext func()

+ type IVariableContext interface

+ GetParser func() antlr.Parser

+ IsVariableContext func()

+ type IVariableDeclarationContext interface

+ GetParser func() antlr.Parser

+ IsVariableDeclarationContext func()

+ type InOperatorContext struct

+ func NewEmptyInOperatorContext() *InOperatorContext

+ func NewInOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InOperatorContext

+ func (*InOperatorContext) IsInOperatorContext()

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

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

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

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

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

+ func (s *InOperatorContext) In() antlr.TerminalNode

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

+ type IntegerLiteralContext struct

+ func NewEmptyIntegerLiteralContext() *IntegerLiteralContext

+ func NewIntegerLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntegerLiteralContext

+ func (*IntegerLiteralContext) IsIntegerLiteralContext()

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

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

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

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

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

+ func (s *IntegerLiteralContext) IntegerLiteral() antlr.TerminalNode

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

+ type LimitClauseContext struct

+ func NewEmptyLimitClauseContext() *LimitClauseContext

+ func NewLimitClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseContext

+ func (*LimitClauseContext) IsLimitClauseContext()

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

+ func (s *LimitClauseContext) AllIntegerLiteral() []antlr.TerminalNode

+ func (s *LimitClauseContext) Comma() antlr.TerminalNode

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

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

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

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

+ func (s *LimitClauseContext) IntegerLiteral(i int) antlr.TerminalNode

+ func (s *LimitClauseContext) Limit() antlr.TerminalNode

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

+ type LogicalOperatorContext struct

+ func NewEmptyLogicalOperatorContext() *LogicalOperatorContext

+ func NewLogicalOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LogicalOperatorContext

+ func (*LogicalOperatorContext) IsLogicalOperatorContext()

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

+ func (s *LogicalOperatorContext) And() antlr.TerminalNode

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

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

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

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

+ func (s *LogicalOperatorContext) Or() antlr.TerminalNode

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

+ type MathOperatorContext struct

+ func NewEmptyMathOperatorContext() *MathOperatorContext

+ func NewMathOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MathOperatorContext

+ func (*MathOperatorContext) IsMathOperatorContext()

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

+ func (s *MathOperatorContext) Div() antlr.TerminalNode

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

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

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

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

+ func (s *MathOperatorContext) Minus() antlr.TerminalNode

+ func (s *MathOperatorContext) Mod() antlr.TerminalNode

+ func (s *MathOperatorContext) Multi() antlr.TerminalNode

+ func (s *MathOperatorContext) Plus() antlr.TerminalNode

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

+ type MemberExpressionContext struct

+ func NewEmptyMemberExpressionContext() *MemberExpressionContext

+ func NewMemberExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberExpressionContext

+ func (*MemberExpressionContext) IsMemberExpressionContext()

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

+ func (s *MemberExpressionContext) AllComputedPropertyName() []IComputedPropertyNameContext

+ func (s *MemberExpressionContext) AllDot() []antlr.TerminalNode

+ func (s *MemberExpressionContext) AllPropertyName() []IPropertyNameContext

+ func (s *MemberExpressionContext) ComputedPropertyName(i int) IComputedPropertyNameContext

+ func (s *MemberExpressionContext) Dot(i int) antlr.TerminalNode

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

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

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

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

+ func (s *MemberExpressionContext) Identifier() antlr.TerminalNode

+ func (s *MemberExpressionContext) PropertyName(i int) IPropertyNameContext

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

+ type NoneLiteralContext struct

+ func NewEmptyNoneLiteralContext() *NoneLiteralContext

+ func NewNoneLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NoneLiteralContext

+ func (*NoneLiteralContext) IsNoneLiteralContext()

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

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

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

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

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

+ func (s *NoneLiteralContext) None() antlr.TerminalNode

+ func (s *NoneLiteralContext) Null() antlr.TerminalNode

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

+ type ObjectLiteralContext struct

+ func NewEmptyObjectLiteralContext() *ObjectLiteralContext

+ func NewObjectLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ObjectLiteralContext

+ func (*ObjectLiteralContext) IsObjectLiteralContext()

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

+ func (s *ObjectLiteralContext) AllComma() []antlr.TerminalNode

+ func (s *ObjectLiteralContext) AllPropertyAssignment() []IPropertyAssignmentContext

+ func (s *ObjectLiteralContext) CloseBrace() antlr.TerminalNode

+ func (s *ObjectLiteralContext) Comma(i int) antlr.TerminalNode

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

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

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

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

+ func (s *ObjectLiteralContext) OpenBrace() antlr.TerminalNode

+ func (s *ObjectLiteralContext) PropertyAssignment(i int) IPropertyAssignmentContext

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

+ type ParamContext struct

+ func NewEmptyParamContext() *ParamContext

+ func NewParamContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParamContext

+ func (*ParamContext) IsParamContext()

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

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

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

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

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

+ func (s *ParamContext) Identifier() antlr.TerminalNode

+ func (s *ParamContext) Param() antlr.TerminalNode

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

+ type ProgramContext struct

+ func NewEmptyProgramContext() *ProgramContext

+ func NewProgramContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProgramContext

+ func (*ProgramContext) IsProgramContext()

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

+ func (s *ProgramContext) Body() IBodyContext

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

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

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

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

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

+ type PropertyAssignmentContext struct

+ func NewEmptyPropertyAssignmentContext() *PropertyAssignmentContext

+ func NewPropertyAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyAssignmentContext

+ func (*PropertyAssignmentContext) IsPropertyAssignmentContext()

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

+ func (s *PropertyAssignmentContext) Colon() antlr.TerminalNode

+ func (s *PropertyAssignmentContext) ComputedPropertyName() IComputedPropertyNameContext

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

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

+ func (s *PropertyAssignmentContext) Expression() IExpressionContext

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

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

+ func (s *PropertyAssignmentContext) PropertyName() IPropertyNameContext

+ func (s *PropertyAssignmentContext) ShorthandPropertyName() IShorthandPropertyNameContext

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

+ type PropertyNameContext struct

+ func NewEmptyPropertyNameContext() *PropertyNameContext

+ func NewPropertyNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyNameContext

+ func (*PropertyNameContext) IsPropertyNameContext()

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

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

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

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

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

+ func (s *PropertyNameContext) Identifier() antlr.TerminalNode

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

+ type RangeOperatorContext struct

+ func NewEmptyRangeOperatorContext() *RangeOperatorContext

+ func NewRangeOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RangeOperatorContext

+ func (*RangeOperatorContext) IsRangeOperatorContext()

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

+ func (s *RangeOperatorContext) AllIntegerLiteral() []IIntegerLiteralContext

+ func (s *RangeOperatorContext) AllParam() []IParamContext

+ func (s *RangeOperatorContext) AllVariable() []IVariableContext

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

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

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

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

+ func (s *RangeOperatorContext) IntegerLiteral(i int) IIntegerLiteralContext

+ func (s *RangeOperatorContext) Param(i int) IParamContext

+ func (s *RangeOperatorContext) Range() antlr.TerminalNode

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

+ func (s *RangeOperatorContext) Variable(i int) IVariableContext

+ type ReturnExpressionContext struct

+ func NewEmptyReturnExpressionContext() *ReturnExpressionContext

+ func NewReturnExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnExpressionContext

+ func (*ReturnExpressionContext) IsReturnExpressionContext()

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

+ func (s *ReturnExpressionContext) CloseParen() antlr.TerminalNode

+ func (s *ReturnExpressionContext) Distinct() antlr.TerminalNode

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

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

+ func (s *ReturnExpressionContext) Expression() IExpressionContext

+ func (s *ReturnExpressionContext) ForExpression() IForExpressionContext

+ func (s *ReturnExpressionContext) ForTernaryExpression() IForTernaryExpressionContext

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

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

+ func (s *ReturnExpressionContext) OpenParen() antlr.TerminalNode

+ func (s *ReturnExpressionContext) Return() antlr.TerminalNode

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

+ type ShorthandPropertyNameContext struct

+ func NewEmptyShorthandPropertyNameContext() *ShorthandPropertyNameContext

+ func NewShorthandPropertyNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShorthandPropertyNameContext

+ func (*ShorthandPropertyNameContext) IsShorthandPropertyNameContext()

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

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

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

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

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

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

+ func (s *ShorthandPropertyNameContext) Variable() IVariableContext

+ type SortClauseContext struct

+ func NewEmptySortClauseContext() *SortClauseContext

+ func NewSortClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortClauseContext

+ func (*SortClauseContext) IsSortClauseContext()

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

+ func (s *SortClauseContext) AllComma() []antlr.TerminalNode

+ func (s *SortClauseContext) AllSortClauseExpression() []ISortClauseExpressionContext

+ func (s *SortClauseContext) Comma(i int) antlr.TerminalNode

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

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

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

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

+ func (s *SortClauseContext) Sort() antlr.TerminalNode

+ func (s *SortClauseContext) SortClauseExpression(i int) ISortClauseExpressionContext

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

+ type SortClauseExpressionContext struct

+ func NewEmptySortClauseExpressionContext() *SortClauseExpressionContext

+ func NewSortClauseExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortClauseExpressionContext

+ func (*SortClauseExpressionContext) IsSortClauseExpressionContext()

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

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

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

+ func (s *SortClauseExpressionContext) Expression() IExpressionContext

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

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

+ func (s *SortClauseExpressionContext) SortDirection() antlr.TerminalNode

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

+ type StringLiteralContext struct

+ func NewEmptyStringLiteralContext() *StringLiteralContext

+ func NewStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringLiteralContext

+ func (*StringLiteralContext) IsStringLiteralContext()

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

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

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

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

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

+ func (s *StringLiteralContext) StringLiteral() antlr.TerminalNode

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

+ type UnaryOperatorContext struct

+ func NewEmptyUnaryOperatorContext() *UnaryOperatorContext

+ func NewUnaryOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryOperatorContext

+ func (*UnaryOperatorContext) IsUnaryOperatorContext()

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

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

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

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

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

+ func (s *UnaryOperatorContext) Like() antlr.TerminalNode

+ func (s *UnaryOperatorContext) Minus() antlr.TerminalNode

+ func (s *UnaryOperatorContext) Not() antlr.TerminalNode

+ func (s *UnaryOperatorContext) Plus() antlr.TerminalNode

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

+ type VariableContext struct

+ func NewEmptyVariableContext() *VariableContext

+ func NewVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableContext

+ func (*VariableContext) IsVariableContext()

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

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

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

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

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

+ func (s *VariableContext) Identifier() antlr.TerminalNode

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

+ type VariableDeclarationContext struct

+ func NewEmptyVariableDeclarationContext() *VariableDeclarationContext

+ func NewVariableDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclarationContext

+ func (*VariableDeclarationContext) IsVariableDeclarationContext()

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

+ func (s *VariableDeclarationContext) Assign() antlr.TerminalNode

+ func (s *VariableDeclarationContext) CloseParen() antlr.TerminalNode

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

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

+ func (s *VariableDeclarationContext) Expression() IExpressionContext

+ func (s *VariableDeclarationContext) ForExpression() IForExpressionContext

+ func (s *VariableDeclarationContext) ForTernaryExpression() IForTernaryExpressionContext

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

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

+ func (s *VariableDeclarationContext) Identifier() antlr.TerminalNode

+ func (s *VariableDeclarationContext) Let() antlr.TerminalNode

+ func (s *VariableDeclarationContext) OpenParen() antlr.TerminalNode

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

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL