fql

package

Go to main page

Versions in this module

v0

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