planparserv2

package
v0.10.3-0...-f06509b Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 25, 2024 License: Apache-2.0 Imports: 5 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	PlanLexerT__0             = 1
	PlanLexerT__1             = 2
	PlanLexerT__2             = 3
	PlanLexerT__3             = 4
	PlanLexerT__4             = 5
	PlanLexerLT               = 6
	PlanLexerLE               = 7
	PlanLexerGT               = 8
	PlanLexerGE               = 9
	PlanLexerEQ               = 10
	PlanLexerNE               = 11
	PlanLexerLIKE             = 12
	PlanLexerEXISTS           = 13
	PlanLexerADD              = 14
	PlanLexerSUB              = 15
	PlanLexerMUL              = 16
	PlanLexerDIV              = 17
	PlanLexerMOD              = 18
	PlanLexerPOW              = 19
	PlanLexerSHL              = 20
	PlanLexerSHR              = 21
	PlanLexerBAND             = 22
	PlanLexerBOR              = 23
	PlanLexerBXOR             = 24
	PlanLexerAND              = 25
	PlanLexerOR               = 26
	PlanLexerBNOT             = 27
	PlanLexerNOT              = 28
	PlanLexerIN               = 29
	PlanLexerNIN              = 30
	PlanLexerEmptyTerm        = 31
	PlanLexerJSONContains     = 32
	PlanLexerJSONContainsAll  = 33
	PlanLexerJSONContainsAny  = 34
	PlanLexerArrayContains    = 35
	PlanLexerArrayContainsAll = 36
	PlanLexerArrayContainsAny = 37
	PlanLexerArrayLength      = 38
	PlanLexerBooleanConstant  = 39
	PlanLexerIntegerConstant  = 40
	PlanLexerFloatingConstant = 41
	PlanLexerIdentifier       = 42
	PlanLexerStringLiteral    = 43
	PlanLexerJSONIdentifier   = 44
	PlanLexerWhitespace       = 45
	PlanLexerNewline          = 46
)

PlanLexer tokens.

View Source 
const (
	PlanParserEOF              = antlr.TokenEOF
	PlanParserT__0             = 1
	PlanParserT__1             = 2
	PlanParserT__2             = 3
	PlanParserT__3             = 4
	PlanParserT__4             = 5
	PlanParserLT               = 6
	PlanParserLE               = 7
	PlanParserGT               = 8
	PlanParserGE               = 9
	PlanParserEQ               = 10
	PlanParserNE               = 11
	PlanParserLIKE             = 12
	PlanParserEXISTS           = 13
	PlanParserADD              = 14
	PlanParserSUB              = 15
	PlanParserMUL              = 16
	PlanParserDIV              = 17
	PlanParserMOD              = 18
	PlanParserPOW              = 19
	PlanParserSHL              = 20
	PlanParserSHR              = 21
	PlanParserBAND             = 22
	PlanParserBOR              = 23
	PlanParserBXOR             = 24
	PlanParserAND              = 25
	PlanParserOR               = 26
	PlanParserBNOT             = 27
	PlanParserNOT              = 28
	PlanParserIN               = 29
	PlanParserNIN              = 30
	PlanParserEmptyTerm        = 31
	PlanParserJSONContains     = 32
	PlanParserJSONContainsAll  = 33
	PlanParserJSONContainsAny  = 34
	PlanParserArrayContains    = 35
	PlanParserArrayContainsAll = 36
	PlanParserArrayContainsAny = 37
	PlanParserArrayLength      = 38
	PlanParserBooleanConstant  = 39
	PlanParserIntegerConstant  = 40
	PlanParserFloatingConstant = 41
	PlanParserIdentifier       = 42
	PlanParserStringLiteral    = 43
	PlanParserJSONIdentifier   = 44
	PlanParserWhitespace       = 45
	PlanParserNewline          = 46
)

PlanParser tokens.

View Source 
const PlanParserRULE_expr = 0

PlanParserRULE_expr is the PlanParser rule.

Variables

This section is empty.

Functions

This section is empty.

Types

type AddSubContext 

type AddSubContext struct {
	*ExprContext
	// contains filtered or unexported fields
}

func NewAddSubContext 

func NewAddSubContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AddSubContext

func (*AddSubContext) ADD 

func (s *AddSubContext) ADD() antlr.TerminalNode

func (*AddSubContext) Accept 

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

func (*AddSubContext) AllExpr 

func (s *AddSubContext) AllExpr() []IExprContext

func (*AddSubContext) Expr 

func (s *AddSubContext) Expr(i int) IExprContext

func (*AddSubContext) GetOp 

func (s *AddSubContext) GetOp() antlr.Token

func (*AddSubContext) GetRuleContext 

func (s *AddSubContext) GetRuleContext() antlr.RuleContext

