mirror of
https://gitee.com/milvus-io/milvus.git
synced 2025-12-06 17:18:35 +08:00
cd931a0388
issue: #43427 pr: #37417 This pr's main goal is merge #37417 to milvus 2.5 without conflicts. # Main Goals 1. Create and describe collections with geospatial type 2. Insert geospatial data into the insert binlog 3. Load segments containing geospatial data into memory 4. Enable query and search can display geospatial data 5. Support using GIS funtions like ST_EQUALS in query # Solution 1. **Add Type**: Modify the Milvus core by adding a Geospatial type in both the C++ and Go code layers, defining the Geospatial data structure and the corresponding interfaces. 2. **Dependency Libraries**: Introduce necessary geospatial data processing libraries. In the C++ source code, use Conan package management to include the GDAL library. In the Go source code, add the go-geom library to the go.mod file. 3. **Protocol Interface**: Revise the Milvus protocol to provide mechanisms for Geospatial message serialization and deserialization. 4. **Data Pipeline**: Facilitate interaction between the client and proxy using the WKT format for geospatial data. The proxy will convert all data into WKB format for downstream processing, providing column data interfaces, segment encapsulation, segment loading, payload writing, and cache block management. 5. **Query Operators**: Implement simple display and support for filter queries. Initially, focus on filtering based on spatial relationships for a single column of geospatial literal values, providing parsing and execution for query expressions.Now only support brutal search 6. **Client Modification**: Enable the client to handle user input for geospatial data and facilitate end-to-end testing.Check the modification in pymilvus. --------- Signed-off-by: Yinwei Li <yinwei.li@zilliz.com> Signed-off-by: Cai Zhang <cai.zhang@zilliz.com> Co-authored-by: cai.zhang <cai.zhang@zilliz.com>
4528 lines
96 KiB
Go
4528 lines
96 KiB
Go
// 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", "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", "STEuqals", "STTouches", "STOverlaps",
|
|
"STCrosses", "STContains", "STIntersects", "STWithin", "BooleanConstant",
|
|
"IntegerConstant", "FloatingConstant", "Identifier", "Meta", "StringLiteral",
|
|
"JSONIdentifier", "Whitespace", "Newline",
|
|
}
|
|
staticData.RuleNames = []string{
|
|
"expr",
|
|
}
|
|
staticData.PredictionContextCache = antlr.NewPredictionContextCache()
|
|
staticData.serializedATN = []int32{
|
|
4, 1, 59, 198, 2, 0, 7, 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, 21,
|
|
8, 0, 10, 0, 12, 0, 24, 9, 0, 1, 0, 3, 0, 27, 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, 47, 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, 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, 124, 8, 0, 10, 0,
|
|
12, 0, 127, 9, 0, 1, 0, 3, 0, 130, 8, 0, 3, 0, 132, 8, 0, 1, 0, 1, 0, 1,
|
|
0, 1, 0, 1, 0, 3, 0, 139, 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, 155, 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, 193,
|
|
8, 0, 10, 0, 12, 0, 196, 9, 0, 1, 0, 0, 1, 0, 1, 0, 0, 13, 1, 0, 54, 55,
|
|
2, 0, 18, 19, 33, 34, 2, 0, 37, 37, 40, 40, 2, 0, 38, 38, 41, 41, 2, 0,
|
|
39, 39, 42, 42, 2, 0, 54, 54, 57, 57, 1, 0, 20, 22, 1, 0, 18, 19, 1, 0,
|
|
24, 25, 1, 0, 8, 9, 1, 0, 10, 11, 1, 0, 8, 11, 1, 0, 12, 13, 245, 0, 138,
|
|
1, 0, 0, 0, 2, 3, 6, 0, -1, 0, 3, 139, 5, 52, 0, 0, 4, 139, 5, 53, 0, 0,
|
|
5, 139, 5, 51, 0, 0, 6, 139, 5, 56, 0, 0, 7, 139, 7, 0, 0, 0, 8, 139, 5,
|
|
57, 0, 0, 9, 10, 5, 6, 0, 0, 10, 11, 5, 54, 0, 0, 11, 139, 5, 7, 0, 0,
|
|
12, 13, 5, 1, 0, 0, 13, 14, 3, 0, 0, 0, 14, 15, 5, 2, 0, 0, 15, 139, 1,
|
|
0, 0, 0, 16, 17, 5, 3, 0, 0, 17, 22, 3, 0, 0, 0, 18, 19, 5, 4, 0, 0, 19,
|
|
21, 3, 0, 0, 0, 20, 18, 1, 0, 0, 0, 21, 24, 1, 0, 0, 0, 22, 20, 1, 0, 0,
|
|
0, 22, 23, 1, 0, 0, 0, 23, 26, 1, 0, 0, 0, 24, 22, 1, 0, 0, 0, 25, 27,
|
|
5, 4, 0, 0, 26, 25, 1, 0, 0, 0, 26, 27, 1, 0, 0, 0, 27, 28, 1, 0, 0, 0,
|
|
28, 29, 5, 5, 0, 0, 29, 139, 1, 0, 0, 0, 30, 139, 5, 36, 0, 0, 31, 32,
|
|
5, 15, 0, 0, 32, 139, 3, 0, 0, 33, 33, 34, 5, 16, 0, 0, 34, 35, 5, 1, 0,
|
|
0, 35, 36, 5, 54, 0, 0, 36, 37, 5, 4, 0, 0, 37, 38, 5, 56, 0, 0, 38, 139,
|
|
5, 2, 0, 0, 39, 40, 5, 17, 0, 0, 40, 41, 5, 1, 0, 0, 41, 42, 5, 54, 0,
|
|
0, 42, 43, 5, 4, 0, 0, 43, 46, 5, 56, 0, 0, 44, 45, 5, 4, 0, 0, 45, 47,
|
|
3, 0, 0, 0, 46, 44, 1, 0, 0, 0, 46, 47, 1, 0, 0, 0, 47, 48, 1, 0, 0, 0,
|
|
48, 139, 5, 2, 0, 0, 49, 50, 7, 1, 0, 0, 50, 139, 3, 0, 0, 28, 51, 52,
|
|
7, 2, 0, 0, 52, 53, 5, 1, 0, 0, 53, 54, 3, 0, 0, 0, 54, 55, 5, 4, 0, 0,
|
|
55, 56, 3, 0, 0, 0, 56, 57, 5, 2, 0, 0, 57, 139, 1, 0, 0, 0, 58, 59, 7,
|
|
3, 0, 0, 59, 60, 5, 1, 0, 0, 60, 61, 3, 0, 0, 0, 61, 62, 5, 4, 0, 0, 62,
|
|
63, 3, 0, 0, 0, 63, 64, 5, 2, 0, 0, 64, 139, 1, 0, 0, 0, 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, 139, 1, 0, 0, 0, 72, 73, 5, 44, 0,
|
|
0, 73, 74, 5, 1, 0, 0, 74, 75, 5, 54, 0, 0, 75, 76, 5, 4, 0, 0, 76, 77,
|
|
5, 56, 0, 0, 77, 139, 5, 2, 0, 0, 78, 79, 5, 45, 0, 0, 79, 80, 5, 1, 0,
|
|
0, 80, 81, 5, 54, 0, 0, 81, 82, 5, 4, 0, 0, 82, 83, 5, 56, 0, 0, 83, 139,
|
|
5, 2, 0, 0, 84, 85, 5, 46, 0, 0, 85, 86, 5, 1, 0, 0, 86, 87, 5, 54, 0,
|
|
0, 87, 88, 5, 4, 0, 0, 88, 89, 5, 56, 0, 0, 89, 139, 5, 2, 0, 0, 90, 91,
|
|
5, 47, 0, 0, 91, 92, 5, 1, 0, 0, 92, 93, 5, 54, 0, 0, 93, 94, 5, 4, 0,
|
|
0, 94, 95, 5, 56, 0, 0, 95, 139, 5, 2, 0, 0, 96, 97, 5, 48, 0, 0, 97, 98,
|
|
5, 1, 0, 0, 98, 99, 5, 54, 0, 0, 99, 100, 5, 4, 0, 0, 100, 101, 5, 56,
|
|
0, 0, 101, 139, 5, 2, 0, 0, 102, 103, 5, 49, 0, 0, 103, 104, 5, 1, 0, 0,
|
|
104, 105, 5, 54, 0, 0, 105, 106, 5, 4, 0, 0, 106, 107, 5, 56, 0, 0, 107,
|
|
139, 5, 2, 0, 0, 108, 109, 5, 50, 0, 0, 109, 110, 5, 1, 0, 0, 110, 111,
|
|
5, 54, 0, 0, 111, 112, 5, 4, 0, 0, 112, 113, 5, 56, 0, 0, 113, 139, 5,
|
|
2, 0, 0, 114, 115, 5, 43, 0, 0, 115, 116, 5, 1, 0, 0, 116, 117, 7, 5, 0,
|
|
0, 117, 139, 5, 2, 0, 0, 118, 119, 5, 54, 0, 0, 119, 131, 5, 1, 0, 0, 120,
|
|
125, 3, 0, 0, 0, 121, 122, 5, 4, 0, 0, 122, 124, 3, 0, 0, 0, 123, 121,
|
|
1, 0, 0, 0, 124, 127, 1, 0, 0, 0, 125, 123, 1, 0, 0, 0, 125, 126, 1, 0,
|
|
0, 0, 126, 129, 1, 0, 0, 0, 127, 125, 1, 0, 0, 0, 128, 130, 5, 4, 0, 0,
|
|
129, 128, 1, 0, 0, 0, 129, 130, 1, 0, 0, 0, 130, 132, 1, 0, 0, 0, 131,
|
|
120, 1, 0, 0, 0, 131, 132, 1, 0, 0, 0, 132, 133, 1, 0, 0, 0, 133, 139,
|
|
5, 2, 0, 0, 134, 135, 7, 5, 0, 0, 135, 139, 5, 31, 0, 0, 136, 137, 7, 5,
|
|
0, 0, 137, 139, 5, 32, 0, 0, 138, 2, 1, 0, 0, 0, 138, 4, 1, 0, 0, 0, 138,
|
|
5, 1, 0, 0, 0, 138, 6, 1, 0, 0, 0, 138, 7, 1, 0, 0, 0, 138, 8, 1, 0, 0,
|
|
0, 138, 9, 1, 0, 0, 0, 138, 12, 1, 0, 0, 0, 138, 16, 1, 0, 0, 0, 138, 30,
|
|
1, 0, 0, 0, 138, 31, 1, 0, 0, 0, 138, 33, 1, 0, 0, 0, 138, 39, 1, 0, 0,
|
|
0, 138, 49, 1, 0, 0, 0, 138, 51, 1, 0, 0, 0, 138, 58, 1, 0, 0, 0, 138,
|
|
65, 1, 0, 0, 0, 138, 72, 1, 0, 0, 0, 138, 78, 1, 0, 0, 0, 138, 84, 1, 0,
|
|
0, 0, 138, 90, 1, 0, 0, 0, 138, 96, 1, 0, 0, 0, 138, 102, 1, 0, 0, 0, 138,
|
|
108, 1, 0, 0, 0, 138, 114, 1, 0, 0, 0, 138, 118, 1, 0, 0, 0, 138, 134,
|
|
1, 0, 0, 0, 138, 136, 1, 0, 0, 0, 139, 194, 1, 0, 0, 0, 140, 141, 10, 29,
|
|
0, 0, 141, 142, 5, 23, 0, 0, 142, 193, 3, 0, 0, 30, 143, 144, 10, 27, 0,
|
|
0, 144, 145, 7, 6, 0, 0, 145, 193, 3, 0, 0, 28, 146, 147, 10, 26, 0, 0,
|
|
147, 148, 7, 7, 0, 0, 148, 193, 3, 0, 0, 27, 149, 150, 10, 25, 0, 0, 150,
|
|
151, 7, 8, 0, 0, 151, 193, 3, 0, 0, 26, 152, 154, 10, 24, 0, 0, 153, 155,
|
|
5, 34, 0, 0, 154, 153, 1, 0, 0, 0, 154, 155, 1, 0, 0, 0, 155, 156, 1, 0,
|
|
0, 0, 156, 157, 5, 35, 0, 0, 157, 193, 3, 0, 0, 25, 158, 159, 10, 11, 0,
|
|
0, 159, 160, 7, 9, 0, 0, 160, 161, 7, 5, 0, 0, 161, 162, 7, 9, 0, 0, 162,
|
|
193, 3, 0, 0, 12, 163, 164, 10, 10, 0, 0, 164, 165, 7, 10, 0, 0, 165, 166,
|
|
7, 5, 0, 0, 166, 167, 7, 10, 0, 0, 167, 193, 3, 0, 0, 11, 168, 169, 10,
|
|
9, 0, 0, 169, 170, 7, 11, 0, 0, 170, 193, 3, 0, 0, 10, 171, 172, 10, 8,
|
|
0, 0, 172, 173, 7, 12, 0, 0, 173, 193, 3, 0, 0, 9, 174, 175, 10, 7, 0,
|
|
0, 175, 176, 5, 26, 0, 0, 176, 193, 3, 0, 0, 8, 177, 178, 10, 6, 0, 0,
|
|
178, 179, 5, 28, 0, 0, 179, 193, 3, 0, 0, 7, 180, 181, 10, 5, 0, 0, 181,
|
|
182, 5, 27, 0, 0, 182, 193, 3, 0, 0, 6, 183, 184, 10, 4, 0, 0, 184, 185,
|
|
5, 29, 0, 0, 185, 193, 3, 0, 0, 5, 186, 187, 10, 3, 0, 0, 187, 188, 5,
|
|
30, 0, 0, 188, 193, 3, 0, 0, 4, 189, 190, 10, 32, 0, 0, 190, 191, 5, 14,
|
|
0, 0, 191, 193, 5, 56, 0, 0, 192, 140, 1, 0, 0, 0, 192, 143, 1, 0, 0, 0,
|
|
192, 146, 1, 0, 0, 0, 192, 149, 1, 0, 0, 0, 192, 152, 1, 0, 0, 0, 192,
|
|
158, 1, 0, 0, 0, 192, 163, 1, 0, 0, 0, 192, 168, 1, 0, 0, 0, 192, 171,
|
|
1, 0, 0, 0, 192, 174, 1, 0, 0, 0, 192, 177, 1, 0, 0, 0, 192, 180, 1, 0,
|
|
0, 0, 192, 183, 1, 0, 0, 0, 192, 186, 1, 0, 0, 0, 192, 189, 1, 0, 0, 0,
|
|
193, 196, 1, 0, 0, 0, 194, 192, 1, 0, 0, 0, 194, 195, 1, 0, 0, 0, 195,
|
|
1, 1, 0, 0, 0, 196, 194, 1, 0, 0, 0, 10, 22, 26, 46, 125, 129, 131, 138,
|
|
154, 192, 194,
|
|
}
|
|
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
|
|
PlanParserADD = 18
|
|
PlanParserSUB = 19
|
|
PlanParserMUL = 20
|
|
PlanParserDIV = 21
|
|
PlanParserMOD = 22
|
|
PlanParserPOW = 23
|
|
PlanParserSHL = 24
|
|
PlanParserSHR = 25
|
|
PlanParserBAND = 26
|
|
PlanParserBOR = 27
|
|
PlanParserBXOR = 28
|
|
PlanParserAND = 29
|
|
PlanParserOR = 30
|
|
PlanParserISNULL = 31
|
|
PlanParserISNOTNULL = 32
|
|
PlanParserBNOT = 33
|
|
PlanParserNOT = 34
|
|
PlanParserIN = 35
|
|
PlanParserEmptyArray = 36
|
|
PlanParserJSONContains = 37
|
|
PlanParserJSONContainsAll = 38
|
|
PlanParserJSONContainsAny = 39
|
|
PlanParserArrayContains = 40
|
|
PlanParserArrayContainsAll = 41
|
|
PlanParserArrayContainsAny = 42
|
|
PlanParserArrayLength = 43
|
|
PlanParserSTEuqals = 44
|
|
PlanParserSTTouches = 45
|
|
PlanParserSTOverlaps = 46
|
|
PlanParserSTCrosses = 47
|
|
PlanParserSTContains = 48
|
|
PlanParserSTIntersects = 49
|
|
PlanParserSTWithin = 50
|
|
PlanParserBooleanConstant = 51
|
|
PlanParserIntegerConstant = 52
|
|
PlanParserFloatingConstant = 53
|
|
PlanParserIdentifier = 54
|
|
PlanParserMeta = 55
|
|
PlanParserStringLiteral = 56
|
|
PlanParserJSONIdentifier = 57
|
|
PlanParserWhitespace = 58
|
|
PlanParserNewline = 59
|
|
)
|
|
|
|
// 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 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 STIntersectsContext struct {
|
|
ExprContext
|
|
}
|
|
|
|
func NewSTIntersectsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *STIntersectsContext {
|
|
var p = new(STIntersectsContext)
|
|
|
|
InitEmptyExprContext(&p.ExprContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExprContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *STIntersectsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *STIntersectsContext) STIntersects() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserSTIntersects, 0)
|
|
}
|
|
|
|
func (s *STIntersectsContext) Identifier() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserIdentifier, 0)
|
|
}
|
|
|
|
func (s *STIntersectsContext) StringLiteral() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserStringLiteral, 0)
|
|
}
|
|
|
|
func (s *STIntersectsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case PlanVisitor:
|
|
return t.VisitSTIntersects(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 STCrossesContext struct {
|
|
ExprContext
|
|
}
|
|
|
|
func NewSTCrossesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *STCrossesContext {
|
|
var p = new(STCrossesContext)
|
|
|
|
InitEmptyExprContext(&p.ExprContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExprContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *STCrossesContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *STCrossesContext) STCrosses() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserSTCrosses, 0)
|
|
}
|
|
|
|
func (s *STCrossesContext) Identifier() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserIdentifier, 0)
|
|
}
|
|
|
|
func (s *STCrossesContext) StringLiteral() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserStringLiteral, 0)
|
|
}
|
|
|
|
func (s *STCrossesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case PlanVisitor:
|
|
return t.VisitSTCrosses(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 STTouchesContext struct {
|
|
ExprContext
|
|
}
|
|
|
|
func NewSTTouchesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *STTouchesContext {
|
|
var p = new(STTouchesContext)
|
|
|
|
InitEmptyExprContext(&p.ExprContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExprContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *STTouchesContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *STTouchesContext) STTouches() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserSTTouches, 0)
|
|
}
|
|
|
|
func (s *STTouchesContext) Identifier() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserIdentifier, 0)
|
|
}
|
|
|
|
func (s *STTouchesContext) StringLiteral() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserStringLiteral, 0)
|
|
}
|
|
|
|
func (s *STTouchesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case PlanVisitor:
|
|
return t.VisitSTTouches(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
type STContainsContext struct {
|
|
ExprContext
|
|
}
|
|
|
|
func NewSTContainsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *STContainsContext {
|
|
var p = new(STContainsContext)
|
|
|
|
InitEmptyExprContext(&p.ExprContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExprContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *STContainsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *STContainsContext) STContains() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserSTContains, 0)
|
|
}
|
|
|
|
func (s *STContainsContext) Identifier() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserIdentifier, 0)
|
|
}
|
|
|
|
func (s *STContainsContext) StringLiteral() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserStringLiteral, 0)
|
|
}
|
|
|
|
func (s *STContainsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case PlanVisitor:
|
|
return t.VisitSTContains(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 STWithinContext struct {
|
|
ExprContext
|
|
}
|
|
|
|
func NewSTWithinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *STWithinContext {
|
|
var p = new(STWithinContext)
|
|
|
|
InitEmptyExprContext(&p.ExprContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExprContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *STWithinContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *STWithinContext) STWithin() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserSTWithin, 0)
|
|
}
|
|
|
|
func (s *STWithinContext) Identifier() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserIdentifier, 0)
|
|
}
|
|
|
|
func (s *STWithinContext) StringLiteral() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserStringLiteral, 0)
|
|
}
|
|
|
|
func (s *STWithinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case PlanVisitor:
|
|
return t.VisitSTWithin(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 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 STEuqalsContext struct {
|
|
ExprContext
|
|
}
|
|
|
|
func NewSTEuqalsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *STEuqalsContext {
|
|
var p = new(STEuqalsContext)
|
|
|
|
InitEmptyExprContext(&p.ExprContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExprContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *STEuqalsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *STEuqalsContext) STEuqals() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserSTEuqals, 0)
|
|
}
|
|
|
|
func (s *STEuqalsContext) Identifier() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserIdentifier, 0)
|
|
}
|
|
|
|
func (s *STEuqalsContext) StringLiteral() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserStringLiteral, 0)
|
|
}
|
|
|
|
func (s *STEuqalsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case PlanVisitor:
|
|
return t.VisitSTEuqals(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)
|
|
}
|
|
}
|
|
|
|
type STOverlapsContext struct {
|
|
ExprContext
|
|
}
|
|
|
|
func NewSTOverlapsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *STOverlapsContext {
|
|
var p = new(STOverlapsContext)
|
|
|
|
InitEmptyExprContext(&p.ExprContext)
|
|
p.parser = parser
|
|
p.CopyAll(ctx.(*ExprContext))
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *STOverlapsContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *STOverlapsContext) STOverlaps() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserSTOverlaps, 0)
|
|
}
|
|
|
|
func (s *STOverlapsContext) Identifier() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserIdentifier, 0)
|
|
}
|
|
|
|
func (s *STOverlapsContext) StringLiteral() antlr.TerminalNode {
|
|
return s.GetToken(PlanParserStringLiteral, 0)
|
|
}
|
|
|
|
func (s *STOverlapsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case PlanVisitor:
|
|
return t.VisitSTOverlaps(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(138)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 6, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewIntegerContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
|
|
{
|
|
p.SetState(3)
|
|
p.Match(PlanParserIntegerConstant)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewFloatingContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(4)
|
|
p.Match(PlanParserFloatingConstant)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewBooleanContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(5)
|
|
p.Match(PlanParserBooleanConstant)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewStringContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(6)
|
|
p.Match(PlanParserStringLiteral)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewIdentifierContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(7)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == PlanParserIdentifier || _la == PlanParserMeta) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
case 6:
|
|
localctx = NewJSONIdentifierContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(8)
|
|
p.Match(PlanParserJSONIdentifier)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 7:
|
|
localctx = NewTemplateVariableContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(9)
|
|
p.Match(PlanParserLBRACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(10)
|
|
p.Match(PlanParserIdentifier)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(11)
|
|
p.Match(PlanParserRBRACE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 8:
|
|
localctx = NewParensContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(12)
|
|
p.Match(PlanParserT__0)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(13)
|
|
p.expr(0)
|
|
}
|
|
{
|
|
p.SetState(14)
|
|
p.Match(PlanParserT__1)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 9:
|
|
localctx = NewArrayContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(16)
|
|
p.Match(PlanParserT__2)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(17)
|
|
p.expr(0)
|
|
}
|
|
p.SetState(22)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 0, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(18)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(19)
|
|
p.expr(0)
|
|
}
|
|
|
|
}
|
|
p.SetState(24)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 0, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(26)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == PlanParserT__3 {
|
|
{
|
|
p.SetState(25)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(28)
|
|
p.Match(PlanParserT__4)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 10:
|
|
localctx = NewEmptyArrayContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(30)
|
|
p.Match(PlanParserEmptyArray)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 11:
|
|
localctx = NewExistsContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(31)
|
|
p.Match(PlanParserEXISTS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(32)
|
|
p.expr(33)
|
|
}
|
|
|
|
case 12:
|
|
localctx = NewTextMatchContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(33)
|
|
p.Match(PlanParserTEXTMATCH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(34)
|
|
p.Match(PlanParserT__0)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(35)
|
|
p.Match(PlanParserIdentifier)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(36)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(37)
|
|
p.Match(PlanParserStringLiteral)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(38)
|
|
p.Match(PlanParserT__1)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 13:
|
|
localctx = NewPhraseMatchContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(39)
|
|
p.Match(PlanParserPHRASEMATCH)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(40)
|
|
p.Match(PlanParserT__0)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(41)
|
|
p.Match(PlanParserIdentifier)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(42)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(43)
|
|
p.Match(PlanParserStringLiteral)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(46)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == PlanParserT__3 {
|
|
{
|
|
p.SetState(44)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(45)
|
|
p.expr(0)
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(48)
|
|
p.Match(PlanParserT__1)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 14:
|
|
localctx = NewUnaryContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(49)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*UnaryContext).op = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&25770590208) != 0) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*UnaryContext).op = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(50)
|
|
p.expr(28)
|
|
}
|
|
|
|
case 15:
|
|
localctx = NewJSONContainsContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(51)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == PlanParserJSONContains || _la == PlanParserArrayContains) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(52)
|
|
p.Match(PlanParserT__0)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(53)
|
|
p.expr(0)
|
|
}
|
|
{
|
|
p.SetState(54)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(55)
|
|
p.expr(0)
|
|
}
|
|
{
|
|
p.SetState(56)
|
|
p.Match(PlanParserT__1)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 16:
|
|
localctx = NewJSONContainsAllContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(58)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == PlanParserJSONContainsAll || _la == PlanParserArrayContainsAll) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
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__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(62)
|
|
p.expr(0)
|
|
}
|
|
{
|
|
p.SetState(63)
|
|
p.Match(PlanParserT__1)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 17:
|
|
localctx = NewJSONContainsAnyContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(65)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == PlanParserJSONContainsAny || _la == PlanParserArrayContainsAny) {
|
|
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 = NewSTEuqalsContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(72)
|
|
p.Match(PlanParserSTEuqals)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(73)
|
|
p.Match(PlanParserT__0)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(74)
|
|
p.Match(PlanParserIdentifier)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(75)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(76)
|
|
p.Match(PlanParserStringLiteral)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(77)
|
|
p.Match(PlanParserT__1)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 19:
|
|
localctx = NewSTTouchesContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(78)
|
|
p.Match(PlanParserSTTouches)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(79)
|
|
p.Match(PlanParserT__0)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(80)
|
|
p.Match(PlanParserIdentifier)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(81)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(82)
|
|
p.Match(PlanParserStringLiteral)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(83)
|
|
p.Match(PlanParserT__1)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 20:
|
|
localctx = NewSTOverlapsContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(84)
|
|
p.Match(PlanParserSTOverlaps)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(85)
|
|
p.Match(PlanParserT__0)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(86)
|
|
p.Match(PlanParserIdentifier)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(87)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(88)
|
|
p.Match(PlanParserStringLiteral)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(89)
|
|
p.Match(PlanParserT__1)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 21:
|
|
localctx = NewSTCrossesContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(90)
|
|
p.Match(PlanParserSTCrosses)
|
|
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(92)
|
|
p.Match(PlanParserIdentifier)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(93)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(94)
|
|
p.Match(PlanParserStringLiteral)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(95)
|
|
p.Match(PlanParserT__1)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 22:
|
|
localctx = NewSTContainsContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(96)
|
|
p.Match(PlanParserSTContains)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(97)
|
|
p.Match(PlanParserT__0)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(98)
|
|
p.Match(PlanParserIdentifier)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(99)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(100)
|
|
p.Match(PlanParserStringLiteral)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(101)
|
|
p.Match(PlanParserT__1)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 23:
|
|
localctx = NewSTIntersectsContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(102)
|
|
p.Match(PlanParserSTIntersects)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(103)
|
|
p.Match(PlanParserT__0)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(104)
|
|
p.Match(PlanParserIdentifier)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(105)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(106)
|
|
p.Match(PlanParserStringLiteral)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(107)
|
|
p.Match(PlanParserT__1)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 24:
|
|
localctx = NewSTWithinContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(108)
|
|
p.Match(PlanParserSTWithin)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(109)
|
|
p.Match(PlanParserT__0)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(110)
|
|
p.Match(PlanParserIdentifier)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(111)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(112)
|
|
p.Match(PlanParserStringLiteral)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(113)
|
|
p.Match(PlanParserT__1)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 25:
|
|
localctx = NewArrayLengthContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(114)
|
|
p.Match(PlanParserArrayLength)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(115)
|
|
p.Match(PlanParserT__0)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(116)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == PlanParserIdentifier || _la == PlanParserJSONIdentifier) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(117)
|
|
p.Match(PlanParserT__1)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 26:
|
|
localctx = NewCallContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(118)
|
|
p.Match(PlanParserIdentifier)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(119)
|
|
p.Match(PlanParserT__0)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(131)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if (int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&288230333203054666) != 0 {
|
|
{
|
|
p.SetState(120)
|
|
p.expr(0)
|
|
}
|
|
p.SetState(125)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
|
|
if _alt == 1 {
|
|
{
|
|
p.SetState(121)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(122)
|
|
p.expr(0)
|
|
}
|
|
|
|
}
|
|
p.SetState(127)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3, p.GetParserRuleContext())
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(129)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == PlanParserT__3 {
|
|
{
|
|
p.SetState(128)
|
|
p.Match(PlanParserT__3)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(133)
|
|
p.Match(PlanParserT__1)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 27:
|
|
localctx = NewIsNullContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(134)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == PlanParserIdentifier || _la == PlanParserJSONIdentifier) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(135)
|
|
p.Match(PlanParserISNULL)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case 28:
|
|
localctx = NewIsNotNullContext(p, localctx)
|
|
p.SetParserRuleContext(localctx)
|
|
_prevctx = localctx
|
|
{
|
|
p.SetState(136)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == PlanParserIdentifier || _la == PlanParserJSONIdentifier) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(137)
|
|
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(194)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 9, 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(192)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 8, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewPowerContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(140)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 29)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 29)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(141)
|
|
p.Match(PlanParserPOW)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(142)
|
|
p.expr(30)
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewMulDivModContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(143)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 27)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 27)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(144)
|
|
|
|
var _lt = p.GetTokenStream().LT(1)
|
|
|
|
localctx.(*MulDivModContext).op = _lt
|
|
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&7340032) != 0) {
|
|
var _ri = p.GetErrorHandler().RecoverInline(p)
|
|
|
|
localctx.(*MulDivModContext).op = _ri
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(145)
|
|
p.expr(28)
|
|
}
|
|
|
|
case 3:
|
|
localctx = NewAddSubContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(146)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 26)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 26)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(147)
|
|
|
|
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(148)
|
|
p.expr(27)
|
|
}
|
|
|
|
case 4:
|
|
localctx = NewShiftContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(149)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 25)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 25)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(150)
|
|
|
|
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(151)
|
|
p.expr(26)
|
|
}
|
|
|
|
case 5:
|
|
localctx = NewTermContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(152)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 24)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 24)", ""))
|
|
goto errorExit
|
|
}
|
|
p.SetState(154)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == PlanParserNOT {
|
|
{
|
|
p.SetState(153)
|
|
|
|
var _m = p.Match(PlanParserNOT)
|
|
|
|
localctx.(*TermContext).op = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(156)
|
|
p.Match(PlanParserIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(157)
|
|
p.expr(25)
|
|
}
|
|
|
|
case 6:
|
|
localctx = NewRangeContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(158)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 11)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 11)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(159)
|
|
|
|
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(160)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == PlanParserIdentifier || _la == PlanParserJSONIdentifier) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(161)
|
|
|
|
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(162)
|
|
p.expr(12)
|
|
}
|
|
|
|
case 7:
|
|
localctx = NewReverseRangeContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(163)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 10)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(164)
|
|
|
|
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(165)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == PlanParserIdentifier || _la == PlanParserJSONIdentifier) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
{
|
|
p.SetState(166)
|
|
|
|
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(167)
|
|
p.expr(11)
|
|
}
|
|
|
|
case 8:
|
|
localctx = NewRelationalContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(168)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 9)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(169)
|
|
|
|
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(170)
|
|
p.expr(10)
|
|
}
|
|
|
|
case 9:
|
|
localctx = NewEqualityContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(171)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 8)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(172)
|
|
|
|
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(173)
|
|
p.expr(9)
|
|
}
|
|
|
|
case 10:
|
|
localctx = NewBitAndContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(174)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 7)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(175)
|
|
p.Match(PlanParserBAND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(176)
|
|
p.expr(8)
|
|
}
|
|
|
|
case 11:
|
|
localctx = NewBitXorContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(177)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 6)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(178)
|
|
p.Match(PlanParserBXOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(179)
|
|
p.expr(7)
|
|
}
|
|
|
|
case 12:
|
|
localctx = NewBitOrContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(180)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 5)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(181)
|
|
p.Match(PlanParserBOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(182)
|
|
p.expr(6)
|
|
}
|
|
|
|
case 13:
|
|
localctx = NewLogicalAndContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(183)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 4)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(184)
|
|
p.Match(PlanParserAND)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(185)
|
|
p.expr(5)
|
|
}
|
|
|
|
case 14:
|
|
localctx = NewLogicalOrContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(186)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 3)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(187)
|
|
p.Match(PlanParserOR)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(188)
|
|
p.expr(4)
|
|
}
|
|
|
|
case 15:
|
|
localctx = NewLikeContext(p, NewExprContext(p, _parentctx, _parentState))
|
|
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
|
|
p.SetState(189)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 32)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 32)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(190)
|
|
p.Match(PlanParserLIKE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(191)
|
|
p.Match(PlanParserStringLiteral)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
p.SetState(196)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 9, 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(), 29)
|
|
|
|
case 1:
|
|
return p.Precpred(p.GetParserRuleContext(), 27)
|
|
|
|
case 2:
|
|
return p.Precpred(p.GetParserRuleContext(), 26)
|
|
|
|
case 3:
|
|
return p.Precpred(p.GetParserRuleContext(), 25)
|
|
|
|
case 4:
|
|
return p.Precpred(p.GetParserRuleContext(), 24)
|
|
|
|
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(), 32)
|
|
|
|
default:
|
|
panic("No predicate with index: " + fmt.Sprint(predIndex))
|
|
}
|
|
}
|