frostfs-sdk-go/netmap/parser/query_parser.go

// Code generated from netmap/parser/Query.g4 by ANTLR 4.13.1. 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'", "'EC'", "'IN'",
		"'AS'", "'CBF'", "'SELECT'", "'FROM'", "'FILTER'", "'*'", "'.'", "'SAME'",
		"'DISTINCT'", "'('", "')'", "'@'", "", "", "'0'",
	}
	staticData.SymbolicNames = []string{
		"", "NOT_OP", "AND_OP", "OR_OP", "SIMPLE_OP", "UNIQUE", "REP", "EC",
		"IN", "AS", "CBF", "SELECT", "FROM", "FILTER", "WILDCARD", "DOT", "CLAUSE_SAME",
		"CLAUSE_DISTINCT", "L_PAREN", "R_PAREN", "AT", "IDENT", "NUMBER1", "ZERO",
		"STRING", "WS",
	}
	staticData.RuleNames = []string{
		"policy", "selectFilterExpr", "ecStmt", "repStmt", "cbfStmt", "selectStmt",
		"clause", "filterExpr", "filterStmt", "expr", "filterKey", "filterValue",
		"number", "keyword", "ident", "identWC",
	}
	staticData.PredictionContextCache = antlr.NewPredictionContextCache()
	staticData.serializedATN = []int32{
		4, 1, 25, 165, 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, 2, 15, 7, 15,
		1, 0, 3, 0, 34, 8, 0, 1, 0, 1, 0, 4, 0, 38, 8, 0, 11, 0, 12, 0, 39, 1,
		0, 3, 0, 43, 8, 0, 1, 0, 5, 0, 46, 8, 0, 10, 0, 12, 0, 49, 9, 0, 1, 0,
		5, 0, 52, 8, 0, 10, 0, 12, 0, 55, 9, 0, 1, 0, 1, 0, 1, 1, 3, 1, 60, 8,
		1, 1, 1, 3, 1, 63, 8, 1, 1, 1, 5, 1, 66, 8, 1, 10, 1, 12, 1, 69, 9, 1,
		1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 79, 8, 2, 1, 3, 1,
		3, 1, 3, 1, 3, 3, 3, 85, 8, 3, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5,
		3, 5, 94, 8, 5, 1, 5, 3, 5, 97, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 103,
		8, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7,
		1, 7, 1, 7, 3, 7, 118, 8, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 5, 7,
		126, 8, 7, 10, 7, 12, 7, 129, 9, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9,
		1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 142, 8, 9, 1, 10, 1, 10, 3, 10, 146,
		8, 10, 1, 11, 1, 11, 1, 11, 3, 11, 151, 8, 11, 1, 12, 1, 12, 1, 13, 1,
		13, 1, 14, 1, 14, 3, 14, 159, 8, 14, 1, 15, 1, 15, 3, 15, 163, 8, 15, 1,
		15, 0, 1, 14, 16, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28,
		30, 0, 3, 1, 0, 16, 17, 1, 0, 22, 23, 3, 0, 6, 6, 8, 9, 11, 13, 172, 0,
		33, 1, 0, 0, 0, 2, 59, 1, 0, 0, 0, 4, 72, 1, 0, 0, 0, 6, 80, 1, 0, 0, 0,
		8, 86, 1, 0, 0, 0, 10, 89, 1, 0, 0, 0, 12, 104, 1, 0, 0, 0, 14, 117, 1,
		0, 0, 0, 16, 130, 1, 0, 0, 0, 18, 141, 1, 0, 0, 0, 20, 145, 1, 0, 0, 0,
		22, 150, 1, 0, 0, 0, 24, 152, 1, 0, 0, 0, 26, 154, 1, 0, 0, 0, 28, 158,
		1, 0, 0, 0, 30, 162, 1, 0, 0, 0, 32, 34, 5, 5, 0, 0, 33, 32, 1, 0, 0, 0,
		33, 34, 1, 0, 0, 0, 34, 37, 1, 0, 0, 0, 35, 38, 3, 6, 3, 0, 36, 38, 3,
		4, 2, 0, 37, 35, 1, 0, 0, 0, 37, 36, 1, 0, 0, 0, 38, 39, 1, 0, 0, 0, 39,
		37, 1, 0, 0, 0, 39, 40, 1, 0, 0, 0, 40, 42, 1, 0, 0, 0, 41, 43, 3, 8, 4,
		0, 42, 41, 1, 0, 0, 0, 42, 43, 1, 0, 0, 0, 43, 47, 1, 0, 0, 0, 44, 46,
		3, 10, 5, 0, 45, 44, 1, 0, 0, 0, 46, 49, 1, 0, 0, 0, 47, 45, 1, 0, 0, 0,
		47, 48, 1, 0, 0, 0, 48, 53, 1, 0, 0, 0, 49, 47, 1, 0, 0, 0, 50, 52, 3,
		16, 8, 0, 51, 50, 1, 0, 0, 0, 52, 55, 1, 0, 0, 0, 53, 51, 1, 0, 0, 0, 53,
		54, 1, 0, 0, 0, 54, 56, 1, 0, 0, 0, 55, 53, 1, 0, 0, 0, 56, 57, 5, 0, 0,
		1, 57, 1, 1, 0, 0, 0, 58, 60, 3, 8, 4, 0, 59, 58, 1, 0, 0, 0, 59, 60, 1,
		0, 0, 0, 60, 62, 1, 0, 0, 0, 61, 63, 3, 10, 5, 0, 62, 61, 1, 0, 0, 0, 62,
		63, 1, 0, 0, 0, 63, 67, 1, 0, 0, 0, 64, 66, 3, 16, 8, 0, 65, 64, 1, 0,
		0, 0, 66, 69, 1, 0, 0, 0, 67, 65, 1, 0, 0, 0, 67, 68, 1, 0, 0, 0, 68, 70,
		1, 0, 0, 0, 69, 67, 1, 0, 0, 0, 70, 71, 5, 0, 0, 1, 71, 3, 1, 0, 0, 0,
		72, 73, 5, 7, 0, 0, 73, 74, 5, 22, 0, 0, 74, 75, 5, 15, 0, 0, 75, 78, 5,
		22, 0, 0, 76, 77, 5, 8, 0, 0, 77, 79, 3, 28, 14, 0, 78, 76, 1, 0, 0, 0,
		78, 79, 1, 0, 0, 0, 79, 5, 1, 0, 0, 0, 80, 81, 5, 6, 0, 0, 81, 84, 5, 22,
		0, 0, 82, 83, 5, 8, 0, 0, 83, 85, 3, 28, 14, 0, 84, 82, 1, 0, 0, 0, 84,
		85, 1, 0, 0, 0, 85, 7, 1, 0, 0, 0, 86, 87, 5, 10, 0, 0, 87, 88, 5, 22,
		0, 0, 88, 9, 1, 0, 0, 0, 89, 90, 5, 11, 0, 0, 90, 96, 5, 22, 0, 0, 91,
		93, 5, 8, 0, 0, 92, 94, 3, 12, 6, 0, 93, 92, 1, 0, 0, 0, 93, 94, 1, 0,
		0, 0, 94, 95, 1, 0, 0, 0, 95, 97, 3, 20, 10, 0, 96, 91, 1, 0, 0, 0, 96,
		97, 1, 0, 0, 0, 97, 98, 1, 0, 0, 0, 98, 99, 5, 12, 0, 0, 99, 102, 3, 30,
		15, 0, 100, 101, 5, 9, 0, 0, 101, 103, 3, 28, 14, 0, 102, 100, 1, 0, 0,
		0, 102, 103, 1, 0, 0, 0, 103, 11, 1, 0, 0, 0, 104, 105, 7, 0, 0, 0, 105,
		13, 1, 0, 0, 0, 106, 107, 6, 7, -1, 0, 107, 108, 5, 1, 0, 0, 108, 109,
		5, 18, 0, 0, 109, 110, 3, 14, 7, 0, 110, 111, 5, 19, 0, 0, 111, 118, 1,
		0, 0, 0, 112, 113, 5, 18, 0, 0, 113, 114, 3, 14, 7, 0, 114, 115, 5, 19,
		0, 0, 115, 118, 1, 0, 0, 0, 116, 118, 3, 18, 9, 0, 117, 106, 1, 0, 0, 0,
		117, 112, 1, 0, 0, 0, 117, 116, 1, 0, 0, 0, 118, 127, 1, 0, 0, 0, 119,
		120, 10, 4, 0, 0, 120, 121, 5, 2, 0, 0, 121, 126, 3, 14, 7, 5, 122, 123,
		10, 3, 0, 0, 123, 124, 5, 3, 0, 0, 124, 126, 3, 14, 7, 4, 125, 119, 1,
		0, 0, 0, 125, 122, 1, 0, 0, 0, 126, 129, 1, 0, 0, 0, 127, 125, 1, 0, 0,
		0, 127, 128, 1, 0, 0, 0, 128, 15, 1, 0, 0, 0, 129, 127, 1, 0, 0, 0, 130,
		131, 5, 13, 0, 0, 131, 132, 3, 14, 7, 0, 132, 133, 5, 9, 0, 0, 133, 134,
		3, 28, 14, 0, 134, 17, 1, 0, 0, 0, 135, 136, 5, 20, 0, 0, 136, 142, 3,
		28, 14, 0, 137, 138, 3, 20, 10, 0, 138, 139, 5, 4, 0, 0, 139, 140, 3, 22,
		11, 0, 140, 142, 1, 0, 0, 0, 141, 135, 1, 0, 0, 0, 141, 137, 1, 0, 0, 0,
		142, 19, 1, 0, 0, 0, 143, 146, 3, 28, 14, 0, 144, 146, 5, 24, 0, 0, 145,
		143, 1, 0, 0, 0, 145, 144, 1, 0, 0, 0, 146, 21, 1, 0, 0, 0, 147, 151, 3,
		28, 14, 0, 148, 151, 3, 24, 12, 0, 149, 151, 5, 24, 0, 0, 150, 147, 1,
		0, 0, 0, 150, 148, 1, 0, 0, 0, 150, 149, 1, 0, 0, 0, 151, 23, 1, 0, 0,
		0, 152, 153, 7, 1, 0, 0, 153, 25, 1, 0, 0, 0, 154, 155, 7, 2, 0, 0, 155,
		27, 1, 0, 0, 0, 156, 159, 3, 26, 13, 0, 157, 159, 5, 21, 0, 0, 158, 156,
		1, 0, 0, 0, 158, 157, 1, 0, 0, 0, 159, 29, 1, 0, 0, 0, 160, 163, 3, 28,
		14, 0, 161, 163, 5, 14, 0, 0, 162, 160, 1, 0, 0, 0, 162, 161, 1, 0, 0,
		0, 163, 31, 1, 0, 0, 0, 22, 33, 37, 39, 42, 47, 53, 59, 62, 67, 78, 84,
		93, 96, 102, 117, 125, 127, 141, 145, 150, 158, 162,
	}
	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
	QueryEC              = 7
	QueryIN              = 8
	QueryAS              = 9
	QueryCBF             = 10
	QuerySELECT          = 11
	QueryFROM            = 12
	QueryFILTER          = 13
	QueryWILDCARD        = 14
	QueryDOT             = 15
	QueryCLAUSE_SAME     = 16
	QueryCLAUSE_DISTINCT = 17
	QueryL_PAREN         = 18
	QueryR_PAREN         = 19
	QueryAT              = 20
	QueryIDENT           = 21
	QueryNUMBER1         = 22
	QueryZERO            = 23
	QuerySTRING          = 24
	QueryWS              = 25
)