func (*AddSubContext) SUB 

func (s *AddSubContext) SUB() antlr.TerminalNode

func (*AddSubContext) SetOp 

func (s *AddSubContext) SetOp(v antlr.Token)

type ArrayContext 

type ArrayContext struct {
	*ExprContext
}

func NewArrayContext 

func NewArrayContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrayContext

func (*ArrayContext) Accept 

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

func (*ArrayContext) AllExpr 

func (s *ArrayContext) AllExpr() []IExprContext

func (*ArrayContext) Expr 

func (s *ArrayContext) Expr(i int) IExprContext

func (*ArrayContext) GetRuleContext 

func (s *ArrayContext) GetRuleContext() antlr.RuleContext

type ArrayLengthContext 

type ArrayLengthContext struct {
	*ExprContext
}

func NewArrayLengthContext 

func NewArrayLengthContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrayLengthContext

func (*ArrayLengthContext) Accept 

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

func (*ArrayLengthContext) ArrayLength 

func (s *ArrayLengthContext) ArrayLength() antlr.TerminalNode

func (*ArrayLengthContext) GetRuleContext 

func (s *ArrayLengthContext) GetRuleContext() antlr.RuleContext

func (*ArrayLengthContext) Identifier 

func (s *ArrayLengthContext) Identifier() antlr.TerminalNode

func (*ArrayLengthContext) JSONIdentifier 

func (s *ArrayLengthContext) JSONIdentifier() antlr.TerminalNode

type BasePlanVisitor 

type BasePlanVisitor struct {
	*antlr.BaseParseTreeVisitor
}

func (*BasePlanVisitor) VisitAddSub 

func (v *BasePlanVisitor) VisitAddSub(ctx *AddSubContext) interface{}

func (*BasePlanVisitor) VisitArray 

func (v *BasePlanVisitor) VisitArray(ctx *ArrayContext) interface{}

func (*BasePlanVisitor) VisitArrayLength 

func (v *BasePlanVisitor) VisitArrayLength(ctx *ArrayLengthContext) interface{}

func (*BasePlanVisitor) VisitBitAnd 

func (v *BasePlanVisitor) VisitBitAnd(ctx *BitAndContext) interface{}

func (*BasePlanVisitor) VisitBitOr 

func (v *BasePlanVisitor) VisitBitOr(ctx *BitOrContext) interface{}

func (*BasePlanVisitor) VisitBitXor 

func (v *BasePlanVisitor) VisitBitXor(ctx *BitXorContext) interface{}

func (*BasePlanVisitor) VisitBoolean 

func (v *BasePlanVisitor) VisitBoolean(ctx *BooleanContext) interface{}

func (*BasePlanVisitor) VisitEmptyTerm 

func (v *BasePlanVisitor) VisitEmptyTerm(ctx *EmptyTermContext) interface{}

func (*BasePlanVisitor) VisitEquality 

func (v *BasePlanVisitor) VisitEquality(ctx *EqualityContext) interface{}

func (*BasePlanVisitor) VisitExists 

func (v *BasePlanVisitor) VisitExists(ctx *ExistsContext) interface{}

func (*BasePlanVisitor) VisitFloating 

func (v *BasePlanVisitor) VisitFloating(ctx *FloatingContext) interface{}

func (*BasePlanVisitor) VisitIdentifier 

func (v *BasePlanVisitor) VisitIdentifier(ctx *IdentifierContext) interface{}

func (*BasePlanVisitor) VisitInteger 

func (v *BasePlanVisitor) VisitInteger(ctx *IntegerContext) interface{}

func (*BasePlanVisitor) VisitJSONContains 

func (v *BasePlanVisitor) VisitJSONContains(ctx *JSONContainsContext) interface{}

func (*BasePlanVisitor) VisitJSONContainsAll 

func (v *BasePlanVisitor) VisitJSONContainsAll(ctx *JSONContainsAllContext) interface{}

func (*BasePlanVisitor) VisitJSONContainsAny 

func (v *BasePlanVisitor) VisitJSONContainsAny(ctx *JSONContainsAnyContext) interface{}

func (*BasePlanVisitor) VisitJSONIdentifier 

func (v *BasePlanVisitor) VisitJSONIdentifier(ctx *JSONIdentifierContext) interface{}

func (*BasePlanVisitor) VisitLike 

func (v *BasePlanVisitor) VisitLike(ctx *LikeContext) interface{}

func (*BasePlanVisitor) VisitLogicalAnd 

func (v *BasePlanVisitor) VisitLogicalAnd(ctx *LogicalAndContext) interface{}

func (*BasePlanVisitor) VisitLogicalOr 

func (v *BasePlanVisitor) VisitLogicalOr(ctx *LogicalOrContext) interface{}

