zitiql

Jul 17, 2024

Changes in this version

+ const ZitiQlLexerICONTAINS

+ const ZitiQlParserICONTAINS

type BinaryContainsOpContext

+ func (s *BinaryContainsOpContext) ICONTAINS() antlr.TerminalNode

Sep 22, 2023

Changes in this version

+ var ZitiQlLexerLexerStaticData struct

+ var ZitiQlParserStaticData struct

+ func InitEmptyBinaryLhsContext(p *BinaryLhsContext)

+ func InitEmptyBoolExprContext(p *BoolExprContext)

+ func InitEmptyDatetimeArrayContext(p *DatetimeArrayContext)

+ func InitEmptyLimitContext(p *LimitContext)

+ func InitEmptyNumberArrayContext(p *NumberArrayContext)

+ func InitEmptyOperationContext(p *OperationContext)

+ func InitEmptyQueryContext(p *QueryContext)

+ func InitEmptySetExprContext(p *SetExprContext)

+ func InitEmptySetFunctionContext(p *SetFunctionContext)

+ func InitEmptySkipContext(p *SkipContext)

+ func InitEmptySortByContext(p *SortByContext)

+ func InitEmptySortFieldContext(p *SortFieldContext)

+ func InitEmptyStartContext(p *StartContext)

+ func InitEmptyStringArrayContext(p *StringArrayContext)

+ func InitEmptySubQueryExprContext(p *SubQueryExprContext)

+ func ZitiQlLexerInit()

+ func ZitiQlParserInit()

type BoolExprContext

+ func (s *BoolExprContext) CopyAll(ctx *BoolExprContext)

type IBinaryLhsContext

+ IDENTIFIER func() antlr.TerminalNode

+ SetFunction func() ISetFunctionContext

type IDatetimeArrayContext

+ AllDATETIME func() []antlr.TerminalNode

+ AllWS func() []antlr.TerminalNode

+ DATETIME func(i int) antlr.TerminalNode

+ LBRACKET func() antlr.TerminalNode

+ RBRACKET func() antlr.TerminalNode

+ WS func(i int) antlr.TerminalNode

type INumberArrayContext

+ AllNUMBER func() []antlr.TerminalNode

+ AllWS func() []antlr.TerminalNode

+ LBRACKET func() antlr.TerminalNode

+ NUMBER func(i int) antlr.TerminalNode

+ RBRACKET func() antlr.TerminalNode

+ WS func(i int) antlr.TerminalNode

type ISetExprContext

+ IDENTIFIER func() antlr.TerminalNode

+ SubQueryExpr func() ISubQueryExprContext

type IStringArrayContext

+ AllSTRING func() []antlr.TerminalNode

+ AllWS func() []antlr.TerminalNode

+ LBRACKET func() antlr.TerminalNode

+ RBRACKET func() antlr.TerminalNode

+ STRING func(i int) antlr.TerminalNode

+ WS func(i int) antlr.TerminalNode

type LimitContext

+ func (s *LimitContext) CopyAll(ctx *LimitContext)

type OperationContext

+ func (s *OperationContext) CopyAll(ctx *OperationContext)

type QueryContext

+ func (s *QueryContext) CopyAll(ctx *QueryContext)

type SetFunctionContext

+ func (s *SetFunctionContext) CopyAll(ctx *SetFunctionContext)

type SkipContext

+ func (s *SkipContext) CopyAll(ctx *SkipContext)

type SortByContext

+ func (s *SortByContext) CopyAll(ctx *SortByContext)

type SortFieldContext

+ func (s *SortFieldContext) CopyAll(ctx *SortFieldContext)

type StartContext

+ func (s *StartContext) CopyAll(ctx *StartContext)

type SubQueryExprContext

+ func (s *SubQueryExprContext) CopyAll(ctx *SubQueryExprContext)

type ZitiQlParser

+ func (p *ZitiQlParser) Start_() (localctx IStartContext)

Mar 30, 2022

Changes in this version

+ const ZitiQlLexerALL_OF

+ const ZitiQlLexerAND

+ const ZitiQlLexerANY_OF

+ const ZitiQlLexerASC

+ const ZitiQlLexerBETWEEN

+ const ZitiQlLexerBOOL

+ const ZitiQlLexerBY

+ const ZitiQlLexerCONTAINS

+ const ZitiQlLexerCOUNT

+ const ZitiQlLexerDATETIME

+ const ZitiQlLexerDESC

+ const ZitiQlLexerEQ

+ const ZitiQlLexerFROM

+ const ZitiQlLexerGT

+ const ZitiQlLexerIDENTIFIER

+ const ZitiQlLexerIN

+ const ZitiQlLexerISEMPTY

+ const ZitiQlLexerLBRACKET

+ const ZitiQlLexerLIMIT_ROWS

+ const ZitiQlLexerLPAREN

+ const ZitiQlLexerLT

+ const ZitiQlLexerNONE

+ const ZitiQlLexerNOT

+ const ZitiQlLexerNULL

+ const ZitiQlLexerNUMBER

+ const ZitiQlLexerOR

+ const ZitiQlLexerRBRACKET

+ const ZitiQlLexerRFC3339_DATE_TIME

+ const ZitiQlLexerRPAREN

+ const ZitiQlLexerSKIP_ROWS

+ const ZitiQlLexerSORT

+ const ZitiQlLexerSTRING

+ const ZitiQlLexerT__0

+ const ZitiQlLexerWHERE

+ const ZitiQlLexerWS

+ const ZitiQlParserALL_OF

+ const ZitiQlParserAND

+ const ZitiQlParserANY_OF

+ const ZitiQlParserASC

+ const ZitiQlParserBETWEEN

+ const ZitiQlParserBOOL

+ const ZitiQlParserBY

+ const ZitiQlParserCONTAINS

+ const ZitiQlParserCOUNT

+ const ZitiQlParserDATETIME

+ const ZitiQlParserDESC

+ const ZitiQlParserEOF

+ const ZitiQlParserEQ

+ const ZitiQlParserFROM

+ const ZitiQlParserGT

+ const ZitiQlParserIDENTIFIER

+ const ZitiQlParserIN

