forked from TrueCloudLab/frostfs-sdk-go
3095 lines
71 KiB
Go
3095 lines
71 KiB
Go
// Code generated from Query.g4 by ANTLR 4.13.0. DO NOT EDIT.
|
|
|
|
package parser // Query
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"sync"
|
|
|
|
"github.com/antlr4-go/antlr/v4"
|
|
)
|
|
|
|
// Suppress unused import errors
|
|
var _ = fmt.Printf
|
|
var _ = strconv.Itoa
|
|
var _ = sync.Once{}
|
|
|
|
type Query struct {
|
|
*antlr.BaseParser
|
|
}
|
|
|
|
var QueryParserStaticData struct {
|
|
once sync.Once
|
|
serializedATN []int32
|
|
LiteralNames []string
|
|
SymbolicNames []string
|
|
RuleNames []string
|
|
PredictionContextCache *antlr.PredictionContextCache
|
|
atn *antlr.ATN
|
|
decisionToDFA []*antlr.DFA
|
|
}
|
|
|
|
func queryParserInit() {
|
|
staticData := &QueryParserStaticData
|
|
staticData.LiteralNames = []string{
|
|
"", "'NOT'", "'AND'", "'OR'", "", "'UNIQUE'", "'REP'", "'IN'", "'AS'",
|
|
"'CBF'", "'SELECT'", "'FROM'", "'FILTER'", "'*'", "'SAME'", "'DISTINCT'",
|
|
"'('", "')'", "'@'", "", "", "'0'",
|
|
}
|
|
staticData.SymbolicNames = []string{
|
|
"", "NOT_OP", "AND_OP", "OR_OP", "SIMPLE_OP", "UNIQUE", "REP", "IN",
|
|
"AS", "CBF", "SELECT", "FROM", "FILTER", "WILDCARD", "CLAUSE_SAME",
|
|
"CLAUSE_DISTINCT", "L_PAREN", "R_PAREN", "AT", "IDENT", "NUMBER1", "ZERO",
|
|
"STRING", "WS",
|
|
}
|
|
staticData.RuleNames = []string{
|
|
"policy", "selectFilterExpr", "repStmt", "cbfStmt", "selectStmt", "clause",
|
|
"filterExpr", "filterStmt", "expr", "filterKey", "filterValue", "number",
|
|
"keyword", "ident", "identWC",
|
|
}
|
|
staticData.PredictionContextCache = antlr.NewPredictionContextCache()
|
|
staticData.serializedATN = []int32{
|
|
4, 1, 23, 154, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7,
|
|
4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7,
|
|
10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 1, 0, 3, 0,
|
|
32, 8, 0, 1, 0, 4, 0, 35, 8, 0, 11, 0, 12, 0, 36, 1, 0, 3, 0, 40, 8, 0,
|
|
1, 0, 5, 0, 43, 8, 0, 10, 0, 12, 0, 46, 9, 0, 1, 0, 5, 0, 49, 8, 0, 10,
|
|
0, 12, 0, 52, 9, 0, 1, 0, 1, 0, 1, 1, 3, 1, 57, 8, 1, 1, 1, 3, 1, 60, 8,
|
|
1, 1, 1, 5, 1, 63, 8, 1, 10, 1, 12, 1, 66, 9, 1, 1, 1, 1, 1, 1, 2, 1, 2,
|
|
1, 2, 1, 2, 3, 2, 74, 8, 2, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 3,
|
|
4, 83, 8, 4, 1, 4, 3, 4, 86, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 92, 8,
|
|
4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1,
|
|
6, 1, 6, 3, 6, 107, 8, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 5, 6, 115,
|
|
8, 6, 10, 6, 12, 6, 118, 9, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8,
|
|
1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 131, 8, 8, 1, 9, 1, 9, 3, 9, 135, 8, 9, 1,
|
|
10, 1, 10, 1, 10, 3, 10, 140, 8, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13,
|
|
1, 13, 3, 13, 148, 8, 13, 1, 14, 1, 14, 3, 14, 152, 8, 14, 1, 14, 0, 1,
|
|
12, 15, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 0, 3, 1,
|
|
0, 14, 15, 1, 0, 20, 21, 2, 0, 6, 8, 10, 12, 160, 0, 31, 1, 0, 0, 0, 2,
|
|
56, 1, 0, 0, 0, 4, 69, 1, 0, 0, 0, 6, 75, 1, 0, 0, 0, 8, 78, 1, 0, 0, 0,
|
|
10, 93, 1, 0, 0, 0, 12, 106, 1, 0, 0, 0, 14, 119, 1, 0, 0, 0, 16, 130,
|
|
1, 0, 0, 0, 18, 134, 1, 0, 0, 0, 20, 139, 1, 0, 0, 0, 22, 141, 1, 0, 0,
|
|
0, 24, 143, 1, 0, 0, 0, 26, 147, 1, 0, 0, 0, 28, 151, 1, 0, 0, 0, 30, 32,
|
|
5, 5, 0, 0, 31, 30, 1, 0, 0, 0, 31, 32, 1, 0, 0, 0, 32, 34, 1, 0, 0, 0,
|
|
33, 35, 3, 4, 2, 0, 34, 33, 1, 0, 0, 0, 35, 36, 1, 0, 0, 0, 36, 34, 1,
|
|
0, 0, 0, 36, 37, 1, 0, 0, 0, 37, 39, 1, 0, 0, 0, 38, 40, 3, 6, 3, 0, 39,
|
|
38, 1, 0, 0, 0, 39, 40, 1, 0, 0, 0, 40, 44, 1, 0, 0, 0, 41, 43, 3, 8, 4,
|
|
0, 42, 41, 1, 0, 0, 0, 43, 46, 1, 0, 0, 0, 44, 42, 1, 0, 0, 0, 44, 45,
|
|
1, 0, 0, 0, 45, 50, 1, 0, 0, 0, 46, 44, 1, 0, 0, 0, 47, 49, 3, 14, 7, 0,
|
|
48, 47, 1, 0, 0, 0, 49, 52, 1, 0, 0, 0, 50, 48, 1, 0, 0, 0, 50, 51, 1,
|
|
0, 0, 0, 51, 53, 1, 0, 0, 0, 52, 50, 1, 0, 0, 0, 53, 54, 5, 0, 0, 1, 54,
|
|
1, 1, 0, 0, 0, 55, 57, 3, 6, 3, 0, 56, 55, 1, 0, 0, 0, 56, 57, 1, 0, 0,
|
|
0, 57, 59, 1, 0, 0, 0, 58, 60, 3, 8, 4, 0, 59, 58, 1, 0, 0, 0, 59, 60,
|
|
1, 0, 0, 0, 60, 64, 1, 0, 0, 0, 61, 63, 3, 14, 7, 0, 62, 61, 1, 0, 0, 0,
|
|
63, 66, 1, 0, 0, 0, 64, 62, 1, 0, 0, 0, 64, 65, 1, 0, 0, 0, 65, 67, 1,
|
|
0, 0, 0, 66, 64, 1, 0, 0, 0, 67, 68, 5, 0, 0, 1, 68, 3, 1, 0, 0, 0, 69,
|
|
70, 5, 6, 0, 0, 70, 73, 5, 20, 0, 0, 71, 72, 5, 7, 0, 0, 72, 74, 3, 26,
|
|
13, 0, 73, 71, 1, 0, 0, 0, 73, 74, 1, 0, 0, 0, 74, 5, 1, 0, 0, 0, 75, 76,
|
|
5, 9, 0, 0, 76, 77, 5, 20, 0, 0, 77, 7, 1, 0, 0, 0, 78, 79, 5, 10, 0, 0,
|
|
79, 85, 5, 20, 0, 0, 80, 82, 5, 7, 0, 0, 81, 83, 3, 10, 5, 0, 82, 81, 1,
|
|
0, 0, 0, 82, 83, 1, 0, 0, 0, 83, 84, 1, 0, 0, 0, 84, 86, 3, 26, 13, 0,
|
|
85, 80, 1, 0, 0, 0, 85, 86, 1, 0, 0, 0, 86, 87, 1, 0, 0, 0, 87, 88, 5,
|
|
11, 0, 0, 88, 91, 3, 28, 14, 0, 89, 90, 5, 8, 0, 0, 90, 92, 3, 26, 13,
|
|
0, 91, 89, 1, 0, 0, 0, 91, 92, 1, 0, 0, 0, 92, 9, 1, 0, 0, 0, 93, 94, 7,
|
|
0, 0, 0, 94, 11, 1, 0, 0, 0, 95, 96, 6, 6, -1, 0, 96, 97, 5, 1, 0, 0, 97,
|
|
98, 5, 16, 0, 0, 98, 99, 3, 12, 6, 0, 99, 100, 5, 17, 0, 0, 100, 107, 1,
|
|
0, 0, 0, 101, 102, 5, 16, 0, 0, 102, 103, 3, 12, 6, 0, 103, 104, 5, 17,
|
|
0, 0, 104, 107, 1, 0, 0, 0, 105, 107, 3, 16, 8, 0, 106, 95, 1, 0, 0, 0,
|
|
106, 101, 1, 0, 0, 0, 106, 105, 1, 0, 0, 0, 107, 116, 1, 0, 0, 0, 108,
|
|
109, 10, 4, 0, 0, 109, 110, 5, 2, 0, 0, 110, 115, 3, 12, 6, 5, 111, 112,
|
|
10, 3, 0, 0, 112, 113, 5, 3, 0, 0, 113, 115, 3, 12, 6, 4, 114, 108, 1,
|
|
0, 0, 0, 114, 111, 1, 0, 0, 0, 115, 118, 1, 0, 0, 0, 116, 114, 1, 0, 0,
|
|
0, 116, 117, 1, 0, 0, 0, 117, 13, 1, 0, 0, 0, 118, 116, 1, 0, 0, 0, 119,
|
|
120, 5, 12, 0, 0, 120, 121, 3, 12, 6, 0, 121, 122, 5, 8, 0, 0, 122, 123,
|
|
3, 26, 13, 0, 123, 15, 1, 0, 0, 0, 124, 125, 5, 18, 0, 0, 125, 131, 3,
|
|
26, 13, 0, 126, 127, 3, 18, 9, 0, 127, 128, 5, 4, 0, 0, 128, 129, 3, 20,
|
|
10, 0, 129, 131, 1, 0, 0, 0, 130, 124, 1, 0, 0, 0, 130, 126, 1, 0, 0, 0,
|
|
131, 17, 1, 0, 0, 0, 132, 135, 3, 26, 13, 0, 133, 135, 5, 22, 0, 0, 134,
|
|
132, 1, 0, 0, 0, 134, 133, 1, 0, 0, 0, 135, 19, 1, 0, 0, 0, 136, 140, 3,
|
|
26, 13, 0, 137, 140, 3, 22, 11, 0, 138, 140, 5, 22, 0, 0, 139, 136, 1,
|
|
0, 0, 0, 139, 137, 1, 0, 0, 0, 139, 138, 1, 0, 0, 0, 140, 21, 1, 0, 0,
|
|
0, 141, 142, 7, 1, 0, 0, 142, 23, 1, 0, 0, 0, 143, 144, 7, 2, 0, 0, 144,
|
|
25, 1, 0, 0, 0, 145, 148, 3, 24, 12, 0, 146, 148, 5, 19, 0, 0, 147, 145,
|
|
1, 0, 0, 0, 147, 146, 1, 0, 0, 0, 148, 27, 1, 0, 0, 0, 149, 152, 3, 26,
|
|
13, 0, 150, 152, 5, 13, 0, 0, 151, 149, 1, 0, 0, 0, 151, 150, 1, 0, 0,
|
|
0, 152, 29, 1, 0, 0, 0, 20, 31, 36, 39, 44, 50, 56, 59, 64, 73, 82, 85,
|
|
91, 106, 114, 116, 130, 134, 139, 147, 151,
|
|
}
|
|
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)
|
|
}
|
|
}
|
|
|
|
// QueryInit initializes any static state used to implement Query. By default the
|
|
// static state used to implement the parser is lazily initialized during the first call to
|
|
// NewQuery(). You can call this function if you wish to initialize the static state ahead
|
|
// of time.
|
|
func QueryInit() {
|
|
staticData := &QueryParserStaticData
|
|
staticData.once.Do(queryParserInit)
|
|
}
|
|
|
|
// NewQuery produces a new parser instance for the optional input antlr.TokenStream.
|
|
func NewQuery(input antlr.TokenStream) *Query {
|
|
QueryInit()
|
|
this := new(Query)
|
|
this.BaseParser = antlr.NewBaseParser(input)
|
|
staticData := &QueryParserStaticData
|
|
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 = "Query.g4"
|
|
|
|
return this
|
|
}
|
|
|
|
// Query tokens.
|
|
const (
|
|
QueryEOF = antlr.TokenEOF
|
|
QueryNOT_OP = 1
|
|
QueryAND_OP = 2
|
|
QueryOR_OP = 3
|
|
QuerySIMPLE_OP = 4
|
|
QueryUNIQUE = 5
|
|
QueryREP = 6
|
|
QueryIN = 7
|
|
QueryAS = 8
|
|
QueryCBF = 9
|
|
QuerySELECT = 10
|
|
QueryFROM = 11
|
|
QueryFILTER = 12
|
|
QueryWILDCARD = 13
|
|
QueryCLAUSE_SAME = 14
|
|
QueryCLAUSE_DISTINCT = 15
|
|
QueryL_PAREN = 16
|
|
QueryR_PAREN = 17
|
|
QueryAT = 18
|
|
QueryIDENT = 19
|
|
QueryNUMBER1 = 20
|
|
QueryZERO = 21
|
|
QuerySTRING = 22
|
|
QueryWS = 23
|
|
)
|
|
|
|
// Query rules.
|
|
const (
|
|
QueryRULE_policy = 0
|
|
QueryRULE_selectFilterExpr = 1
|
|
QueryRULE_repStmt = 2
|
|
QueryRULE_cbfStmt = 3
|
|
QueryRULE_selectStmt = 4
|
|
QueryRULE_clause = 5
|
|
QueryRULE_filterExpr = 6
|
|
QueryRULE_filterStmt = 7
|
|
QueryRULE_expr = 8
|
|
QueryRULE_filterKey = 9
|
|
QueryRULE_filterValue = 10
|
|
QueryRULE_number = 11
|
|
QueryRULE_keyword = 12
|
|
QueryRULE_ident = 13
|
|
QueryRULE_identWC = 14
|
|
)
|
|
|
|
// IPolicyContext is an interface to support dynamic dispatch.
|
|
type IPolicyContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
EOF() antlr.TerminalNode
|
|
UNIQUE() antlr.TerminalNode
|
|
AllRepStmt() []IRepStmtContext
|
|
RepStmt(i int) IRepStmtContext
|
|
CbfStmt() ICbfStmtContext
|
|
AllSelectStmt() []ISelectStmtContext
|
|
SelectStmt(i int) ISelectStmtContext
|
|
AllFilterStmt() []IFilterStmtContext
|
|
FilterStmt(i int) IFilterStmtContext
|
|
|
|
// IsPolicyContext differentiates from other interfaces.
|
|
IsPolicyContext()
|
|
}
|
|
|
|
type PolicyContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyPolicyContext() *PolicyContext {
|
|
var p = new(PolicyContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_policy
|
|
return p
|
|
}
|
|
|
|
func InitEmptyPolicyContext(p *PolicyContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_policy
|
|
}
|
|
|
|
func (*PolicyContext) IsPolicyContext() {}
|
|
|
|
func NewPolicyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PolicyContext {
|
|
var p = new(PolicyContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = QueryRULE_policy
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *PolicyContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *PolicyContext) EOF() antlr.TerminalNode {
|
|
return s.GetToken(QueryEOF, 0)
|
|
}
|
|
|
|
func (s *PolicyContext) UNIQUE() antlr.TerminalNode {
|
|
return s.GetToken(QueryUNIQUE, 0)
|
|
}
|
|
|
|
func (s *PolicyContext) AllRepStmt() []IRepStmtContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IRepStmtContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IRepStmtContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IRepStmtContext); ok {
|
|
tst[i] = t.(IRepStmtContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PolicyContext) RepStmt(i int) IRepStmtContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IRepStmtContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IRepStmtContext)
|
|
}
|
|
|
|
func (s *PolicyContext) CbfStmt() ICbfStmtContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICbfStmtContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICbfStmtContext)
|
|
}
|
|
|
|
func (s *PolicyContext) AllSelectStmt() []ISelectStmtContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(ISelectStmtContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]ISelectStmtContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(ISelectStmtContext); ok {
|
|
tst[i] = t.(ISelectStmtContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PolicyContext) SelectStmt(i int) ISelectStmtContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectStmtContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectStmtContext)
|
|
}
|
|
|
|
func (s *PolicyContext) AllFilterStmt() []IFilterStmtContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFilterStmtContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFilterStmtContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFilterStmtContext); ok {
|
|
tst[i] = t.(IFilterStmtContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *PolicyContext) FilterStmt(i int) IFilterStmtContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFilterStmtContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFilterStmtContext)
|
|
}
|
|
|
|
func (s *PolicyContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *PolicyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *PolicyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitPolicy(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) Policy() (localctx IPolicyContext) {
|
|
localctx = NewPolicyContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 0, QueryRULE_policy)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(31)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == QueryUNIQUE {
|
|
{
|
|
p.SetState(30)
|
|
p.Match(QueryUNIQUE)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
}
|
|
p.SetState(34)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = _la == QueryREP {
|
|
{
|
|
p.SetState(33)
|
|
p.RepStmt()
|
|
}
|
|
|
|
p.SetState(36)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(39)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == QueryCBF {
|
|
{
|
|
p.SetState(38)
|
|
p.CbfStmt()
|
|
}
|
|
|
|
}
|
|
p.SetState(44)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == QuerySELECT {
|
|
{
|
|
p.SetState(41)
|
|
p.SelectStmt()
|
|
}
|
|
|
|
p.SetState(46)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
p.SetState(50)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == QueryFILTER {
|
|
{
|
|
p.SetState(47)
|
|
p.FilterStmt()
|
|
}
|
|
|
|
p.SetState(52)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(53)
|
|
p.Match(QueryEOF)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
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.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISelectFilterExprContext is an interface to support dynamic dispatch.
|
|
type ISelectFilterExprContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
EOF() antlr.TerminalNode
|
|
CbfStmt() ICbfStmtContext
|
|
SelectStmt() ISelectStmtContext
|
|
AllFilterStmt() []IFilterStmtContext
|
|
FilterStmt(i int) IFilterStmtContext
|
|
|
|
// IsSelectFilterExprContext differentiates from other interfaces.
|
|
IsSelectFilterExprContext()
|
|
}
|
|
|
|
type SelectFilterExprContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptySelectFilterExprContext() *SelectFilterExprContext {
|
|
var p = new(SelectFilterExprContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_selectFilterExpr
|
|
return p
|
|
}
|
|
|
|
func InitEmptySelectFilterExprContext(p *SelectFilterExprContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_selectFilterExpr
|
|
}
|
|
|
|
func (*SelectFilterExprContext) IsSelectFilterExprContext() {}
|
|
|
|
func NewSelectFilterExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectFilterExprContext {
|
|
var p = new(SelectFilterExprContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = QueryRULE_selectFilterExpr
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectFilterExprContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SelectFilterExprContext) EOF() antlr.TerminalNode {
|
|
return s.GetToken(QueryEOF, 0)
|
|
}
|
|
|
|
func (s *SelectFilterExprContext) CbfStmt() ICbfStmtContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ICbfStmtContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ICbfStmtContext)
|
|
}
|
|
|
|
func (s *SelectFilterExprContext) SelectStmt() ISelectStmtContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(ISelectStmtContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(ISelectStmtContext)
|
|
}
|
|
|
|
func (s *SelectFilterExprContext) AllFilterStmt() []IFilterStmtContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFilterStmtContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFilterStmtContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFilterStmtContext); ok {
|
|
tst[i] = t.(IFilterStmtContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SelectFilterExprContext) FilterStmt(i int) IFilterStmtContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFilterStmtContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFilterStmtContext)
|
|
}
|
|
|
|
func (s *SelectFilterExprContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectFilterExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SelectFilterExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitSelectFilterExpr(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) SelectFilterExpr() (localctx ISelectFilterExprContext) {
|
|
localctx = NewSelectFilterExprContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 2, QueryRULE_selectFilterExpr)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(56)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == QueryCBF {
|
|
{
|
|
p.SetState(55)
|
|
p.CbfStmt()
|
|
}
|
|
|
|
}
|
|
p.SetState(59)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == QuerySELECT {
|
|
{
|
|
p.SetState(58)
|
|
p.SelectStmt()
|
|
}
|
|
|
|
}
|
|
p.SetState(64)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for _la == QueryFILTER {
|
|
{
|
|
p.SetState(61)
|
|
p.FilterStmt()
|
|
}
|
|
|
|
p.SetState(66)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(67)
|
|
p.Match(QueryEOF)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
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.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IRepStmtContext is an interface to support dynamic dispatch.
|
|
type IRepStmtContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetCount returns the Count token.
|
|
GetCount() antlr.Token
|
|
|
|
// SetCount sets the Count token.
|
|
SetCount(antlr.Token)
|
|
|
|
// GetSelector returns the Selector rule contexts.
|
|
GetSelector() IIdentContext
|
|
|
|
// SetSelector sets the Selector rule contexts.
|
|
SetSelector(IIdentContext)
|
|
|
|
// Getter signatures
|
|
REP() antlr.TerminalNode
|
|
NUMBER1() antlr.TerminalNode
|
|
IN() antlr.TerminalNode
|
|
Ident() IIdentContext
|
|
|
|
// IsRepStmtContext differentiates from other interfaces.
|
|
IsRepStmtContext()
|
|
}
|
|
|
|
type RepStmtContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
Count antlr.Token
|
|
Selector IIdentContext
|
|
}
|
|
|
|
func NewEmptyRepStmtContext() *RepStmtContext {
|
|
var p = new(RepStmtContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_repStmt
|
|
return p
|
|
}
|
|
|
|
func InitEmptyRepStmtContext(p *RepStmtContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_repStmt
|
|
}
|
|
|
|
func (*RepStmtContext) IsRepStmtContext() {}
|
|
|
|
func NewRepStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RepStmtContext {
|
|
var p = new(RepStmtContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = QueryRULE_repStmt
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *RepStmtContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *RepStmtContext) GetCount() antlr.Token { return s.Count }
|
|
|
|
func (s *RepStmtContext) SetCount(v antlr.Token) { s.Count = v }
|
|
|
|
func (s *RepStmtContext) GetSelector() IIdentContext { return s.Selector }
|
|
|
|
func (s *RepStmtContext) SetSelector(v IIdentContext) { s.Selector = v }
|
|
|
|
func (s *RepStmtContext) REP() antlr.TerminalNode {
|
|
return s.GetToken(QueryREP, 0)
|
|
}
|
|
|
|
func (s *RepStmtContext) NUMBER1() antlr.TerminalNode {
|
|
return s.GetToken(QueryNUMBER1, 0)
|
|
}
|
|
|
|
func (s *RepStmtContext) IN() antlr.TerminalNode {
|
|
return s.GetToken(QueryIN, 0)
|
|
}
|
|
|
|
func (s *RepStmtContext) Ident() IIdentContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIdentContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIdentContext)
|
|
}
|
|
|
|
func (s *RepStmtContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *RepStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *RepStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitRepStmt(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) RepStmt() (localctx IRepStmtContext) {
|
|
localctx = NewRepStmtContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 4, QueryRULE_repStmt)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(69)
|
|
p.Match(QueryREP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(70)
|
|
|
|
var _m = p.Match(QueryNUMBER1)
|
|
|
|
localctx.(*RepStmtContext).Count = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(73)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == QueryIN {
|
|
{
|
|
p.SetState(71)
|
|
p.Match(QueryIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(72)
|
|
|
|
var _x = p.Ident()
|
|
|
|
localctx.(*RepStmtContext).Selector = _x
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ICbfStmtContext is an interface to support dynamic dispatch.
|
|
type ICbfStmtContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetBackupFactor returns the BackupFactor token.
|
|
GetBackupFactor() antlr.Token
|
|
|
|
// SetBackupFactor sets the BackupFactor token.
|
|
SetBackupFactor(antlr.Token)
|
|
|
|
// Getter signatures
|
|
CBF() antlr.TerminalNode
|
|
NUMBER1() antlr.TerminalNode
|
|
|
|
// IsCbfStmtContext differentiates from other interfaces.
|
|
IsCbfStmtContext()
|
|
}
|
|
|
|
type CbfStmtContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
BackupFactor antlr.Token
|
|
}
|
|
|
|
func NewEmptyCbfStmtContext() *CbfStmtContext {
|
|
var p = new(CbfStmtContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_cbfStmt
|
|
return p
|
|
}
|
|
|
|
func InitEmptyCbfStmtContext(p *CbfStmtContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_cbfStmt
|
|
}
|
|
|
|
func (*CbfStmtContext) IsCbfStmtContext() {}
|
|
|
|
func NewCbfStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CbfStmtContext {
|
|
var p = new(CbfStmtContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = QueryRULE_cbfStmt
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *CbfStmtContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *CbfStmtContext) GetBackupFactor() antlr.Token { return s.BackupFactor }
|
|
|
|
func (s *CbfStmtContext) SetBackupFactor(v antlr.Token) { s.BackupFactor = v }
|
|
|
|
func (s *CbfStmtContext) CBF() antlr.TerminalNode {
|
|
return s.GetToken(QueryCBF, 0)
|
|
}
|
|
|
|
func (s *CbfStmtContext) NUMBER1() antlr.TerminalNode {
|
|
return s.GetToken(QueryNUMBER1, 0)
|
|
}
|
|
|
|
func (s *CbfStmtContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *CbfStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *CbfStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitCbfStmt(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) CbfStmt() (localctx ICbfStmtContext) {
|
|
localctx = NewCbfStmtContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 6, QueryRULE_cbfStmt)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(75)
|
|
p.Match(QueryCBF)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(76)
|
|
|
|
var _m = p.Match(QueryNUMBER1)
|
|
|
|
localctx.(*CbfStmtContext).BackupFactor = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
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.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// ISelectStmtContext is an interface to support dynamic dispatch.
|
|
type ISelectStmtContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetCount returns the Count token.
|
|
GetCount() antlr.Token
|
|
|
|
// SetCount sets the Count token.
|
|
SetCount(antlr.Token)
|
|
|
|
// GetBucket returns the Bucket rule contexts.
|
|
GetBucket() IIdentContext
|
|
|
|
// GetFilter returns the Filter rule contexts.
|
|
GetFilter() IIdentWCContext
|
|
|
|
// GetName returns the Name rule contexts.
|
|
GetName() IIdentContext
|
|
|
|
// SetBucket sets the Bucket rule contexts.
|
|
SetBucket(IIdentContext)
|
|
|
|
// SetFilter sets the Filter rule contexts.
|
|
SetFilter(IIdentWCContext)
|
|
|
|
// SetName sets the Name rule contexts.
|
|
SetName(IIdentContext)
|
|
|
|
// Getter signatures
|
|
SELECT() antlr.TerminalNode
|
|
FROM() antlr.TerminalNode
|
|
NUMBER1() antlr.TerminalNode
|
|
IdentWC() IIdentWCContext
|
|
IN() antlr.TerminalNode
|
|
AS() antlr.TerminalNode
|
|
AllIdent() []IIdentContext
|
|
Ident(i int) IIdentContext
|
|
Clause() IClauseContext
|
|
|
|
// IsSelectStmtContext differentiates from other interfaces.
|
|
IsSelectStmtContext()
|
|
}
|
|
|
|
type SelectStmtContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
Count antlr.Token
|
|
Bucket IIdentContext
|
|
Filter IIdentWCContext
|
|
Name IIdentContext
|
|
}
|
|
|
|
func NewEmptySelectStmtContext() *SelectStmtContext {
|
|
var p = new(SelectStmtContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_selectStmt
|
|
return p
|
|
}
|
|
|
|
func InitEmptySelectStmtContext(p *SelectStmtContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_selectStmt
|
|
}
|
|
|
|
func (*SelectStmtContext) IsSelectStmtContext() {}
|
|
|
|
func NewSelectStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectStmtContext {
|
|
var p = new(SelectStmtContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = QueryRULE_selectStmt
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *SelectStmtContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *SelectStmtContext) GetCount() antlr.Token { return s.Count }
|
|
|
|
func (s *SelectStmtContext) SetCount(v antlr.Token) { s.Count = v }
|
|
|
|
func (s *SelectStmtContext) GetBucket() IIdentContext { return s.Bucket }
|
|
|
|
func (s *SelectStmtContext) GetFilter() IIdentWCContext { return s.Filter }
|
|
|
|
func (s *SelectStmtContext) GetName() IIdentContext { return s.Name }
|
|
|
|
func (s *SelectStmtContext) SetBucket(v IIdentContext) { s.Bucket = v }
|
|
|
|
func (s *SelectStmtContext) SetFilter(v IIdentWCContext) { s.Filter = v }
|
|
|
|
func (s *SelectStmtContext) SetName(v IIdentContext) { s.Name = v }
|
|
|
|
func (s *SelectStmtContext) SELECT() antlr.TerminalNode {
|
|
return s.GetToken(QuerySELECT, 0)
|
|
}
|
|
|
|
func (s *SelectStmtContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(QueryFROM, 0)
|
|
}
|
|
|
|
func (s *SelectStmtContext) NUMBER1() antlr.TerminalNode {
|
|
return s.GetToken(QueryNUMBER1, 0)
|
|
}
|
|
|
|
func (s *SelectStmtContext) IdentWC() IIdentWCContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIdentWCContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIdentWCContext)
|
|
}
|
|
|
|
func (s *SelectStmtContext) IN() antlr.TerminalNode {
|
|
return s.GetToken(QueryIN, 0)
|
|
}
|
|
|
|
func (s *SelectStmtContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(QueryAS, 0)
|
|
}
|
|
|
|
func (s *SelectStmtContext) AllIdent() []IIdentContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IIdentContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IIdentContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IIdentContext); ok {
|
|
tst[i] = t.(IIdentContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *SelectStmtContext) Ident(i int) IIdentContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIdentContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIdentContext)
|
|
}
|
|
|
|
func (s *SelectStmtContext) Clause() IClauseContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IClauseContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IClauseContext)
|
|
}
|
|
|
|
func (s *SelectStmtContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SelectStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SelectStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitSelectStmt(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) SelectStmt() (localctx ISelectStmtContext) {
|
|
localctx = NewSelectStmtContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 8, QueryRULE_selectStmt)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(78)
|
|
p.Match(QuerySELECT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(79)
|
|
|
|
var _m = p.Match(QueryNUMBER1)
|
|
|
|
localctx.(*SelectStmtContext).Count = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(85)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == QueryIN {
|
|
{
|
|
p.SetState(80)
|
|
p.Match(QueryIN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
p.SetState(82)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == QueryCLAUSE_SAME || _la == QueryCLAUSE_DISTINCT {
|
|
{
|
|
p.SetState(81)
|
|
p.Clause()
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(84)
|
|
|
|
var _x = p.Ident()
|
|
|
|
localctx.(*SelectStmtContext).Bucket = _x
|
|
}
|
|
|
|
}
|
|
{
|
|
p.SetState(87)
|
|
p.Match(QueryFROM)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(88)
|
|
|
|
var _x = p.IdentWC()
|
|
|
|
localctx.(*SelectStmtContext).Filter = _x
|
|
}
|
|
p.SetState(91)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if _la == QueryAS {
|
|
{
|
|
p.SetState(89)
|
|
p.Match(QueryAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(90)
|
|
|
|
var _x = p.Ident()
|
|
|
|
localctx.(*SelectStmtContext).Name = _x
|
|
}
|
|
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IClauseContext is an interface to support dynamic dispatch.
|
|
type IClauseContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
CLAUSE_SAME() antlr.TerminalNode
|
|
CLAUSE_DISTINCT() antlr.TerminalNode
|
|
|
|
// IsClauseContext differentiates from other interfaces.
|
|
IsClauseContext()
|
|
}
|
|
|
|
type ClauseContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyClauseContext() *ClauseContext {
|
|
var p = new(ClauseContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_clause
|
|
return p
|
|
}
|
|
|
|
func InitEmptyClauseContext(p *ClauseContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_clause
|
|
}
|
|
|
|
func (*ClauseContext) IsClauseContext() {}
|
|
|
|
func NewClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClauseContext {
|
|
var p = new(ClauseContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = QueryRULE_clause
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ClauseContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ClauseContext) CLAUSE_SAME() antlr.TerminalNode {
|
|
return s.GetToken(QueryCLAUSE_SAME, 0)
|
|
}
|
|
|
|
func (s *ClauseContext) CLAUSE_DISTINCT() antlr.TerminalNode {
|
|
return s.GetToken(QueryCLAUSE_DISTINCT, 0)
|
|
}
|
|
|
|
func (s *ClauseContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitClause(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) Clause() (localctx IClauseContext) {
|
|
localctx = NewClauseContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 10, QueryRULE_clause)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(93)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == QueryCLAUSE_SAME || _la == QueryCLAUSE_DISTINCT) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFilterExprContext is an interface to support dynamic dispatch.
|
|
type IFilterExprContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetOp returns the Op token.
|
|
GetOp() antlr.Token
|
|
|
|
// SetOp sets the Op token.
|
|
SetOp(antlr.Token)
|
|
|
|
// GetF1 returns the F1 rule contexts.
|
|
GetF1() IFilterExprContext
|
|
|
|
// GetInner returns the Inner rule contexts.
|
|
GetInner() IFilterExprContext
|
|
|
|
// GetF2 returns the F2 rule contexts.
|
|
GetF2() IFilterExprContext
|
|
|
|
// SetF1 sets the F1 rule contexts.
|
|
SetF1(IFilterExprContext)
|
|
|
|
// SetInner sets the Inner rule contexts.
|
|
SetInner(IFilterExprContext)
|
|
|
|
// SetF2 sets the F2 rule contexts.
|
|
SetF2(IFilterExprContext)
|
|
|
|
// Getter signatures
|
|
L_PAREN() antlr.TerminalNode
|
|
R_PAREN() antlr.TerminalNode
|
|
NOT_OP() antlr.TerminalNode
|
|
AllFilterExpr() []IFilterExprContext
|
|
FilterExpr(i int) IFilterExprContext
|
|
Expr() IExprContext
|
|
AND_OP() antlr.TerminalNode
|
|
OR_OP() antlr.TerminalNode
|
|
|
|
// IsFilterExprContext differentiates from other interfaces.
|
|
IsFilterExprContext()
|
|
}
|
|
|
|
type FilterExprContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
F1 IFilterExprContext
|
|
Op antlr.Token
|
|
Inner IFilterExprContext
|
|
F2 IFilterExprContext
|
|
}
|
|
|
|
func NewEmptyFilterExprContext() *FilterExprContext {
|
|
var p = new(FilterExprContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_filterExpr
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFilterExprContext(p *FilterExprContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_filterExpr
|
|
}
|
|
|
|
func (*FilterExprContext) IsFilterExprContext() {}
|
|
|
|
func NewFilterExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterExprContext {
|
|
var p = new(FilterExprContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = QueryRULE_filterExpr
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FilterExprContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FilterExprContext) GetOp() antlr.Token { return s.Op }
|
|
|
|
func (s *FilterExprContext) SetOp(v antlr.Token) { s.Op = v }
|
|
|
|
func (s *FilterExprContext) GetF1() IFilterExprContext { return s.F1 }
|
|
|
|
func (s *FilterExprContext) GetInner() IFilterExprContext { return s.Inner }
|
|
|
|
func (s *FilterExprContext) GetF2() IFilterExprContext { return s.F2 }
|
|
|
|
func (s *FilterExprContext) SetF1(v IFilterExprContext) { s.F1 = v }
|
|
|
|
func (s *FilterExprContext) SetInner(v IFilterExprContext) { s.Inner = v }
|
|
|
|
func (s *FilterExprContext) SetF2(v IFilterExprContext) { s.F2 = v }
|
|
|
|
func (s *FilterExprContext) L_PAREN() antlr.TerminalNode {
|
|
return s.GetToken(QueryL_PAREN, 0)
|
|
}
|
|
|
|
func (s *FilterExprContext) R_PAREN() antlr.TerminalNode {
|
|
return s.GetToken(QueryR_PAREN, 0)
|
|
}
|
|
|
|
func (s *FilterExprContext) NOT_OP() antlr.TerminalNode {
|
|
return s.GetToken(QueryNOT_OP, 0)
|
|
}
|
|
|
|
func (s *FilterExprContext) AllFilterExpr() []IFilterExprContext {
|
|
children := s.GetChildren()
|
|
len := 0
|
|
for _, ctx := range children {
|
|
if _, ok := ctx.(IFilterExprContext); ok {
|
|
len++
|
|
}
|
|
}
|
|
|
|
tst := make([]IFilterExprContext, len)
|
|
i := 0
|
|
for _, ctx := range children {
|
|
if t, ok := ctx.(IFilterExprContext); ok {
|
|
tst[i] = t.(IFilterExprContext)
|
|
i++
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *FilterExprContext) FilterExpr(i int) IFilterExprContext {
|
|
var t antlr.RuleContext
|
|
j := 0
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFilterExprContext); ok {
|
|
if j == i {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFilterExprContext)
|
|
}
|
|
|
|
func (s *FilterExprContext) 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 *FilterExprContext) AND_OP() antlr.TerminalNode {
|
|
return s.GetToken(QueryAND_OP, 0)
|
|
}
|
|
|
|
func (s *FilterExprContext) OR_OP() antlr.TerminalNode {
|
|
return s.GetToken(QueryOR_OP, 0)
|
|
}
|
|
|
|
func (s *FilterExprContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FilterExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FilterExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitFilterExpr(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) FilterExpr() (localctx IFilterExprContext) {
|
|
return p.filterExpr(0)
|
|
}
|
|
|
|
func (p *Query) filterExpr(_p int) (localctx IFilterExprContext) {
|
|
var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
|
|
|
|
_parentState := p.GetState()
|
|
localctx = NewFilterExprContext(p, p.GetParserRuleContext(), _parentState)
|
|
var _prevctx IFilterExprContext = localctx
|
|
var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
|
|
_startState := 12
|
|
p.EnterRecursionRule(localctx, 12, QueryRULE_filterExpr, _p)
|
|
var _alt int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
p.SetState(106)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case QueryNOT_OP:
|
|
{
|
|
p.SetState(96)
|
|
|
|
var _m = p.Match(QueryNOT_OP)
|
|
|
|
localctx.(*FilterExprContext).Op = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(97)
|
|
p.Match(QueryL_PAREN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(98)
|
|
|
|
var _x = p.filterExpr(0)
|
|
|
|
localctx.(*FilterExprContext).F1 = _x
|
|
}
|
|
{
|
|
p.SetState(99)
|
|
p.Match(QueryR_PAREN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case QueryL_PAREN:
|
|
{
|
|
p.SetState(101)
|
|
p.Match(QueryL_PAREN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(102)
|
|
|
|
var _x = p.filterExpr(0)
|
|
|
|
localctx.(*FilterExprContext).Inner = _x
|
|
}
|
|
{
|
|
p.SetState(103)
|
|
p.Match(QueryR_PAREN)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
case QueryREP, QueryIN, QueryAS, QuerySELECT, QueryFROM, QueryFILTER, QueryAT, QueryIDENT, QuerySTRING:
|
|
{
|
|
p.SetState(105)
|
|
p.Expr()
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
goto errorExit
|
|
}
|
|
p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
|
|
p.SetState(116)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 14, 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(114)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 13, p.GetParserRuleContext()) {
|
|
case 1:
|
|
localctx = NewFilterExprContext(p, _parentctx, _parentState)
|
|
localctx.(*FilterExprContext).F1 = _prevctx
|
|
p.PushNewRecursionContext(localctx, _startState, QueryRULE_filterExpr)
|
|
p.SetState(108)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 4)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(109)
|
|
|
|
var _m = p.Match(QueryAND_OP)
|
|
|
|
localctx.(*FilterExprContext).Op = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(110)
|
|
|
|
var _x = p.filterExpr(5)
|
|
|
|
localctx.(*FilterExprContext).F2 = _x
|
|
}
|
|
|
|
case 2:
|
|
localctx = NewFilterExprContext(p, _parentctx, _parentState)
|
|
localctx.(*FilterExprContext).F1 = _prevctx
|
|
p.PushNewRecursionContext(localctx, _startState, QueryRULE_filterExpr)
|
|
p.SetState(111)
|
|
|
|
if !(p.Precpred(p.GetParserRuleContext(), 3)) {
|
|
p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
|
|
goto errorExit
|
|
}
|
|
{
|
|
p.SetState(112)
|
|
|
|
var _m = p.Match(QueryOR_OP)
|
|
|
|
localctx.(*FilterExprContext).Op = _m
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(113)
|
|
|
|
var _x = p.filterExpr(4)
|
|
|
|
localctx.(*FilterExprContext).F2 = _x
|
|
}
|
|
|
|
case antlr.ATNInvalidAltNumber:
|
|
goto errorExit
|
|
}
|
|
|
|
}
|
|
p.SetState(118)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 14, 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
|
|
}
|
|
|
|
// IFilterStmtContext is an interface to support dynamic dispatch.
|
|
type IFilterStmtContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetExpr returns the Expr rule contexts.
|
|
GetExpr() IFilterExprContext
|
|
|
|
// GetName returns the Name rule contexts.
|
|
GetName() IIdentContext
|
|
|
|
// SetExpr sets the Expr rule contexts.
|
|
SetExpr(IFilterExprContext)
|
|
|
|
// SetName sets the Name rule contexts.
|
|
SetName(IIdentContext)
|
|
|
|
// Getter signatures
|
|
FILTER() antlr.TerminalNode
|
|
AS() antlr.TerminalNode
|
|
FilterExpr() IFilterExprContext
|
|
Ident() IIdentContext
|
|
|
|
// IsFilterStmtContext differentiates from other interfaces.
|
|
IsFilterStmtContext()
|
|
}
|
|
|
|
type FilterStmtContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
Expr IFilterExprContext
|
|
Name IIdentContext
|
|
}
|
|
|
|
func NewEmptyFilterStmtContext() *FilterStmtContext {
|
|
var p = new(FilterStmtContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_filterStmt
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFilterStmtContext(p *FilterStmtContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_filterStmt
|
|
}
|
|
|
|
func (*FilterStmtContext) IsFilterStmtContext() {}
|
|
|
|
func NewFilterStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterStmtContext {
|
|
var p = new(FilterStmtContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = QueryRULE_filterStmt
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FilterStmtContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FilterStmtContext) GetExpr() IFilterExprContext { return s.Expr }
|
|
|
|
func (s *FilterStmtContext) GetName() IIdentContext { return s.Name }
|
|
|
|
func (s *FilterStmtContext) SetExpr(v IFilterExprContext) { s.Expr = v }
|
|
|
|
func (s *FilterStmtContext) SetName(v IIdentContext) { s.Name = v }
|
|
|
|
func (s *FilterStmtContext) FILTER() antlr.TerminalNode {
|
|
return s.GetToken(QueryFILTER, 0)
|
|
}
|
|
|
|
func (s *FilterStmtContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(QueryAS, 0)
|
|
}
|
|
|
|
func (s *FilterStmtContext) FilterExpr() IFilterExprContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFilterExprContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFilterExprContext)
|
|
}
|
|
|
|
func (s *FilterStmtContext) Ident() IIdentContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIdentContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIdentContext)
|
|
}
|
|
|
|
func (s *FilterStmtContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FilterStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FilterStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitFilterStmt(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) FilterStmt() (localctx IFilterStmtContext) {
|
|
localctx = NewFilterStmtContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 14, QueryRULE_filterStmt)
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(119)
|
|
p.Match(QueryFILTER)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(120)
|
|
|
|
var _x = p.filterExpr(0)
|
|
|
|
localctx.(*FilterStmtContext).Expr = _x
|
|
}
|
|
{
|
|
p.SetState(121)
|
|
p.Match(QueryAS)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(122)
|
|
|
|
var _x = p.Ident()
|
|
|
|
localctx.(*FilterStmtContext).Name = _x
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IExprContext is an interface to support dynamic dispatch.
|
|
type IExprContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetFilter returns the Filter rule contexts.
|
|
GetFilter() IIdentContext
|
|
|
|
// GetKey returns the Key rule contexts.
|
|
GetKey() IFilterKeyContext
|
|
|
|
// GetValue returns the Value rule contexts.
|
|
GetValue() IFilterValueContext
|
|
|
|
// SetFilter sets the Filter rule contexts.
|
|
SetFilter(IIdentContext)
|
|
|
|
// SetKey sets the Key rule contexts.
|
|
SetKey(IFilterKeyContext)
|
|
|
|
// SetValue sets the Value rule contexts.
|
|
SetValue(IFilterValueContext)
|
|
|
|
// Getter signatures
|
|
AT() antlr.TerminalNode
|
|
Ident() IIdentContext
|
|
SIMPLE_OP() antlr.TerminalNode
|
|
FilterKey() IFilterKeyContext
|
|
FilterValue() IFilterValueContext
|
|
|
|
// IsExprContext differentiates from other interfaces.
|
|
IsExprContext()
|
|
}
|
|
|
|
type ExprContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
Filter IIdentContext
|
|
Key IFilterKeyContext
|
|
Value IFilterValueContext
|
|
}
|
|
|
|
func NewEmptyExprContext() *ExprContext {
|
|
var p = new(ExprContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_expr
|
|
return p
|
|
}
|
|
|
|
func InitEmptyExprContext(p *ExprContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_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 = QueryRULE_expr
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ExprContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ExprContext) GetFilter() IIdentContext { return s.Filter }
|
|
|
|
func (s *ExprContext) GetKey() IFilterKeyContext { return s.Key }
|
|
|
|
func (s *ExprContext) GetValue() IFilterValueContext { return s.Value }
|
|
|
|
func (s *ExprContext) SetFilter(v IIdentContext) { s.Filter = v }
|
|
|
|
func (s *ExprContext) SetKey(v IFilterKeyContext) { s.Key = v }
|
|
|
|
func (s *ExprContext) SetValue(v IFilterValueContext) { s.Value = v }
|
|
|
|
func (s *ExprContext) AT() antlr.TerminalNode {
|
|
return s.GetToken(QueryAT, 0)
|
|
}
|
|
|
|
func (s *ExprContext) Ident() IIdentContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIdentContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIdentContext)
|
|
}
|
|
|
|
func (s *ExprContext) SIMPLE_OP() antlr.TerminalNode {
|
|
return s.GetToken(QuerySIMPLE_OP, 0)
|
|
}
|
|
|
|
func (s *ExprContext) FilterKey() IFilterKeyContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFilterKeyContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFilterKeyContext)
|
|
}
|
|
|
|
func (s *ExprContext) FilterValue() IFilterValueContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IFilterValueContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IFilterValueContext)
|
|
}
|
|
|
|
func (s *ExprContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitExpr(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) Expr() (localctx IExprContext) {
|
|
localctx = NewExprContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 16, QueryRULE_expr)
|
|
p.SetState(130)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case QueryAT:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(124)
|
|
p.Match(QueryAT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(125)
|
|
|
|
var _x = p.Ident()
|
|
|
|
localctx.(*ExprContext).Filter = _x
|
|
}
|
|
|
|
case QueryREP, QueryIN, QueryAS, QuerySELECT, QueryFROM, QueryFILTER, QueryIDENT, QuerySTRING:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(126)
|
|
|
|
var _x = p.FilterKey()
|
|
|
|
localctx.(*ExprContext).Key = _x
|
|
}
|
|
{
|
|
p.SetState(127)
|
|
p.Match(QuerySIMPLE_OP)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
{
|
|
p.SetState(128)
|
|
|
|
var _x = p.FilterValue()
|
|
|
|
localctx.(*ExprContext).Value = _x
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
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.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFilterKeyContext is an interface to support dynamic dispatch.
|
|
type IFilterKeyContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Ident() IIdentContext
|
|
STRING() antlr.TerminalNode
|
|
|
|
// IsFilterKeyContext differentiates from other interfaces.
|
|
IsFilterKeyContext()
|
|
}
|
|
|
|
type FilterKeyContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFilterKeyContext() *FilterKeyContext {
|
|
var p = new(FilterKeyContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_filterKey
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFilterKeyContext(p *FilterKeyContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_filterKey
|
|
}
|
|
|
|
func (*FilterKeyContext) IsFilterKeyContext() {}
|
|
|
|
func NewFilterKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterKeyContext {
|
|
var p = new(FilterKeyContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = QueryRULE_filterKey
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FilterKeyContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FilterKeyContext) Ident() IIdentContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIdentContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIdentContext)
|
|
}
|
|
|
|
func (s *FilterKeyContext) STRING() antlr.TerminalNode {
|
|
return s.GetToken(QuerySTRING, 0)
|
|
}
|
|
|
|
func (s *FilterKeyContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FilterKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FilterKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitFilterKey(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) FilterKey() (localctx IFilterKeyContext) {
|
|
localctx = NewFilterKeyContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 18, QueryRULE_filterKey)
|
|
p.SetState(134)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case QueryREP, QueryIN, QueryAS, QuerySELECT, QueryFROM, QueryFILTER, QueryIDENT:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(132)
|
|
p.Ident()
|
|
}
|
|
|
|
case QuerySTRING:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(133)
|
|
p.Match(QuerySTRING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
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.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IFilterValueContext is an interface to support dynamic dispatch.
|
|
type IFilterValueContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Ident() IIdentContext
|
|
Number() INumberContext
|
|
STRING() antlr.TerminalNode
|
|
|
|
// IsFilterValueContext differentiates from other interfaces.
|
|
IsFilterValueContext()
|
|
}
|
|
|
|
type FilterValueContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyFilterValueContext() *FilterValueContext {
|
|
var p = new(FilterValueContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_filterValue
|
|
return p
|
|
}
|
|
|
|
func InitEmptyFilterValueContext(p *FilterValueContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_filterValue
|
|
}
|
|
|
|
func (*FilterValueContext) IsFilterValueContext() {}
|
|
|
|
func NewFilterValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterValueContext {
|
|
var p = new(FilterValueContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = QueryRULE_filterValue
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *FilterValueContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *FilterValueContext) Ident() IIdentContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIdentContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIdentContext)
|
|
}
|
|
|
|
func (s *FilterValueContext) Number() INumberContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(INumberContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(INumberContext)
|
|
}
|
|
|
|
func (s *FilterValueContext) STRING() antlr.TerminalNode {
|
|
return s.GetToken(QuerySTRING, 0)
|
|
}
|
|
|
|
func (s *FilterValueContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *FilterValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *FilterValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitFilterValue(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) FilterValue() (localctx IFilterValueContext) {
|
|
localctx = NewFilterValueContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 20, QueryRULE_filterValue)
|
|
p.SetState(139)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case QueryREP, QueryIN, QueryAS, QuerySELECT, QueryFROM, QueryFILTER, QueryIDENT:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(136)
|
|
p.Ident()
|
|
}
|
|
|
|
case QueryNUMBER1, QueryZERO:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(137)
|
|
p.Number()
|
|
}
|
|
|
|
case QuerySTRING:
|
|
p.EnterOuterAlt(localctx, 3)
|
|
{
|
|
p.SetState(138)
|
|
p.Match(QuerySTRING)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
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.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// INumberContext is an interface to support dynamic dispatch.
|
|
type INumberContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
ZERO() antlr.TerminalNode
|
|
NUMBER1() antlr.TerminalNode
|
|
|
|
// IsNumberContext differentiates from other interfaces.
|
|
IsNumberContext()
|
|
}
|
|
|
|
type NumberContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyNumberContext() *NumberContext {
|
|
var p = new(NumberContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_number
|
|
return p
|
|
}
|
|
|
|
func InitEmptyNumberContext(p *NumberContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_number
|
|
}
|
|
|
|
func (*NumberContext) IsNumberContext() {}
|
|
|
|
func NewNumberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumberContext {
|
|
var p = new(NumberContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = QueryRULE_number
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *NumberContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *NumberContext) ZERO() antlr.TerminalNode {
|
|
return s.GetToken(QueryZERO, 0)
|
|
}
|
|
|
|
func (s *NumberContext) NUMBER1() antlr.TerminalNode {
|
|
return s.GetToken(QueryNUMBER1, 0)
|
|
}
|
|
|
|
func (s *NumberContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *NumberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *NumberContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitNumber(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) Number() (localctx INumberContext) {
|
|
localctx = NewNumberContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 22, QueryRULE_number)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(141)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !(_la == QueryNUMBER1 || _la == QueryZERO) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IKeywordContext is an interface to support dynamic dispatch.
|
|
type IKeywordContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
REP() antlr.TerminalNode
|
|
IN() antlr.TerminalNode
|
|
AS() antlr.TerminalNode
|
|
SELECT() antlr.TerminalNode
|
|
FROM() antlr.TerminalNode
|
|
FILTER() antlr.TerminalNode
|
|
|
|
// IsKeywordContext differentiates from other interfaces.
|
|
IsKeywordContext()
|
|
}
|
|
|
|
type KeywordContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyKeywordContext() *KeywordContext {
|
|
var p = new(KeywordContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_keyword
|
|
return p
|
|
}
|
|
|
|
func InitEmptyKeywordContext(p *KeywordContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_keyword
|
|
}
|
|
|
|
func (*KeywordContext) IsKeywordContext() {}
|
|
|
|
func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordContext {
|
|
var p = new(KeywordContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = QueryRULE_keyword
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *KeywordContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *KeywordContext) REP() antlr.TerminalNode {
|
|
return s.GetToken(QueryREP, 0)
|
|
}
|
|
|
|
func (s *KeywordContext) IN() antlr.TerminalNode {
|
|
return s.GetToken(QueryIN, 0)
|
|
}
|
|
|
|
func (s *KeywordContext) AS() antlr.TerminalNode {
|
|
return s.GetToken(QueryAS, 0)
|
|
}
|
|
|
|
func (s *KeywordContext) SELECT() antlr.TerminalNode {
|
|
return s.GetToken(QuerySELECT, 0)
|
|
}
|
|
|
|
func (s *KeywordContext) FROM() antlr.TerminalNode {
|
|
return s.GetToken(QueryFROM, 0)
|
|
}
|
|
|
|
func (s *KeywordContext) FILTER() antlr.TerminalNode {
|
|
return s.GetToken(QueryFILTER, 0)
|
|
}
|
|
|
|
func (s *KeywordContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *KeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *KeywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitKeyword(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) Keyword() (localctx IKeywordContext) {
|
|
localctx = NewKeywordContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 24, QueryRULE_keyword)
|
|
var _la int
|
|
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(143)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&7616) != 0) {
|
|
p.GetErrorHandler().RecoverInline(p)
|
|
} else {
|
|
p.GetErrorHandler().ReportMatch(p)
|
|
p.Consume()
|
|
}
|
|
}
|
|
|
|
errorExit:
|
|
if p.HasError() {
|
|
v := p.GetError()
|
|
localctx.SetException(v)
|
|
p.GetErrorHandler().ReportError(p, v)
|
|
p.GetErrorHandler().Recover(p, v)
|
|
p.SetError(nil)
|
|
}
|
|
p.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIdentContext is an interface to support dynamic dispatch.
|
|
type IIdentContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Keyword() IKeywordContext
|
|
IDENT() antlr.TerminalNode
|
|
|
|
// IsIdentContext differentiates from other interfaces.
|
|
IsIdentContext()
|
|
}
|
|
|
|
type IdentContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyIdentContext() *IdentContext {
|
|
var p = new(IdentContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_ident
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIdentContext(p *IdentContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_ident
|
|
}
|
|
|
|
func (*IdentContext) IsIdentContext() {}
|
|
|
|
func NewIdentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentContext {
|
|
var p = new(IdentContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = QueryRULE_ident
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IdentContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IdentContext) Keyword() IKeywordContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IKeywordContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IKeywordContext)
|
|
}
|
|
|
|
func (s *IdentContext) IDENT() antlr.TerminalNode {
|
|
return s.GetToken(QueryIDENT, 0)
|
|
}
|
|
|
|
func (s *IdentContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IdentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IdentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitIdent(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) Ident() (localctx IIdentContext) {
|
|
localctx = NewIdentContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 26, QueryRULE_ident)
|
|
p.SetState(147)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case QueryREP, QueryIN, QueryAS, QuerySELECT, QueryFROM, QueryFILTER:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(145)
|
|
p.Keyword()
|
|
}
|
|
|
|
case QueryIDENT:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(146)
|
|
p.Match(QueryIDENT)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
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.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
// IIdentWCContext is an interface to support dynamic dispatch.
|
|
type IIdentWCContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// Getter signatures
|
|
Ident() IIdentContext
|
|
WILDCARD() antlr.TerminalNode
|
|
|
|
// IsIdentWCContext differentiates from other interfaces.
|
|
IsIdentWCContext()
|
|
}
|
|
|
|
type IdentWCContext struct {
|
|
antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyIdentWCContext() *IdentWCContext {
|
|
var p = new(IdentWCContext)
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_identWC
|
|
return p
|
|
}
|
|
|
|
func InitEmptyIdentWCContext(p *IdentWCContext) {
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
|
|
p.RuleIndex = QueryRULE_identWC
|
|
}
|
|
|
|
func (*IdentWCContext) IsIdentWCContext() {}
|
|
|
|
func NewIdentWCContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentWCContext {
|
|
var p = new(IdentWCContext)
|
|
|
|
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = QueryRULE_identWC
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *IdentWCContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *IdentWCContext) Ident() IIdentContext {
|
|
var t antlr.RuleContext
|
|
for _, ctx := range s.GetChildren() {
|
|
if _, ok := ctx.(IIdentContext); ok {
|
|
t = ctx.(antlr.RuleContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IIdentContext)
|
|
}
|
|
|
|
func (s *IdentWCContext) WILDCARD() antlr.TerminalNode {
|
|
return s.GetToken(QueryWILDCARD, 0)
|
|
}
|
|
|
|
func (s *IdentWCContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *IdentWCContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *IdentWCContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
|
|
switch t := visitor.(type) {
|
|
case QueryVisitor:
|
|
return t.VisitIdentWC(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *Query) IdentWC() (localctx IIdentWCContext) {
|
|
localctx = NewIdentWCContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 28, QueryRULE_identWC)
|
|
p.SetState(151)
|
|
p.GetErrorHandler().Sync(p)
|
|
if p.HasError() {
|
|
goto errorExit
|
|
}
|
|
|
|
switch p.GetTokenStream().LA(1) {
|
|
case QueryREP, QueryIN, QueryAS, QuerySELECT, QueryFROM, QueryFILTER, QueryIDENT:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(149)
|
|
p.Ident()
|
|
}
|
|
|
|
case QueryWILDCARD:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(150)
|
|
p.Match(QueryWILDCARD)
|
|
if p.HasError() {
|
|
// Recognition error - abort rule
|
|
goto errorExit
|
|
}
|
|
}
|
|
|
|
default:
|
|
p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
|
|
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.ExitRule()
|
|
return localctx
|
|
goto errorExit // Trick to prevent compiler error if the label is not used
|
|
}
|
|
|
|
func (p *Query) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
|
|
switch ruleIndex {
|
|
case 6:
|
|
var t *FilterExprContext = nil
|
|
if localctx != nil {
|
|
t = localctx.(*FilterExprContext)
|
|
}
|
|
return p.FilterExpr_Sempred(t, predIndex)
|
|
|
|
default:
|
|
panic("No predicate with index: " + fmt.Sprint(ruleIndex))
|
|
}
|
|
}
|
|
|
|
func (p *Query) FilterExpr_Sempred(localctx antlr.RuleContext, predIndex int) bool {
|
|
switch predIndex {
|
|
case 0:
|
|
return p.Precpred(p.GetParserRuleContext(), 4)
|
|
|
|
case 1:
|
|
return p.Precpred(p.GetParserRuleContext(), 3)
|
|
|
|
default:
|
|
panic("No predicate with index: " + fmt.Sprint(predIndex))
|
|
}
|
|
}
|