func (*BasePlanVisitor) VisitMulDivMod 

func (v *BasePlanVisitor) VisitMulDivMod(ctx *MulDivModContext) interface{}

func (*BasePlanVisitor) VisitParens 

func (v *BasePlanVisitor) VisitParens(ctx *ParensContext) interface{}

func (*BasePlanVisitor) VisitPower 

func (v *BasePlanVisitor) VisitPower(ctx *PowerContext) interface{}

func (*BasePlanVisitor) VisitRange 

func (v *BasePlanVisitor) VisitRange(ctx *RangeContext) interface{}

func (*BasePlanVisitor) VisitRelational 

func (v *BasePlanVisitor) VisitRelational(ctx *RelationalContext) interface{}

func (*BasePlanVisitor) VisitReverseRange 

func (v *BasePlanVisitor) VisitReverseRange(ctx *ReverseRangeContext) interface{}

func (*BasePlanVisitor) VisitShift 

func (v *BasePlanVisitor) VisitShift(ctx *ShiftContext) interface{}

func (*BasePlanVisitor) VisitString 

func (v *BasePlanVisitor) VisitString(ctx *StringContext) interface{}

func (*BasePlanVisitor) VisitTerm 

func (v *BasePlanVisitor) VisitTerm(ctx *TermContext) interface{}

func (*BasePlanVisitor) VisitUnary 

func (v *BasePlanVisitor) VisitUnary(ctx *UnaryContext) interface{}

type BitAndContext 

type BitAndContext struct {
	*ExprContext
}

func NewBitAndContext 

func NewBitAndContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitAndContext

func (*BitAndContext) Accept 

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

func (*BitAndContext) AllExpr 

func (s *BitAndContext) AllExpr() []IExprContext

func (*BitAndContext) BAND 

func (s *BitAndContext) BAND() antlr.TerminalNode

func (*BitAndContext) Expr 

func (s *BitAndContext) Expr(i int) IExprContext

func (*BitAndContext) GetRuleContext 

func (s *BitAndContext) GetRuleContext() antlr.RuleContext

type BitOrContext 

type BitOrContext struct {
	*ExprContext
}

func NewBitOrContext 

func NewBitOrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitOrContext

func (*BitOrContext) Accept 

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

func (*BitOrContext) AllExpr 

func (s *BitOrContext) AllExpr() []IExprContext

func (*BitOrContext) BOR 

func (s *BitOrContext) BOR() antlr.TerminalNode

func (*BitOrContext) Expr 

func (s *BitOrContext) Expr(i int) IExprContext

func (*BitOrContext) GetRuleContext 

func (s *BitOrContext) GetRuleContext() antlr.RuleContext

type BitXorContext 

type BitXorContext struct {
	*ExprContext
}

func NewBitXorContext 

func NewBitXorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitXorContext

func (*BitXorContext) Accept 

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

func (*BitXorContext) AllExpr 

func (s *BitXorContext) AllExpr() []IExprContext

func (*BitXorContext) BXOR 

func (s *BitXorContext) BXOR() antlr.TerminalNode

func (*BitXorContext) Expr 

func (s *BitXorContext) Expr(i int) IExprContext

func (*BitXorContext) GetRuleContext 

func (s *BitXorContext) GetRuleContext() antlr.RuleContext

type BooleanContext 

type BooleanContext struct {
	*ExprContext
}

func NewBooleanContext 

func NewBooleanContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BooleanContext

func (*BooleanContext) Accept 

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

func (*BooleanContext) BooleanConstant 

func (s *BooleanContext) BooleanConstant() antlr.TerminalNode

func (*BooleanContext) GetRuleContext 

func (s *BooleanContext) GetRuleContext() antlr.RuleContext

type EmptyTermContext 

type EmptyTermContext struct {
	*ExprContext
	// contains filtered or unexported fields
}

func NewEmptyTermContext 

func NewEmptyTermContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EmptyTermContext

func (*EmptyTermContext) Accept 

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

func (*EmptyTermContext) EmptyTerm 

func (s *EmptyTermContext) EmptyTerm() antlr.TerminalNode

func (*EmptyTermContext) Expr 

func (s *EmptyTermContext) Expr() IExprContext

func (*EmptyTermContext) GetOp 

func (s *EmptyTermContext) GetOp() antlr.Token

func (*EmptyTermContext) GetRuleContext 

func (s *EmptyTermContext) GetRuleContext() antlr.RuleContext

func (*EmptyTermContext) IN 

func (s *EmptyTermContext) IN() antlr.TerminalNode

func (*EmptyTermContext) NIN 

func (s *EmptyTermContext) NIN() antlr.TerminalNode

func (*EmptyTermContext) SetOp 

func (s *EmptyTermContext) SetOp(v antlr.Token)