+ const ZitiQlParserISEMPTY

+ const ZitiQlParserLBRACKET

+ const ZitiQlParserLIMIT_ROWS

+ const ZitiQlParserLPAREN

+ const ZitiQlParserLT

+ const ZitiQlParserNONE

+ const ZitiQlParserNOT

+ const ZitiQlParserNULL

+ const ZitiQlParserNUMBER

+ const ZitiQlParserOR

+ const ZitiQlParserRBRACKET

+ const ZitiQlParserRFC3339_DATE_TIME

+ const ZitiQlParserRPAREN

+ const ZitiQlParserRULE_binaryLhs

+ const ZitiQlParserRULE_boolExpr

+ const ZitiQlParserRULE_datetimeArray

+ const ZitiQlParserRULE_limit

+ const ZitiQlParserRULE_numberArray

+ const ZitiQlParserRULE_operation

+ const ZitiQlParserRULE_query

+ const ZitiQlParserRULE_setExpr

+ const ZitiQlParserRULE_setFunction

+ const ZitiQlParserRULE_skip

+ const ZitiQlParserRULE_sortBy

+ const ZitiQlParserRULE_sortField

+ const ZitiQlParserRULE_start

+ const ZitiQlParserRULE_stringArray

+ const ZitiQlParserRULE_subQueryExpr

+ const ZitiQlParserSKIP_ROWS

+ const ZitiQlParserSORT

+ const ZitiQlParserSTRING

+ const ZitiQlParserT__0

+ const ZitiQlParserWHERE

+ const ZitiQlParserWS

+ func ParseZqlDatetime(text string) (time.Time, error)

+ func ParseZqlString(text string) string

+ type AndExprContext struct

+ func NewAndExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AndExprContext

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

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

+ func (s *AndExprContext) AllBoolExpr() []IBoolExprContext

+ func (s *AndExprContext) AllWS() []antlr.TerminalNode

+ func (s *AndExprContext) BoolExpr(i int) IBoolExprContext

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

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

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

+ func (s *AndExprContext) WS(i int) antlr.TerminalNode

+ type BaseZitiQlListener struct

+ func (s *BaseZitiQlListener) EnterAndExpr(ctx *AndExprContext)

+ func (s *BaseZitiQlListener) EnterBetweenDateOp(ctx *BetweenDateOpContext)

+ func (s *BaseZitiQlListener) EnterBetweenNumberOp(ctx *BetweenNumberOpContext)

+ func (s *BaseZitiQlListener) EnterBinaryContainsOp(ctx *BinaryContainsOpContext)

+ func (s *BaseZitiQlListener) EnterBinaryEqualToBoolOp(ctx *BinaryEqualToBoolOpContext)

+ func (s *BaseZitiQlListener) EnterBinaryEqualToDatetimeOp(ctx *BinaryEqualToDatetimeOpContext)

+ func (s *BaseZitiQlListener) EnterBinaryEqualToNullOp(ctx *BinaryEqualToNullOpContext)

+ func (s *BaseZitiQlListener) EnterBinaryEqualToNumberOp(ctx *BinaryEqualToNumberOpContext)

+ func (s *BaseZitiQlListener) EnterBinaryEqualToStringOp(ctx *BinaryEqualToStringOpContext)

+ func (s *BaseZitiQlListener) EnterBinaryGreaterThanDatetimeOp(ctx *BinaryGreaterThanDatetimeOpContext)

+ func (s *BaseZitiQlListener) EnterBinaryGreaterThanNumberOp(ctx *BinaryGreaterThanNumberOpContext)

+ func (s *BaseZitiQlListener) EnterBinaryGreaterThanStringOp(ctx *BinaryGreaterThanStringOpContext)

+ func (s *BaseZitiQlListener) EnterBinaryLessThanDatetimeOp(ctx *BinaryLessThanDatetimeOpContext)

+ func (s *BaseZitiQlListener) EnterBinaryLessThanNumberOp(ctx *BinaryLessThanNumberOpContext)

+ func (s *BaseZitiQlListener) EnterBinaryLessThanStringOp(ctx *BinaryLessThanStringOpContext)

+ func (s *BaseZitiQlListener) EnterBinaryLhs(ctx *BinaryLhsContext)

+ func (s *BaseZitiQlListener) EnterBoolConst(ctx *BoolConstContext)

+ func (s *BaseZitiQlListener) EnterBoolSymbol(ctx *BoolSymbolContext)

+ func (s *BaseZitiQlListener) EnterDatetimeArray(ctx *DatetimeArrayContext)

+ func (s *BaseZitiQlListener) EnterEnd(ctx *EndContext)

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

+ func (s *BaseZitiQlListener) EnterGroup(ctx *GroupContext)

+ func (s *BaseZitiQlListener) EnterInDatetimeArrayOp(ctx *InDatetimeArrayOpContext)

+ func (s *BaseZitiQlListener) EnterInNumberArrayOp(ctx *InNumberArrayOpContext)

+ func (s *BaseZitiQlListener) EnterInStringArrayOp(ctx *InStringArrayOpContext)

+ func (s *BaseZitiQlListener) EnterIsEmptyFunction(ctx *IsEmptyFunctionContext)

+ func (s *BaseZitiQlListener) EnterLimitExpr(ctx *LimitExprContext)

+ func (s *BaseZitiQlListener) EnterNotExpr(ctx *NotExprContext)

+ func (s *BaseZitiQlListener) EnterNumberArray(ctx *NumberArrayContext)

+ func (s *BaseZitiQlListener) EnterOperationOp(ctx *OperationOpContext)

+ func (s *BaseZitiQlListener) EnterOrExpr(ctx *OrExprContext)

+ func (s *BaseZitiQlListener) EnterQueryStmt(ctx *QueryStmtContext)

+ func (s *BaseZitiQlListener) EnterSetExpr(ctx *SetExprContext)

+ func (s *BaseZitiQlListener) EnterSetFunctionExpr(ctx *SetFunctionExprContext)

+ func (s *BaseZitiQlListener) EnterSkipExpr(ctx *SkipExprContext)

+ func (s *BaseZitiQlListener) EnterSortByExpr(ctx *SortByExprContext)