// Query rules.
const (
	QueryRULE_policy           = 0
	QueryRULE_selectFilterExpr = 1
	QueryRULE_ecStmt           = 2
	QueryRULE_repStmt          = 3
	QueryRULE_cbfStmt          = 4
	QueryRULE_selectStmt       = 5
	QueryRULE_clause           = 6
	QueryRULE_filterExpr       = 7
	QueryRULE_filterStmt       = 8
	QueryRULE_expr             = 9
	QueryRULE_filterKey        = 10
	QueryRULE_filterValue      = 11
	QueryRULE_number           = 12
	QueryRULE_keyword          = 13
	QueryRULE_ident            = 14
	QueryRULE_identWC          = 15
)

// 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
	AllEcStmt() []IEcStmtContext
	EcStmt(i int) IEcStmtContext
	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) AllEcStmt() []IEcStmtContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IEcStmtContext); ok {
			len++
		}
	}

	tst := make([]IEcStmtContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IEcStmtContext); ok {
			tst[i] = t.(IEcStmtContext)
			i++
		}
	}

	return tst
}

func (s *PolicyContext) EcStmt(i int) IEcStmtContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IEcStmtContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IEcStmtContext)
}

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(33)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == QueryUNIQUE {
		{
			p.SetState(32)
			p.Match(QueryUNIQUE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	p.SetState(37)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == QueryREP || _la == QueryEC {
		p.SetState(37)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case QueryREP:
			{
				p.SetState(35)
				p.RepStmt()
			}

		case QueryEC:
			{
				p.SetState(36)
				p.EcStmt()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

		p.SetState(39)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(42)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == QueryCBF {
		{
			p.SetState(41)
			p.CbfStmt()
		}

	}
	p.SetState(47)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == QuerySELECT {
		{
			p.SetState(44)
			p.SelectStmt()
		}

		p.SetState(49)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(53)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == QueryFILTER {
		{
			p.SetState(50)
			p.FilterStmt()
		}

		p.SetState(55)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(56)
		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(59)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == QueryCBF {
		{
			p.SetState(58)
			p.CbfStmt()
		}

	}
	p.SetState(62)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == QuerySELECT {
		{
			p.SetState(61)
			p.SelectStmt()
		}

	}
	p.SetState(67)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == QueryFILTER {
		{
			p.SetState(64)
			p.FilterStmt()
		}

		p.SetState(69)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(70)
		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
}

// IEcStmtContext is an interface to support dynamic dispatch.
type IEcStmtContext interface {
	antlr.ParserRuleContext

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

	// GetData returns the Data token.
	GetData() antlr.Token

	// GetParity returns the Parity token.
	GetParity() antlr.Token

	// SetData sets the Data token.
	SetData(antlr.Token)

	// SetParity sets the Parity token.
	SetParity(antlr.Token)

	// GetSelector returns the Selector rule contexts.
	GetSelector() IIdentContext

	// SetSelector sets the Selector rule contexts.
	SetSelector(IIdentContext)

	// Getter signatures
	EC() antlr.TerminalNode
	DOT() antlr.TerminalNode
	AllNUMBER1() []antlr.TerminalNode
	NUMBER1(i int) antlr.TerminalNode
	IN() antlr.TerminalNode
	Ident() IIdentContext

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

type EcStmtContext struct {
	antlr.BaseParserRuleContext
	parser   antlr.Parser
	Data     antlr.Token
	Parity   antlr.Token
	Selector IIdentContext
}

func NewEmptyEcStmtContext() *EcStmtContext {
	var p = new(EcStmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = QueryRULE_ecStmt
	return p
}

func InitEmptyEcStmtContext(p *EcStmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = QueryRULE_ecStmt
}

func (*EcStmtContext) IsEcStmtContext() {}

func NewEcStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EcStmtContext {
	var p = new(EcStmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = QueryRULE_ecStmt

	return p
}

func (s *EcStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *EcStmtContext) GetData() antlr.Token { return s.Data }

func (s *EcStmtContext) GetParity() antlr.Token { return s.Parity }

func (s *EcStmtContext) SetData(v antlr.Token) { s.Data = v }

func (s *EcStmtContext) SetParity(v antlr.Token) { s.Parity = v }

func (s *EcStmtContext) GetSelector() IIdentContext { return s.Selector }

func (s *EcStmtContext) SetSelector(v IIdentContext) { s.Selector = v }

func (s *EcStmtContext) EC() antlr.TerminalNode {
	return s.GetToken(QueryEC, 0)
}

func (s *EcStmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(QueryDOT, 0)
}

func (s *EcStmtContext) AllNUMBER1() []antlr.TerminalNode {
	return s.GetTokens(QueryNUMBER1)
}

func (s *EcStmtContext) NUMBER1(i int) antlr.TerminalNode {
	return s.GetToken(QueryNUMBER1, i)
}

func (s *EcStmtContext) IN() antlr.TerminalNode {
	return s.GetToken(QueryIN, 0)
}

func (s *EcStmtContext) 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 *EcStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EcStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EcStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case QueryVisitor:
		return t.VisitEcStmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *Query) EcStmt() (localctx IEcStmtContext) {
	localctx = NewEcStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, QueryRULE_ecStmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(72)
		p.Match(QueryEC)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(73)

		var _m = p.Match(QueryNUMBER1)

		localctx.(*EcStmtContext).Data = _m
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(74)
		p.Match(QueryDOT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(75)

		var _m = p.Match(QueryNUMBER1)

		localctx.(*EcStmtContext).Parity = _m
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(78)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == QueryIN {
		{
			p.SetState(76)
			p.Match(QueryIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(77)

			var _x = p.Ident()

			localctx.(*EcStmtContext).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
}

// 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, 6, QueryRULE_repStmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(80)
		p.Match(QueryREP)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(81)

		var _m = p.Match(QueryNUMBER1)

		localctx.(*RepStmtContext).Count = _m
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(84)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == QueryIN {
		{
			p.SetState(82)
			p.Match(QueryIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(83)

			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, 8, QueryRULE_cbfStmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(86)
		p.Match(QueryCBF)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(87)

		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() IFilterKeyContext

	// GetFilter returns the Filter rule contexts.
	GetFilter() IIdentWCContext

	// GetName returns the Name rule contexts.
	GetName() IIdentContext

	// SetBucket sets the Bucket rule contexts.
	SetBucket(IFilterKeyContext)

	// 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
	FilterKey() IFilterKeyContext
	Ident() IIdentContext
	Clause() IClauseContext

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

type SelectStmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
	Count  antlr.Token
	Bucket IFilterKeyContext
	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() IFilterKeyContext { return s.Bucket }

func (s *SelectStmtContext) GetFilter() IIdentWCContext { return s.Filter }

func (s *SelectStmtContext) GetName() IIdentContext { return s.Name }

func (s *SelectStmtContext) SetBucket(v IFilterKeyContext) { 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) 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 *SelectStmtContext) 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 *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, 10, QueryRULE_selectStmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(89)
		p.Match(QuerySELECT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(90)

		var _m = p.Match(QueryNUMBER1)

		localctx.(*SelectStmtContext).Count = _m
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(96)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == QueryIN {
		{
			p.SetState(91)
			p.Match(QueryIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(93)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == QueryCLAUSE_SAME || _la == QueryCLAUSE_DISTINCT {
			{
				p.SetState(92)
				p.Clause()
			}

		}
		{
			p.SetState(95)

			var _x = p.FilterKey()

			localctx.(*SelectStmtContext).Bucket = _x
		}

	}
	{
		p.SetState(98)
		p.Match(QueryFROM)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(99)

		var _x = p.IdentWC()

		localctx.(*SelectStmtContext).Filter = _x
	}
	p.SetState(102)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == QueryAS {
		{
			p.SetState(100)
			p.Match(QueryAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(101)

			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, 12, QueryRULE_clause)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(104)
		_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 := 14
	p.EnterRecursionRule(localctx, 14, QueryRULE_filterExpr, _p)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(117)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case QueryNOT_OP:
		{
			p.SetState(107)

			var _m = p.Match(QueryNOT_OP)

			localctx.(*FilterExprContext).Op = _m
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(108)
			p.Match(QueryL_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(109)

			var _x = p.filterExpr(0)

			localctx.(*FilterExprContext).F1 = _x
		}
		{
			p.SetState(110)
			p.Match(QueryR_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case QueryL_PAREN:
		{
			p.SetState(112)
			p.Match(QueryL_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(113)

			var _x = p.filterExpr(0)

			localctx.(*FilterExprContext).Inner = _x
		}
		{
			p.SetState(114)
			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(116)
			p.Expr()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(127)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 16, 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(125)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}

			switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 15, p.GetParserRuleContext()) {
			case 1:
				localctx = NewFilterExprContext(p, _parentctx, _parentState)
				localctx.(*FilterExprContext).F1 = _prevctx
				p.PushNewRecursionContext(localctx, _startState, QueryRULE_filterExpr)
				p.SetState(119)

				if !(p.Precpred(p.GetParserRuleContext(), 4)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
					goto errorExit
				}
				{
					p.SetState(120)

					var _m = p.Match(QueryAND_OP)

					localctx.(*FilterExprContext).Op = _m
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(121)

					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(122)

				if !(p.Precpred(p.GetParserRuleContext(), 3)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
					goto errorExit
				}
				{
					p.SetState(123)

					var _m = p.Match(QueryOR_OP)

					localctx.(*FilterExprContext).Op = _m
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(124)

					var _x = p.filterExpr(4)

					localctx.(*FilterExprContext).F2 = _x
				}

			case antlr.ATNInvalidAltNumber:
				goto errorExit
			}

		}
		p.SetState(129)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 16, 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, 16, QueryRULE_filterStmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(130)
		p.Match(QueryFILTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(131)

		var _x = p.filterExpr(0)

		localctx.(*FilterStmtContext).Expr = _x
	}
	{
		p.SetState(132)
		p.Match(QueryAS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(133)

		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, 18, QueryRULE_expr)
	p.SetState(141)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case QueryAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(135)
			p.Match(QueryAT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(136)

			var _x = p.Ident()

			localctx.(*ExprContext).Filter = _x
		}

	case QueryREP, QueryIN, QueryAS, QuerySELECT, QueryFROM, QueryFILTER, QueryIDENT, QuerySTRING:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(137)

			var _x = p.FilterKey()

			localctx.(*ExprContext).Key = _x
		}
		{
			p.SetState(138)
			p.Match(QuerySIMPLE_OP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(139)

			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, 20, QueryRULE_filterKey)
	p.SetState(145)
	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(143)
			p.Ident()
		}

	case QuerySTRING:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(144)
			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, 22, QueryRULE_filterValue)
	p.SetState(150)
	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(147)
			p.Ident()
		}

	case QueryNUMBER1, QueryZERO:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(148)
			p.Number()
		}

	case QuerySTRING:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(149)
			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, 24, QueryRULE_number)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(152)
		_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, 26, QueryRULE_keyword)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(154)
		_la = p.GetTokenStream().LA(1)

		if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&15168) != 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, 28, QueryRULE_ident)
	p.SetState(158)
	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(156)
			p.Keyword()
		}

	case QueryIDENT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(157)
			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, 30, QueryRULE_identWC)
	p.SetState(162)
	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(160)
			p.Ident()
		}

	case QueryWILDCARD:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(161)
			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 7:
		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))
	}
}