type EqualityContext 

type EqualityContext struct {
	*ExprContext
	// contains filtered or unexported fields
}

func NewEqualityContext 

func NewEqualityContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EqualityContext

func (*EqualityContext) Accept 

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

func (*EqualityContext) AllExpr 

func (s *EqualityContext) AllExpr() []IExprContext

func (*EqualityContext) EQ 

func (s *EqualityContext) EQ() antlr.TerminalNode

func (*EqualityContext) Expr 

func (s *EqualityContext) Expr(i int) IExprContext

func (*EqualityContext) GetOp 

func (s *EqualityContext) GetOp() antlr.Token

func (*EqualityContext) GetRuleContext 

func (s *EqualityContext) GetRuleContext() antlr.RuleContext

func (*EqualityContext) NE 

func (s *EqualityContext) NE() antlr.TerminalNode

func (*EqualityContext) SetOp 

func (s *EqualityContext) SetOp(v antlr.Token)

type ExistsContext 

type ExistsContext struct {
	*ExprContext
}

func NewExistsContext 

func NewExistsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExistsContext

func (*ExistsContext) Accept 

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

func (*ExistsContext) EXISTS 

func (s *ExistsContext) EXISTS() antlr.TerminalNode

func (*ExistsContext) Expr 

func (s *ExistsContext) Expr() IExprContext

func (*ExistsContext) GetRuleContext 

func (s *ExistsContext) GetRuleContext() antlr.RuleContext

type ExprContext 

type ExprContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExprContext 

func NewEmptyExprContext() *ExprContext

func NewExprContext 

func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext

func (*ExprContext) CopyFrom 

func (s *ExprContext) CopyFrom(ctx *ExprContext)

func (*ExprContext) GetParser 

func (s *ExprContext) GetParser() antlr.Parser

func (*ExprContext) GetRuleContext 

func (s *ExprContext) GetRuleContext() antlr.RuleContext

func (*ExprContext) IsExprContext 

func (*ExprContext) IsExprContext()

func (*ExprContext) ToStringTree 

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

type FloatingContext 

type FloatingContext struct {
	*ExprContext
}

func NewFloatingContext 

func NewFloatingContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FloatingContext

func (*FloatingContext) Accept 

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

func (*FloatingContext) FloatingConstant 

func (s *FloatingContext) FloatingConstant() antlr.TerminalNode

func (*FloatingContext) GetRuleContext 

func (s *FloatingContext) GetRuleContext() antlr.RuleContext

type IExprContext 

type IExprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExprContext differentiates from other interfaces.
	IsExprContext()
}

IExprContext is an interface to support dynamic dispatch.

type IdentifierContext 

type IdentifierContext struct {
	*ExprContext
}

func NewIdentifierContext 

func NewIdentifierContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentifierContext

func (*IdentifierContext) Accept 

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

func (*IdentifierContext) GetRuleContext 

func (s *IdentifierContext) GetRuleContext() antlr.RuleContext

func (*IdentifierContext) Identifier 

func (s *IdentifierContext) Identifier() antlr.TerminalNode

type IntegerContext 

type IntegerContext struct {
	*ExprContext
}

func NewIntegerContext 

func NewIntegerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntegerContext

func (*IntegerContext) Accept 

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

func (*IntegerContext) GetRuleContext 

func (s *IntegerContext) GetRuleContext() antlr.RuleContext

func (*IntegerContext) IntegerConstant 

func (s *IntegerContext) IntegerConstant() antlr.TerminalNode

type JSONContainsAllContext 

type JSONContainsAllContext struct {
	*ExprContext
}

func NewJSONContainsAllContext 

func NewJSONContainsAllContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JSONContainsAllContext

func (*JSONContainsAllContext) Accept 

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

func (*JSONContainsAllContext) AllExpr 

func (s *JSONContainsAllContext) AllExpr() []IExprContext

func (*JSONContainsAllContext) ArrayContainsAll 

func (s *JSONContainsAllContext) ArrayContainsAll() antlr.TerminalNode

func (*JSONContainsAllContext) Expr 

func (s *JSONContainsAllContext) Expr(i int) IExprContext

func (*JSONContainsAllContext) GetRuleContext 

func (s *JSONContainsAllContext) GetRuleContext() antlr.RuleContext

func (*JSONContainsAllContext) JSONContainsAll 

func (s *JSONContainsAllContext) JSONContainsAll() antlr.TerminalNode

type JSONContainsAnyContext 

type JSONContainsAnyContext struct {
	*ExprContext
}

func NewJSONContainsAnyContext 

func NewJSONContainsAnyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JSONContainsAnyContext

func (*JSONContainsAnyContext) Accept 

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

func (*JSONContainsAnyContext) AllExpr 