+ func (s *BaseZitiQlListener) EnterSortFieldExpr(ctx *SortFieldExprContext)

+ func (s *BaseZitiQlListener) EnterStringArray(ctx *StringArrayContext)

+ func (s *BaseZitiQlListener) EnterSubQuery(ctx *SubQueryContext)

+ func (s *BaseZitiQlListener) ExitAndExpr(ctx *AndExprContext)

+ func (s *BaseZitiQlListener) ExitBetweenDateOp(ctx *BetweenDateOpContext)

+ func (s *BaseZitiQlListener) ExitBetweenNumberOp(ctx *BetweenNumberOpContext)

+ func (s *BaseZitiQlListener) ExitBinaryContainsOp(ctx *BinaryContainsOpContext)

+ func (s *BaseZitiQlListener) ExitBinaryEqualToBoolOp(ctx *BinaryEqualToBoolOpContext)

+ func (s *BaseZitiQlListener) ExitBinaryEqualToDatetimeOp(ctx *BinaryEqualToDatetimeOpContext)

+ func (s *BaseZitiQlListener) ExitBinaryEqualToNullOp(ctx *BinaryEqualToNullOpContext)

+ func (s *BaseZitiQlListener) ExitBinaryEqualToNumberOp(ctx *BinaryEqualToNumberOpContext)

+ func (s *BaseZitiQlListener) ExitBinaryEqualToStringOp(ctx *BinaryEqualToStringOpContext)

+ func (s *BaseZitiQlListener) ExitBinaryGreaterThanDatetimeOp(ctx *BinaryGreaterThanDatetimeOpContext)

+ func (s *BaseZitiQlListener) ExitBinaryGreaterThanNumberOp(ctx *BinaryGreaterThanNumberOpContext)

+ func (s *BaseZitiQlListener) ExitBinaryGreaterThanStringOp(ctx *BinaryGreaterThanStringOpContext)

+ func (s *BaseZitiQlListener) ExitBinaryLessThanDatetimeOp(ctx *BinaryLessThanDatetimeOpContext)

+ func (s *BaseZitiQlListener) ExitBinaryLessThanNumberOp(ctx *BinaryLessThanNumberOpContext)

+ func (s *BaseZitiQlListener) ExitBinaryLessThanStringOp(ctx *BinaryLessThanStringOpContext)

+ func (s *BaseZitiQlListener) ExitBinaryLhs(ctx *BinaryLhsContext)

+ func (s *BaseZitiQlListener) ExitBoolConst(ctx *BoolConstContext)

+ func (s *BaseZitiQlListener) ExitBoolSymbol(ctx *BoolSymbolContext)

+ func (s *BaseZitiQlListener) ExitDatetimeArray(ctx *DatetimeArrayContext)

+ func (s *BaseZitiQlListener) ExitEnd(ctx *EndContext)

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

+ func (s *BaseZitiQlListener) ExitGroup(ctx *GroupContext)

+ func (s *BaseZitiQlListener) ExitInDatetimeArrayOp(ctx *InDatetimeArrayOpContext)

+ func (s *BaseZitiQlListener) ExitInNumberArrayOp(ctx *InNumberArrayOpContext)

+ func (s *BaseZitiQlListener) ExitInStringArrayOp(ctx *InStringArrayOpContext)

+ func (s *BaseZitiQlListener) ExitIsEmptyFunction(ctx *IsEmptyFunctionContext)

+ func (s *BaseZitiQlListener) ExitLimitExpr(ctx *LimitExprContext)

+ func (s *BaseZitiQlListener) ExitNotExpr(ctx *NotExprContext)

+ func (s *BaseZitiQlListener) ExitNumberArray(ctx *NumberArrayContext)

+ func (s *BaseZitiQlListener) ExitOperationOp(ctx *OperationOpContext)

+ func (s *BaseZitiQlListener) ExitOrExpr(ctx *OrExprContext)

+ func (s *BaseZitiQlListener) ExitQueryStmt(ctx *QueryStmtContext)

+ func (s *BaseZitiQlListener) ExitSetExpr(ctx *SetExprContext)

+ func (s *BaseZitiQlListener) ExitSetFunctionExpr(ctx *SetFunctionExprContext)

+ func (s *BaseZitiQlListener) ExitSkipExpr(ctx *SkipExprContext)

+ func (s *BaseZitiQlListener) ExitSortByExpr(ctx *SortByExprContext)

+ func (s *BaseZitiQlListener) ExitSortFieldExpr(ctx *SortFieldExprContext)

+ func (s *BaseZitiQlListener) ExitStringArray(ctx *StringArrayContext)

+ func (s *BaseZitiQlListener) ExitSubQuery(ctx *SubQueryContext)

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

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

+ type BetweenDateOpContext struct

+ func NewBetweenDateOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BetweenDateOpContext

+ func (s *BetweenDateOpContext) AND() antlr.TerminalNode

+ func (s *BetweenDateOpContext) AllDATETIME() []antlr.TerminalNode

+ func (s *BetweenDateOpContext) AllWS() []antlr.TerminalNode

+ func (s *BetweenDateOpContext) BETWEEN() antlr.TerminalNode

+ func (s *BetweenDateOpContext) BinaryLhs() IBinaryLhsContext

+ func (s *BetweenDateOpContext) DATETIME(i int) antlr.TerminalNode

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

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

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

+ func (s *BetweenDateOpContext) WS(i int) antlr.TerminalNode

+ type BetweenNumberOpContext struct

+ func NewBetweenNumberOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BetweenNumberOpContext

+ func (s *BetweenNumberOpContext) AND() antlr.TerminalNode

+ func (s *BetweenNumberOpContext) AllNUMBER() []antlr.TerminalNode

+ func (s *BetweenNumberOpContext) AllWS() []antlr.TerminalNode

+ func (s *BetweenNumberOpContext) BETWEEN() antlr.TerminalNode

+ func (s *BetweenNumberOpContext) BinaryLhs() IBinaryLhsContext

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

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

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

+ func (s *BetweenNumberOpContext) NUMBER(i int) antlr.TerminalNode

