admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2025-12-08 18:18:30 +08:00
Code Issues Packages Projects Releases Wiki Activity
milvus/internal/parser/planparserv2/generated/plan_parser.go
Tianx 2c0c5ef41e
feat: timestamptz expression & index & timezone (#44080) 
issue: https://github.com/milvus-io/milvus/issues/27467

>My plan is as follows.
>- [x] M1 Create collection with timestamptz field
>- [x] M2 Insert timestamptz field data
>- [x] M3 Retrieve timestamptz field data
>- [x] M4 Implement handoff
>- [x] M5 Implement compare operator
>- [x] M6 Implement extract operator
 >- [x] M8 Support database/collection level default timezone
>- [x] M7 Support STL-SORT index for datatype timestamptz

---

The third PR of issue: https://github.com/milvus-io/milvus/issues/27467,
which completes M5, M6, M7, M8 described above.

## M8 Default Timezone

We will be able to use alter_collection() and alter_database() in a
future Python SDK release to modify the default timezone at the
collection or database level.

For insert requests, the timezone will be resolved using the following
order of precedence: String Literal-> Collection Default -> Database
Default.
For retrieval requests, the timezone will be resolved in this order:
Query Parameters -> Collection Default -> Database Default.
In both cases, the final fallback timezone is UTC.


## M5: Comparison Operators

We can now use the following expression format to filter on the
timestamptz field:

- `timestamptz_field [+/- INTERVAL 'interval_string'] {comparison_op}
ISO 'iso_string' `

- The interval_string follows the ISO 8601 duration format, for example:
P1Y2M3DT1H2M3S.

- The iso_string follows the ISO 8601 timestamp format, for example:
2025-01-03T00:00:00+08:00.

- Example expressions: "tsz + INTERVAL 'P0D' != ISO
'2025-01-03T00:00:00+08:00'" or "tsz != ISO
'2025-01-03T00:00:00+08:00'".

## M6: Extract

We will be able to extract sepecific time filed by kwargs in a future
Python SDK release.
The key is `time_fields`, and value should be one or more of "year,
month, day, hour, minute, second, microsecond", seperated by comma or
space. Then the result of each record would be an array of int64.



## M7: Indexing Support

Expressions without interval arithmetic can be accelerated using an
STL-SORT index. However, expressions that include interval arithmetic
cannot be indexed. This is because the result of an interval calculation
depends on the specific timestamp value. For example, adding one month
to a date in February results in a different number of added days than
adding one month to a date in March.

--- 

After this PR, the input / output type of timestamptz would be iso
string. Timestampz would be stored as timestamptz data, which is int64_t
finally.

> for more information, see https://en.wikipedia.org/wiki/ISO_8601

---------

Signed-off-by: xtx <xtianx@smail.nju.edu.cn>
2025-09-23 10:24:12 +08:00

4138 lines
89 KiB
Go
Raw Blame History

// Code generated from Plan.g4 by ANTLR 4.13.2. DO NOT EDIT.
package planparserv2 // Plan
import (
"fmt"
"strconv"
"sync"
"github.com/antlr4-go/antlr/v4"
)
// Suppress unused import errors
var _ = fmt.Printf
var _ = strconv.Itoa
var _ = sync.Once{}
type PlanParser struct {
*antlr.BaseParser
}
var PlanParserStaticData struct {
once sync.Once
serializedATN []int32
LiteralNames []string
SymbolicNames []string
RuleNames []string
PredictionContextCache *antlr.PredictionContextCache
atn *antlr.ATN
decisionToDFA []*antlr.DFA
}
func planParserInit() {
staticData := &PlanParserStaticData
staticData.LiteralNames = []string{
"", "'('", "')'", "'['", "','", "']'", "'{'", "'}'", "'<'", "'<='",
"'>'", "'>='", "'=='", "'!='", "", "", "", "", "", "", "", "'+'", "'-'",
"'*'", "'/'", "'%'", "'**'", "'<<'", "'>>'", "'&'", "'|'", "'^'", "",
"", "", "", "'~'", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "'$meta'",
}
staticData.SymbolicNames = []string{
"", "", "", "", "", "", "LBRACE", "RBRACE", "LT", "LE", "GT", "GE",
"EQ", "NE", "LIKE", "EXISTS", "TEXTMATCH", "PHRASEMATCH", "RANDOMSAMPLE",
"INTERVAL", "ISO", "ADD", "SUB", "MUL", "DIV", "MOD", "POW", "SHL",
"SHR", "BAND", "BOR", "BXOR", "AND", "OR", "ISNULL", "ISNOTNULL", "BNOT",
"NOT", "IN", "EmptyArray", "JSONContains", "JSONContainsAll", "JSONContainsAny",
"ArrayContains", "ArrayContainsAll", "ArrayContainsAny", "ArrayLength",
"BooleanConstant", "IntegerConstant", "FloatingConstant", "Identifier",
"Meta", "StringLiteral", "JSONIdentifier", "Whitespace", "Newline",
}
staticData.RuleNames = []string{
"expr",
}
staticData.PredictionContextCache = antlr.NewPredictionContextCache()
staticData.serializedATN = []int32{
4, 1, 55, 170, 2, 0, 7, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 8, 8, 0,
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 30, 8, 0, 10, 0,
12, 0, 33, 9, 0, 1, 0, 3, 0, 36, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
0, 3, 0, 56, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 96, 8, 0, 10, 0, 12, 0, 99, 9, 0, 1,
0, 3, 0, 102, 8, 0, 3, 0, 104, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0,
111, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 127, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 165, 8, 0, 10, 0, 12, 0,
168, 9, 0, 1, 0, 0, 1, 0, 1, 0, 0, 14, 1, 0, 21, 22, 1, 0, 8, 13, 1, 0,
50, 51, 2, 0, 21, 22, 36, 37, 2, 0, 40, 40, 43, 43, 2, 0, 41, 41, 44, 44,
2, 0, 42, 42, 45, 45, 2, 0, 50, 50, 53, 53, 1, 0, 23, 25, 1, 0, 27, 28,
1, 0, 8, 9, 1, 0, 10, 11, 1, 0, 8, 11, 1, 0, 12, 13, 213, 0, 110, 1, 0,
0, 0, 2, 3, 6, 0, -1, 0, 3, 7, 5, 50, 0, 0, 4, 5, 7, 0, 0, 0, 5, 6, 5,
19, 0, 0, 6, 8, 5, 52, 0, 0, 7, 4, 1, 0, 0, 0, 7, 8, 1, 0, 0, 0, 8, 9,
1, 0, 0, 0, 9, 10, 7, 1, 0, 0, 10, 11, 5, 20, 0, 0, 11, 111, 5, 52, 0,
0, 12, 111, 5, 48, 0, 0, 13, 111, 5, 49, 0, 0, 14, 111, 5, 47, 0, 0, 15,
111, 5, 52, 0, 0, 16, 111, 7, 2, 0, 0, 17, 111, 5, 53, 0, 0, 18, 19, 5,
6, 0, 0, 19, 20, 5, 50, 0, 0, 20, 111, 5, 7, 0, 0, 21, 22, 5, 1, 0, 0,
22, 23, 3, 0, 0, 0, 23, 24, 5, 2, 0, 0, 24, 111, 1, 0, 0, 0, 25, 26, 5,
3, 0, 0, 26, 31, 3, 0, 0, 0, 27, 28, 5, 4, 0, 0, 28, 30, 3, 0, 0, 0, 29,
27, 1, 0, 0, 0, 30, 33, 1, 0, 0, 0, 31, 29, 1, 0, 0, 0, 31, 32, 1, 0, 0,
0, 32, 35, 1, 0, 0, 0, 33, 31, 1, 0, 0, 0, 34, 36, 5, 4, 0, 0, 35, 34,
1, 0, 0, 0, 35, 36, 1, 0, 0, 0, 36, 37, 1, 0, 0, 0, 37, 38, 5, 5, 0, 0,
38, 111, 1, 0, 0, 0, 39, 111, 5, 39, 0, 0, 40, 41, 5, 15, 0, 0, 41, 111,
3, 0, 0, 27, 42, 43, 5, 16, 0, 0, 43, 44, 5, 1, 0, 0, 44, 45, 5, 50, 0,
0, 45, 46, 5, 4, 0, 0, 46, 47, 5, 52, 0, 0, 47, 111, 5, 2, 0, 0, 48, 49,
5, 17, 0, 0, 49, 50, 5, 1, 0, 0, 50, 51, 5, 50, 0, 0, 51, 52, 5, 4, 0,
0, 52, 55, 5, 52, 0, 0, 53, 54, 5, 4, 0, 0, 54, 56, 3, 0, 0, 0, 55, 53,
1, 0, 0, 0, 55, 56, 1, 0, 0, 0, 56, 57, 1, 0, 0, 0, 57, 111, 5, 2, 0, 0,
58, 59, 5, 18, 0, 0, 59, 60, 5, 1, 0, 0, 60, 61, 3, 0, 0, 0, 61, 62, 5,
2, 0, 0, 62, 111, 1, 0, 0, 0, 63, 64, 7, 3, 0, 0, 64, 111, 3, 0, 0, 21,
65, 66, 7, 4, 0, 0, 66, 67, 5, 1, 0, 0, 67, 68, 3, 0, 0, 0, 68, 69, 5,
4, 0, 0, 69, 70, 3, 0, 0, 0, 70, 71, 5, 2, 0, 0, 71, 111, 1, 0, 0, 0, 72,
73, 7, 5, 0, 0, 73, 74, 5, 1, 0, 0, 74, 75, 3, 0, 0, 0, 75, 76, 5, 4, 0,
0, 76, 77, 3, 0, 0, 0, 77, 78, 5, 2, 0, 0, 78, 111, 1, 0, 0, 0, 79, 80,
7, 6, 0, 0, 80, 81, 5, 1, 0, 0, 81, 82, 3, 0, 0, 0, 82, 83, 5, 4, 0, 0,
83, 84, 3, 0, 0, 0, 84, 85, 5, 2, 0, 0, 85, 111, 1, 0, 0, 0, 86, 87, 5,
46, 0, 0, 87, 88, 5, 1, 0, 0, 88, 89, 7, 7, 0, 0, 89, 111, 5, 2, 0, 0,
90, 91, 5, 50, 0, 0, 91, 103, 5, 1, 0, 0, 92, 97, 3, 0, 0, 0, 93, 94, 5,
4, 0, 0, 94, 96, 3, 0, 0, 0, 95, 93, 1, 0, 0, 0, 96, 99, 1, 0, 0, 0, 97,
95, 1, 0, 0, 0, 97, 98, 1, 0, 0, 0, 98, 101, 1, 0, 0, 0, 99, 97, 1, 0,
0, 0, 100, 102, 5, 4, 0, 0, 101, 100, 1, 0, 0, 0, 101, 102, 1, 0, 0, 0,
102, 104, 1, 0, 0, 0, 103, 92, 1, 0, 0, 0, 103, 104, 1, 0, 0, 0, 104, 105,
1, 0, 0, 0, 105, 111, 5, 2, 0, 0, 106, 107, 7, 7, 0, 0, 107, 111, 5, 34,
0, 0, 108, 109, 7, 7, 0, 0, 109, 111, 5, 35, 0, 0, 110, 2, 1, 0, 0, 0,
110, 12, 1, 0, 0, 0, 110, 13, 1, 0, 0, 0, 110, 14, 1, 0, 0, 0, 110, 15,
1, 0, 0, 0, 110, 16, 1, 0, 0, 0, 110, 17, 1, 0, 0, 0, 110, 18, 1, 0, 0,
0, 110, 21, 1, 0, 0, 0, 110, 25, 1, 0, 0, 0, 110, 39, 1, 0, 0, 0, 110,
40, 1, 0, 0, 0, 110, 42, 1, 0, 0, 0, 110, 48, 1, 0, 0, 0, 110, 58, 1, 0,
0, 0, 110, 63, 1, 0, 0, 0, 110, 65, 1, 0, 0, 0, 110, 72, 1, 0, 0, 0, 110,
79, 1, 0, 0, 0, 110, 86, 1, 0, 0, 0, 110, 90, 1, 0, 0, 0, 110, 106, 1,
0, 0, 0, 110, 108, 1, 0, 0, 0, 111, 166, 1, 0, 0, 0, 112, 113, 10, 22,
0, 0, 113, 114, 5, 26, 0, 0, 114, 165, 3, 0, 0, 23, 115, 116, 10, 20, 0,
0, 116, 117, 7, 8, 0, 0, 117, 165, 3, 0, 0, 21, 118, 119, 10, 19, 0, 0,
119, 120, 7, 0, 0, 0, 120, 165, 3, 0, 0, 20, 121, 122, 10, 18, 0, 0, 122,
123, 7, 9, 0, 0, 123, 165, 3, 0, 0, 19, 124, 126, 10, 17, 0, 0, 125, 127,
5, 37, 0, 0, 126, 125, 1, 0, 0, 0, 126, 127, 1, 0, 0, 0, 127, 128, 1, 0,
0, 0, 128, 129, 5, 38, 0, 0, 129, 165, 3, 0, 0, 18, 130, 131, 10, 11, 0,
0, 131, 132, 7, 10, 0, 0, 132, 133, 7, 7, 0, 0, 133, 134, 7, 10, 0, 0,
134, 165, 3, 0, 0, 12, 135, 136, 10, 10, 0, 0, 136, 137, 7, 11, 0, 0, 137,
138, 7, 7, 0, 0, 138, 139, 7, 11, 0, 0, 139, 165, 3, 0, 0, 11, 140, 141,
10, 9, 0, 0, 141, 142, 7, 12, 0, 0, 142, 165, 3, 0, 0, 10, 143, 144, 10,
8, 0, 0, 144, 145, 7, 13, 0, 0, 145, 165, 3, 0, 0, 9, 146, 147, 10, 7,
0, 0, 147, 148, 5, 29, 0, 0, 148, 165, 3, 0, 0, 8, 149, 150, 10, 6, 0,
0, 150, 151, 5, 31, 0, 0, 151, 165, 3, 0, 0, 7, 152, 153, 10, 5, 0, 0,
153, 154, 5, 30, 0, 0, 154, 165, 3, 0, 0, 6, 155, 156, 10, 4, 0, 0, 156,
157, 5, 32, 0, 0, 157, 165, 3, 0, 0, 5, 158, 159, 10, 3, 0, 0, 159, 160,
5, 33, 0, 0, 160, 165, 3, 0, 0, 4, 161, 162, 10, 26, 0, 0, 162, 163, 5,
14, 0, 0, 163, 165, 5, 52, 0, 0, 164, 112, 1, 0, 0, 0, 164, 115, 1, 0,
0, 0, 164, 118, 1, 0, 0, 0, 164, 121, 1, 0, 0, 0, 164, 124, 1, 0, 0, 0,
164, 130, 1, 0, 0, 0, 164, 135, 1, 0, 0, 0, 164, 140, 1, 0, 0, 0, 164,
143, 1, 0, 0, 0, 164, 146, 1, 0, 0, 0, 164, 149, 1, 0, 0, 0, 164, 152,
1, 0, 0, 0, 164, 155, 1, 0, 0, 0, 164, 158, 1, 0, 0, 0, 164, 161, 1, 0,
0, 0, 165, 168, 1, 0, 0, 0, 166, 164, 1, 0, 0, 0, 166, 167, 1, 0, 0, 0,
167, 1, 1, 0, 0, 0, 168, 166, 1, 0, 0, 0, 11, 7, 31, 35, 55, 97, 101, 103,
110, 126, 164, 166,
}
deserializer := antlr.NewATNDeserializer(nil)
staticData.atn = deserializer.Deserialize(staticData.serializedATN)
atn := staticData.atn
staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState))
decisionToDFA := staticData.decisionToDFA
for index, state := range atn.DecisionToState {
decisionToDFA[index] = antlr.NewDFA(state, index)
}
}
// PlanParserInit initializes any static state used to implement PlanParser. By default the
// static state used to implement the parser is lazily initialized during the first call to
// NewPlanParser(). You can call this function if you wish to initialize the static state ahead
// of time.
func PlanParserInit() {
staticData := &PlanParserStaticData
staticData.once.Do(planParserInit)
}
// NewPlanParser produces a new parser instance for the optional input antlr.TokenStream.
func NewPlanParser(input antlr.TokenStream) *PlanParser {
PlanParserInit()
this := new(PlanParser)
this.BaseParser = antlr.NewBaseParser(input)
staticData := &PlanParserStaticData
this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache)
this.RuleNames = staticData.RuleNames
this.LiteralNames = staticData.LiteralNames
this.SymbolicNames = staticData.SymbolicNames
this.GrammarFileName = "Plan.g4"
return this
}
// PlanParser tokens.
const (
PlanParserEOF = antlr.TokenEOF
PlanParserT__0 = 1
PlanParserT__1 = 2
PlanParserT__2 = 3
PlanParserT__3 = 4
PlanParserT__4 = 5
PlanParserLBRACE = 6
PlanParserRBRACE = 7
PlanParserLT = 8
PlanParserLE = 9
PlanParserGT = 10
PlanParserGE = 11
PlanParserEQ = 12
PlanParserNE = 13
PlanParserLIKE = 14
PlanParserEXISTS = 15
PlanParserTEXTMATCH = 16
PlanParserPHRASEMATCH = 17
PlanParserRANDOMSAMPLE = 18
PlanParserINTERVAL = 19
PlanParserISO = 20
PlanParserADD = 21
PlanParserSUB = 22
PlanParserMUL = 23
PlanParserDIV = 24
PlanParserMOD = 25
PlanParserPOW = 26
PlanParserSHL = 27
PlanParserSHR = 28
PlanParserBAND = 29
PlanParserBOR = 30
PlanParserBXOR = 31
PlanParserAND = 32
PlanParserOR = 33
PlanParserISNULL = 34
PlanParserISNOTNULL = 35
PlanParserBNOT = 36
PlanParserNOT = 37
PlanParserIN = 38
PlanParserEmptyArray = 39
PlanParserJSONContains = 40
PlanParserJSONContainsAll = 41
PlanParserJSONContainsAny = 42
PlanParserArrayContains = 43
PlanParserArrayContainsAll = 44
PlanParserArrayContainsAny = 45
PlanParserArrayLength = 46
PlanParserBooleanConstant = 47
PlanParserIntegerConstant = 48
PlanParserFloatingConstant = 49
PlanParserIdentifier = 50
PlanParserMeta = 51
PlanParserStringLiteral = 52
PlanParserJSONIdentifier = 53
PlanParserWhitespace = 54
PlanParserNewline = 55
)
// PlanParserRULE_expr is the PlanParser rule.
const PlanParserRULE_expr = 0
// IExprContext is an interface to support dynamic dispatch.
type IExprContext interface {
antlr.ParserRuleContext
// GetParser returns the parser.
GetParser() antlr.Parser
// IsExprContext differentiates from other interfaces.
IsExprContext()
}
type ExprContext struct {
antlr.BaseParserRuleContext
parser antlr.Parser
}
func NewEmptyExprContext() *ExprContext {
var p = new(ExprContext)
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
p.RuleIndex = PlanParserRULE_expr
return p
}
func InitEmptyExprContext(p *ExprContext) {
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
p.RuleIndex = PlanParserRULE_expr
}
func (*ExprContext) IsExprContext() {}
func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext {
var p = new(ExprContext)
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
p.parser = parser
p.RuleIndex = PlanParserRULE_expr
return p
}
func (s *ExprContext) GetParser() antlr.Parser { return s.parser }
func (s *ExprContext) CopyAll(ctx *ExprContext) {
s.CopyFrom(&ctx.BaseParserRuleContext)
}
func (s *ExprContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *ExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
return antlr.TreesStringTree(s, ruleNames, recog)
}
type JSONIdentifierContext struct {
ExprContext
}
func NewJSONIdentifierContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JSONIdentifierContext {
var p = new(JSONIdentifierContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *JSONIdentifierContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *JSONIdentifierContext) JSONIdentifier() antlr.TerminalNode {
return s.GetToken(PlanParserJSONIdentifier, 0)
}
func (s *JSONIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitJSONIdentifier(s)
default:
return t.VisitChildren(s)
}
}
type RandomSampleContext struct {
ExprContext
}
func NewRandomSampleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RandomSampleContext {
var p = new(RandomSampleContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *RandomSampleContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *RandomSampleContext) RANDOMSAMPLE() antlr.TerminalNode {
return s.GetToken(PlanParserRANDOMSAMPLE, 0)
}
func (s *RandomSampleContext) Expr() IExprContext {
var t antlr.RuleContext
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
t = ctx.(antlr.RuleContext)
break
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *RandomSampleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitRandomSample(s)
default:
return t.VisitChildren(s)
}
}
type ParensContext struct {
ExprContext
}
func NewParensContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParensContext {
var p = new(ParensContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *ParensContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *ParensContext) Expr() IExprContext {
var t antlr.RuleContext
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
t = ctx.(antlr.RuleContext)
break
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *ParensContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitParens(s)
default:
return t.VisitChildren(s)
}
}
type StringContext struct {
ExprContext
}
func NewStringContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StringContext {
var p = new(StringContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *StringContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *StringContext) StringLiteral() antlr.TerminalNode {
return s.GetToken(PlanParserStringLiteral, 0)
}
func (s *StringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitString(s)
default:
return t.VisitChildren(s)
}
}
type FloatingContext struct {
ExprContext
}
func NewFloatingContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FloatingContext {
var p = new(FloatingContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *FloatingContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *FloatingContext) FloatingConstant() antlr.TerminalNode {
return s.GetToken(PlanParserFloatingConstant, 0)
}
func (s *FloatingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitFloating(s)
default:
return t.VisitChildren(s)
}
}
type JSONContainsAllContext struct {
ExprContext
}
func NewJSONContainsAllContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JSONContainsAllContext {
var p = new(JSONContainsAllContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *JSONContainsAllContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *JSONContainsAllContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *JSONContainsAllContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *JSONContainsAllContext) JSONContainsAll() antlr.TerminalNode {
return s.GetToken(PlanParserJSONContainsAll, 0)
}
func (s *JSONContainsAllContext) ArrayContainsAll() antlr.TerminalNode {
return s.GetToken(PlanParserArrayContainsAll, 0)
}
func (s *JSONContainsAllContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitJSONContainsAll(s)
default:
return t.VisitChildren(s)
}
}
type LogicalOrContext struct {
ExprContext
}
func NewLogicalOrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalOrContext {
var p = new(LogicalOrContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *LogicalOrContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *LogicalOrContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *LogicalOrContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *LogicalOrContext) OR() antlr.TerminalNode {
return s.GetToken(PlanParserOR, 0)
}
func (s *LogicalOrContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitLogicalOr(s)
default:
return t.VisitChildren(s)
}
}
type IsNotNullContext struct {
ExprContext
}
func NewIsNotNullContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IsNotNullContext {
var p = new(IsNotNullContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *IsNotNullContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *IsNotNullContext) ISNOTNULL() antlr.TerminalNode {
return s.GetToken(PlanParserISNOTNULL, 0)
}
func (s *IsNotNullContext) Identifier() antlr.TerminalNode {
return s.GetToken(PlanParserIdentifier, 0)
}
func (s *IsNotNullContext) JSONIdentifier() antlr.TerminalNode {
return s.GetToken(PlanParserJSONIdentifier, 0)
}
func (s *IsNotNullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitIsNotNull(s)
default:
return t.VisitChildren(s)
}
}
type MulDivModContext struct {
ExprContext
op antlr.Token
}
func NewMulDivModContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MulDivModContext {
var p = new(MulDivModContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *MulDivModContext) GetOp() antlr.Token { return s.op }
func (s *MulDivModContext) SetOp(v antlr.Token) { s.op = v }
func (s *MulDivModContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *MulDivModContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *MulDivModContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *MulDivModContext) MUL() antlr.TerminalNode {
return s.GetToken(PlanParserMUL, 0)
}
func (s *MulDivModContext) DIV() antlr.TerminalNode {
return s.GetToken(PlanParserDIV, 0)
}
func (s *MulDivModContext) MOD() antlr.TerminalNode {
return s.GetToken(PlanParserMOD, 0)
}
func (s *MulDivModContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitMulDivMod(s)
default:
return t.VisitChildren(s)
}
}
type IdentifierContext struct {
ExprContext
}
func NewIdentifierContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentifierContext {
var p = new(IdentifierContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *IdentifierContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *IdentifierContext) Identifier() antlr.TerminalNode {
return s.GetToken(PlanParserIdentifier, 0)
}
func (s *IdentifierContext) Meta() antlr.TerminalNode {
return s.GetToken(PlanParserMeta, 0)
}
func (s *IdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitIdentifier(s)
default:
return t.VisitChildren(s)
}
}
type LikeContext struct {
ExprContext
}
func NewLikeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LikeContext {
var p = new(LikeContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *LikeContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *LikeContext) Expr() IExprContext {
var t antlr.RuleContext
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
t = ctx.(antlr.RuleContext)
break
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *LikeContext) LIKE() antlr.TerminalNode {
return s.GetToken(PlanParserLIKE, 0)
}
func (s *LikeContext) StringLiteral() antlr.TerminalNode {
return s.GetToken(PlanParserStringLiteral, 0)
}
func (s *LikeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitLike(s)
default:
return t.VisitChildren(s)
}
}
type LogicalAndContext struct {
ExprContext
}
func NewLogicalAndContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalAndContext {
var p = new(LogicalAndContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *LogicalAndContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *LogicalAndContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *LogicalAndContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *LogicalAndContext) AND() antlr.TerminalNode {
return s.GetToken(PlanParserAND, 0)
}
func (s *LogicalAndContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitLogicalAnd(s)
default:
return t.VisitChildren(s)
}
}
type TemplateVariableContext struct {
ExprContext
}
func NewTemplateVariableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TemplateVariableContext {
var p = new(TemplateVariableContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *TemplateVariableContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *TemplateVariableContext) LBRACE() antlr.TerminalNode {
return s.GetToken(PlanParserLBRACE, 0)
}
func (s *TemplateVariableContext) Identifier() antlr.TerminalNode {
return s.GetToken(PlanParserIdentifier, 0)
}
func (s *TemplateVariableContext) RBRACE() antlr.TerminalNode {
return s.GetToken(PlanParserRBRACE, 0)
}
func (s *TemplateVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitTemplateVariable(s)
default:
return t.VisitChildren(s)
}
}
type EqualityContext struct {
ExprContext
op antlr.Token
}
func NewEqualityContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EqualityContext {
var p = new(EqualityContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *EqualityContext) GetOp() antlr.Token { return s.op }
func (s *EqualityContext) SetOp(v antlr.Token) { s.op = v }
func (s *EqualityContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *EqualityContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *EqualityContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *EqualityContext) EQ() antlr.TerminalNode {
return s.GetToken(PlanParserEQ, 0)
}
func (s *EqualityContext) NE() antlr.TerminalNode {
return s.GetToken(PlanParserNE, 0)
}
func (s *EqualityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitEquality(s)
default:
return t.VisitChildren(s)
}
}
type BooleanContext struct {
ExprContext
}
func NewBooleanContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BooleanContext {
var p = new(BooleanContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *BooleanContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *BooleanContext) BooleanConstant() antlr.TerminalNode {
return s.GetToken(PlanParserBooleanConstant, 0)
}
func (s *BooleanContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitBoolean(s)
default:
return t.VisitChildren(s)
}
}
type ShiftContext struct {
ExprContext
op antlr.Token
}
func NewShiftContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShiftContext {
var p = new(ShiftContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *ShiftContext) GetOp() antlr.Token { return s.op }
func (s *ShiftContext) SetOp(v antlr.Token) { s.op = v }
func (s *ShiftContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *ShiftContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *ShiftContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *ShiftContext) SHL() antlr.TerminalNode {
return s.GetToken(PlanParserSHL, 0)
}
func (s *ShiftContext) SHR() antlr.TerminalNode {
return s.GetToken(PlanParserSHR, 0)
}
func (s *ShiftContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitShift(s)
default:
return t.VisitChildren(s)
}
}
type CallContext struct {
ExprContext
}
func NewCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CallContext {
var p = new(CallContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *CallContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *CallContext) Identifier() antlr.TerminalNode {
return s.GetToken(PlanParserIdentifier, 0)
}
func (s *CallContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *CallContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *CallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitCall(s)
default:
return t.VisitChildren(s)
}
}
type ReverseRangeContext struct {
ExprContext
op1 antlr.Token
op2 antlr.Token
}
func NewReverseRangeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReverseRangeContext {
var p = new(ReverseRangeContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *ReverseRangeContext) GetOp1() antlr.Token { return s.op1 }
func (s *ReverseRangeContext) GetOp2() antlr.Token { return s.op2 }
func (s *ReverseRangeContext) SetOp1(v antlr.Token) { s.op1 = v }
func (s *ReverseRangeContext) SetOp2(v antlr.Token) { s.op2 = v }
func (s *ReverseRangeContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *ReverseRangeContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *ReverseRangeContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *ReverseRangeContext) Identifier() antlr.TerminalNode {
return s.GetToken(PlanParserIdentifier, 0)
}
func (s *ReverseRangeContext) JSONIdentifier() antlr.TerminalNode {
return s.GetToken(PlanParserJSONIdentifier, 0)
}
func (s *ReverseRangeContext) AllGT() []antlr.TerminalNode {
return s.GetTokens(PlanParserGT)
}
func (s *ReverseRangeContext) GT(i int) antlr.TerminalNode {
return s.GetToken(PlanParserGT, i)
}
func (s *ReverseRangeContext) AllGE() []antlr.TerminalNode {
return s.GetTokens(PlanParserGE)
}
func (s *ReverseRangeContext) GE(i int) antlr.TerminalNode {
return s.GetToken(PlanParserGE, i)
}
func (s *ReverseRangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitReverseRange(s)
default:
return t.VisitChildren(s)
}
}
type BitOrContext struct {
ExprContext
}
func NewBitOrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitOrContext {
var p = new(BitOrContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *BitOrContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *BitOrContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *BitOrContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *BitOrContext) BOR() antlr.TerminalNode {
return s.GetToken(PlanParserBOR, 0)
}
func (s *BitOrContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitBitOr(s)
default:
return t.VisitChildren(s)
}
}
type EmptyArrayContext struct {
ExprContext
}
func NewEmptyArrayContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EmptyArrayContext {
var p = new(EmptyArrayContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *EmptyArrayContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *EmptyArrayContext) EmptyArray() antlr.TerminalNode {
return s.GetToken(PlanParserEmptyArray, 0)
}
func (s *EmptyArrayContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitEmptyArray(s)
default:
return t.VisitChildren(s)
}
}
type AddSubContext struct {
ExprContext
op antlr.Token
}
func NewAddSubContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AddSubContext {
var p = new(AddSubContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *AddSubContext) GetOp() antlr.Token { return s.op }
func (s *AddSubContext) SetOp(v antlr.Token) { s.op = v }
func (s *AddSubContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *AddSubContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *AddSubContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *AddSubContext) ADD() antlr.TerminalNode {
return s.GetToken(PlanParserADD, 0)
}
func (s *AddSubContext) SUB() antlr.TerminalNode {
return s.GetToken(PlanParserSUB, 0)
}
func (s *AddSubContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitAddSub(s)
default:
return t.VisitChildren(s)
}
}
type PhraseMatchContext struct {
ExprContext
}
func NewPhraseMatchContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PhraseMatchContext {
var p = new(PhraseMatchContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *PhraseMatchContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *PhraseMatchContext) PHRASEMATCH() antlr.TerminalNode {
return s.GetToken(PlanParserPHRASEMATCH, 0)
}
func (s *PhraseMatchContext) Identifier() antlr.TerminalNode {
return s.GetToken(PlanParserIdentifier, 0)
}
func (s *PhraseMatchContext) StringLiteral() antlr.TerminalNode {
return s.GetToken(PlanParserStringLiteral, 0)
}
func (s *PhraseMatchContext) Expr() IExprContext {
var t antlr.RuleContext
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
t = ctx.(antlr.RuleContext)
break
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *PhraseMatchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitPhraseMatch(s)
default:
return t.VisitChildren(s)
}
}
type RelationalContext struct {
ExprContext
op antlr.Token
}
func NewRelationalContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RelationalContext {
var p = new(RelationalContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *RelationalContext) GetOp() antlr.Token { return s.op }
func (s *RelationalContext) SetOp(v antlr.Token) { s.op = v }
func (s *RelationalContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *RelationalContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *RelationalContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *RelationalContext) LT() antlr.TerminalNode {
return s.GetToken(PlanParserLT, 0)
}
func (s *RelationalContext) LE() antlr.TerminalNode {
return s.GetToken(PlanParserLE, 0)
}
func (s *RelationalContext) GT() antlr.TerminalNode {
return s.GetToken(PlanParserGT, 0)
}
func (s *RelationalContext) GE() antlr.TerminalNode {
return s.GetToken(PlanParserGE, 0)
}
func (s *RelationalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitRelational(s)
default:
return t.VisitChildren(s)
}
}
type ArrayLengthContext struct {
ExprContext
}
func NewArrayLengthContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrayLengthContext {
var p = new(ArrayLengthContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *ArrayLengthContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *ArrayLengthContext) ArrayLength() antlr.TerminalNode {
return s.GetToken(PlanParserArrayLength, 0)
}
func (s *ArrayLengthContext) Identifier() antlr.TerminalNode {
return s.GetToken(PlanParserIdentifier, 0)
}
func (s *ArrayLengthContext) JSONIdentifier() antlr.TerminalNode {
return s.GetToken(PlanParserJSONIdentifier, 0)
}
func (s *ArrayLengthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitArrayLength(s)
default:
return t.VisitChildren(s)
}
}
type TextMatchContext struct {
ExprContext
}
func NewTextMatchContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TextMatchContext {
var p = new(TextMatchContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *TextMatchContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *TextMatchContext) TEXTMATCH() antlr.TerminalNode {
return s.GetToken(PlanParserTEXTMATCH, 0)
}
func (s *TextMatchContext) Identifier() antlr.TerminalNode {
return s.GetToken(PlanParserIdentifier, 0)
}
func (s *TextMatchContext) StringLiteral() antlr.TerminalNode {
return s.GetToken(PlanParserStringLiteral, 0)
}
func (s *TextMatchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitTextMatch(s)
default:
return t.VisitChildren(s)
}
}
type TermContext struct {
ExprContext
op antlr.Token
}
func NewTermContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TermContext {
var p = new(TermContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *TermContext) GetOp() antlr.Token { return s.op }
func (s *TermContext) SetOp(v antlr.Token) { s.op = v }
func (s *TermContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *TermContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *TermContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *TermContext) IN() antlr.TerminalNode {
return s.GetToken(PlanParserIN, 0)
}
func (s *TermContext) NOT() antlr.TerminalNode {
return s.GetToken(PlanParserNOT, 0)
}
func (s *TermContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitTerm(s)
default:
return t.VisitChildren(s)
}
}
type JSONContainsContext struct {
ExprContext
}
func NewJSONContainsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JSONContainsContext {
var p = new(JSONContainsContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *JSONContainsContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *JSONContainsContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *JSONContainsContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *JSONContainsContext) JSONContains() antlr.TerminalNode {
return s.GetToken(PlanParserJSONContains, 0)
}
func (s *JSONContainsContext) ArrayContains() antlr.TerminalNode {
return s.GetToken(PlanParserArrayContains, 0)
}
func (s *JSONContainsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitJSONContains(s)
default:
return t.VisitChildren(s)
}
}
type RangeContext struct {
ExprContext
op1 antlr.Token
op2 antlr.Token
}
func NewRangeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RangeContext {
var p = new(RangeContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *RangeContext) GetOp1() antlr.Token { return s.op1 }
func (s *RangeContext) GetOp2() antlr.Token { return s.op2 }
func (s *RangeContext) SetOp1(v antlr.Token) { s.op1 = v }
func (s *RangeContext) SetOp2(v antlr.Token) { s.op2 = v }
func (s *RangeContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *RangeContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *RangeContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *RangeContext) Identifier() antlr.TerminalNode {
return s.GetToken(PlanParserIdentifier, 0)
}
func (s *RangeContext) JSONIdentifier() antlr.TerminalNode {
return s.GetToken(PlanParserJSONIdentifier, 0)
}
func (s *RangeContext) AllLT() []antlr.TerminalNode {
return s.GetTokens(PlanParserLT)
}
func (s *RangeContext) LT(i int) antlr.TerminalNode {
return s.GetToken(PlanParserLT, i)
}
func (s *RangeContext) AllLE() []antlr.TerminalNode {
return s.GetTokens(PlanParserLE)
}
func (s *RangeContext) LE(i int) antlr.TerminalNode {
return s.GetToken(PlanParserLE, i)
}
func (s *RangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitRange(s)
default:
return t.VisitChildren(s)
}
}
type UnaryContext struct {
ExprContext
op antlr.Token
}
func NewUnaryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryContext {
var p = new(UnaryContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *UnaryContext) GetOp() antlr.Token { return s.op }
func (s *UnaryContext) SetOp(v antlr.Token) { s.op = v }
func (s *UnaryContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *UnaryContext) Expr() IExprContext {
var t antlr.RuleContext
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
t = ctx.(antlr.RuleContext)
break
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *UnaryContext) ADD() antlr.TerminalNode {
return s.GetToken(PlanParserADD, 0)
}
func (s *UnaryContext) SUB() antlr.TerminalNode {
return s.GetToken(PlanParserSUB, 0)
}
func (s *UnaryContext) BNOT() antlr.TerminalNode {
return s.GetToken(PlanParserBNOT, 0)
}
func (s *UnaryContext) NOT() antlr.TerminalNode {
return s.GetToken(PlanParserNOT, 0)
}
func (s *UnaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitUnary(s)
default:
return t.VisitChildren(s)
}
}
type TimestamptzCompareContext struct {
ExprContext
op1 antlr.Token
interval_string antlr.Token
op2 antlr.Token
compare_string antlr.Token
}
func NewTimestamptzCompareContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TimestamptzCompareContext {
var p = new(TimestamptzCompareContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *TimestamptzCompareContext) GetOp1() antlr.Token { return s.op1 }
func (s *TimestamptzCompareContext) GetInterval_string() antlr.Token { return s.interval_string }
func (s *TimestamptzCompareContext) GetOp2() antlr.Token { return s.op2 }
func (s *TimestamptzCompareContext) GetCompare_string() antlr.Token { return s.compare_string }
func (s *TimestamptzCompareContext) SetOp1(v antlr.Token) { s.op1 = v }
func (s *TimestamptzCompareContext) SetInterval_string(v antlr.Token) { s.interval_string = v }
func (s *TimestamptzCompareContext) SetOp2(v antlr.Token) { s.op2 = v }
func (s *TimestamptzCompareContext) SetCompare_string(v antlr.Token) { s.compare_string = v }
func (s *TimestamptzCompareContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *TimestamptzCompareContext) Identifier() antlr.TerminalNode {
return s.GetToken(PlanParserIdentifier, 0)
}
func (s *TimestamptzCompareContext) ISO() antlr.TerminalNode {
return s.GetToken(PlanParserISO, 0)
}
func (s *TimestamptzCompareContext) AllStringLiteral() []antlr.TerminalNode {
return s.GetTokens(PlanParserStringLiteral)
}
func (s *TimestamptzCompareContext) StringLiteral(i int) antlr.TerminalNode {
return s.GetToken(PlanParserStringLiteral, i)
}
func (s *TimestamptzCompareContext) LT() antlr.TerminalNode {
return s.GetToken(PlanParserLT, 0)
}
func (s *TimestamptzCompareContext) LE() antlr.TerminalNode {
return s.GetToken(PlanParserLE, 0)
}
func (s *TimestamptzCompareContext) GT() antlr.TerminalNode {
return s.GetToken(PlanParserGT, 0)
}
func (s *TimestamptzCompareContext) GE() antlr.TerminalNode {
return s.GetToken(PlanParserGE, 0)
}
func (s *TimestamptzCompareContext) EQ() antlr.TerminalNode {
return s.GetToken(PlanParserEQ, 0)
}
func (s *TimestamptzCompareContext) NE() antlr.TerminalNode {
return s.GetToken(PlanParserNE, 0)
}
func (s *TimestamptzCompareContext) INTERVAL() antlr.TerminalNode {
return s.GetToken(PlanParserINTERVAL, 0)
}
func (s *TimestamptzCompareContext) ADD() antlr.TerminalNode {
return s.GetToken(PlanParserADD, 0)
}
func (s *TimestamptzCompareContext) SUB() antlr.TerminalNode {
return s.GetToken(PlanParserSUB, 0)
}
func (s *TimestamptzCompareContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitTimestamptzCompare(s)
default:
return t.VisitChildren(s)
}
}
type IntegerContext struct {
ExprContext
}
func NewIntegerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntegerContext {
var p = new(IntegerContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *IntegerContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *IntegerContext) IntegerConstant() antlr.TerminalNode {
return s.GetToken(PlanParserIntegerConstant, 0)
}
func (s *IntegerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitInteger(s)
default:
return t.VisitChildren(s)
}
}
type ArrayContext struct {
ExprContext
}
func NewArrayContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrayContext {
var p = new(ArrayContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *ArrayContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *ArrayContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *ArrayContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *ArrayContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitArray(s)
default:
return t.VisitChildren(s)
}
}
type JSONContainsAnyContext struct {
ExprContext
}
func NewJSONContainsAnyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JSONContainsAnyContext {
var p = new(JSONContainsAnyContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *JSONContainsAnyContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *JSONContainsAnyContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *JSONContainsAnyContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *JSONContainsAnyContext) JSONContainsAny() antlr.TerminalNode {
return s.GetToken(PlanParserJSONContainsAny, 0)
}
func (s *JSONContainsAnyContext) ArrayContainsAny() antlr.TerminalNode {
return s.GetToken(PlanParserArrayContainsAny, 0)
}
func (s *JSONContainsAnyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitJSONContainsAny(s)
default:
return t.VisitChildren(s)
}
}
type BitXorContext struct {
ExprContext
}
func NewBitXorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitXorContext {
var p = new(BitXorContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *BitXorContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *BitXorContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *BitXorContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *BitXorContext) BXOR() antlr.TerminalNode {
return s.GetToken(PlanParserBXOR, 0)
}
func (s *BitXorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitBitXor(s)
default:
return t.VisitChildren(s)
}
}
type ExistsContext struct {
ExprContext
}
func NewExistsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExistsContext {
var p = new(ExistsContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *ExistsContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *ExistsContext) EXISTS() antlr.TerminalNode {
return s.GetToken(PlanParserEXISTS, 0)
}
func (s *ExistsContext) Expr() IExprContext {
var t antlr.RuleContext
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
t = ctx.(antlr.RuleContext)
break
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *ExistsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitExists(s)
default:
return t.VisitChildren(s)
}
}
type BitAndContext struct {
ExprContext
}
func NewBitAndContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitAndContext {
var p = new(BitAndContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *BitAndContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *BitAndContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *BitAndContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *BitAndContext) BAND() antlr.TerminalNode {
return s.GetToken(PlanParserBAND, 0)
}
func (s *BitAndContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitBitAnd(s)
default:
return t.VisitChildren(s)
}
}
type IsNullContext struct {
ExprContext
}
func NewIsNullContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IsNullContext {
var p = new(IsNullContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *IsNullContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *IsNullContext) ISNULL() antlr.TerminalNode {
return s.GetToken(PlanParserISNULL, 0)
}
func (s *IsNullContext) Identifier() antlr.TerminalNode {
return s.GetToken(PlanParserIdentifier, 0)
}
func (s *IsNullContext) JSONIdentifier() antlr.TerminalNode {
return s.GetToken(PlanParserJSONIdentifier, 0)
}
func (s *IsNullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitIsNull(s)
default:
return t.VisitChildren(s)
}
}
type PowerContext struct {
ExprContext
}
func NewPowerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PowerContext {
var p = new(PowerContext)
InitEmptyExprContext(&p.ExprContext)
p.parser = parser
p.CopyAll(ctx.(*ExprContext))
return p
}
func (s *PowerContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *PowerContext) AllExpr() []IExprContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IExprContext); ok {
len++
}
}
tst := make([]IExprContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IExprContext); ok {
tst[i] = t.(IExprContext)
i++
}
}
return tst
}
func (s *PowerContext) Expr(i int) IExprContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IExprContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *PowerContext) POW() antlr.TerminalNode {
return s.GetToken(PlanParserPOW, 0)
}
func (s *PowerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitPower(s)
default:
return t.VisitChildren(s)
}
}
func (p *PlanParser) Expr() (localctx IExprContext) {
return p.expr(0)
}
func (p *PlanParser) expr(_p int) (localctx IExprContext) {
var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
_parentState := p.GetState()
localctx = NewExprContext(p, p.GetParserRuleContext(), _parentState)
var _prevctx IExprContext = localctx
var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
_startState := 0
p.EnterRecursionRule(localctx, 0, PlanParserRULE_expr, _p)
var _la int
var _alt int
p.EnterOuterAlt(localctx, 1)
p.SetState(110)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 7, p.GetParserRuleContext()) {
case 1:
localctx = NewTimestamptzCompareContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(3)
p.Match(PlanParserIdentifier)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
p.SetState(7)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_la = p.GetTokenStream().LA(1)
if _la == PlanParserADD || _la == PlanParserSUB {
{
p.SetState(4)
var _lt = p.GetTokenStream().LT(1)
localctx.(*TimestamptzCompareContext).op1 = _lt
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserADD || _la == PlanParserSUB) {
var _ri = p.GetErrorHandler().RecoverInline(p)
localctx.(*TimestamptzCompareContext).op1 = _ri
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(5)
p.Match(PlanParserINTERVAL)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(6)
var _m = p.Match(PlanParserStringLiteral)
localctx.(*TimestamptzCompareContext).interval_string = _m
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
}
{
p.SetState(9)
var _lt = p.GetTokenStream().LT(1)
localctx.(*TimestamptzCompareContext).op2 = _lt
_la = p.GetTokenStream().LA(1)
if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&16128) != 0) {
var _ri = p.GetErrorHandler().RecoverInline(p)
localctx.(*TimestamptzCompareContext).op2 = _ri
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(10)
p.Match(PlanParserISO)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(11)
var _m = p.Match(PlanParserStringLiteral)
localctx.(*TimestamptzCompareContext).compare_string = _m
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 2:
localctx = NewIntegerContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(12)
p.Match(PlanParserIntegerConstant)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 3:
localctx = NewFloatingContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(13)
p.Match(PlanParserFloatingConstant)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 4:
localctx = NewBooleanContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(14)
p.Match(PlanParserBooleanConstant)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 5:
localctx = NewStringContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(15)
p.Match(PlanParserStringLiteral)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 6:
localctx = NewIdentifierContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(16)
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserIdentifier || _la == PlanParserMeta) {
p.GetErrorHandler().RecoverInline(p)
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
case 7:
localctx = NewJSONIdentifierContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(17)
p.Match(PlanParserJSONIdentifier)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 8:
localctx = NewTemplateVariableContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(18)
p.Match(PlanParserLBRACE)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(19)
p.Match(PlanParserIdentifier)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(20)
p.Match(PlanParserRBRACE)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 9:
localctx = NewParensContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(21)
p.Match(PlanParserT__0)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(22)
p.expr(0)
}
{
p.SetState(23)
p.Match(PlanParserT__1)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 10:
localctx = NewArrayContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(25)
p.Match(PlanParserT__2)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(26)
p.expr(0)
}
p.SetState(31)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1, p.GetParserRuleContext())
if p.HasError() {
goto errorExit
}
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
if _alt == 1 {
{
p.SetState(27)
p.Match(PlanParserT__3)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(28)
p.expr(0)
}
}
p.SetState(33)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1, p.GetParserRuleContext())
if p.HasError() {
goto errorExit
}
}
p.SetState(35)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_la = p.GetTokenStream().LA(1)
if _la == PlanParserT__3 {
{
p.SetState(34)
p.Match(PlanParserT__3)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
}
{
p.SetState(37)
p.Match(PlanParserT__4)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 11:
localctx = NewEmptyArrayContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(39)
p.Match(PlanParserEmptyArray)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 12:
localctx = NewExistsContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(40)
p.Match(PlanParserEXISTS)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(41)
p.expr(27)
}
case 13:
localctx = NewTextMatchContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(42)
p.Match(PlanParserTEXTMATCH)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(43)
p.Match(PlanParserT__0)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(44)
p.Match(PlanParserIdentifier)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(45)
p.Match(PlanParserT__3)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(46)
p.Match(PlanParserStringLiteral)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(47)
p.Match(PlanParserT__1)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 14:
localctx = NewPhraseMatchContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(48)
p.Match(PlanParserPHRASEMATCH)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(49)
p.Match(PlanParserT__0)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(50)
p.Match(PlanParserIdentifier)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(51)
p.Match(PlanParserT__3)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(52)
p.Match(PlanParserStringLiteral)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
p.SetState(55)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_la = p.GetTokenStream().LA(1)
if _la == PlanParserT__3 {
{
p.SetState(53)
p.Match(PlanParserT__3)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(54)
p.expr(0)
}
}
{
p.SetState(57)
p.Match(PlanParserT__1)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 15:
localctx = NewRandomSampleContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(58)
p.Match(PlanParserRANDOMSAMPLE)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(59)
p.Match(PlanParserT__0)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(60)
p.expr(0)
}
{
p.SetState(61)
p.Match(PlanParserT__1)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 16:
localctx = NewUnaryContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(63)
var _lt = p.GetTokenStream().LT(1)
localctx.(*UnaryContext).op = _lt
_la = p.GetTokenStream().LA(1)
if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&206164721664) != 0) {
var _ri = p.GetErrorHandler().RecoverInline(p)
localctx.(*UnaryContext).op = _ri
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(64)
p.expr(21)
}
case 17:
localctx = NewJSONContainsContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(65)
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserJSONContains || _la == PlanParserArrayContains) {
p.GetErrorHandler().RecoverInline(p)
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(66)
p.Match(PlanParserT__0)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(67)
p.expr(0)
}
{
p.SetState(68)
p.Match(PlanParserT__3)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(69)
p.expr(0)
}
{
p.SetState(70)
p.Match(PlanParserT__1)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 18:
localctx = NewJSONContainsAllContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(72)
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserJSONContainsAll || _la == PlanParserArrayContainsAll) {
p.GetErrorHandler().RecoverInline(p)
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(73)
p.Match(PlanParserT__0)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(74)
p.expr(0)
}
{
p.SetState(75)
p.Match(PlanParserT__3)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(76)
p.expr(0)
}
{
p.SetState(77)
p.Match(PlanParserT__1)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 19:
localctx = NewJSONContainsAnyContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(79)
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserJSONContainsAny || _la == PlanParserArrayContainsAny) {
p.GetErrorHandler().RecoverInline(p)
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(80)
p.Match(PlanParserT__0)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(81)
p.expr(0)
}
{
p.SetState(82)
p.Match(PlanParserT__3)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(83)
p.expr(0)
}
{
p.SetState(84)
p.Match(PlanParserT__1)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 20:
localctx = NewArrayLengthContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(86)
p.Match(PlanParserArrayLength)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(87)
p.Match(PlanParserT__0)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(88)
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserIdentifier || _la == PlanParserJSONIdentifier) {
p.GetErrorHandler().RecoverInline(p)
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(89)
p.Match(PlanParserT__1)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 21:
localctx = NewCallContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(90)
p.Match(PlanParserIdentifier)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(91)
p.Match(PlanParserT__0)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
p.SetState(103)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_la = p.GetTokenStream().LA(1)
if (int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&18014054918881354) != 0 {
{
p.SetState(92)
p.expr(0)
}
p.SetState(97)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 4, p.GetParserRuleContext())
if p.HasError() {
goto errorExit
}
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
if _alt == 1 {
{
p.SetState(93)
p.Match(PlanParserT__3)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(94)
p.expr(0)
}
}
p.SetState(99)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 4, p.GetParserRuleContext())
if p.HasError() {
goto errorExit
}
}
p.SetState(101)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_la = p.GetTokenStream().LA(1)
if _la == PlanParserT__3 {
{
p.SetState(100)
p.Match(PlanParserT__3)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
}
}
{
p.SetState(105)
p.Match(PlanParserT__1)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 22:
localctx = NewIsNullContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(106)
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserIdentifier || _la == PlanParserJSONIdentifier) {
p.GetErrorHandler().RecoverInline(p)
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(107)
p.Match(PlanParserISNULL)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case 23:
localctx = NewIsNotNullContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(108)
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserIdentifier || _la == PlanParserJSONIdentifier) {
p.GetErrorHandler().RecoverInline(p)
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(109)
p.Match(PlanParserISNOTNULL)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case antlr.ATNInvalidAltNumber:
goto errorExit
}
p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
p.SetState(166)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 10, p.GetParserRuleContext())
if p.HasError() {
goto errorExit
}
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
if _alt == 1 {
if p.GetParseListeners() != nil {
p.TriggerExitRuleEvent()
}
_prevctx = localctx
p.SetState(164)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 9, p.GetParserRuleContext()) {
case 1:
localctx = NewPowerContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(112)
if !(p.Precpred(p.GetParserRuleContext(), 22)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 22)", ""))
goto errorExit
}
{
p.SetState(113)
p.Match(PlanParserPOW)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(114)
p.expr(23)
}
case 2:
localctx = NewMulDivModContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(115)
if !(p.Precpred(p.GetParserRuleContext(), 20)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 20)", ""))
goto errorExit
}
{
p.SetState(116)
var _lt = p.GetTokenStream().LT(1)
localctx.(*MulDivModContext).op = _lt
_la = p.GetTokenStream().LA(1)
if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&58720256) != 0) {
var _ri = p.GetErrorHandler().RecoverInline(p)
localctx.(*MulDivModContext).op = _ri
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(117)
p.expr(21)
}
case 3:
localctx = NewAddSubContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(118)
if !(p.Precpred(p.GetParserRuleContext(), 19)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 19)", ""))
goto errorExit
}
{
p.SetState(119)
var _lt = p.GetTokenStream().LT(1)
localctx.(*AddSubContext).op = _lt
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserADD || _la == PlanParserSUB) {
var _ri = p.GetErrorHandler().RecoverInline(p)
localctx.(*AddSubContext).op = _ri
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(120)
p.expr(20)
}
case 4:
localctx = NewShiftContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(121)
if !(p.Precpred(p.GetParserRuleContext(), 18)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 18)", ""))
goto errorExit
}
{
p.SetState(122)
var _lt = p.GetTokenStream().LT(1)
localctx.(*ShiftContext).op = _lt
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserSHL || _la == PlanParserSHR) {
var _ri = p.GetErrorHandler().RecoverInline(p)
localctx.(*ShiftContext).op = _ri
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(123)
p.expr(19)
}
case 5:
localctx = NewTermContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(124)
if !(p.Precpred(p.GetParserRuleContext(), 17)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 17)", ""))
goto errorExit
}
p.SetState(126)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_la = p.GetTokenStream().LA(1)
if _la == PlanParserNOT {
{
p.SetState(125)
var _m = p.Match(PlanParserNOT)
localctx.(*TermContext).op = _m
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
}
{
p.SetState(128)
p.Match(PlanParserIN)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(129)
p.expr(18)
}
case 6:
localctx = NewRangeContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(130)
if !(p.Precpred(p.GetParserRuleContext(), 11)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 11)", ""))
goto errorExit
}
{
p.SetState(131)
var _lt = p.GetTokenStream().LT(1)
localctx.(*RangeContext).op1 = _lt
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserLT || _la == PlanParserLE) {
var _ri = p.GetErrorHandler().RecoverInline(p)
localctx.(*RangeContext).op1 = _ri
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(132)
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserIdentifier || _la == PlanParserJSONIdentifier) {
p.GetErrorHandler().RecoverInline(p)
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(133)
var _lt = p.GetTokenStream().LT(1)
localctx.(*RangeContext).op2 = _lt
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserLT || _la == PlanParserLE) {
var _ri = p.GetErrorHandler().RecoverInline(p)
localctx.(*RangeContext).op2 = _ri
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(134)
p.expr(12)
}
case 7:
localctx = NewReverseRangeContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(135)
if !(p.Precpred(p.GetParserRuleContext(), 10)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", ""))
goto errorExit
}
{
p.SetState(136)
var _lt = p.GetTokenStream().LT(1)
localctx.(*ReverseRangeContext).op1 = _lt
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserGT || _la == PlanParserGE) {
var _ri = p.GetErrorHandler().RecoverInline(p)
localctx.(*ReverseRangeContext).op1 = _ri
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(137)
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserIdentifier || _la == PlanParserJSONIdentifier) {
p.GetErrorHandler().RecoverInline(p)
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(138)
var _lt = p.GetTokenStream().LT(1)
localctx.(*ReverseRangeContext).op2 = _lt
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserGT || _la == PlanParserGE) {
var _ri = p.GetErrorHandler().RecoverInline(p)
localctx.(*ReverseRangeContext).op2 = _ri
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(139)
p.expr(11)
}
case 8:
localctx = NewRelationalContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(140)
if !(p.Precpred(p.GetParserRuleContext(), 9)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", ""))
goto errorExit
}
{
p.SetState(141)
var _lt = p.GetTokenStream().LT(1)
localctx.(*RelationalContext).op = _lt
_la = p.GetTokenStream().LA(1)
if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3840) != 0) {
var _ri = p.GetErrorHandler().RecoverInline(p)
localctx.(*RelationalContext).op = _ri
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(142)
p.expr(10)
}
case 9:
localctx = NewEqualityContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(143)
if !(p.Precpred(p.GetParserRuleContext(), 8)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", ""))
goto errorExit
}
{
p.SetState(144)
var _lt = p.GetTokenStream().LT(1)
localctx.(*EqualityContext).op = _lt
_la = p.GetTokenStream().LA(1)
if !(_la == PlanParserEQ || _la == PlanParserNE) {
var _ri = p.GetErrorHandler().RecoverInline(p)
localctx.(*EqualityContext).op = _ri
} else {
p.GetErrorHandler().ReportMatch(p)
p.Consume()
}
}
{
p.SetState(145)
p.expr(9)
}
case 10:
localctx = NewBitAndContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(146)
if !(p.Precpred(p.GetParserRuleContext(), 7)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", ""))
goto errorExit
}
{
p.SetState(147)
p.Match(PlanParserBAND)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(148)
p.expr(8)
}
case 11:
localctx = NewBitXorContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(149)
if !(p.Precpred(p.GetParserRuleContext(), 6)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", ""))
goto errorExit
}
{
p.SetState(150)
p.Match(PlanParserBXOR)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(151)
p.expr(7)
}
case 12:
localctx = NewBitOrContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(152)
if !(p.Precpred(p.GetParserRuleContext(), 5)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
goto errorExit
}
{
p.SetState(153)
p.Match(PlanParserBOR)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(154)
p.expr(6)
}
case 13:
localctx = NewLogicalAndContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(155)
if !(p.Precpred(p.GetParserRuleContext(), 4)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
goto errorExit
}
{
p.SetState(156)
p.Match(PlanParserAND)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(157)
p.expr(5)
}
case 14:
localctx = NewLogicalOrContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(158)
if !(p.Precpred(p.GetParserRuleContext(), 3)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
goto errorExit
}
{
p.SetState(159)
p.Match(PlanParserOR)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(160)
p.expr(4)
}
case 15:
localctx = NewLikeContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(161)
if !(p.Precpred(p.GetParserRuleContext(), 26)) {
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 26)", ""))
goto errorExit
}
{
p.SetState(162)
p.Match(PlanParserLIKE)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
{
p.SetState(163)
p.Match(PlanParserStringLiteral)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
case antlr.ATNInvalidAltNumber:
goto errorExit
}
}
p.SetState(168)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 10, p.GetParserRuleContext())
if p.HasError() {
goto errorExit
}
}
errorExit:
if p.HasError() {
v := p.GetError()
localctx.SetException(v)
p.GetErrorHandler().ReportError(p, v)
p.GetErrorHandler().Recover(p, v)
p.SetError(nil)
}
p.UnrollRecursionContexts(_parentctx)
return localctx
goto errorExit // Trick to prevent compiler error if the label is not used
}
func (p *PlanParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
switch ruleIndex {
case 0:
var t *ExprContext = nil
if localctx != nil {
t = localctx.(*ExprContext)
}
return p.Expr_Sempred(t, predIndex)
default:
panic("No predicate with index: " + fmt.Sprint(ruleIndex))
}
}
func (p *PlanParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool {
switch predIndex {
case 0:
return p.Precpred(p.GetParserRuleContext(), 22)
case 1:
return p.Precpred(p.GetParserRuleContext(), 20)
case 2:
return p.Precpred(p.GetParserRuleContext(), 19)
case 3:
return p.Precpred(p.GetParserRuleContext(), 18)
case 4:
return p.Precpred(p.GetParserRuleContext(), 17)
case 5:
return p.Precpred(p.GetParserRuleContext(), 11)
case 6:
return p.Precpred(p.GetParserRuleContext(), 10)
case 7:
return p.Precpred(p.GetParserRuleContext(), 9)
case 8:
return p.Precpred(p.GetParserRuleContext(), 8)
case 9:
return p.Precpred(p.GetParserRuleContext(), 7)
case 10:
return p.Precpred(p.GetParserRuleContext(), 6)
case 11:
return p.Precpred(p.GetParserRuleContext(), 5)
case 12:
return p.Precpred(p.GetParserRuleContext(), 4)
case 13:
return p.Precpred(p.GetParserRuleContext(), 3)
case 14:
return p.Precpred(p.GetParserRuleContext(), 26)
default:
panic("No predicate with index: " + fmt.Sprint(predIndex))
}
}
Reference in New Issue View Git Blame Copy Permalink