func (s *JSONContainsAnyContext) AllExpr() []IExprContext

func (*JSONContainsAnyContext) ArrayContainsAny 

func (s *JSONContainsAnyContext) ArrayContainsAny() antlr.TerminalNode

func (*JSONContainsAnyContext) Expr 

func (s *JSONContainsAnyContext) Expr(i int) IExprContext

func (*JSONContainsAnyContext) GetRuleContext 

func (s *JSONContainsAnyContext) GetRuleContext() antlr.RuleContext

func (*JSONContainsAnyContext) JSONContainsAny 

func (s *JSONContainsAnyContext) JSONContainsAny() antlr.TerminalNode

type JSONContainsContext 

type JSONContainsContext struct {
	*ExprContext
}

func NewJSONContainsContext 

func NewJSONContainsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JSONContainsContext

func (*JSONContainsContext) Accept 

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

func (*JSONContainsContext) AllExpr 

func (s *JSONContainsContext) AllExpr() []IExprContext

func (*JSONContainsContext) ArrayContains 

func (s *JSONContainsContext) ArrayContains() antlr.TerminalNode

func (*JSONContainsContext) Expr 

func (s *JSONContainsContext) Expr(i int) IExprContext

func (*JSONContainsContext) GetRuleContext 

func (s *JSONContainsContext) GetRuleContext() antlr.RuleContext

func (*JSONContainsContext) JSONContains 

func (s *JSONContainsContext) JSONContains() antlr.TerminalNode

type JSONIdentifierContext 

type JSONIdentifierContext struct {
	*ExprContext
}

func NewJSONIdentifierContext 

func NewJSONIdentifierContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JSONIdentifierContext

func (*JSONIdentifierContext) Accept 

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

func (*JSONIdentifierContext) GetRuleContext 

func (s *JSONIdentifierContext) GetRuleContext() antlr.RuleContext

func (*JSONIdentifierContext) JSONIdentifier 

func (s *JSONIdentifierContext) JSONIdentifier() antlr.TerminalNode

type LikeContext 

type LikeContext struct {
	*ExprContext
}

func NewLikeContext 

func NewLikeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LikeContext

func (*LikeContext) Accept 

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

func (*LikeContext) Expr 

func (s *LikeContext) Expr() IExprContext

func (*LikeContext) GetRuleContext 

func (s *LikeContext) GetRuleContext() antlr.RuleContext

func (*LikeContext) LIKE 

func (s *LikeContext) LIKE() antlr.TerminalNode

func (*LikeContext) StringLiteral 

func (s *LikeContext) StringLiteral() antlr.TerminalNode

type LogicalAndContext 

type LogicalAndContext struct {
	*ExprContext
}

func NewLogicalAndContext 

func NewLogicalAndContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalAndContext

func (*LogicalAndContext) AND 

func (s *LogicalAndContext) AND() antlr.TerminalNode

func (*LogicalAndContext) Accept 

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

func (*LogicalAndContext) AllExpr 

func (s *LogicalAndContext) AllExpr() []IExprContext

func (*LogicalAndContext) Expr 

func (s *LogicalAndContext) Expr(i int) IExprContext

func (*LogicalAndContext) GetRuleContext 

func (s *LogicalAndContext) GetRuleContext() antlr.RuleContext

type LogicalOrContext 

type LogicalOrContext struct {
	*ExprContext
}

func NewLogicalOrContext 

func NewLogicalOrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalOrContext

func (*LogicalOrContext) Accept 

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

func (*LogicalOrContext) AllExpr 

func (s *LogicalOrContext) AllExpr() []IExprContext

func (*LogicalOrContext) Expr 

func (s *LogicalOrContext) Expr(i int) IExprContext

func (*LogicalOrContext) GetRuleContext 

func (s *LogicalOrContext) GetRuleContext() antlr.RuleContext

func (*LogicalOrContext) OR 

func (s *LogicalOrContext) OR() antlr.TerminalNode

type MulDivModContext 

type MulDivModContext struct {
	*ExprContext
	// contains filtered or unexported fields
}

func NewMulDivModContext 

func NewMulDivModContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MulDivModContext

func (*MulDivModContext) Accept 

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

func (*MulDivModContext) AllExpr 

func (s *MulDivModContext) AllExpr() []IExprContext

func (*MulDivModContext) DIV 

func (s *MulDivModContext) DIV() antlr.TerminalNode

func (*MulDivModContext) Expr 

func (s *MulDivModContext) Expr(i int) IExprContext

func (*MulDivModContext) GetOp 

func (s *MulDivModContext) GetOp() antlr.Token

func (*MulDivModContext) GetRuleContext 

func (s *MulDivModContext) GetRuleContext() antlr.RuleContext

func (*MulDivModContext) MOD 