+ func (s *BetweenNumberOpContext) WS(i int) antlr.TerminalNode

+ type BinaryContainsOpContext struct

+ func NewBinaryContainsOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryContainsOpContext

+ func (s *BinaryContainsOpContext) AllWS() []antlr.TerminalNode

+ func (s *BinaryContainsOpContext) BinaryLhs() IBinaryLhsContext

+ func (s *BinaryContainsOpContext) CONTAINS() antlr.TerminalNode

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

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

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

+ func (s *BinaryContainsOpContext) NUMBER() antlr.TerminalNode

+ func (s *BinaryContainsOpContext) STRING() antlr.TerminalNode

+ func (s *BinaryContainsOpContext) WS(i int) antlr.TerminalNode

+ type BinaryEqualToBoolOpContext struct

+ func NewBinaryEqualToBoolOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryEqualToBoolOpContext

+ func (s *BinaryEqualToBoolOpContext) AllWS() []antlr.TerminalNode

+ func (s *BinaryEqualToBoolOpContext) BOOL() antlr.TerminalNode

+ func (s *BinaryEqualToBoolOpContext) BinaryLhs() IBinaryLhsContext

+ func (s *BinaryEqualToBoolOpContext) EQ() antlr.TerminalNode

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

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

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

+ func (s *BinaryEqualToBoolOpContext) WS(i int) antlr.TerminalNode

+ type BinaryEqualToDatetimeOpContext struct

+ func NewBinaryEqualToDatetimeOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryEqualToDatetimeOpContext

+ func (s *BinaryEqualToDatetimeOpContext) AllWS() []antlr.TerminalNode

+ func (s *BinaryEqualToDatetimeOpContext) BinaryLhs() IBinaryLhsContext

+ func (s *BinaryEqualToDatetimeOpContext) DATETIME() antlr.TerminalNode

+ func (s *BinaryEqualToDatetimeOpContext) EQ() antlr.TerminalNode

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

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

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

+ func (s *BinaryEqualToDatetimeOpContext) WS(i int) antlr.TerminalNode

+ type BinaryEqualToNullOpContext struct

+ func NewBinaryEqualToNullOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryEqualToNullOpContext

+ func (s *BinaryEqualToNullOpContext) AllWS() []antlr.TerminalNode

+ func (s *BinaryEqualToNullOpContext) BinaryLhs() IBinaryLhsContext

+ func (s *BinaryEqualToNullOpContext) EQ() antlr.TerminalNode

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

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

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

+ func (s *BinaryEqualToNullOpContext) NULL() antlr.TerminalNode

+ func (s *BinaryEqualToNullOpContext) WS(i int) antlr.TerminalNode

+ type BinaryEqualToNumberOpContext struct

+ func NewBinaryEqualToNumberOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryEqualToNumberOpContext

+ func (s *BinaryEqualToNumberOpContext) AllWS() []antlr.TerminalNode

+ func (s *BinaryEqualToNumberOpContext) BinaryLhs() IBinaryLhsContext

+ func (s *BinaryEqualToNumberOpContext) EQ() antlr.TerminalNode

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

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

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

+ func (s *BinaryEqualToNumberOpContext) NUMBER() antlr.TerminalNode

+ func (s *BinaryEqualToNumberOpContext) WS(i int) antlr.TerminalNode

+ type BinaryEqualToStringOpContext struct

+ func NewBinaryEqualToStringOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryEqualToStringOpContext

+ func (s *BinaryEqualToStringOpContext) AllWS() []antlr.TerminalNode

+ func (s *BinaryEqualToStringOpContext) BinaryLhs() IBinaryLhsContext

+ func (s *BinaryEqualToStringOpContext) EQ() antlr.TerminalNode

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

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

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

+ func (s *BinaryEqualToStringOpContext) STRING() antlr.TerminalNode

+ func (s *BinaryEqualToStringOpContext) WS(i int) antlr.TerminalNode

+ type BinaryGreaterThanDatetimeOpContext struct

+ func NewBinaryGreaterThanDatetimeOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryGreaterThanDatetimeOpContext

+ func (s *BinaryGreaterThanDatetimeOpContext) AllWS() []antlr.TerminalNode

+ func (s *BinaryGreaterThanDatetimeOpContext) BinaryLhs() IBinaryLhsContext

+ func (s *BinaryGreaterThanDatetimeOpContext) DATETIME() antlr.TerminalNode

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

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

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

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

+ func (s *BinaryGreaterThanDatetimeOpContext) WS(i int) antlr.TerminalNode

+ type BinaryGreaterThanNumberOpContext struct

+ func NewBinaryGreaterThanNumberOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryGreaterThanNumberOpContext

+ func (s *BinaryGreaterThanNumberOpContext) AllWS() []antlr.TerminalNode

+ func (s *BinaryGreaterThanNumberOpContext) BinaryLhs() IBinaryLhsContext

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

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

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

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

+ func (s *BinaryGreaterThanNumberOpContext) NUMBER() antlr.TerminalNode

+ func (s *BinaryGreaterThanNumberOpContext) WS(i int) antlr.TerminalNode

+ type BinaryGreaterThanStringOpContext struct

+ func NewBinaryGreaterThanStringOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryGreaterThanStringOpContext

+ func (s *BinaryGreaterThanStringOpContext) AllWS() []antlr.TerminalNode

+ func (s *BinaryGreaterThanStringOpContext) BinaryLhs() IBinaryLhsContext

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

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

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

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

+ func (s *BinaryGreaterThanStringOpContext) STRING() antlr.TerminalNode

+ func (s *BinaryGreaterThanStringOpContext) WS(i int) antlr.TerminalNode

+ type BinaryLessThanDatetimeOpContext struct

+ func NewBinaryLessThanDatetimeOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryLessThanDatetimeOpContext

+ func (s *BinaryLessThanDatetimeOpContext) AllWS() []antlr.TerminalNode

+ func (s *BinaryLessThanDatetimeOpContext) BinaryLhs() IBinaryLhsContext

+ func (s *BinaryLessThanDatetimeOpContext) DATETIME() antlr.TerminalNode

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

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

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

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

+ func (s *BinaryLessThanDatetimeOpContext) WS(i int) antlr.TerminalNode

+ type BinaryLessThanNumberOpContext struct

+ func NewBinaryLessThanNumberOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryLessThanNumberOpContext

+ func (s *BinaryLessThanNumberOpContext) AllWS() []antlr.TerminalNode

+ func (s *BinaryLessThanNumberOpContext) BinaryLhs() IBinaryLhsContext

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

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

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

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

+ func (s *BinaryLessThanNumberOpContext) NUMBER() antlr.TerminalNode

+ func (s *BinaryLessThanNumberOpContext) WS(i int) antlr.TerminalNode

+ type BinaryLessThanStringOpContext struct

+ func NewBinaryLessThanStringOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryLessThanStringOpContext

+ func (s *BinaryLessThanStringOpContext) AllWS() []antlr.TerminalNode

+ func (s *BinaryLessThanStringOpContext) BinaryLhs() IBinaryLhsContext

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

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

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

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

+ func (s *BinaryLessThanStringOpContext) STRING() antlr.TerminalNode

+ func (s *BinaryLessThanStringOpContext) WS(i int) antlr.TerminalNode

+ type BinaryLhsContext struct

+ func NewBinaryLhsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BinaryLhsContext

+ func NewEmptyBinaryLhsContext() *BinaryLhsContext

+ func (*BinaryLhsContext) IsBinaryLhsContext()

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

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

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

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

+ func (s *BinaryLhsContext) IDENTIFIER() antlr.TerminalNode

+ func (s *BinaryLhsContext) SetFunction() ISetFunctionContext

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

+ type BoolConstContext struct

+ func NewBoolConstContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BoolConstContext

+ func (s *BoolConstContext) BOOL() antlr.TerminalNode

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

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

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

+ type BoolExprContext struct

+ func NewBoolExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BoolExprContext

+ func NewEmptyBoolExprContext() *BoolExprContext

+ func (*BoolExprContext) IsBoolExprContext()

+ func (s *BoolExprContext) CopyFrom(ctx *BoolExprContext)

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

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

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

+ type BoolSymbolContext struct

+ func NewBoolSymbolContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BoolSymbolContext

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

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

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

+ func (s *BoolSymbolContext) IDENTIFIER() antlr.TerminalNode

+ type DatetimeArrayContext struct

+ func NewDatetimeArrayContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DatetimeArrayContext

+ func NewEmptyDatetimeArrayContext() *DatetimeArrayContext

+ func (*DatetimeArrayContext) IsDatetimeArrayContext()

+ func (s *DatetimeArrayContext) AllDATETIME() []antlr.TerminalNode

+ func (s *DatetimeArrayContext) AllWS() []antlr.TerminalNode

+ func (s *DatetimeArrayContext) DATETIME(i int) antlr.TerminalNode

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

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

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

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

+ func (s *DatetimeArrayContext) LBRACKET() antlr.TerminalNode

+ func (s *DatetimeArrayContext) RBRACKET() antlr.TerminalNode

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

+ func (s *DatetimeArrayContext) WS(i int) antlr.TerminalNode

+ type EndContext struct

+ func NewEndContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EndContext

+ func (s *EndContext) AllQuery() []IQueryContext

+ func (s *EndContext) AllWS() []antlr.TerminalNode

+ func (s *EndContext) EOF() antlr.TerminalNode

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

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

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

+ func (s *EndContext) Query(i int) IQueryContext

+ func (s *EndContext) WS(i int) antlr.TerminalNode

+ type ErrorListener struct

+ Errors []ParseError

+ func (el *ErrorListener) ReportAmbiguity(antlr.Parser, *antlr.DFA, int, int, bool, *antlr.BitSet, antlr.ATNConfigSet)

+ func (el *ErrorListener) ReportAttemptingFullContext(antlr.Parser, *antlr.DFA, int, int, *antlr.BitSet, antlr.ATNConfigSet)

+ func (el *ErrorListener) ReportContextSensitivity(antlr.Parser, *antlr.DFA, int, int, int, antlr.ATNConfigSet)

+ func (el *ErrorListener) SyntaxError(_ antlr.Recognizer, offendingSymbol interface{}, line, column int, _ string, ...)

+ type GroupContext struct

+ func NewGroupContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GroupContext

+ func (s *GroupContext) AllWS() []antlr.TerminalNode

+ func (s *GroupContext) BoolExpr() IBoolExprContext

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

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

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

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

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

+ func (s *GroupContext) WS(i int) antlr.TerminalNode

+ type IBinaryLhsContext interface

+ GetParser func() antlr.Parser

+ IsBinaryLhsContext func()

+ type IBoolExprContext interface

+ GetParser func() antlr.Parser

+ IsBoolExprContext func()

+ type IDatetimeArrayContext interface

+ GetParser func() antlr.Parser

+ IsDatetimeArrayContext func()

+ type ILimitContext interface

+ GetParser func() antlr.Parser

+ IsLimitContext func()

+ type INumberArrayContext interface

+ GetParser func() antlr.Parser

+ IsNumberArrayContext func()

+ type IOperationContext interface

+ GetParser func() antlr.Parser

+ IsOperationContext func()

+ type IQueryContext interface

+ GetParser func() antlr.Parser

+ IsQueryContext func()

+ type ISetExprContext interface

+ GetParser func() antlr.Parser

+ IsSetExprContext func()

+ type ISetFunctionContext interface

+ GetParser func() antlr.Parser

+ IsSetFunctionContext func()

+ type ISkipContext interface

+ GetParser func() antlr.Parser

+ IsSkipContext func()

+ type ISortByContext interface

+ GetParser func() antlr.Parser

+ IsSortByContext func()

+ type ISortFieldContext interface

+ GetParser func() antlr.Parser

+ IsSortFieldContext func()

+ type IStartContext interface

+ GetParser func() antlr.Parser

+ IsStartContext func()

+ type IStringArrayContext interface

+ GetParser func() antlr.Parser

+ IsStringArrayContext func()

+ type ISubQueryExprContext interface

+ GetParser func() antlr.Parser