func (s *MulDivModContext) MOD() antlr.TerminalNode

func (*MulDivModContext) MUL 

func (s *MulDivModContext) MUL() antlr.TerminalNode

func (*MulDivModContext) SetOp 

func (s *MulDivModContext) SetOp(v antlr.Token)

type ParensContext 

type ParensContext struct {
	*ExprContext
}

func NewParensContext 

func NewParensContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParensContext

func (*ParensContext) Accept 

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

func (*ParensContext) Expr 

func (s *ParensContext) Expr() IExprContext

func (*ParensContext) GetRuleContext 

func (s *ParensContext) GetRuleContext() antlr.RuleContext

type PlanLexer 

type PlanLexer struct {
	*antlr.BaseLexer
	// contains filtered or unexported fields
}

func NewPlanLexer 

func NewPlanLexer(input antlr.CharStream) *PlanLexer

NewPlanLexer produces a new lexer instance for the optional input antlr.CharStream.

The *PlanLexer instance produced may be reused by calling the SetInputStream method. The initial lexer configuration is expensive to construct, and the object is not thread-safe; however, if used within a Golang sync.Pool, the construction cost amortizes well and the objects can be used in a thread-safe manner.

type PlanParser 

type PlanParser struct {
	*antlr.BaseParser
}

func NewPlanParser 

func NewPlanParser(input antlr.TokenStream) *PlanParser

NewPlanParser produces a new parser instance for the optional input antlr.TokenStream.

The *PlanParser instance produced may be reused by calling the SetInputStream method. The initial parser configuration is expensive to construct, and the object is not thread-safe; however, if used within a Golang sync.Pool, the construction cost amortizes well and the objects can be used in a thread-safe manner.

func (*PlanParser) Expr 

func (p *PlanParser) Expr() (localctx IExprContext)

func (*PlanParser) Expr_Sempred 

func (p *PlanParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*PlanParser) Sempred 

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

type PlanVisitor 

type PlanVisitor interface {
	antlr.ParseTreeVisitor

	// Visit a parse tree produced by PlanParser#JSONIdentifier.
	VisitJSONIdentifier(ctx *JSONIdentifierContext) interface{}

	// Visit a parse tree produced by PlanParser#Parens.
	VisitParens(ctx *ParensContext) interface{}

	// Visit a parse tree produced by PlanParser#String.
	VisitString(ctx *StringContext) interface{}

	// Visit a parse tree produced by PlanParser#Floating.
	VisitFloating(ctx *FloatingContext) interface{}

	// Visit a parse tree produced by PlanParser#JSONContainsAll.
	VisitJSONContainsAll(ctx *JSONContainsAllContext) interface{}

	// Visit a parse tree produced by PlanParser#LogicalOr.
	VisitLogicalOr(ctx *LogicalOrContext) interface{}

	// Visit a parse tree produced by PlanParser#MulDivMod.
	VisitMulDivMod(ctx *MulDivModContext) interface{}

	// Visit a parse tree produced by PlanParser#Identifier.
	VisitIdentifier(ctx *IdentifierContext) interface{}

	// Visit a parse tree produced by PlanParser#Like.
	VisitLike(ctx *LikeContext) interface{}

	// Visit a parse tree produced by PlanParser#LogicalAnd.
	VisitLogicalAnd(ctx *LogicalAndContext) interface{}

	// Visit a parse tree produced by PlanParser#Equality.
	VisitEquality(ctx *EqualityContext) interface{}

	// Visit a parse tree produced by PlanParser#Boolean.
	VisitBoolean(ctx *BooleanContext) interface{}

	// Visit a parse tree produced by PlanParser#Shift.
	VisitShift(ctx *ShiftContext) interface{}

	// Visit a parse tree produced by PlanParser#ReverseRange.
	VisitReverseRange(ctx *ReverseRangeContext) interface{}

	// Visit a parse tree produced by PlanParser#BitOr.
	VisitBitOr(ctx *BitOrContext) interface{}

	// Visit a parse tree produced by PlanParser#AddSub.
	VisitAddSub(ctx *AddSubContext) interface{}

	// Visit a parse tree produced by PlanParser#Relational.
	VisitRelational(ctx *RelationalContext) interface{}

	// Visit a parse tree produced by PlanParser#ArrayLength.
	VisitArrayLength(ctx *ArrayLengthContext) interface{}

	// Visit a parse tree produced by PlanParser#Term.
	VisitTerm(ctx *TermContext) interface{}

	// Visit a parse tree produced by PlanParser#JSONContains.
	VisitJSONContains(ctx *JSONContainsContext) interface{}

	// Visit a parse tree produced by PlanParser#Range.
	VisitRange(ctx *RangeContext) interface{}

	// Visit a parse tree produced by PlanParser#Unary.
	VisitUnary(ctx *UnaryContext) interface{}

	// Visit a parse tree produced by PlanParser#Integer.
	VisitInteger(ctx *IntegerContext) interface{}

	// Visit a parse tree produced by PlanParser#Array.
	VisitArray(ctx *ArrayContext) interface{}

	// Visit a parse tree produced by PlanParser#JSONContainsAny.
	VisitJSONContainsAny(ctx *JSONContainsAnyContext) interface{}

	// Visit a parse tree produced by PlanParser#BitXor.
	VisitBitXor(ctx *BitXorContext) interface{}

	// Visit a parse tree produced by PlanParser#Exists.
	VisitExists(ctx *ExistsContext) interface{}

	// Visit a parse tree produced by PlanParser#BitAnd.
	VisitBitAnd(ctx *BitAndContext) interface{}

	// Visit a parse tree produced by PlanParser#EmptyTerm.
	VisitEmptyTerm(ctx *EmptyTermContext) interface{}

	// Visit a parse tree produced by PlanParser#Power.
	VisitPower(ctx *PowerContext) interface{}
}