+ IsSubQueryExprContext func()

+ type InDatetimeArrayOpContext struct

+ func NewInDatetimeArrayOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InDatetimeArrayOpContext

+ func (s *InDatetimeArrayOpContext) AllWS() []antlr.TerminalNode

+ func (s *InDatetimeArrayOpContext) BinaryLhs() IBinaryLhsContext

+ func (s *InDatetimeArrayOpContext) DatetimeArray() IDatetimeArrayContext

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

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

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

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

+ func (s *InDatetimeArrayOpContext) WS(i int) antlr.TerminalNode

+ type InNumberArrayOpContext struct

+ func NewInNumberArrayOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InNumberArrayOpContext

+ func (s *InNumberArrayOpContext) AllWS() []antlr.TerminalNode

+ func (s *InNumberArrayOpContext) BinaryLhs() IBinaryLhsContext

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

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

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

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

+ func (s *InNumberArrayOpContext) NumberArray() INumberArrayContext

+ func (s *InNumberArrayOpContext) WS(i int) antlr.TerminalNode

+ type InStringArrayOpContext struct

+ func NewInStringArrayOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InStringArrayOpContext

+ func (s *InStringArrayOpContext) AllWS() []antlr.TerminalNode

+ func (s *InStringArrayOpContext) BinaryLhs() IBinaryLhsContext

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

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

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

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

+ func (s *InStringArrayOpContext) StringArray() IStringArrayContext

+ func (s *InStringArrayOpContext) WS(i int) antlr.TerminalNode

+ type IsEmptyFunctionContext struct

+ func NewIsEmptyFunctionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IsEmptyFunctionContext

+ func (s *IsEmptyFunctionContext) AllWS() []antlr.TerminalNode

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

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

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

+ func (s *IsEmptyFunctionContext) ISEMPTY() antlr.TerminalNode

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

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

+ func (s *IsEmptyFunctionContext) SetExpr() ISetExprContext

+ func (s *IsEmptyFunctionContext) WS(i int) antlr.TerminalNode

+ type LimitContext struct

+ func NewEmptyLimitContext() *LimitContext

+ func NewLimitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitContext

+ func (*LimitContext) IsLimitContext()

+ func (s *LimitContext) CopyFrom(ctx *LimitContext)

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

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

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

+ type LimitExprContext struct

+ func NewLimitExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LimitExprContext

+ func (s *LimitExprContext) AllWS() []antlr.TerminalNode

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

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

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

+ func (s *LimitExprContext) LIMIT_ROWS() antlr.TerminalNode

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

+ func (s *LimitExprContext) NUMBER() antlr.TerminalNode

+ func (s *LimitExprContext) WS(i int) antlr.TerminalNode

+ type NotExprContext struct

+ func NewNotExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NotExprContext

+ func (s *NotExprContext) AllWS() []antlr.TerminalNode

+ func (s *NotExprContext) BoolExpr() IBoolExprContext

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

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

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

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

+ func (s *NotExprContext) WS(i int) antlr.TerminalNode

+ type NumberArrayContext struct

+ func NewEmptyNumberArrayContext() *NumberArrayContext

+ func NewNumberArrayContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumberArrayContext

+ func (*NumberArrayContext) IsNumberArrayContext()

+ func (s *NumberArrayContext) AllNUMBER() []antlr.TerminalNode

+ func (s *NumberArrayContext) AllWS() []antlr.TerminalNode

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

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

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

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

+ func (s *NumberArrayContext) LBRACKET() antlr.TerminalNode

+ func (s *NumberArrayContext) NUMBER(i int) antlr.TerminalNode

+ func (s *NumberArrayContext) RBRACKET() antlr.TerminalNode

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

+ func (s *NumberArrayContext) WS(i int) antlr.TerminalNode

+ type OperationContext struct

+ func NewEmptyOperationContext() *OperationContext

+ func NewOperationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OperationContext

+ func (*OperationContext) IsOperationContext()

+ func (s *OperationContext) CopyFrom(ctx *OperationContext)

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

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

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

+ type OperationOpContext struct

+ func NewOperationOpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OperationOpContext

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

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

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

+ func (s *OperationOpContext) Operation() IOperationContext

+ type OrExprContext struct

+ func NewOrExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OrExprContext

+ func (s *OrExprContext) AllBoolExpr() []IBoolExprContext

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

+ func (s *OrExprContext) AllWS() []antlr.TerminalNode

+ func (s *OrExprContext) BoolExpr(i int) IBoolExprContext

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

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

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

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

+ func (s *OrExprContext) WS(i int) antlr.TerminalNode

+ type ParseError struct

+ Column int

+ Line int

+ Message string

+ Symbol string

+ func Parse(str string, l ZitiQlListener) []ParseError

+ func ParseWithDebug(str string, l ZitiQlListener, debug bool) []ParseError

+ func (p ParseError) Error() string

+ type QueryContext struct

+ func NewEmptyQueryContext() *QueryContext

+ func NewQueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryContext

+ func (*QueryContext) IsQueryContext()

+ func (s *QueryContext) CopyFrom(ctx *QueryContext)

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

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

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

+ type QueryStmtContext struct

+ func NewQueryStmtContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *QueryStmtContext

+ func (s *QueryStmtContext) AllWS() []antlr.TerminalNode

+ func (s *QueryStmtContext) BoolExpr() IBoolExprContext

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

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

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

+ func (s *QueryStmtContext) Limit() ILimitContext

+ func (s *QueryStmtContext) Skip() ISkipContext

+ func (s *QueryStmtContext) SortBy() ISortByContext

+ func (s *QueryStmtContext) WS(i int) antlr.TerminalNode

+ type SetExprContext struct

+ func NewEmptySetExprContext() *SetExprContext

+ func NewSetExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetExprContext

+ func (*SetExprContext) IsSetExprContext()

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

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

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

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

+ func (s *SetExprContext) IDENTIFIER() antlr.TerminalNode

+ func (s *SetExprContext) SubQueryExpr() ISubQueryExprContext

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

+ type SetFunctionContext struct

+ func NewEmptySetFunctionContext() *SetFunctionContext

+ func NewSetFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetFunctionContext

+ func (*SetFunctionContext) IsSetFunctionContext()

+ func (s *SetFunctionContext) CopyFrom(ctx *SetFunctionContext)

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

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

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

+ type SetFunctionExprContext struct

+ func NewSetFunctionExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetFunctionExprContext

+ func (s *SetFunctionExprContext) ALL_OF() antlr.TerminalNode

+ func (s *SetFunctionExprContext) ANY_OF() antlr.TerminalNode

+ func (s *SetFunctionExprContext) AllWS() []antlr.TerminalNode

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

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

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

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

+ func (s *SetFunctionExprContext) IDENTIFIER() antlr.TerminalNode

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

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

+ func (s *SetFunctionExprContext) SetExpr() ISetExprContext

+ func (s *SetFunctionExprContext) WS(i int) antlr.TerminalNode

+ type SkipContext struct

+ func NewEmptySkipContext() *SkipContext

+ func NewSkipContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SkipContext

+ func (*SkipContext) IsSkipContext()

+ func (s *SkipContext) CopyFrom(ctx *SkipContext)

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

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

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

+ type SkipExprContext struct

+ func NewSkipExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SkipExprContext

+ func (s *SkipExprContext) AllWS() []antlr.TerminalNode

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

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

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

+ func (s *SkipExprContext) NUMBER() antlr.TerminalNode

+ func (s *SkipExprContext) SKIP_ROWS() antlr.TerminalNode

+ func (s *SkipExprContext) WS(i int) antlr.TerminalNode

+ type SortByContext struct

+ func NewEmptySortByContext() *SortByContext

+ func NewSortByContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortByContext

+ func (*SortByContext) IsSortByContext()

+ func (s *SortByContext) CopyFrom(ctx *SortByContext)

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

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

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

+ type SortByExprContext struct

+ func NewSortByExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SortByExprContext

+ func (s *SortByExprContext) AllSortField() []ISortFieldContext

+ func (s *SortByExprContext) AllWS() []antlr.TerminalNode

+ func (s *SortByExprContext) BY() antlr.TerminalNode

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

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

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

+ func (s *SortByExprContext) SORT() antlr.TerminalNode

+ func (s *SortByExprContext) SortField(i int) ISortFieldContext

+ func (s *SortByExprContext) WS(i int) antlr.TerminalNode

+ type SortFieldContext struct

+ func NewEmptySortFieldContext() *SortFieldContext

+ func NewSortFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortFieldContext

+ func (*SortFieldContext) IsSortFieldContext()

+ func (s *SortFieldContext) CopyFrom(ctx *SortFieldContext)

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

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

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

+ type SortFieldExprContext struct

+ func NewSortFieldExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SortFieldExprContext

+ func (s *SortFieldExprContext) ASC() antlr.TerminalNode

+ func (s *SortFieldExprContext) AllWS() []antlr.TerminalNode

+ func (s *SortFieldExprContext) DESC() antlr.TerminalNode

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

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

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

+ func (s *SortFieldExprContext) IDENTIFIER() antlr.TerminalNode

+ func (s *SortFieldExprContext) WS(i int) antlr.TerminalNode

+ type StartContext struct

+ func NewEmptyStartContext() *StartContext

+ func NewStartContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StartContext

+ func (*StartContext) IsStartContext()

+ func (s *StartContext) CopyFrom(ctx *StartContext)

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

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

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

+ type StringArrayContext struct

+ func NewEmptyStringArrayContext() *StringArrayContext

+ func NewStringArrayContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringArrayContext

+ func (*StringArrayContext) IsStringArrayContext()

+ func (s *StringArrayContext) AllSTRING() []antlr.TerminalNode

+ func (s *StringArrayContext) AllWS() []antlr.TerminalNode

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

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

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

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

+ func (s *StringArrayContext) LBRACKET() antlr.TerminalNode

+ func (s *StringArrayContext) RBRACKET() antlr.TerminalNode

+ func (s *StringArrayContext) STRING(i int) antlr.TerminalNode

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

+ func (s *StringArrayContext) WS(i int) antlr.TerminalNode

+ type SubQueryContext struct

+ func NewSubQueryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubQueryContext

+ func (s *SubQueryContext) AllWS() []antlr.TerminalNode

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

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

+ func (s *SubQueryContext) FROM() antlr.TerminalNode

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

+ func (s *SubQueryContext) IDENTIFIER() antlr.TerminalNode

+ func (s *SubQueryContext) Query() IQueryContext

+ func (s *SubQueryContext) WHERE() antlr.TerminalNode

+ func (s *SubQueryContext) WS(i int) antlr.TerminalNode

+ type SubQueryExprContext struct

+ func NewEmptySubQueryExprContext() *SubQueryExprContext

+ func NewSubQueryExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SubQueryExprContext

+ func (*SubQueryExprContext) IsSubQueryExprContext()

+ func (s *SubQueryExprContext) CopyFrom(ctx *SubQueryExprContext)

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

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

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

+ type ZitiQlLexer struct

+ func NewZitiQlLexer(input antlr.CharStream) *ZitiQlLexer

+ type ZitiQlListener interface

+ EnterAndExpr func(c *AndExprContext)

+ EnterBetweenDateOp func(c *BetweenDateOpContext)

+ EnterBetweenNumberOp func(c *BetweenNumberOpContext)

+ EnterBinaryContainsOp func(c *BinaryContainsOpContext)

+ EnterBinaryEqualToBoolOp func(c *BinaryEqualToBoolOpContext)

+ EnterBinaryEqualToDatetimeOp func(c *BinaryEqualToDatetimeOpContext)

+ EnterBinaryEqualToNullOp func(c *BinaryEqualToNullOpContext)

+ EnterBinaryEqualToNumberOp func(c *BinaryEqualToNumberOpContext)

+ EnterBinaryEqualToStringOp func(c *BinaryEqualToStringOpContext)

+ EnterBinaryGreaterThanDatetimeOp func(c *BinaryGreaterThanDatetimeOpContext)

+ EnterBinaryGreaterThanNumberOp func(c *BinaryGreaterThanNumberOpContext)