A complete Visitor for a parse tree produced by PlanParser.

type PowerContext 

type PowerContext struct {
	*ExprContext
}

func NewPowerContext 

func NewPowerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PowerContext

func (*PowerContext) Accept 

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

func (*PowerContext) AllExpr 

func (s *PowerContext) AllExpr() []IExprContext

func (*PowerContext) Expr 

func (s *PowerContext) Expr(i int) IExprContext

func (*PowerContext) GetRuleContext 

func (s *PowerContext) GetRuleContext() antlr.RuleContext

func (*PowerContext) POW 

func (s *PowerContext) POW() antlr.TerminalNode

type RangeContext 

type RangeContext struct {
	*ExprContext
	// contains filtered or unexported fields
}

func NewRangeContext 

func NewRangeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RangeContext

func (*RangeContext) Accept 

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

func (*RangeContext) AllExpr 

func (s *RangeContext) AllExpr() []IExprContext

func (*RangeContext) AllLE 

func (s *RangeContext) AllLE() []antlr.TerminalNode

func (*RangeContext) AllLT 

func (s *RangeContext) AllLT() []antlr.TerminalNode

func (*RangeContext) Expr 

func (s *RangeContext) Expr(i int) IExprContext

func (*RangeContext) GetOp1 

func (s *RangeContext) GetOp1() antlr.Token

func (*RangeContext) GetOp2 

func (s *RangeContext) GetOp2() antlr.Token

func (*RangeContext) GetRuleContext 

func (s *RangeContext) GetRuleContext() antlr.RuleContext

func (*RangeContext) Identifier 

func (s *RangeContext) Identifier() antlr.TerminalNode

func (*RangeContext) JSONIdentifier 

func (s *RangeContext) JSONIdentifier() antlr.TerminalNode

func (*RangeContext) LE 

func (s *RangeContext) LE(i int) antlr.TerminalNode

func (*RangeContext) LT 

func (s *RangeContext) LT(i int) antlr.TerminalNode

func (*RangeContext) SetOp1 

func (s *RangeContext) SetOp1(v antlr.Token)

func (*RangeContext) SetOp2 

func (s *RangeContext) SetOp2(v antlr.Token)

type RelationalContext 

type RelationalContext struct {
	*ExprContext
	// contains filtered or unexported fields
}

func NewRelationalContext 

func NewRelationalContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RelationalContext

func (*RelationalContext) Accept 

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

func (*RelationalContext) AllExpr 

func (s *RelationalContext) AllExpr() []IExprContext

func (*RelationalContext) Expr 

func (s *RelationalContext) Expr(i int) IExprContext

func (*RelationalContext) GE 

func (s *RelationalContext) GE() antlr.TerminalNode

func (*RelationalContext) GT 

func (s *RelationalContext) GT() antlr.TerminalNode

func (*RelationalContext) GetOp 

func (s *RelationalContext) GetOp() antlr.Token

func (*RelationalContext) GetRuleContext 

func (s *RelationalContext) GetRuleContext() antlr.RuleContext

func (*RelationalContext) LE 

func (s *RelationalContext) LE() antlr.TerminalNode

func (*RelationalContext) LT 

func (s *RelationalContext) LT() antlr.TerminalNode

func (*RelationalContext) SetOp 

func (s *RelationalContext) SetOp(v antlr.Token)

type ReverseRangeContext 

type ReverseRangeContext struct {
	*ExprContext
	// contains filtered or unexported fields
}

func NewReverseRangeContext 

func NewReverseRangeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReverseRangeContext

func (*ReverseRangeContext) Accept 

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

func (*ReverseRangeContext) AllExpr 