+ EnterBinaryGreaterThanStringOp func(c *BinaryGreaterThanStringOpContext)

+ EnterBinaryLessThanDatetimeOp func(c *BinaryLessThanDatetimeOpContext)

+ EnterBinaryLessThanNumberOp func(c *BinaryLessThanNumberOpContext)

+ EnterBinaryLessThanStringOp func(c *BinaryLessThanStringOpContext)

+ EnterBinaryLhs func(c *BinaryLhsContext)

+ EnterBoolConst func(c *BoolConstContext)

+ EnterBoolSymbol func(c *BoolSymbolContext)

+ EnterDatetimeArray func(c *DatetimeArrayContext)

+ EnterEnd func(c *EndContext)

+ EnterGroup func(c *GroupContext)

+ EnterInDatetimeArrayOp func(c *InDatetimeArrayOpContext)

+ EnterInNumberArrayOp func(c *InNumberArrayOpContext)

+ EnterInStringArrayOp func(c *InStringArrayOpContext)

+ EnterIsEmptyFunction func(c *IsEmptyFunctionContext)

+ EnterLimitExpr func(c *LimitExprContext)

+ EnterNotExpr func(c *NotExprContext)

+ EnterNumberArray func(c *NumberArrayContext)

+ EnterOperationOp func(c *OperationOpContext)

+ EnterOrExpr func(c *OrExprContext)

+ EnterQueryStmt func(c *QueryStmtContext)

+ EnterSetExpr func(c *SetExprContext)

+ EnterSetFunctionExpr func(c *SetFunctionExprContext)

+ EnterSkipExpr func(c *SkipExprContext)

+ EnterSortByExpr func(c *SortByExprContext)

+ EnterSortFieldExpr func(c *SortFieldExprContext)

+ EnterStringArray func(c *StringArrayContext)

+ EnterSubQuery func(c *SubQueryContext)

+ ExitAndExpr func(c *AndExprContext)

+ ExitBetweenDateOp func(c *BetweenDateOpContext)

+ ExitBetweenNumberOp func(c *BetweenNumberOpContext)

+ ExitBinaryContainsOp func(c *BinaryContainsOpContext)

+ ExitBinaryEqualToBoolOp func(c *BinaryEqualToBoolOpContext)

+ ExitBinaryEqualToDatetimeOp func(c *BinaryEqualToDatetimeOpContext)

+ ExitBinaryEqualToNullOp func(c *BinaryEqualToNullOpContext)

+ ExitBinaryEqualToNumberOp func(c *BinaryEqualToNumberOpContext)

+ ExitBinaryEqualToStringOp func(c *BinaryEqualToStringOpContext)

+ ExitBinaryGreaterThanDatetimeOp func(c *BinaryGreaterThanDatetimeOpContext)

+ ExitBinaryGreaterThanNumberOp func(c *BinaryGreaterThanNumberOpContext)

+ ExitBinaryGreaterThanStringOp func(c *BinaryGreaterThanStringOpContext)

+ ExitBinaryLessThanDatetimeOp func(c *BinaryLessThanDatetimeOpContext)

+ ExitBinaryLessThanNumberOp func(c *BinaryLessThanNumberOpContext)

+ ExitBinaryLessThanStringOp func(c *BinaryLessThanStringOpContext)

+ ExitBinaryLhs func(c *BinaryLhsContext)

+ ExitBoolConst func(c *BoolConstContext)

+ ExitBoolSymbol func(c *BoolSymbolContext)

+ ExitDatetimeArray func(c *DatetimeArrayContext)

+ ExitEnd func(c *EndContext)

+ ExitGroup func(c *GroupContext)

+ ExitInDatetimeArrayOp func(c *InDatetimeArrayOpContext)

+ ExitInNumberArrayOp func(c *InNumberArrayOpContext)

+ ExitInStringArrayOp func(c *InStringArrayOpContext)

+ ExitIsEmptyFunction func(c *IsEmptyFunctionContext)

+ ExitLimitExpr func(c *LimitExprContext)

+ ExitNotExpr func(c *NotExprContext)

+ ExitNumberArray func(c *NumberArrayContext)

+ ExitOperationOp func(c *OperationOpContext)

+ ExitOrExpr func(c *OrExprContext)

+ ExitQueryStmt func(c *QueryStmtContext)

+ ExitSetExpr func(c *SetExprContext)

+ ExitSetFunctionExpr func(c *SetFunctionExprContext)

+ ExitSkipExpr func(c *SkipExprContext)

+ ExitSortByExpr func(c *SortByExprContext)

+ ExitSortFieldExpr func(c *SortFieldExprContext)

+ ExitStringArray func(c *StringArrayContext)

+ ExitSubQuery func(c *SubQueryContext)

+ type ZitiQlParser struct

+ func NewZitiQlParser(input antlr.TokenStream) *ZitiQlParser

+ func (p *ZitiQlParser) BinaryLhs() (localctx IBinaryLhsContext)

+ func (p *ZitiQlParser) BoolExpr() (localctx IBoolExprContext)

+ func (p *ZitiQlParser) BoolExpr_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *ZitiQlParser) DatetimeArray() (localctx IDatetimeArrayContext)

+ func (p *ZitiQlParser) Limit() (localctx ILimitContext)

+ func (p *ZitiQlParser) NumberArray() (localctx INumberArrayContext)

+ func (p *ZitiQlParser) Operation() (localctx IOperationContext)

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

+ func (p *ZitiQlParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

+ func (p *ZitiQlParser) SetExpr() (localctx ISetExprContext)

+ func (p *ZitiQlParser) SetFunction() (localctx ISetFunctionContext)

+ func (p *ZitiQlParser) Skip() (localctx ISkipContext)

+ func (p *ZitiQlParser) SortBy() (localctx ISortByContext)

+ func (p *ZitiQlParser) SortField() (localctx ISortFieldContext)

+ func (p *ZitiQlParser) Start() (localctx IStartContext)

+ func (p *ZitiQlParser) StringArray() (localctx IStringArrayContext)

+ func (p *ZitiQlParser) SubQueryExpr() (localctx ISubQueryExprContext)