func (s *ReverseRangeContext) AllExpr() []IExprContext

func (*ReverseRangeContext) AllGE 

func (s *ReverseRangeContext) AllGE() []antlr.TerminalNode

func (*ReverseRangeContext) AllGT 

func (s *ReverseRangeContext) AllGT() []antlr.TerminalNode

func (*ReverseRangeContext) Expr 

func (s *ReverseRangeContext) Expr(i int) IExprContext

func (*ReverseRangeContext) GE 

func (s *ReverseRangeContext) GE(i int) antlr.TerminalNode

func (*ReverseRangeContext) GT 

func (s *ReverseRangeContext) GT(i int) antlr.TerminalNode

func (*ReverseRangeContext) GetOp1 

func (s *ReverseRangeContext) GetOp1() antlr.Token

func (*ReverseRangeContext) GetOp2 

func (s *ReverseRangeContext) GetOp2() antlr.Token

func (*ReverseRangeContext) GetRuleContext 

func (s *ReverseRangeContext) GetRuleContext() antlr.RuleContext

func (*ReverseRangeContext) Identifier 

func (s *ReverseRangeContext) Identifier() antlr.TerminalNode

func (*ReverseRangeContext) JSONIdentifier 

func (s *ReverseRangeContext) JSONIdentifier() antlr.TerminalNode

func (*ReverseRangeContext) SetOp1 

func (s *ReverseRangeContext) SetOp1(v antlr.Token)

func (*ReverseRangeContext) SetOp2 

func (s *ReverseRangeContext) SetOp2(v antlr.Token)

type ShiftContext 

type ShiftContext struct {
	*ExprContext
	// contains filtered or unexported fields
}

func NewShiftContext 

func NewShiftContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShiftContext

func (*ShiftContext) Accept 

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

func (*ShiftContext) AllExpr 

func (s *ShiftContext) AllExpr() []IExprContext

func (*ShiftContext) Expr 

func (s *ShiftContext) Expr(i int) IExprContext

func (*ShiftContext) GetOp 

func (s *ShiftContext) GetOp() antlr.Token

func (*ShiftContext) GetRuleContext 

func (s *ShiftContext) GetRuleContext() antlr.RuleContext

func (*ShiftContext) SHL 

func (s *ShiftContext) SHL() antlr.TerminalNode

func (*ShiftContext) SHR 

func (s *ShiftContext) SHR() antlr.TerminalNode

func (*ShiftContext) SetOp 

func (s *ShiftContext) SetOp(v antlr.Token)

type StringContext 

type StringContext struct {
	*ExprContext
}

func NewStringContext 

func NewStringContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StringContext

func (*StringContext) Accept 

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

func (*StringContext) GetRuleContext 

func (s *StringContext) GetRuleContext() antlr.RuleContext

func (*StringContext) StringLiteral 

func (s *StringContext) StringLiteral() antlr.TerminalNode

type TermContext 

type TermContext struct {
	*ExprContext
	// contains filtered or unexported fields
}

func NewTermContext 

func NewTermContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TermContext

func (*TermContext) Accept 

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

func (*TermContext) AllExpr 

func (s *TermContext) AllExpr() []IExprContext

func (*TermContext) Expr 

func (s *TermContext) Expr(i int) IExprContext

func (*TermContext) GetOp 

func (s *TermContext) GetOp() antlr.Token

func (*TermContext) GetRuleContext 

func (s *TermContext) GetRuleContext() antlr.RuleContext

func (*TermContext) IN 

func (s *TermContext) IN() antlr.TerminalNode

func (*TermContext) NIN 

func (s *TermContext) NIN() antlr.TerminalNode

func (*TermContext) SetOp 

func (s *TermContext) SetOp(v antlr.Token)

type UnaryContext 

type UnaryContext struct {
	*ExprContext
	// contains filtered or unexported fields
}

func NewUnaryContext 

func NewUnaryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryContext

func (*UnaryContext) ADD 

func (s *UnaryContext) ADD() antlr.TerminalNode

func (*UnaryContext) Accept 

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

func (*UnaryContext) BNOT 

func (s *UnaryContext) BNOT() antlr.TerminalNode

func (*UnaryContext) Expr 

func (s *UnaryContext) Expr() IExprContext

func (*UnaryContext) GetOp 

func (s *UnaryContext) GetOp() antlr.Token

func (*UnaryContext) GetRuleContext 

func (s *UnaryContext) GetRuleContext() antlr.RuleContext

func (*UnaryContext) NOT 

func (s *UnaryContext) NOT() antlr.TerminalNode

func (*UnaryContext) SUB 

func (s *UnaryContext) SUB() antlr.TerminalNode

func (*UnaryContext) SetOp 

func (s *UnaryContext) SetOp(v antlr.Token)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.