# Generated from SqlBase.g4 by ANTLR 4.9.2
# encoding: utf-8
import sys
from io import StringIO

from antlr4 import *

if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u013e")
        buf.write("\u0b6e\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
        buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
        buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4")
        buf.write("h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\3\2\3\2\3\2\3")
        buf.write("\3\3\3\3\3\3\4\3\4\3\4\3\5\3\5\3\5\3\6\3\6\3\6\3\7\3\7")
        buf.write("\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u00f9")
        buf.write("\n\7\3\7\3\7\3\7\5\7\u00fe\n\7\3\7\3\7\5\7\u0102\n\7\3")
        buf.write("\7\3\7\3\7\3\7\5\7\u0108\n\7\3\7\3\7\5\7\u010c\n\7\3\7")
        buf.write("\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\3\7\5\7\u0121\n\7\3\7\3\7\5\7\u0125\n\7")
        buf.write("\3\7\3\7\5\7\u0129\n\7\3\7\3\7\5\7\u012d\n\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\5\7\u0135\n\7\3\7\3\7\5\7\u0139\n\7\3\7")
        buf.write("\5\7\u013c\n\7\3\7\3\7\3\7\3\7\3\7\5\7\u0143\n\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\7\7\u014a\n\7\f\7\16\7\u014d\13\7\3\7\3")
        buf.write("\7\3\7\5\7\u0152\n\7\3\7\3\7\5\7\u0156\n\7\3\7\3\7\3\7")
        buf.write("\3\7\5\7\u015c\n\7\3\7\3\7\3\7\3\7\3\7\5\7\u0163\n\7\3")
        buf.write("\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u016c\n\7\3\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u0178\n\7\3\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\5\7\u0181\n\7\3\7\3\7\3\7\3\7\5\7\u0187")
        buf.write("\n\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u0192\n\7")
        buf.write("\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u019a\n\7\3\7\3\7\3\7\3\7")
        buf.write("\3\7\3\7\5\7\u01a2\n\7\3\7\3\7\3\7\3\7\3\7\5\7\u01a9\n")
        buf.write("\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u01b3\n\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\5\7\u01ba\n\7\3\7\3\7\3\7\3\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7")
        buf.write("\3\7\3\7\3\7\3\7\3\7\7\7\u01d5\n\7\f\7\16\7\u01d8\13\7")
        buf.write("\5\7\u01da\n\7\3\7\5\7\u01dd\n\7\3\7\3\7\5\7\u01e1\n\7")
        buf.write("\3\7\3\7\3\7\3\7\5\7\u01e7\n\7\3\7\3\7\3\7\5\7\u01ec\n")
        buf.write("\7\3\7\3\7\3\7\3\7\3\7\5\7\u01f3\n\7\3\7\3\7\3\7\5\7\u01f8")
        buf.write("\n\7\3\7\3\7\5\7\u01fc\n\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7")
        buf.write("\u0204\n\7\3\7\3\7\3\7\3\7\5\7\u020a\n\7\3\7\3\7\5\7\u020e")
        buf.write("\n\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5")
        buf.write("\7\u021c\n\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u0224\n\7\3\7")
        buf.write("\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\5\7\u0237\n\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7")
        buf.write("\7\7\u024e\n\7\f\7\16\7\u0251\13\7\5\7\u0253\n\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u025d\n\7\3\7\3\7\5\7\u0261")
        buf.write("\n\7\3\7\3\7\3\7\3\7\3\7\5\7\u0268\n\7\3\7\3\7\3\7\3\7")
        buf.write("\3\7\3\7\7\7\u0270\n\7\f\7\16\7\u0273\13\7\3\7\3\7\3\7")
        buf.write("\5\7\u0278\n\7\3\7\3\7\3\7\5\7\u027d\n\7\3\7\3\7\5\7\u0281")
        buf.write("\n\7\3\7\3\7\3\7\3\7\5\7\u0287\n\7\3\7\3\7\3\7\3\7\3\7")
        buf.write("\7\7\u028e\n\7\f\7\16\7\u0291\13\7\3\7\3\7\3\7\5\7\u0296")
        buf.write("\n\7\3\7\3\7\5\7\u029a\n\7\3\7\3\7\3\7\3\7\3\7\5\7\u02a1")
        buf.write("\n\7\3\7\3\7\5\7\u02a5\n\7\3\7\3\7\3\7\3\7\7\7\u02ab\n")
        buf.write("\7\f\7\16\7\u02ae\13\7\3\7\3\7\5\7\u02b2\n\7\3\7\3\7\5")
        buf.write("\7\u02b6\n\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u02be\n\7\3\7")
        buf.write("\3\7\3\7\3\7\7\7\u02c4\n\7\f\7\16\7\u02c7\13\7\3\7\3\7")
        buf.write("\5\7\u02cb\n\7\3\7\3\7\5\7\u02cf\n\7\3\7\3\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\5\7\u02d9\n\7\3\7\3\7\3\7\7\7\u02de\n\7")
        buf.write("\f\7\16\7\u02e1\13\7\3\7\3\7\5\7\u02e5\n\7\3\7\3\7\5\7")
        buf.write("\u02e9\n\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u02f3\n")
        buf.write("\7\3\7\5\7\u02f6\n\7\3\7\3\7\3\7\3\7\3\7\7\7\u02fd\n\7")
        buf.write("\f\7\16\7\u0300\13\7\3\7\3\7\5\7\u0304\n\7\3\7\3\7\3\7")
        buf.write("\3\7\5\7\u030a\n\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7")
        buf.write("\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5")
        buf.write("\7\u0322\n\7\3\7\3\7\3\7\3\7\5\7\u0328\n\7\5\7\u032a\n")
        buf.write("\7\3\7\3\7\3\7\3\7\5\7\u0330\n\7\3\7\3\7\3\7\3\7\5\7\u0336")
        buf.write("\n\7\5\7\u0338\n\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u0340\n")
        buf.write("\7\5\7\u0342\n\7\3\7\3\7\3\7\3\7\5\7\u0348\n\7\3\7\3\7")
        buf.write("\3\7\3\7\5\7\u034e\n\7\5\7\u0350\n\7\3\7\3\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u035f\n\7\3\7\3")
        buf.write("\7\3\7\5\7\u0364\n\7\3\7\3\7\3\7\3\7\3\7\5\7\u036b\n\7")
        buf.write("\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u0377\n\7")
        buf.write("\5\7\u0379\n\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u0381\n\7\5")
        buf.write("\7\u0383\n\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\7\7\u0393\n\7\f\7\16\7\u0396\13\7\5\7\u0398")
        buf.write("\n\7\3\7\3\7\5\7\u039c\n\7\3\7\3\7\5\7\u03a0\n\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\7\7")
        buf.write("\u03b0\n\7\f\7\16\7\u03b3\13\7\5\7\u03b5\n\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u03c5")
        buf.write("\n\7\3\7\3\7\3\7\3\7\3\7\3\7\7\7\u03cd\n\7\f\7\16\7\u03d0")
        buf.write("\13\7\3\7\3\7\5\7\u03d4\n\7\3\7\3\7\3\7\3\7\5\7\u03da")
        buf.write("\n\7\3\7\5\7\u03dd\n\7\3\7\3\7\3\7\3\7\3\7\6\7\u03e4\n")
        buf.write("\7\r\7\16\7\u03e5\5\7\u03e8\n\7\3\b\5\b\u03eb\n\b\3\b")
        buf.write("\3\b\3\t\3\t\5\t\u03f1\n\t\3\t\3\t\3\t\7\t\u03f6\n\t\f")
        buf.write("\t\16\t\u03f9\13\t\3\n\3\n\5\n\u03fd\n\n\3\13\3\13\3\13")
        buf.write("\3\13\5\13\u0403\n\13\3\13\3\13\5\13\u0407\n\13\3\13\3")
        buf.write("\13\5\13\u040b\n\13\3\f\3\f\3\f\3\f\5\f\u0411\n\f\3\r")
        buf.write("\3\r\3\r\3\r\3\16\3\16\3\16\7\16\u041a\n\16\f\16\16\16")
        buf.write("\u041d\13\16\3\17\3\17\3\17\3\17\3\20\3\20\5\20\u0425")
        buf.write("\n\20\3\21\3\21\3\21\3\21\3\21\3\21\7\21\u042d\n\21\f")
        buf.write("\21\16\21\u0430\13\21\5\21\u0432\n\21\3\21\3\21\3\21\5")
        buf.write("\21\u0437\n\21\5\21\u0439\n\21\3\21\3\21\3\21\3\21\3\21")
        buf.write("\5\21\u0440\n\21\3\21\3\21\3\21\3\21\5\21\u0446\n\21\5")
        buf.write("\21\u0448\n\21\3\22\3\22\5\22\u044c\n\22\3\23\3\23\3\24")
        buf.write("\3\24\3\24\3\24\3\24\3\24\5\24\u0456\n\24\3\24\3\24\3")
        buf.write("\24\3\24\5\24\u045c\n\24\3\24\7\24\u045f\n\24\f\24\16")
        buf.write("\24\u0462\13\24\3\25\3\25\3\25\3\25\3\25\3\25\3\25\7\25")
        buf.write("\u046b\n\25\f\25\16\25\u046e\13\25\3\25\3\25\3\25\3\25")
        buf.write("\5\25\u0474\n\25\3\26\3\26\5\26\u0478\n\26\3\26\3\26\5")
        buf.write("\26\u047c\n\26\3\27\3\27\5\27\u0480\n\27\3\27\3\27\3\27")
        buf.write("\7\27\u0485\n\27\f\27\16\27\u0488\13\27\3\27\3\27\3\27")
        buf.write("\3\27\7\27\u048e\n\27\f\27\16\27\u0491\13\27\5\27\u0493")
        buf.write("\n\27\3\27\3\27\5\27\u0497\n\27\3\27\3\27\3\27\5\27\u049c")
        buf.write("\n\27\3\27\3\27\5\27\u04a0\n\27\3\27\3\27\3\27\3\27\7")
        buf.write("\27\u04a6\n\27\f\27\16\27\u04a9\13\27\5\27\u04ab\n\27")
        buf.write("\3\30\5\30\u04ae\n\30\3\30\3\30\3\30\7\30\u04b3\n\30\f")
        buf.write("\30\16\30\u04b6\13\30\3\31\3\31\3\31\3\31\3\31\3\31\7")
        buf.write("\31\u04be\n\31\f\31\16\31\u04c1\13\31\5\31\u04c3\n\31")
        buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\7\31\u04cb\n\31\f\31\16")
        buf.write("\31\u04ce\13\31\5\31\u04d0\n\31\3\31\3\31\3\31\3\31\3")
        buf.write("\31\3\31\3\31\7\31\u04d9\n\31\f\31\16\31\u04dc\13\31\3")
        buf.write("\31\3\31\5\31\u04e0\n\31\3\32\3\32\3\32\3\32\7\32\u04e6")
        buf.write("\n\32\f\32\16\32\u04e9\13\32\5\32\u04eb\n\32\3\32\3\32")
        buf.write("\5\32\u04ef\n\32\3\33\3\33\3\33\3\33\3\33\3\33\3\34\5")
        buf.write("\34\u04f8\n\34\3\34\3\34\3\34\3\34\3\34\7\34\u04ff\n\34")
        buf.write("\f\34\16\34\u0502\13\34\5\34\u0504\n\34\3\34\3\34\3\34")
        buf.write("\3\34\3\34\7\34\u050b\n\34\f\34\16\34\u050e\13\34\5\34")
        buf.write("\u0510\n\34\3\34\5\34\u0513\n\34\3\35\3\35\5\35\u0517")
        buf.write("\n\35\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3\37\3\37\5\37")
        buf.write("\u0522\n\37\3\37\5\37\u0525\n\37\3\37\3\37\3\37\3\37\3")
        buf.write("\37\5\37\u052c\n\37\3\37\5\37\u052f\n\37\3 \3 \3 \3 \3")
        buf.write(" \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \5 \u0542\n \7 \u0544")
        buf.write("\n \f \16 \u0547\13 \3!\5!\u054a\n!\3!\3!\5!\u054e\n!")
        buf.write("\3!\3!\5!\u0552\n!\3!\3!\5!\u0556\n!\5!\u0558\n!\3\"\3")
        buf.write("\"\3\"\3\"\3\"\3\"\3\"\7\"\u0561\n\"\f\"\16\"\u0564\13")
        buf.write("\"\3\"\3\"\5\"\u0568\n\"\3#\3#\3#\3#\3#\3#\3#\5#\u0571")
        buf.write("\n#\3$\3$\3%\3%\3&\3&\3&\5&\u057a\n&\3&\5&\u057d\n&\3")
        buf.write("\'\3\'\3\'\3\'\5\'\u0583\n\'\3(\3(\3(\3(\3(\3(\3(\3(\7")
        buf.write("(\u058d\n(\f(\16(\u0590\13(\5(\u0592\n(\3(\3(\3(\3(\3")
        buf.write("(\7(\u0599\n(\f(\16(\u059c\13(\5(\u059e\n(\3(\3(\3(\3")
        buf.write("(\7(\u05a4\n(\f(\16(\u05a7\13(\5(\u05a9\n(\3(\5(\u05ac")
        buf.write("\n(\3(\3(\3(\5(\u05b1\n(\3(\5(\u05b4\n(\3(\3(\3(\3(\3")
        buf.write("(\3(\3(\3(\7(\u05be\n(\f(\16(\u05c1\13(\5(\u05c3\n(\3")
        buf.write("(\3(\3(\3(\7(\u05c9\n(\f(\16(\u05cc\13(\3(\3(\5(\u05d0")
        buf.write("\n(\3(\3(\5(\u05d4\n(\5(\u05d6\n(\5(\u05d8\n(\3)\3)\3")
        buf.write(")\3)\3*\3*\3*\3*\3*\3*\3*\3*\3*\5*\u05e7\n*\5*\u05e9\n")
        buf.write("*\3+\3+\3+\3+\3+\3+\3+\3+\3+\5+\u05f4\n+\3,\3,\3,\3,\3")
        buf.write(",\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\5,\u0609\n")
        buf.write(",\3-\3-\3-\3-\3-\3-\7-\u0611\n-\f-\16-\u0614\13-\3-\3")
        buf.write("-\3.\3.\3.\3.\3/\3/\5/\u061e\n/\3/\3/\5/\u0622\n/\5/\u0624")
        buf.write("\n/\3\60\3\60\3\60\3\60\7\60\u062a\n\60\f\60\16\60\u062d")
        buf.write("\13\60\3\60\3\60\3\61\3\61\5\61\u0633\n\61\3\61\3\61\3")
        buf.write("\61\3\61\3\61\3\61\3\61\3\61\3\61\7\61\u063e\n\61\f\61")
        buf.write("\16\61\u0641\13\61\3\61\3\61\3\61\5\61\u0646\n\61\3\61")
        buf.write("\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61")
        buf.write("\3\61\3\61\5\61\u0656\n\61\3\62\3\62\3\62\3\62\3\62\7")
        buf.write("\62\u065d\n\62\f\62\16\62\u0660\13\62\5\62\u0662\n\62")
        buf.write("\3\62\3\62\3\62\3\62\7\62\u0668\n\62\f\62\16\62\u066b")
        buf.write("\13\62\5\62\u066d\n\62\3\62\3\62\3\63\3\63\3\63\5\63\u0674")
        buf.write("\n\63\3\63\3\63\3\63\5\63\u0679\n\63\3\64\3\64\3\64\3")
        buf.write("\64\3\64\3\64\3\64\7\64\u0682\n\64\f\64\16\64\u0685\13")
        buf.write("\64\5\64\u0687\n\64\3\64\3\64\5\64\u068b\n\64\5\64\u068d")
        buf.write("\n\64\3\64\3\64\3\64\3\64\3\64\3\64\5\64\u0695\n\64\3")
        buf.write("\64\3\64\3\64\3\64\3\64\3\64\7\64\u069d\n\64\f\64\16\64")
        buf.write("\u06a0\13\64\3\64\3\64\3\64\5\64\u06a5\n\64\5\64\u06a7")
        buf.write("\n\64\3\65\3\65\3\65\3\65\3\65\5\65\u06ae\n\65\3\65\3")
        buf.write("\65\5\65\u06b2\n\65\5\65\u06b4\n\65\3\65\3\65\3\65\3\65")
        buf.write("\3\65\5\65\u06bb\n\65\3\65\3\65\5\65\u06bf\n\65\5\65\u06c1")
        buf.write("\n\65\5\65\u06c3\n\65\3\66\3\66\3\66\3\66\3\66\7\66\u06ca")
        buf.write("\n\66\f\66\16\66\u06cd\13\66\3\66\3\66\3\66\3\66\3\66")
        buf.write("\3\66\3\66\3\66\5\66\u06d7\n\66\3\67\3\67\5\67\u06db\n")
        buf.write("\67\38\38\38\38\38\38\78\u06e3\n8\f8\168\u06e6\138\38")
        buf.write("\38\39\39\3:\3:\3:\5:\u06ef\n:\3:\3:\5:\u06f3\n:\3:\3")
        buf.write(":\3:\3:\3:\3:\7:\u06fb\n:\f:\16:\u06fe\13:\3;\3;\3;\3")
        buf.write(";\3;\3;\3;\3;\3;\3;\5;\u070a\n;\3;\3;\3;\3;\3;\3;\5;\u0712")
        buf.write("\n;\3;\3;\3;\3;\3;\7;\u0719\n;\f;\16;\u071c\13;\3;\3;")
        buf.write("\3;\5;\u0721\n;\3;\3;\3;\3;\3;\3;\5;\u0729\n;\3;\3;\3")
        buf.write(";\3;\5;\u072f\n;\3;\3;\5;\u0733\n;\3;\3;\3;\5;\u0738\n")
        buf.write(";\3;\3;\3;\5;\u073d\n;\3<\3<\3<\3<\5<\u0743\n<\3<\3<\3")
        buf.write("<\3<\3<\3<\3<\3<\3<\3<\3<\3<\7<\u0751\n<\f<\16<\u0754")
        buf.write("\13<\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3")
        buf.write("=\3=\3=\3=\3=\3=\3=\3=\3=\6=\u076f\n=\r=\16=\u0770\3=")
        buf.write("\3=\3=\3=\3=\3=\3=\7=\u077a\n=\f=\16=\u077d\13=\3=\3=")
        buf.write("\3=\3=\3=\5=\u0784\n=\3=\3=\3=\5=\u0789\n=\3=\3=\3=\5")
        buf.write("=\u078e\n=\3=\3=\3=\3=\3=\3=\3=\3=\3=\7=\u0799\n=\f=\16")
        buf.write("=\u079c\13=\3=\3=\3=\5=\u07a1\n=\3=\3=\3=\3=\3=\5=\u07a8")
        buf.write("\n=\3=\3=\3=\5=\u07ad\n=\3=\5=\u07b0\n=\3=\5=\u07b3\n")
        buf.write("=\3=\3=\3=\5=\u07b8\n=\3=\3=\3=\7=\u07bd\n=\f=\16=\u07c0")
        buf.write("\13=\5=\u07c2\n=\3=\3=\3=\3=\3=\7=\u07c9\n=\f=\16=\u07cc")
        buf.write("\13=\5=\u07ce\n=\3=\3=\5=\u07d2\n=\3=\5=\u07d5\n=\3=\5")
        buf.write("=\u07d8\n=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\7=\u07e5\n")
        buf.write("=\f=\16=\u07e8\13=\5=\u07ea\n=\3=\3=\3=\3=\3=\3=\3=\3")
        buf.write("=\3=\3=\3=\3=\3=\3=\3=\6=\u07fb\n=\r=\16=\u07fc\3=\3=")
        buf.write("\5=\u0801\n=\3=\3=\3=\3=\6=\u0807\n=\r=\16=\u0808\3=\3")
        buf.write("=\5=\u080d\n=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3")
        buf.write("=\3=\3=\3=\3=\3=\3=\3=\7=\u0824\n=\f=\16=\u0827\13=\5")
        buf.write("=\u0829\n=\3=\3=\3=\3=\3=\3=\3=\5=\u0832\n=\3=\3=\3=\3")
        buf.write("=\5=\u0838\n=\3=\3=\3=\3=\5=\u083e\n=\3=\3=\3=\3=\5=\u0844")
        buf.write("\n=\3=\3=\3=\3=\3=\3=\3=\5=\u084d\n=\3=\5=\u0850\n=\3")
        buf.write("=\5=\u0853\n=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3")
        buf.write("=\3=\3=\3=\5=\u0866\n=\3=\3=\3=\3=\3=\3=\3=\5=\u086f\n")
        buf.write("=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3")
        buf.write("=\7=\u0883\n=\f=\16=\u0886\13=\5=\u0888\n=\3=\3=\3=\3")
        buf.write("=\3=\3=\3=\3=\5=\u0892\n=\3=\3=\3=\3=\3=\3=\3=\5=\u089b")
        buf.write("\n=\3=\3=\3=\3=\5=\u08a1\n=\3=\3=\3=\3=\5=\u08a7\n=\3")
        buf.write("=\3=\3=\3=\3=\3=\3=\3=\3=\5=\u08b2\n=\5=\u08b4\n=\3=\3")
        buf.write("=\3=\5=\u08b9\n=\3=\3=\3=\3=\3=\5=\u08c0\n=\5=\u08c2\n")
        buf.write("=\3=\3=\3=\3=\5=\u08c8\n=\3=\3=\3=\3=\5=\u08ce\n=\3=\3")
        buf.write("=\3=\3=\3=\3=\3=\7=\u08d7\n=\f=\16=\u08da\13=\3=\3=\3")
        buf.write("=\3=\3=\3=\5=\u08e2\n=\3=\3=\3=\5=\u08e7\n=\3=\3=\3=\5")
        buf.write("=\u08ec\n=\5=\u08ee\n=\5=\u08f0\n=\3=\3=\3=\3=\5=\u08f6")
        buf.write("\n=\5=\u08f8\n=\3=\3=\3=\3=\3=\3=\7=\u0900\n=\f=\16=\u0903")
        buf.write("\13=\3=\3=\3=\3=\3=\3=\5=\u090b\n=\5=\u090d\n=\3=\3=\3")
        buf.write("=\3=\5=\u0913\n=\5=\u0915\n=\3=\5=\u0918\n=\3=\3=\3=\3")
        buf.write("=\3=\3=\3=\3=\7=\u0922\n=\f=\16=\u0925\13=\3>\3>\3>\3")
        buf.write(">\3>\3>\3>\7>\u092e\n>\f>\16>\u0931\13>\5>\u0933\n>\3")
        buf.write("?\3?\3?\5?\u0938\n?\3@\3@\3@\5@\u093d\n@\3A\3A\3A\3A\3")
        buf.write("B\3B\3C\3C\3C\3C\5C\u0949\nC\3D\3D\5D\u094d\nD\3D\3D\5")
        buf.write("D\u0951\nD\3D\5D\u0954\nD\5D\u0956\nD\3E\3E\3E\3E\3E\3")
        buf.write("E\5E\u095e\nE\3F\5F\u0961\nF\3F\3F\3F\3F\3F\3F\3F\3F\5")
        buf.write("F\u096b\nF\3G\3G\3H\3H\3H\3H\5H\u0973\nH\3I\3I\3I\3I\5")
        buf.write("I\u0979\nI\5I\u097b\nI\3J\3J\3J\3J\3J\3J\5J\u0983\nJ\3")
        buf.write("K\3K\3L\3L\3M\3M\3N\3N\5N\u098d\nN\3N\3N\3N\3N\5N\u0993")
        buf.write("\nN\3O\3O\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\7Q\u099f\nQ\fQ\16Q\u09a2")
        buf.write("\13Q\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u09aa\nQ\3Q\3Q\3Q\3Q\3Q\5Q\u09b1")
        buf.write("\nQ\3Q\3Q\3Q\5Q\u09b6\nQ\3Q\3Q\3Q\3Q\3Q\5Q\u09bd\nQ\3")
        buf.write("Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u09c7\nQ\3Q\3Q\3Q\5Q\u09cc\n")
        buf.write("Q\3Q\3Q\3Q\3Q\3Q\5Q\u09d3\nQ\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3")
        buf.write("Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\7Q\u09eb\nQ\f")
        buf.write("Q\16Q\u09ee\13Q\3Q\3Q\5Q\u09f2\nQ\5Q\u09f4\nQ\3Q\3Q\3")
        buf.write("Q\3Q\3Q\5Q\u09fb\nQ\7Q\u09fd\nQ\fQ\16Q\u0a00\13Q\3R\3")
        buf.write("R\3R\3R\5R\u0a06\nR\3S\3S\5S\u0a0a\nS\3T\3T\3T\3T\3T\3")
        buf.write("U\3U\3U\3U\3U\3U\3V\3V\3V\3V\5V\u0a1b\nV\3V\3V\3V\3V\3")
        buf.write("V\3V\3V\3V\3V\3V\3V\7V\u0a28\nV\fV\16V\u0a2b\13V\3V\3")
        buf.write("V\3V\3V\5V\u0a31\nV\3V\3V\3V\3V\3V\3V\3V\5V\u0a3a\nV\3")
        buf.write("V\3V\3V\3V\3V\3V\7V\u0a42\nV\fV\16V\u0a45\13V\3V\3V\5")
        buf.write("V\u0a49\nV\3V\3V\3V\3V\3V\7V\u0a50\nV\fV\16V\u0a53\13")
        buf.write("V\3V\3V\5V\u0a57\nV\3W\3W\3W\3W\3W\3W\5W\u0a5f\nW\3X\3")
        buf.write("X\3X\3X\7X\u0a65\nX\fX\16X\u0a68\13X\5X\u0a6a\nX\3X\3")
        buf.write("X\3X\3X\5X\u0a70\nX\3X\5X\u0a73\nX\3X\3X\3X\3X\3X\5X\u0a7a")
        buf.write("\nX\3X\3X\3X\3X\7X\u0a80\nX\fX\16X\u0a83\13X\5X\u0a85")
        buf.write("\nX\3X\3X\3X\3X\7X\u0a8b\nX\fX\16X\u0a8e\13X\5X\u0a90")
        buf.write("\nX\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3")
        buf.write("Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\5Y\u0aaa\nY\3Z\3Z\3Z\3Z\3Z\3Z\3")
        buf.write("Z\3Z\3Z\5Z\u0ab5\nZ\3[\3[\3[\5[\u0aba\n[\3[\3[\3[\3[\3")
        buf.write("[\7[\u0ac1\n[\f[\16[\u0ac4\13[\3\\\3\\\3\\\3\\\3\\\3\\")
        buf.write("\3\\\3\\\7\\\u0ace\n\\\f\\\16\\\u0ad1\13\\\3\\\3\\\3\\")
        buf.write("\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\5\\\u0adf\n\\\3]")
        buf.write("\3]\5]\u0ae3\n]\3]\3]\5]\u0ae7\n]\3]\3]\5]\u0aeb\n]\3")
        buf.write("]\3]\3]\3]\5]\u0af1\n]\3]\3]\5]\u0af5\n]\3]\3]\5]\u0af9")
        buf.write("\n]\3]\3]\5]\u0afd\n]\5]\u0aff\n]\3^\3^\3^\3^\3_\3_\3")
        buf.write("_\3_\5_\u0b09\n_\3`\3`\3`\3`\3`\5`\u0b10\n`\3a\3a\3a\3")
        buf.write("a\3a\3a\3a\5a\u0b19\na\3b\3b\3b\3b\3b\5b\u0b20\nb\3c\3")
        buf.write("c\3c\3c\3c\5c\u0b27\nc\3d\3d\3d\7d\u0b2c\nd\fd\16d\u0b2f")
        buf.write("\13d\3e\3e\3f\3f\3f\7f\u0b36\nf\ff\16f\u0b39\13f\3g\3")
        buf.write("g\3g\3g\3g\3g\3h\3h\3i\3i\3i\5i\u0b46\ni\3j\3j\3j\3j\3")
        buf.write("j\5j\u0b4d\nj\3k\3k\3k\7k\u0b52\nk\fk\16k\u0b55\13k\3")
        buf.write("l\3l\3l\3l\3l\5l\u0b5c\nl\3m\5m\u0b5f\nm\3m\3m\5m\u0b63")
        buf.write("\nm\3m\3m\5m\u0b67\nm\3m\5m\u0b6a\nm\3n\3n\3n\2\t&>rv")
        buf.write("x\u00a0\u00b4o\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36")
        buf.write(" \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprt")
        buf.write("vxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e")
        buf.write("\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0")
        buf.write("\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2")
        buf.write("\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4")
        buf.write("\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6")
        buf.write("\u00d8\u00da\2$\4\2\'\'\u00d4\u00d4\4\2EE{{\4\2\u00e0")
        buf.write("\u00e0\u00f1\u00f1\4\2ddrr\4\2WWss\3\2\u00dc\u00dd\4\2")
        buf.write("``\u00a0\u00a0\4\2\u012f\u012f\u0133\u0133\4\2VV\u0106")
        buf.write("\u0106\4\2\37\37HH\4\2``\u0089\u0089\4\2\30\30LL\4\2\"")
        buf.write("\"\u00f0\u00f0\5\2$$\u008b\u008b\u00fb\u00fb\4\2tt\u00e4")
        buf.write("\u00e4\3\2\u0129\u012a\3\2\u012b\u012d\4\2\u0086\u0086")
        buf.write("\u00ae\u00ae\3\2\u010f\u0111\6\2TT\\\\\u00fe\u00fe\u0108")
        buf.write("\u0108\4\2\60\60\u0105\u0105\4\2__\u00de\u00de\3\2\u0123")
        buf.write("\u0128\5\2\30\30\34\34\u00eb\u00eb\4\2\\\\\u00fe\u00fe")
        buf.write("\7\2BBoo\u009d\u009e\u00e2\u00e2\u0121\u0121\3\2\u00a1")
        buf.write("\u00a4\4\2aa\u00c4\u00c4\5\2jj\u0080\u0080\u00f4\u00f4")
        buf.write("\6\2MM||\u0094\u0094\u0112\u0112\4\2\u00b2\u00b2\u0120")
        buf.write("\u0120\7\2\64\64FFww\u00e5\u00e5\u010b\u010b\4\2\u00f9")
        buf.write("\u00f9\u0116\u01168\2\24\30\32\32\34\35\37\"$$&\'*\60")
        buf.write("\62\63\67\67@BDEGHJKMNQRTTWWZZ]accfjmmoqstvvyy{|~~\u0080")
        buf.write("\u0080\u0086\u008b\u008d\u008d\u008f\u008f\u0091\u0091")
        buf.write("\u0094\u009e\u00a0\u00a6\u00aa\u00af\u00b1\u00b3\u00b6")
        buf.write("\u00b6\u00b8\u00c5\u00c7\u00cc\u00ce\u00d6\u00d8\u00da")
        buf.write("\u00dc\u00e4\u00e6\u00f0\u00f2\u00f5\u00f7\u00fc\u00ff")
        buf.write("\u0101\u0103\u0105\u0107\u0109\u010b\u010d\u010f\u0113")
        buf.write("\u0115\u0117\u011a\u011a\u011c\u0122\2\u0d3d\2\u00dc\3")
        buf.write("\2\2\2\4\u00df\3\2\2\2\6\u00e2\3\2\2\2\b\u00e5\3\2\2\2")
        buf.write("\n\u00e8\3\2\2\2\f\u03e7\3\2\2\2\16\u03ea\3\2\2\2\20\u03ee")
        buf.write("\3\2\2\2\22\u03fc\3\2\2\2\24\u03fe\3\2\2\2\26\u040c\3")
        buf.write("\2\2\2\30\u0412\3\2\2\2\32\u0416\3\2\2\2\34\u041e\3\2")
        buf.write("\2\2\36\u0424\3\2\2\2 \u0426\3\2\2\2\"\u044b\3\2\2\2$")
        buf.write("\u044d\3\2\2\2&\u044f\3\2\2\2(\u0473\3\2\2\2*\u0475\3")
        buf.write("\2\2\2,\u047d\3\2\2\2.\u04ad\3\2\2\2\60\u04df\3\2\2\2")
        buf.write("\62\u04ee\3\2\2\2\64\u04f0\3\2\2\2\66\u04f7\3\2\2\28\u0514")
        buf.write("\3\2\2\2:\u051d\3\2\2\2<\u052e\3\2\2\2>\u0530\3\2\2\2")
        buf.write("@\u0557\3\2\2\2B\u0567\3\2\2\2D\u0569\3\2\2\2F\u0572\3")
        buf.write("\2\2\2H\u0574\3\2\2\2J\u057c\3\2\2\2L\u0582\3\2\2\2N\u0584")
        buf.write("\3\2\2\2P\u05d9\3\2\2\2R\u05e8\3\2\2\2T\u05f3\3\2\2\2")
        buf.write("V\u0608\3\2\2\2X\u060a\3\2\2\2Z\u0617\3\2\2\2\\\u061b")
        buf.write("\3\2\2\2^\u0625\3\2\2\2`\u0655\3\2\2\2b\u0657\3\2\2\2")
        buf.write("d\u0673\3\2\2\2f\u067a\3\2\2\2h\u06c2\3\2\2\2j\u06d6\3")
        buf.write("\2\2\2l\u06d8\3\2\2\2n\u06dc\3\2\2\2p\u06e9\3\2\2\2r\u06f2")
        buf.write("\3\2\2\2t\u073c\3\2\2\2v\u0742\3\2\2\2x\u0917\3\2\2\2")
        buf.write("z\u0926\3\2\2\2|\u0934\3\2\2\2~\u0939\3\2\2\2\u0080\u093e")
        buf.write("\3\2\2\2\u0082\u0942\3\2\2\2\u0084\u0948\3\2\2\2\u0086")
        buf.write("\u0955\3\2\2\2\u0088\u095d\3\2\2\2\u008a\u096a\3\2\2\2")
        buf.write("\u008c\u096c\3\2\2\2\u008e\u0972\3\2\2\2\u0090\u097a\3")
        buf.write("\2\2\2\u0092\u0982\3\2\2\2\u0094\u0984\3\2\2\2\u0096\u0986")
        buf.write("\3\2\2\2\u0098\u0988\3\2\2\2\u009a\u098a\3\2\2\2\u009c")
        buf.write("\u0994\3\2\2\2\u009e\u0996\3\2\2\2\u00a0\u09f3\3\2\2\2")
        buf.write("\u00a2\u0a05\3\2\2\2\u00a4\u0a09\3\2\2\2\u00a6\u0a0b\3")
        buf.write("\2\2\2\u00a8\u0a10\3\2\2\2\u00aa\u0a56\3\2\2\2\u00ac\u0a58")
        buf.write("\3\2\2\2\u00ae\u0a69\3\2\2\2\u00b0\u0aa9\3\2\2\2\u00b2")
        buf.write("\u0ab4\3\2\2\2\u00b4\u0ab6\3\2\2\2\u00b6\u0ade\3\2\2\2")
        buf.write("\u00b8\u0afe\3\2\2\2\u00ba\u0b00\3\2\2\2\u00bc\u0b08\3")
        buf.write("\2\2\2\u00be\u0b0f\3\2\2\2\u00c0\u0b18\3\2\2\2\u00c2\u0b1f")
        buf.write("\3\2\2\2\u00c4\u0b26\3\2\2\2\u00c6\u0b28\3\2\2\2\u00c8")
        buf.write("\u0b30\3\2\2\2\u00ca\u0b32\3\2\2\2\u00cc\u0b3a\3\2\2\2")
        buf.write("\u00ce\u0b40\3\2\2\2\u00d0\u0b45\3\2\2\2\u00d2\u0b4c\3")
        buf.write("\2\2\2\u00d4\u0b4e\3\2\2\2\u00d6\u0b5b\3\2\2\2\u00d8\u0b69")
        buf.write("\3\2\2\2\u00da\u0b6b\3\2\2\2\u00dc\u00dd\5\f\7\2\u00dd")
        buf.write("\u00de\7\2\2\3\u00de\3\3\2\2\2\u00df\u00e0\5p9\2\u00e0")
        buf.write("\u00e1\7\2\2\3\u00e1\5\3\2\2\2\u00e2\u00e3\5\u00c6d\2")
        buf.write("\u00e3\u00e4\7\2\2\3\u00e4\7\3\2\2\2\u00e5\u00e6\5\u00a0")
        buf.write("Q\2\u00e6\u00e7\7\2\2\3\u00e7\t\3\2\2\2\u00e8\u00e9\5")
        buf.write("\u00b4[\2\u00e9\u00ea\7\2\2\3\u00ea\13\3\2\2\2\u00eb\u03e8")
        buf.write("\5\16\b\2\u00ec\u00ed\7\u010c\2\2\u00ed\u03e8\5\u00d6")
        buf.write("l\2\u00ee\u00ef\7\u010c\2\2\u00ef\u00f0\5\u00d6l\2\u00f0")
        buf.write("\u00f1\7\3\2\2\u00f1\u00f2\5\u00d6l\2\u00f2\u03e8\3\2")
        buf.write("\2\2\u00f3\u00f4\7\64\2\2\u00f4\u00f8\7\u00e0\2\2\u00f5")
        buf.write("\u00f6\7p\2\2\u00f6\u00f7\7\u00a8\2\2\u00f7\u00f9\7Y\2")
        buf.write("\2\u00f8\u00f5\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9\u00fa")
        buf.write("\3\2\2\2\u00fa\u00fd\5\u00caf\2\u00fb\u00fc\7!\2\2\u00fc")
        buf.write("\u00fe\5\u00d2j\2\u00fd\u00fb\3\2\2\2\u00fd\u00fe\3\2")
        buf.write("\2\2\u00fe\u0101\3\2\2\2\u00ff\u0100\7\u011b\2\2\u0100")
        buf.write("\u0102\5\30\r\2\u0101\u00ff\3\2\2\2\u0101\u0102\3\2\2")
        buf.write("\2\u0102\u03e8\3\2\2\2\u0103\u0104\7O\2\2\u0104\u0107")
        buf.write("\7\u00e0\2\2\u0105\u0106\7p\2\2\u0106\u0108\7Y\2\2\u0107")
        buf.write("\u0105\3\2\2\2\u0107\u0108\3\2\2\2\u0108\u0109\3\2\2\2")
        buf.write("\u0109\u010b\5\u00caf\2\u010a\u010c\t\2\2\2\u010b\u010a")
        buf.write("\3\2\2\2\u010b\u010c\3\2\2\2\u010c\u03e8\3\2\2\2\u010d")
        buf.write("\u010e\7\31\2\2\u010e\u010f\7\u00e0\2\2\u010f\u0110\5")
        buf.write("\u00caf\2\u0110\u0111\7\u00cf\2\2\u0111\u0112\7\u00fa")
        buf.write("\2\2\u0112\u0113\5\u00d6l\2\u0113\u03e8\3\2\2\2\u0114")
        buf.write("\u0115\7\31\2\2\u0115\u0116\7\u00e0\2\2\u0116\u0117\5")
        buf.write("\u00caf\2\u0117\u0118\7\u00e8\2\2\u0118\u0119\7!\2\2\u0119")
        buf.write("\u011a\5\u00d2j\2\u011a\u03e8\3\2\2\2\u011b\u011c\7\64")
        buf.write("\2\2\u011c\u0120\7\u00f1\2\2\u011d\u011e\7p\2\2\u011e")
        buf.write("\u011f\7\u00a8\2\2\u011f\u0121\7Y\2\2\u0120\u011d\3\2")
        buf.write("\2\2\u0120\u0121\3\2\2\2\u0121\u0122\3\2\2\2\u0122\u0124")
        buf.write("\5\u00caf\2\u0123\u0125\5^\60\2\u0124\u0123\3\2\2\2\u0124")
        buf.write("\u0125\3\2\2\2\u0125\u0128\3\2\2\2\u0126\u0127\7-\2\2")
        buf.write("\u0127\u0129\5\u0090I\2\u0128\u0126\3\2\2\2\u0128\u0129")
        buf.write("\3\2\2\2\u0129\u012c\3\2\2\2\u012a\u012b\7\u011b\2\2\u012b")
        buf.write("\u012d\5\30\r\2\u012c\u012a\3\2\2\2\u012c\u012d\3\2\2")
        buf.write("\2\u012d\u012e\3\2\2\2\u012e\u0134\7\36\2\2\u012f\u0135")
        buf.write("\5\16\b\2\u0130\u0131\7\4\2\2\u0131\u0132\5\16\b\2\u0132")
        buf.write("\u0133\7\5\2\2\u0133\u0135\3\2\2\2\u0134\u012f\3\2\2\2")
        buf.write("\u0134\u0130\3\2\2\2\u0135\u013b\3\2\2\2\u0136\u0138\7")
        buf.write("\u011b\2\2\u0137\u0139\7\u00a5\2\2\u0138\u0137\3\2\2\2")
        buf.write("\u0138\u0139\3\2\2\2\u0139\u013a\3\2\2\2\u013a\u013c\7")
        buf.write("@\2\2\u013b\u0136\3\2\2\2\u013b\u013c\3\2\2\2\u013c\u03e8")
        buf.write("\3\2\2\2\u013d\u013e\7\64\2\2\u013e\u0142\7\u00f1\2\2")
        buf.write("\u013f\u0140\7p\2\2\u0140\u0141\7\u00a8\2\2\u0141\u0143")
        buf.write("\7Y\2\2\u0142\u013f\3\2\2\2\u0142\u0143\3\2\2\2\u0143")
        buf.write("\u0144\3\2\2\2\u0144\u0145\5\u00caf\2\u0145\u0146\7\4")
        buf.write("\2\2\u0146\u014b\5\22\n\2\u0147\u0148\7\6\2\2\u0148\u014a")
        buf.write("\5\22\n\2\u0149\u0147\3\2\2\2\u014a\u014d\3\2\2\2\u014b")
        buf.write("\u0149\3\2\2\2\u014b\u014c\3\2\2\2\u014c\u014e\3\2\2\2")
        buf.write("\u014d\u014b\3\2\2\2\u014e\u0151\7\5\2\2\u014f\u0150\7")
        buf.write("-\2\2\u0150\u0152\5\u0090I\2\u0151\u014f\3\2\2\2\u0151")
        buf.write("\u0152\3\2\2\2\u0152\u0155\3\2\2\2\u0153\u0154\7\u011b")
        buf.write("\2\2\u0154\u0156\5\30\r\2\u0155\u0153\3\2\2\2\u0155\u0156")
        buf.write("\3\2\2\2\u0156\u03e8\3\2\2\2\u0157\u0158\7O\2\2\u0158")
        buf.write("\u015b\7\u00f1\2\2\u0159\u015a\7p\2\2\u015a\u015c\7Y\2")
        buf.write("\2\u015b\u0159\3\2\2\2\u015b\u015c\3\2\2\2\u015c\u015d")
        buf.write("\3\2\2\2\u015d\u03e8\5\u00caf\2\u015e\u015f\7w\2\2\u015f")
        buf.write("\u0160\7z\2\2\u0160\u0162\5\u00caf\2\u0161\u0163\5^\60")
        buf.write("\2\u0162\u0161\3\2\2\2\u0162\u0163\3\2\2\2\u0163\u0164")
        buf.write("\3\2\2\2\u0164\u0165\5\16\b\2\u0165\u03e8\3\2\2\2\u0166")
        buf.write("\u0167\7F\2\2\u0167\u0168\7d\2\2\u0168\u016b\5\u00caf")
        buf.write("\2\u0169\u016a\7\u0119\2\2\u016a\u016c\5r:\2\u016b\u0169")
        buf.write("\3\2\2\2\u016b\u016c\3\2\2\2\u016c\u03e8\3\2\2\2\u016d")
        buf.write("\u016e\7\u00ff\2\2\u016e\u016f\7\u00f1\2\2\u016f\u03e8")
        buf.write("\5\u00caf\2\u0170\u0171\7-\2\2\u0171\u0172\7\u00b0\2\2")
        buf.write("\u0172\u0173\7\u00f1\2\2\u0173\u0174\5\u00caf\2\u0174")
        buf.write("\u0177\7}\2\2\u0175\u0178\5\u0090I\2\u0176\u0178\7\u00a9")
        buf.write("\2\2\u0177\u0175\3\2\2\2\u0177\u0176\3\2\2\2\u0178\u03e8")
        buf.write("\3\2\2\2\u0179\u017a\7-\2\2\u017a\u017b\7\u00b0\2\2\u017b")
        buf.write("\u017c\7+\2\2\u017c\u017d\5\u00caf\2\u017d\u0180\7}\2")
        buf.write("\2\u017e\u0181\5\u0090I\2\u017f\u0181\7\u00a9\2\2\u0180")
        buf.write("\u017e\3\2\2\2\u0180\u017f\3\2\2\2\u0181\u03e8\3\2\2\2")
        buf.write("\u0182\u0183\7\31\2\2\u0183\u0186\7\u00f1\2\2\u0184\u0185")
        buf.write("\7p\2\2\u0185\u0187\7Y\2\2\u0186\u0184\3\2\2\2\u0186\u0187")
        buf.write("\3\2\2\2\u0187\u0188\3\2\2\2\u0188\u0189\5\u00caf\2\u0189")
        buf.write("\u018a\7\u00cf\2\2\u018a\u018b\7\u00fa\2\2\u018b\u018c")
        buf.write("\5\u00caf\2\u018c\u03e8\3\2\2\2\u018d\u018e\7\31\2\2\u018e")
        buf.write("\u0191\7\u00f1\2\2\u018f\u0190\7p\2\2\u0190\u0192\7Y\2")
        buf.write("\2\u0191\u018f\3\2\2\2\u0191\u0192\3\2\2\2\u0192\u0193")
        buf.write("\3\2\2\2\u0193\u0194\5\u00caf\2\u0194\u0195\7\25\2\2\u0195")
        buf.write("\u0199\7+\2\2\u0196\u0197\7p\2\2\u0197\u0198\7\u00a8\2")
        buf.write("\2\u0198\u019a\7Y\2\2\u0199\u0196\3\2\2\2\u0199\u019a")
        buf.write("\3\2\2\2\u019a\u019b\3\2\2\2\u019b\u019c\5\24\13\2\u019c")
        buf.write("\u03e8\3\2\2\2\u019d\u019e\7\31\2\2\u019e\u01a1\7\u00f1")
        buf.write("\2\2\u019f\u01a0\7p\2\2\u01a0\u01a2\7Y\2\2\u01a1\u019f")
        buf.write("\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2\u01a3\3\2\2\2\u01a3")
        buf.write("\u01a4\5\u00caf\2\u01a4\u01a5\7\u00cf\2\2\u01a5\u01a8")
        buf.write("\7+\2\2\u01a6\u01a7\7p\2\2\u01a7\u01a9\7Y\2\2\u01a8\u01a6")
        buf.write("\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa")
        buf.write("\u01ab\5\u00d6l\2\u01ab\u01ac\7\u00fa\2\2\u01ac\u01ad")
        buf.write("\5\u00d6l\2\u01ad\u03e8\3\2\2\2\u01ae\u01af\7\31\2\2\u01af")
        buf.write("\u01b2\7\u00f1\2\2\u01b0\u01b1\7p\2\2\u01b1\u01b3\7Y\2")
        buf.write("\2\u01b2\u01b0\3\2\2\2\u01b2\u01b3\3\2\2\2\u01b3\u01b4")
        buf.write("\3\2\2\2\u01b4\u01b5\5\u00caf\2\u01b5\u01b6\7O\2\2\u01b6")
        buf.write("\u01b9\7+\2\2\u01b7\u01b8\7p\2\2\u01b8\u01ba\7Y\2\2\u01b9")
        buf.write("\u01b7\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bb\3\2\2\2")
        buf.write("\u01bb\u01bc\5\u00caf\2\u01bc\u03e8\3\2\2\2\u01bd\u01be")
        buf.write("\7\31\2\2\u01be\u01bf\7\u00f1\2\2\u01bf\u01c0\5\u00ca")
        buf.write("f\2\u01c0\u01c1\7\u00e8\2\2\u01c1\u01c2\7!\2\2\u01c2\u01c3")
        buf.write("\5\u00d2j\2\u01c3\u03e8\3\2\2\2\u01c4\u01c5\7\31\2\2\u01c5")
        buf.write("\u01c6\7\u00f1\2\2\u01c6\u01c7\5\u00caf\2\u01c7\u01c8")
        buf.write("\7\u00e8\2\2\u01c8\u01c9\7\u00c8\2\2\u01c9\u01ca\5\32")
        buf.write("\16\2\u01ca\u03e8\3\2\2\2\u01cb\u01cc\7\31\2\2\u01cc\u01cd")
        buf.write("\7\u00f1\2\2\u01cd\u01ce\5\u00caf\2\u01ce\u01cf\7X\2\2")
        buf.write("\u01cf\u01dc\5\u00d6l\2\u01d0\u01d9\7\4\2\2\u01d1\u01d6")
        buf.write("\5\u00c2b\2\u01d2\u01d3\7\6\2\2\u01d3\u01d5\5\u00c2b\2")
        buf.write("\u01d4\u01d2\3\2\2\2\u01d5\u01d8\3\2\2\2\u01d6\u01d4\3")
        buf.write("\2\2\2\u01d6\u01d7\3\2\2\2\u01d7\u01da\3\2\2\2\u01d8\u01d6")
        buf.write("\3\2\2\2\u01d9\u01d1\3\2\2\2\u01d9\u01da\3\2\2\2\u01da")
        buf.write("\u01db\3\2\2\2\u01db\u01dd\7\5\2\2\u01dc\u01d0\3\2\2\2")
        buf.write("\u01dc\u01dd\3\2\2\2\u01dd\u01e0\3\2\2\2\u01de\u01df\7")
        buf.write("\u0119\2\2\u01df\u01e1\5r:\2\u01e0\u01de\3\2\2\2\u01e0")
        buf.write("\u01e1\3\2\2\2\u01e1\u03e8\3\2\2\2\u01e2\u01e3\7\32\2")
        buf.write("\2\u01e3\u01e6\5\u00caf\2\u01e4\u01e5\7\u011b\2\2\u01e5")
        buf.write("\u01e7\5\30\r\2\u01e6\u01e4\3\2\2\2\u01e6\u01e7\3\2\2")
        buf.write("\2\u01e7\u03e8\3\2\2\2\u01e8\u01eb\7\64\2\2\u01e9\u01ea")
        buf.write("\7\u00b4\2\2\u01ea\u01ec\7\u00d1\2\2\u01eb\u01e9\3\2\2")
        buf.write("\2\u01eb\u01ec\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ee")
        buf.write("\7\u009a\2\2\u01ee\u01f2\7\u0117\2\2\u01ef\u01f0\7p\2")
        buf.write("\2\u01f0\u01f1\7\u00a8\2\2\u01f1\u01f3\7Y\2\2\u01f2\u01ef")
        buf.write("\3\2\2\2\u01f2\u01f3\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4")
        buf.write("\u01f7\5\u00caf\2\u01f5\u01f6\7-\2\2\u01f6\u01f8\5\u0090")
        buf.write("I\2\u01f7\u01f5\3\2\2\2\u01f7\u01f8\3\2\2\2\u01f8\u01fb")
        buf.write("\3\2\2\2\u01f9\u01fa\7\u011b\2\2\u01fa\u01fc\5\30\r\2")
        buf.write("\u01fb\u01f9\3\2\2\2\u01fb\u01fc\3\2\2\2\u01fc\u01fd\3")
        buf.write("\2\2\2\u01fd\u01fe\7\36\2\2\u01fe\u01ff\5\16\b\2\u01ff")
        buf.write("\u03e8\3\2\2\2\u0200\u0203\7\64\2\2\u0201\u0202\7\u00b4")
        buf.write("\2\2\u0202\u0204\7\u00d1\2\2\u0203\u0201\3\2\2\2\u0203")
        buf.write("\u0204\3\2\2\2\u0204\u0205\3\2\2\2\u0205\u0206\7\u0117")
        buf.write("\2\2\u0206\u0209\5\u00caf\2\u0207\u0208\7-\2\2\u0208\u020a")
        buf.write("\5\u0090I\2\u0209\u0207\3\2\2\2\u0209\u020a\3\2\2\2\u020a")
        buf.write("\u020d\3\2\2\2\u020b\u020c\7\u00e3\2\2\u020c\u020e\t\3")
        buf.write("\2\2\u020d\u020b\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u020f")
        buf.write("\3\2\2\2\u020f\u0210\7\36\2\2\u0210\u0211\5\16\b\2\u0211")
        buf.write("\u03e8\3\2\2\2\u0212\u0213\7\u00ce\2\2\u0213\u0214\7\u009a")
        buf.write("\2\2\u0214\u0215\7\u0117\2\2\u0215\u03e8\5\u00caf\2\u0216")
        buf.write("\u0217\7O\2\2\u0217\u0218\7\u009a\2\2\u0218\u021b\7\u0117")
        buf.write("\2\2\u0219\u021a\7p\2\2\u021a\u021c\7Y\2\2\u021b\u0219")
        buf.write("\3\2\2\2\u021b\u021c\3\2\2\2\u021c\u021d\3\2\2\2\u021d")
        buf.write("\u03e8\5\u00caf\2\u021e\u021f\7\31\2\2\u021f\u0220\7\u009a")
        buf.write("\2\2\u0220\u0223\7\u0117\2\2\u0221\u0222\7p\2\2\u0222")
        buf.write("\u0224\7Y\2\2\u0223\u0221\3\2\2\2\u0223\u0224\3\2\2\2")
        buf.write("\u0224\u0225\3\2\2\2\u0225\u0226\5\u00caf\2\u0226\u0227")
        buf.write("\7\u00cf\2\2\u0227\u0228\7\u00fa\2\2\u0228\u0229\5\u00ca")
        buf.write("f\2\u0229\u03e8\3\2\2\2\u022a\u022b\7\31\2\2\u022b\u022c")
        buf.write("\7\u009a\2\2\u022c\u022d\7\u0117\2\2\u022d\u022e\5\u00ca")
        buf.write("f\2\u022e\u022f\7\u00e8\2\2\u022f\u0230\7\u00c8\2\2\u0230")
        buf.write("\u0231\5\32\16\2\u0231\u03e8\3\2\2\2\u0232\u0233\7O\2")
        buf.write("\2\u0233\u0236\7\u0117\2\2\u0234\u0235\7p\2\2\u0235\u0237")
        buf.write("\7Y\2\2\u0236\u0234\3\2\2\2\u0236\u0237\3\2\2\2\u0237")
        buf.write("\u0238\3\2\2\2\u0238\u03e8\5\u00caf\2\u0239\u023a\7\31")
        buf.write("\2\2\u023a\u023b\7\u0117\2\2\u023b\u023c\5\u00caf\2\u023c")
        buf.write("\u023d\7\u00cf\2\2\u023d\u023e\7\u00fa\2\2\u023e\u023f")
        buf.write("\5\u00caf\2\u023f\u03e8\3\2\2\2\u0240\u0241\7\31\2\2\u0241")
        buf.write("\u0242\7\u0117\2\2\u0242\u0243\5\u00caf\2\u0243\u0244")
        buf.write("\7\u00e8\2\2\u0244\u0245\7!\2\2\u0245\u0246\5\u00d2j\2")
        buf.write("\u0246\u03e8\3\2\2\2\u0247\u0248\7&\2\2\u0248\u0249\5")
        buf.write("\u00caf\2\u0249\u0252\7\4\2\2\u024a\u024f\5\u00c2b\2\u024b")
        buf.write("\u024c\7\6\2\2\u024c\u024e\5\u00c2b\2\u024d\u024b\3\2")
        buf.write("\2\2\u024e\u0251\3\2\2\2\u024f\u024d\3\2\2\2\u024f\u0250")
        buf.write("\3\2\2\2\u0250\u0253\3\2\2\2\u0251\u024f\3\2\2\2\u0252")
        buf.write("\u024a\3\2\2\2\u0252\u0253\3\2\2\2\u0253\u0254\3\2\2\2")
        buf.write("\u0254\u0255\7\5\2\2\u0255\u03e8\3\2\2\2\u0256\u0257\7")
        buf.write("\64\2\2\u0257\u0258\7\u00d8\2\2\u0258\u025c\5\u00d6l\2")
        buf.write("\u0259\u025a\7\u011b\2\2\u025a\u025b\7\26\2\2\u025b\u025d")
        buf.write("\5\u00d0i\2\u025c\u0259\3\2\2\2\u025c\u025d\3\2\2\2\u025d")
        buf.write("\u0260\3\2\2\2\u025e\u025f\7r\2\2\u025f\u0261\5\u00d6")
        buf.write("l\2\u0260\u025e\3\2\2\2\u0260\u0261\3\2\2\2\u0261\u03e8")
        buf.write("\3\2\2\2\u0262\u0263\7O\2\2\u0263\u0264\7\u00d8\2\2\u0264")
        buf.write("\u0267\5\u00d6l\2\u0265\u0266\7r\2\2\u0266\u0268\5\u00d6")
        buf.write("l\2\u0267\u0265\3\2\2\2\u0267\u0268\3\2\2\2\u0268\u03e8")
        buf.write("\3\2\2\2\u0269\u026a\7g\2\2\u026a\u026b\5\u00d4k\2\u026b")
        buf.write("\u026c\7\u00fa\2\2\u026c\u0271\5\u00d2j\2\u026d\u026e")
        buf.write("\7\6\2\2\u026e\u0270\5\u00d2j\2\u026f\u026d\3\2\2\2\u0270")
        buf.write("\u0273\3\2\2\2\u0271\u026f\3\2\2\2\u0271\u0272\3\2\2\2")
        buf.write("\u0272\u0277\3\2\2\2\u0273\u0271\3\2\2\2\u0274\u0275\7")
        buf.write("\u011b\2\2\u0275\u0276\7\26\2\2\u0276\u0278\7\u00b3\2")
        buf.write("\2\u0277\u0274\3\2\2\2\u0277\u0278\3\2\2\2\u0278\u027c")
        buf.write("\3\2\2\2\u0279\u027a\7h\2\2\u027a\u027b\7%\2\2\u027b\u027d")
        buf.write("\5\u00d0i\2\u027c\u0279\3\2\2\2\u027c\u027d\3\2\2\2\u027d")
        buf.write("\u0280\3\2\2\2\u027e\u027f\7r\2\2\u027f\u0281\5\u00d6")
        buf.write("l\2\u0280\u027e\3\2\2\2\u0280\u0281\3\2\2\2\u0281\u03e8")
        buf.write("\3\2\2\2\u0282\u0286\7\u00d6\2\2\u0283\u0284\7\26\2\2")
        buf.write("\u0284\u0285\7\u00b3\2\2\u0285\u0287\7b\2\2\u0286\u0283")
        buf.write("\3\2\2\2\u0286\u0287\3\2\2\2\u0287\u0288\3\2\2\2\u0288")
        buf.write("\u0289\5\u00d4k\2\u0289\u028a\7d\2\2\u028a\u028f\5\u00d2")
        buf.write("j\2\u028b\u028c\7\6\2\2\u028c\u028e\5\u00d2j\2\u028d\u028b")
        buf.write("\3\2\2\2\u028e\u0291\3\2\2\2\u028f\u028d\3\2\2\2\u028f")
        buf.write("\u0290\3\2\2\2\u0290\u0295\3\2\2\2\u0291\u028f\3\2\2\2")
        buf.write("\u0292\u0293\7h\2\2\u0293\u0294\7%\2\2\u0294\u0296\5\u00d0")
        buf.write("i\2\u0295\u0292\3\2\2\2\u0295\u0296\3\2\2\2\u0296\u0299")
        buf.write("\3\2\2\2\u0297\u0298\7r\2\2\u0298\u029a\5\u00d6l\2\u0299")
        buf.write("\u0297\3\2\2\2\u0299\u029a\3\2\2\2\u029a\u03e8\3\2\2\2")
        buf.write("\u029b\u029c\7\u00e8\2\2\u029c\u02a0\7\u00d8\2\2\u029d")
        buf.write("\u02a1\7\30\2\2\u029e\u02a1\7\u00a6\2\2\u029f\u02a1\5")
        buf.write("\u00d6l\2\u02a0\u029d\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0")
        buf.write("\u029f\3\2\2\2\u02a1\u02a4\3\2\2\2\u02a2\u02a3\7r\2\2")
        buf.write("\u02a3\u02a5\5\u00d6l\2\u02a4\u02a2\3\2\2\2\u02a4\u02a5")
        buf.write("\3\2\2\2\u02a5\u03e8\3\2\2\2\u02a6\u02b1\7g\2\2\u02a7")
        buf.write("\u02ac\5\u00c8e\2\u02a8\u02a9\7\6\2\2\u02a9\u02ab\5\u00c8")
        buf.write("e\2\u02aa\u02a8\3\2\2\2\u02ab\u02ae\3\2\2\2\u02ac\u02aa")
        buf.write("\3\2\2\2\u02ac\u02ad\3\2\2\2\u02ad\u02b2\3\2\2\2\u02ae")
        buf.write("\u02ac\3\2\2\2\u02af\u02b0\7\30\2\2\u02b0\u02b2\7\u00c7")
        buf.write("\2\2\u02b1\u02a7\3\2\2\2\u02b1\u02af\3\2\2\2\u02b2\u02b3")
        buf.write("\3\2\2\2\u02b3\u02b5\7\u00b0\2\2\u02b4\u02b6\t\4\2\2\u02b5")
        buf.write("\u02b4\3\2\2\2\u02b5\u02b6\3\2\2\2\u02b6\u02b7\3\2\2\2")
        buf.write("\u02b7\u02b8\5\u00caf\2\u02b8\u02b9\7\u00fa\2\2\u02b9")
        buf.write("\u02bd\5\u00d2j\2\u02ba\u02bb\7\u011b\2\2\u02bb\u02bc")
        buf.write("\7g\2\2\u02bc\u02be\7\u00b3\2\2\u02bd\u02ba\3\2\2\2\u02bd")
        buf.write("\u02be\3\2\2\2\u02be\u03e8\3\2\2\2\u02bf\u02ca\7G\2\2")
        buf.write("\u02c0\u02c5\5\u00c8e\2\u02c1\u02c2\7\6\2\2\u02c2\u02c4")
        buf.write("\5\u00c8e\2\u02c3\u02c1\3\2\2\2\u02c4\u02c7\3\2\2\2\u02c5")
        buf.write("\u02c3\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6\u02cb\3\2\2\2")
        buf.write("\u02c7\u02c5\3\2\2\2\u02c8\u02c9\7\30\2\2\u02c9\u02cb")
        buf.write("\7\u00c7\2\2\u02ca\u02c0\3\2\2\2\u02ca\u02c8\3\2\2\2\u02cb")
        buf.write("\u02cc\3\2\2\2\u02cc\u02ce\7\u00b0\2\2\u02cd\u02cf\t\4")
        buf.write("\2\2\u02ce\u02cd\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02d0")
        buf.write("\3\2\2\2\u02d0\u02d1\5\u00caf\2\u02d1\u02d2\7\u00fa\2")
        buf.write("\2\u02d2\u02d3\5\u00d2j\2\u02d3\u03e8\3\2\2\2\u02d4\u02d8")
        buf.write("\7\u00d6\2\2\u02d5\u02d6\7g\2\2\u02d6\u02d7\7\u00b3\2")
        buf.write("\2\u02d7\u02d9\7b\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d9")
        buf.write("\3\2\2\2\u02d9\u02e4\3\2\2\2\u02da\u02df\5\u00c8e\2\u02db")
        buf.write("\u02dc\7\6\2\2\u02dc\u02de\5\u00c8e\2\u02dd\u02db\3\2")
        buf.write("\2\2\u02de\u02e1\3\2\2\2\u02df\u02dd\3\2\2\2\u02df\u02e0")
        buf.write("\3\2\2\2\u02e0\u02e5\3\2\2\2\u02e1\u02df\3\2\2\2\u02e2")
        buf.write("\u02e3\7\30\2\2\u02e3\u02e5\7\u00c7\2\2\u02e4\u02da\3")
        buf.write("\2\2\2\u02e4\u02e2\3\2\2\2\u02e5\u02e6\3\2\2\2\u02e6\u02e8")
        buf.write("\7\u00b0\2\2\u02e7\u02e9\t\4\2\2\u02e8\u02e7\3\2\2\2\u02e8")
        buf.write("\u02e9\3\2\2\2\u02e9\u02ea\3\2\2\2\u02ea\u02eb\5\u00ca")
        buf.write("f\2\u02eb\u02ec\7d\2\2\u02ec\u02ed\5\u00d2j\2\u02ed\u03e8")
        buf.write("\3\2\2\2\u02ee\u02ef\7\u00ea\2\2\u02ef\u02f5\7i\2\2\u02f0")
        buf.write("\u02f2\7\u00b0\2\2\u02f1\u02f3\7\u00f1\2\2\u02f2\u02f1")
        buf.write("\3\2\2\2\u02f2\u02f3\3\2\2\2\u02f3\u02f4\3\2\2\2\u02f4")
        buf.write("\u02f6\5\u00caf\2\u02f5\u02f0\3\2\2\2\u02f5\u02f6\3\2")
        buf.write("\2\2\u02f6\u03e8\3\2\2\2\u02f7\u0303\7Z\2\2\u02f8\u02f9")
        buf.write("\7\4\2\2\u02f9\u02fe\5\u00bc_\2\u02fa\u02fb\7\6\2\2\u02fb")
        buf.write("\u02fd\5\u00bc_\2\u02fc\u02fa\3\2\2\2\u02fd\u0300\3\2")
        buf.write("\2\2\u02fe\u02fc\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ff\u0301")
        buf.write("\3\2\2\2\u0300\u02fe\3\2\2\2\u0301\u0302\7\5\2\2\u0302")
        buf.write("\u0304\3\2\2\2\u0303\u02f8\3\2\2\2\u0303\u0304\3\2\2\2")
        buf.write("\u0304\u0305\3\2\2\2\u0305\u03e8\5\f\7\2\u0306\u0307\7")
        buf.write("Z\2\2\u0307\u0309\7\32\2\2\u0308\u030a\7\u0115\2\2\u0309")
        buf.write("\u0308\3\2\2\2\u0309\u030a\3\2\2\2\u030a\u030b\3\2\2\2")
        buf.write("\u030b\u03e8\5\f\7\2\u030c\u030d\7\u00ea\2\2\u030d\u030e")
        buf.write("\7\64\2\2\u030e\u030f\7\u00f1\2\2\u030f\u03e8\5\u00ca")
        buf.write("f\2\u0310\u0311\7\u00ea\2\2\u0311\u0312\7\64\2\2\u0312")
        buf.write("\u0313\7\u00e0\2\2\u0313\u03e8\5\u00caf\2\u0314\u0315")
        buf.write("\7\u00ea\2\2\u0315\u0316\7\64\2\2\u0316\u0317\7\u0117")
        buf.write("\2\2\u0317\u03e8\5\u00caf\2\u0318\u0319\7\u00ea\2\2\u0319")
        buf.write("\u031a\7\64\2\2\u031a\u031b\7\u009a\2\2\u031b\u031c\7")
        buf.write("\u0117\2\2\u031c\u03e8\5\u00caf\2\u031d\u031e\7\u00ea")
        buf.write("\2\2\u031e\u0321\7\u00f2\2\2\u031f\u0320\t\5\2\2\u0320")
        buf.write("\u0322\5\u00caf\2\u0321\u031f\3\2\2\2\u0321\u0322\3\2")
        buf.write("\2\2\u0322\u0329\3\2\2\2\u0323\u0324\7\u008e\2\2\u0324")
        buf.write("\u0327\5\u0090I\2\u0325\u0326\7U\2\2\u0326\u0328\5\u0090")
        buf.write("I\2\u0327\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u032a")
        buf.write("\3\2\2\2\u0329\u0323\3\2\2\2\u0329\u032a\3\2\2\2\u032a")
        buf.write("\u03e8\3\2\2\2\u032b\u032c\7\u00ea\2\2\u032c\u032f\7\u00e1")
        buf.write("\2\2\u032d\u032e\t\5\2\2\u032e\u0330\5\u00d6l\2\u032f")
        buf.write("\u032d\3\2\2\2\u032f\u0330\3\2\2\2\u0330\u0337\3\2\2\2")
        buf.write("\u0331\u0332\7\u008e\2\2\u0332\u0335\5\u0090I\2\u0333")
        buf.write("\u0334\7U\2\2\u0334\u0336\5\u0090I\2\u0335\u0333\3\2\2")
        buf.write("\2\u0335\u0336\3\2\2\2\u0336\u0338\3\2\2\2\u0337\u0331")
        buf.write("\3\2\2\2\u0337\u0338\3\2\2\2\u0338\u03e8\3\2\2\2\u0339")
        buf.write("\u033a\7\u00ea\2\2\u033a\u0341\7*\2\2\u033b\u033c\7\u008e")
        buf.write("\2\2\u033c\u033f\5\u0090I\2\u033d\u033e\7U\2\2\u033e\u0340")
        buf.write("\5\u0090I\2\u033f\u033d\3\2\2\2\u033f\u0340\3\2\2\2\u0340")
        buf.write("\u0342\3\2\2\2\u0341\u033b\3\2\2\2\u0341\u0342\3\2\2\2")
        buf.write("\u0342\u03e8\3\2\2\2\u0343\u0344\7\u00ea\2\2\u0344\u0345")
        buf.write("\7,\2\2\u0345\u0347\t\5\2\2\u0346\u0348\5\u00caf\2\u0347")
        buf.write("\u0346\3\2\2\2\u0347\u0348\3\2\2\2\u0348\u034f\3\2\2\2")
        buf.write("\u0349\u034a\7\u008e\2\2\u034a\u034d\5\u0090I\2\u034b")
        buf.write("\u034c\7U\2\2\u034c\u034e\5\u0090I\2\u034d\u034b\3\2\2")
        buf.write("\2\u034d\u034e\3\2\2\2\u034e\u0350\3\2\2\2\u034f\u0349")
        buf.write("\3\2\2\2\u034f\u0350\3\2\2\2\u0350\u03e8\3\2\2\2\u0351")
        buf.write("\u0352\7\u00ea\2\2\u0352\u0353\7\u00ed\2\2\u0353\u0354")
        buf.write("\7b\2\2\u0354\u03e8\5\u00caf\2\u0355\u0356\7\u00ea\2\2")
        buf.write("\u0356\u0357\7\u00ed\2\2\u0357\u0358\7b\2\2\u0358\u0359")
        buf.write("\7\4\2\2\u0359\u035a\5\16\b\2\u035a\u035b\7\5\2\2\u035b")
        buf.write("\u03e8\3\2\2\2\u035c\u035e\7\u00ea\2\2\u035d\u035f\7\67")
        buf.write("\2\2\u035e\u035d\3\2\2\2\u035e\u035f\3\2\2\2\u035f\u0360")
        buf.write("\3\2\2\2\u0360\u0363\7\u00d9\2\2\u0361\u0362\t\5\2\2\u0362")
        buf.write("\u0364\5\u00d6l\2\u0363\u0361\3\2\2\2\u0363\u0364\3\2")
        buf.write("\2\2\u0364\u03e8\3\2\2\2\u0365\u0366\7\u00ea\2\2\u0366")
        buf.write("\u0367\7\u00d8\2\2\u0367\u036a\7i\2\2\u0368\u0369\t\5")
        buf.write("\2\2\u0369\u036b\5\u00d6l\2\u036a\u0368\3\2\2\2\u036a")
        buf.write("\u036b\3\2\2\2\u036b\u03e8\3\2\2\2\u036c\u036d\7I\2\2")
        buf.write("\u036d\u03e8\5\u00caf\2\u036e\u036f\7H\2\2\u036f\u03e8")
        buf.write("\5\u00caf\2\u0370\u0371\7\u00ea\2\2\u0371\u0378\7f\2\2")
        buf.write("\u0372\u0373\7\u008e\2\2\u0373\u0376\5\u0090I\2\u0374")
        buf.write("\u0375\7U\2\2\u0375\u0377\5\u0090I\2\u0376\u0374\3\2\2")
        buf.write("\2\u0376\u0377\3\2\2\2\u0377\u0379\3\2\2\2\u0378\u0372")
        buf.write("\3\2\2\2\u0378\u0379\3\2\2\2\u0379\u03e8\3\2\2\2\u037a")
        buf.write("\u037b\7\u00ea\2\2\u037b\u0382\7\u00e7\2\2\u037c\u037d")
        buf.write("\7\u008e\2\2\u037d\u0380\5\u0090I\2\u037e\u037f\7U\2\2")
        buf.write("\u037f\u0381\5\u0090I\2\u0380\u037e\3\2\2\2\u0380\u0381")
        buf.write("\3\2\2\2\u0381\u0383\3\2\2\2\u0382\u037c\3\2\2\2\u0382")
        buf.write("\u0383\3\2\2\2\u0383\u03e8\3\2\2\2\u0384\u0385\7\u00e8")
        buf.write("\2\2\u0385\u0386\7\u00e7\2\2\u0386\u0387\5\u00caf\2\u0387")
        buf.write("\u0388\7\u0123\2\2\u0388\u0389\5p9\2\u0389\u03e8\3\2\2")
        buf.write("\2\u038a\u038b\7\u00d2\2\2\u038b\u038c\7\u00e7\2\2\u038c")
        buf.write("\u03e8\5\u00caf\2\u038d\u038e\7\u00ec\2\2\u038e\u0397")
        buf.write("\7\u00fc\2\2\u038f\u0394\5\u00be`\2\u0390\u0391\7\6\2")
        buf.write("\2\u0391\u0393\5\u00be`\2\u0392\u0390\3\2\2\2\u0393\u0396")
        buf.write("\3\2\2\2\u0394\u0392\3\2\2\2\u0394\u0395\3\2\2\2\u0395")
        buf.write("\u0398\3\2\2\2\u0396\u0394\3\2\2\2\u0397\u038f\3\2\2\2")
        buf.write("\u0397\u0398\3\2\2\2\u0398\u03e8\3\2\2\2\u0399\u039b\7")
        buf.write(".\2\2\u039a\u039c\7\u011e\2\2\u039b\u039a\3\2\2\2\u039b")
        buf.write("\u039c\3\2\2\2\u039c\u03e8\3\2\2\2\u039d\u039f\7\u00da")
        buf.write("\2\2\u039e\u03a0\7\u011e\2\2\u039f\u039e\3\2\2\2\u039f")
        buf.write("\u03a0\3\2\2\2\u03a0\u03e8\3\2\2\2\u03a1\u03a2\7\u00c6")
        buf.write("\2\2\u03a2\u03a3\5\u00d6l\2\u03a3\u03a4\7d\2\2\u03a4\u03a5")
        buf.write("\5\f\7\2\u03a5\u03e8\3\2\2\2\u03a6\u03a7\7C\2\2\u03a7")
        buf.write("\u03a8\7\u00c6\2\2\u03a8\u03e8\5\u00d6l\2\u03a9\u03aa")
        buf.write("\7X\2\2\u03aa\u03b4\5\u00d6l\2\u03ab\u03ac\7\u010e\2\2")
        buf.write("\u03ac\u03b1\5p9\2\u03ad\u03ae\7\6\2\2\u03ae\u03b0\5p")
        buf.write("9\2\u03af\u03ad\3\2\2\2\u03b0\u03b3\3\2\2\2\u03b1\u03af")
        buf.write("\3\2\2\2\u03b1\u03b2\3\2\2\2\u03b2\u03b5\3\2\2\2\u03b3")
        buf.write("\u03b1\3\2\2\2\u03b4\u03ab\3\2\2\2\u03b4\u03b5\3\2\2\2")
        buf.write("\u03b5\u03e8\3\2\2\2\u03b6\u03b7\7I\2\2\u03b7\u03b8\7")
        buf.write("v\2\2\u03b8\u03e8\5\u00d6l\2\u03b9\u03ba\7I\2\2\u03ba")
        buf.write("\u03bb\7\u00b8\2\2\u03bb\u03e8\5\u00d6l\2\u03bc\u03bd")
        buf.write("\7\u00e8\2\2\u03bd\u03be\7\u00bf\2\2\u03be\u03e8\5\u00c6")
        buf.write("d\2\u03bf\u03c0\7\u00e8\2\2\u03c0\u03c1\7\u00f8\2\2\u03c1")
        buf.write("\u03c4\7\u0122\2\2\u03c2\u03c5\7\u0091\2\2\u03c3\u03c5")
        buf.write("\5p9\2\u03c4\u03c2\3\2\2\2\u03c4\u03c3\3\2\2\2\u03c5\u03e8")
        buf.write("\3\2\2\2\u03c6\u03c7\7\u010b\2\2\u03c7\u03c8\5\u00caf")
        buf.write("\2\u03c8\u03c9\7\u00e8\2\2\u03c9\u03ce\5\u00ba^\2\u03ca")
        buf.write("\u03cb\7\6\2\2\u03cb\u03cd\5\u00ba^\2\u03cc\u03ca\3\2")
        buf.write("\2\2\u03cd\u03d0\3\2\2\2\u03ce\u03cc\3\2\2\2\u03ce\u03cf")
        buf.write("\3\2\2\2\u03cf\u03d3\3\2\2\2\u03d0\u03ce\3\2\2\2\u03d1")
        buf.write("\u03d2\7\u0119\2\2\u03d2\u03d4\5r:\2\u03d3\u03d1\3\2\2")
        buf.write("\2\u03d3\u03d4\3\2\2\2\u03d4\u03e8\3\2\2\2\u03d5\u03d6")
        buf.write("\7\u009c\2\2\u03d6\u03d7\7z\2\2\u03d7\u03dc\5\u00caf\2")
        buf.write("\u03d8\u03da\7\36\2\2\u03d9\u03d8\3\2\2\2\u03d9\u03da")
        buf.write("\3\2\2\2\u03da\u03db\3\2\2\2\u03db\u03dd\5\u00d6l\2\u03dc")
        buf.write("\u03d9\3\2\2\2\u03dc\u03dd\3\2\2\2\u03dd\u03de\3\2\2\2")
        buf.write("\u03de\u03df\7\u010e\2\2\u03df\u03e0\5> \2\u03e0\u03e1")
        buf.write("\7\u00b0\2\2\u03e1\u03e3\5p9\2\u03e2\u03e4\5\u00aaV\2")
        buf.write("\u03e3\u03e2\3\2\2\2\u03e4\u03e5\3\2\2\2\u03e5\u03e3\3")
        buf.write("\2\2\2\u03e5\u03e6\3\2\2\2\u03e6\u03e8\3\2\2\2\u03e7\u00eb")
        buf.write("\3\2\2\2\u03e7\u00ec\3\2\2\2\u03e7\u00ee\3\2\2\2\u03e7")
        buf.write("\u00f3\3\2\2\2\u03e7\u0103\3\2\2\2\u03e7\u010d\3\2\2\2")
        buf.write("\u03e7\u0114\3\2\2\2\u03e7\u011b\3\2\2\2\u03e7\u013d\3")
        buf.write("\2\2\2\u03e7\u0157\3\2\2\2\u03e7\u015e\3\2\2\2\u03e7\u0166")
        buf.write("\3\2\2\2\u03e7\u016d\3\2\2\2\u03e7\u0170\3\2\2\2\u03e7")
        buf.write("\u0179\3\2\2\2\u03e7\u0182\3\2\2\2\u03e7\u018d\3\2\2\2")
        buf.write("\u03e7\u019d\3\2\2\2\u03e7\u01ae\3\2\2\2\u03e7\u01bd\3")
        buf.write("\2\2\2\u03e7\u01c4\3\2\2\2\u03e7\u01cb\3\2\2\2\u03e7\u01e2")
        buf.write("\3\2\2\2\u03e7\u01e8\3\2\2\2\u03e7\u0200\3\2\2\2\u03e7")
        buf.write("\u0212\3\2\2\2\u03e7\u0216\3\2\2\2\u03e7\u021e\3\2\2\2")
        buf.write("\u03e7\u022a\3\2\2\2\u03e7\u0232\3\2\2\2\u03e7\u0239\3")
        buf.write("\2\2\2\u03e7\u0240\3\2\2\2\u03e7\u0247\3\2\2\2\u03e7\u0256")
        buf.write("\3\2\2\2\u03e7\u0262\3\2\2\2\u03e7\u0269\3\2\2\2\u03e7")
        buf.write("\u0282\3\2\2\2\u03e7\u029b\3\2\2\2\u03e7\u02a6\3\2\2\2")
        buf.write("\u03e7\u02bf\3\2\2\2\u03e7\u02d4\3\2\2\2\u03e7\u02ee\3")
        buf.write("\2\2\2\u03e7\u02f7\3\2\2\2\u03e7\u0306\3\2\2\2\u03e7\u030c")
        buf.write("\3\2\2\2\u03e7\u0310\3\2\2\2\u03e7\u0314\3\2\2\2\u03e7")
        buf.write("\u0318\3\2\2\2\u03e7\u031d\3\2\2\2\u03e7\u032b\3\2\2\2")
        buf.write("\u03e7\u0339\3\2\2\2\u03e7\u0343\3\2\2\2\u03e7\u0351\3")
        buf.write("\2\2\2\u03e7\u0355\3\2\2\2\u03e7\u035c\3\2\2\2\u03e7\u0365")
        buf.write("\3\2\2\2\u03e7\u036c\3\2\2\2\u03e7\u036e\3\2\2\2\u03e7")
        buf.write("\u0370\3\2\2\2\u03e7\u037a\3\2\2\2\u03e7\u0384\3\2\2\2")
        buf.write("\u03e7\u038a\3\2\2\2\u03e7\u038d\3\2\2\2\u03e7\u0399\3")
        buf.write("\2\2\2\u03e7\u039d\3\2\2\2\u03e7\u03a1\3\2\2\2\u03e7\u03a6")
        buf.write("\3\2\2\2\u03e7\u03a9\3\2\2\2\u03e7\u03b6\3\2\2\2\u03e7")
        buf.write("\u03b9\3\2\2\2\u03e7\u03bc\3\2\2\2\u03e7\u03bf\3\2\2\2")
        buf.write("\u03e7\u03c6\3\2\2\2\u03e7\u03d5\3\2\2\2\u03e8\r\3\2\2")
        buf.write("\2\u03e9\u03eb\5\20\t\2\u03ea\u03e9\3\2\2\2\u03ea\u03eb")
        buf.write("\3\2\2\2\u03eb\u03ec\3\2\2\2\u03ec\u03ed\5 \21\2\u03ed")
        buf.write("\17\3\2\2\2\u03ee\u03f0\7\u011b\2\2\u03ef\u03f1\7\u00cd")
        buf.write("\2\2\u03f0\u03ef\3\2\2\2\u03f0\u03f1\3\2\2\2\u03f1\u03f2")
        buf.write("\3\2\2\2\u03f2\u03f7\58\35\2\u03f3\u03f4\7\6\2\2\u03f4")
        buf.write("\u03f6\58\35\2\u03f5\u03f3\3\2\2\2\u03f6\u03f9\3\2\2\2")
        buf.write("\u03f7\u03f5\3\2\2\2\u03f7\u03f8\3\2\2\2\u03f8\21\3\2")
        buf.write("\2\2\u03f9\u03f7\3\2\2\2\u03fa\u03fd\5\24\13\2\u03fb\u03fd")
        buf.write("\5\26\f\2\u03fc\u03fa\3\2\2\2\u03fc\u03fb\3\2\2\2\u03fd")
        buf.write("\23\3\2\2\2\u03fe\u03ff\5\u00d6l\2\u03ff\u0402\5\u00a0")
        buf.write("Q\2\u0400\u0401\7\u00a8\2\2\u0401\u0403\7\u00a9\2\2\u0402")
        buf.write("\u0400\3\2\2\2\u0402\u0403\3\2\2\2\u0403\u0406\3\2\2\2")
        buf.write("\u0404\u0405\7-\2\2\u0405\u0407\5\u0090I\2\u0406\u0404")
        buf.write("\3\2\2\2\u0406\u0407\3\2\2\2\u0407\u040a\3\2\2\2\u0408")
        buf.write("\u0409\7\u011b\2\2\u0409\u040b\5\30\r\2\u040a\u0408\3")
        buf.write("\2\2\2\u040a\u040b\3\2\2\2\u040b\25\3\2\2\2\u040c\u040d")
        buf.write("\7\u008e\2\2\u040d\u0410\5\u00caf\2\u040e\u040f\t\6\2")
        buf.write("\2\u040f\u0411\7\u00c8\2\2\u0410\u040e\3\2\2\2\u0410\u0411")
        buf.write("\3\2\2\2\u0411\27\3\2\2\2\u0412\u0413\7\4\2\2\u0413\u0414")
        buf.write("\5\32\16\2\u0414\u0415\7\5\2\2\u0415\31\3\2\2\2\u0416")
        buf.write("\u041b\5\34\17\2\u0417\u0418\7\6\2\2\u0418\u041a\5\34")
        buf.write("\17\2\u0419\u0417\3\2\2\2\u041a\u041d\3\2\2\2\u041b\u0419")
        buf.write("\3\2\2\2\u041b\u041c\3\2\2\2\u041c\33\3\2\2\2\u041d\u041b")
        buf.write("\3\2\2\2\u041e\u041f\5\u00d6l\2\u041f\u0420\7\u0123\2")
        buf.write("\2\u0420\u0421\5\36\20\2\u0421\35\3\2\2\2\u0422\u0425")
        buf.write("\7D\2\2\u0423\u0425\5p9\2\u0424\u0422\3\2\2\2\u0424\u0423")
        buf.write("\3\2\2\2\u0425\37\3\2\2\2\u0426\u0431\5&\24\2\u0427\u0428")
        buf.write("\7\u00b5\2\2\u0428\u0429\7%\2\2\u0429\u042e\5*\26\2\u042a")
        buf.write("\u042b\7\6\2\2\u042b\u042d\5*\26\2\u042c\u042a\3\2\2\2")
        buf.write("\u042d\u0430\3\2\2\2\u042e\u042c\3\2\2\2\u042e\u042f\3")
        buf.write("\2\2\2\u042f\u0432\3\2\2\2\u0430\u042e\3\2\2\2\u0431\u0427")
        buf.write("\3\2\2\2\u0431\u0432\3\2\2\2\u0432\u0438\3\2\2\2\u0433")
        buf.write("\u0434\7\u00ad\2\2\u0434\u0436\5$\23\2\u0435\u0437\t\7")
        buf.write("\2\2\u0436\u0435\3\2\2\2\u0436\u0437\3\2\2\2\u0437\u0439")
        buf.write("\3\2\2\2\u0438\u0433\3\2\2\2\u0438\u0439\3\2\2\2\u0439")
        buf.write("\u0447\3\2\2\2\u043a\u043b\7\u008f\2\2\u043b\u0448\5\"")
        buf.write("\22\2\u043c\u043d\7]\2\2\u043d\u043f\t\b\2\2\u043e\u0440")
        buf.write("\5$\23\2\u043f\u043e\3\2\2\2\u043f\u0440\3\2\2\2\u0440")
        buf.write("\u0441\3\2\2\2\u0441\u0445\t\7\2\2\u0442\u0446\7\u00b2")
        buf.write("\2\2\u0443\u0444\7\u011b\2\2\u0444\u0446\7\u00f7\2\2\u0445")
        buf.write("\u0442\3\2\2\2\u0445\u0443\3\2\2\2\u0446\u0448\3\2\2\2")
        buf.write("\u0447\u043a\3\2\2\2\u0447\u043c\3\2\2\2\u0447\u0448\3")
        buf.write("\2\2\2\u0448!\3\2\2\2\u0449\u044c\7\30\2\2\u044a\u044c")
        buf.write("\5$\23\2\u044b\u0449\3\2\2\2\u044b\u044a\3\2\2\2\u044c")
        buf.write("#\3\2\2\2\u044d\u044e\t\t\2\2\u044e%\3\2\2\2\u044f\u0450")
        buf.write("\b\24\1\2\u0450\u0451\5(\25\2\u0451\u0460\3\2\2\2\u0452")
        buf.write("\u0453\f\4\2\2\u0453\u0455\7x\2\2\u0454\u0456\5:\36\2")
        buf.write("\u0455\u0454\3\2\2\2\u0455\u0456\3\2\2\2\u0456\u0457\3")
        buf.write("\2\2\2\u0457\u045f\5&\24\5\u0458\u0459\f\3\2\2\u0459\u045b")
        buf.write("\t\n\2\2\u045a\u045c\5:\36\2\u045b\u045a\3\2\2\2\u045b")
        buf.write("\u045c\3\2\2\2\u045c\u045d\3\2\2\2\u045d\u045f\5&\24\4")
        buf.write("\u045e\u0452\3\2\2\2\u045e\u0458\3\2\2\2\u045f\u0462\3")
        buf.write("\2\2\2\u0460\u045e\3\2\2\2\u0460\u0461\3\2\2\2\u0461\'")
        buf.write("\3\2\2\2\u0462\u0460\3\2\2\2\u0463\u0474\5,\27\2\u0464")
        buf.write("\u0465\7\u00f1\2\2\u0465\u0474\5\u00caf\2\u0466\u0467")
        buf.write("\7\u0114\2\2\u0467\u046c\5p9\2\u0468\u0469\7\6\2\2\u0469")
        buf.write("\u046b\5p9\2\u046a\u0468\3\2\2\2\u046b\u046e\3\2\2\2\u046c")
        buf.write("\u046a\3\2\2\2\u046c\u046d\3\2\2\2\u046d\u0474\3\2\2\2")
        buf.write("\u046e\u046c\3\2\2\2\u046f\u0470\7\4\2\2\u0470\u0471\5")
        buf.write(" \21\2\u0471\u0472\7\5\2\2\u0472\u0474\3\2\2\2\u0473\u0463")
        buf.write("\3\2\2\2\u0473\u0464\3\2\2\2\u0473\u0466\3\2\2\2\u0473")
        buf.write("\u046f\3\2\2\2\u0474)\3\2\2\2\u0475\u0477\5p9\2\u0476")
        buf.write("\u0478\t\13\2\2\u0477\u0476\3\2\2\2\u0477\u0478\3\2\2")
        buf.write("\2\u0478\u047b\3\2\2\2\u0479\u047a\7\u00ab\2\2\u047a\u047c")
        buf.write("\t\f\2\2\u047b\u0479\3\2\2\2\u047b\u047c\3\2\2\2\u047c")
        buf.write("+\3\2\2\2\u047d\u047f\7\u00e5\2\2\u047e\u0480\5:\36\2")
        buf.write("\u047f\u047e\3\2\2\2\u047f\u0480\3\2\2\2\u0480\u0481\3")
        buf.write("\2\2\2\u0481\u0486\5<\37\2\u0482\u0483\7\6\2\2\u0483\u0485")
        buf.write("\5<\37\2\u0484\u0482\3\2\2\2\u0485\u0488\3\2\2\2\u0486")
        buf.write("\u0484\3\2\2\2\u0486\u0487\3\2\2\2\u0487\u0492\3\2\2\2")
        buf.write("\u0488\u0486\3\2\2\2\u0489\u048a\7d\2\2\u048a\u048f\5")
        buf.write("> \2\u048b\u048c\7\6\2\2\u048c\u048e\5> \2\u048d\u048b")
        buf.write("\3\2\2\2\u048e\u0491\3\2\2\2\u048f\u048d\3\2\2\2\u048f")
        buf.write("\u0490\3\2\2\2\u0490\u0493\3\2\2\2\u0491\u048f\3\2\2\2")
        buf.write("\u0492\u0489\3\2\2\2\u0492\u0493\3\2\2\2\u0493\u0496\3")
        buf.write("\2\2\2\u0494\u0495\7\u0119\2\2\u0495\u0497\5r:\2\u0496")
        buf.write("\u0494\3\2\2\2\u0496\u0497\3\2\2\2\u0497\u049b\3\2\2\2")
        buf.write("\u0498\u0499\7k\2\2\u0499\u049a\7%\2\2\u049a\u049c\5.")
        buf.write("\30\2\u049b\u0498\3\2\2\2\u049b\u049c\3\2\2\2\u049c\u049f")
        buf.write("\3\2\2\2\u049d\u049e\7n\2\2\u049e\u04a0\5r:\2\u049f\u049d")
        buf.write("\3\2\2\2\u049f\u04a0\3\2\2\2\u04a0\u04aa\3\2\2\2\u04a1")
        buf.write("\u04a2\7\u011a\2\2\u04a2\u04a7\5\64\33\2\u04a3\u04a4\7")
        buf.write("\6\2\2\u04a4\u04a6\5\64\33\2\u04a5\u04a3\3\2\2\2\u04a6")
        buf.write("\u04a9\3\2\2\2\u04a7\u04a5\3\2\2\2\u04a7\u04a8\3\2\2\2")
        buf.write("\u04a8\u04ab\3\2\2\2\u04a9\u04a7\3\2\2\2\u04aa\u04a1\3")
        buf.write("\2\2\2\u04aa\u04ab\3\2\2\2\u04ab-\3\2\2\2\u04ac\u04ae")
        buf.write("\5:\36\2\u04ad\u04ac\3\2\2\2\u04ad\u04ae\3\2\2\2\u04ae")
        buf.write("\u04af\3\2\2\2\u04af\u04b4\5\60\31\2\u04b0\u04b1\7\6\2")
        buf.write("\2\u04b1\u04b3\5\60\31\2\u04b2\u04b0\3\2\2\2\u04b3\u04b6")
        buf.write("\3\2\2\2\u04b4\u04b2\3\2\2\2\u04b4\u04b5\3\2\2\2\u04b5")
        buf.write("/\3\2\2\2\u04b6\u04b4\3\2\2\2\u04b7\u04e0\5\62\32\2\u04b8")
        buf.write("\u04b9\7\u00db\2\2\u04b9\u04c2\7\4\2\2\u04ba\u04bf\5p")
        buf.write("9\2\u04bb\u04bc\7\6\2\2\u04bc\u04be\5p9\2\u04bd\u04bb")
        buf.write("\3\2\2\2\u04be\u04c1\3\2\2\2\u04bf\u04bd\3\2\2\2\u04bf")
        buf.write("\u04c0\3\2\2\2\u04c0\u04c3\3\2\2\2\u04c1\u04bf\3\2\2\2")
        buf.write("\u04c2\u04ba\3\2\2\2\u04c2\u04c3\3\2\2\2\u04c3\u04c4\3")
        buf.write("\2\2\2\u04c4\u04e0\7\5\2\2\u04c5\u04c6\7\66\2\2\u04c6")
        buf.write("\u04cf\7\4\2\2\u04c7\u04cc\5p9\2\u04c8\u04c9\7\6\2\2\u04c9")
        buf.write("\u04cb\5p9\2\u04ca\u04c8\3\2\2\2\u04cb\u04ce\3\2\2\2\u04cc")
        buf.write("\u04ca\3\2\2\2\u04cc\u04cd\3\2\2\2\u04cd\u04d0\3\2\2\2")
        buf.write("\u04ce\u04cc\3\2\2\2\u04cf\u04c7\3\2\2\2\u04cf\u04d0\3")
        buf.write("\2\2\2\u04d0\u04d1\3\2\2\2\u04d1\u04e0\7\5\2\2\u04d2\u04d3")
        buf.write("\7l\2\2\u04d3\u04d4\7\u00e9\2\2\u04d4\u04d5\7\4\2\2\u04d5")
        buf.write("\u04da\5\62\32\2\u04d6\u04d7\7\6\2\2\u04d7\u04d9\5\62")
        buf.write("\32\2\u04d8\u04d6\3\2\2\2\u04d9\u04dc\3\2\2\2\u04da\u04d8")
        buf.write("\3\2\2\2\u04da\u04db\3\2\2\2\u04db\u04dd\3\2\2\2\u04dc")
        buf.write("\u04da\3\2\2\2\u04dd\u04de\7\5\2\2\u04de\u04e0\3\2\2\2")
        buf.write("\u04df\u04b7\3\2\2\2\u04df\u04b8\3\2\2\2\u04df\u04c5\3")
        buf.write("\2\2\2\u04df\u04d2\3\2\2\2\u04e0\61\3\2\2\2\u04e1\u04ea")
        buf.write("\7\4\2\2\u04e2\u04e7\5p9\2\u04e3\u04e4\7\6\2\2\u04e4\u04e6")
        buf.write("\5p9\2\u04e5\u04e3\3\2\2\2\u04e6\u04e9\3\2\2\2\u04e7\u04e5")
        buf.write("\3\2\2\2\u04e7\u04e8\3\2\2\2\u04e8\u04eb\3\2\2\2\u04e9")
        buf.write("\u04e7\3\2\2\2\u04ea\u04e2\3\2\2\2\u04ea\u04eb\3\2\2\2")
        buf.write("\u04eb\u04ec\3\2\2\2\u04ec\u04ef\7\5\2\2\u04ed\u04ef\5")
        buf.write("p9\2\u04ee\u04e1\3\2\2\2\u04ee\u04ed\3\2\2\2\u04ef\63")
        buf.write("\3\2\2\2\u04f0\u04f1\5\u00d6l\2\u04f1\u04f2\7\36\2\2\u04f2")
        buf.write("\u04f3\7\4\2\2\u04f3\u04f4\5\66\34\2\u04f4\u04f5\7\5\2")
        buf.write("\2\u04f5\65\3\2\2\2\u04f6\u04f8\5\u00d6l\2\u04f7\u04f6")
        buf.write("\3\2\2\2\u04f7\u04f8\3\2\2\2\u04f8\u0503\3\2\2\2\u04f9")
        buf.write("\u04fa\7\u00bb\2\2\u04fa\u04fb\7%\2\2\u04fb\u0500\5p9")
        buf.write("\2\u04fc\u04fd\7\6\2\2\u04fd\u04ff\5p9\2\u04fe\u04fc\3")
        buf.write("\2\2\2\u04ff\u0502\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u0501")
        buf.write("\3\2\2\2\u0501\u0504\3\2\2\2\u0502\u0500\3\2\2\2\u0503")
        buf.write("\u04f9\3\2\2\2\u0503\u0504\3\2\2\2\u0504\u050f\3\2\2\2")
        buf.write("\u0505\u0506\7\u00b5\2\2\u0506\u0507\7%\2\2\u0507\u050c")
        buf.write("\5*\26\2\u0508\u0509\7\6\2\2\u0509\u050b\5*\26\2\u050a")
        buf.write("\u0508\3\2\2\2\u050b\u050e\3\2\2\2\u050c\u050a\3\2\2\2")
        buf.write("\u050c\u050d\3\2\2\2\u050d\u0510\3\2\2\2\u050e\u050c\3")
        buf.write("\2\2\2\u050f\u0505\3\2\2\2\u050f\u0510\3\2\2\2\u0510\u0512")
        buf.write("\3\2\2\2\u0511\u0513\5\u00aeX\2\u0512\u0511\3\2\2\2\u0512")
        buf.write("\u0513\3\2\2\2\u0513\67\3\2\2\2\u0514\u0516\5\u00d6l\2")
        buf.write("\u0515\u0517\5^\60\2\u0516\u0515\3\2\2\2\u0516\u0517\3")
        buf.write("\2\2\2\u0517\u0518\3\2\2\2\u0518\u0519\7\36\2\2\u0519")
        buf.write("\u051a\7\4\2\2\u051a\u051b\5\16\b\2\u051b\u051c\7\5\2")
        buf.write("\2\u051c9\3\2\2\2\u051d\u051e\t\r\2\2\u051e;\3\2\2\2\u051f")
        buf.write("\u0524\5p9\2\u0520\u0522\7\36\2\2\u0521\u0520\3\2\2\2")
        buf.write("\u0521\u0522\3\2\2\2\u0522\u0523\3\2\2\2\u0523\u0525\5")
        buf.write("\u00d6l\2\u0524\u0521\3\2\2\2\u0524\u0525\3\2\2\2\u0525")
        buf.write("\u052f\3\2\2\2\u0526\u0527\5x=\2\u0527\u0528\7\3\2\2\u0528")
        buf.write("\u052b\7\u012b\2\2\u0529\u052a\7\36\2\2\u052a\u052c\5")
        buf.write("^\60\2\u052b\u0529\3\2\2\2\u052b\u052c\3\2\2\2\u052c\u052f")
        buf.write("\3\2\2\2\u052d\u052f\7\u012b\2\2\u052e\u051f\3\2\2\2\u052e")
        buf.write("\u0526\3\2\2\2\u052e\u052d\3\2\2\2\u052f=\3\2\2\2\u0530")
        buf.write("\u0531\b \1\2\u0531\u0532\5D#\2\u0532\u0545\3\2\2\2\u0533")
        buf.write("\u0541\f\4\2\2\u0534\u0535\7\65\2\2\u0535\u0536\7\177")
        buf.write("\2\2\u0536\u0542\5D#\2\u0537\u0538\5@!\2\u0538\u0539\7")
        buf.write("\177\2\2\u0539\u053a\5> \2\u053a\u053b\5B\"\2\u053b\u0542")
        buf.write("\3\2\2\2\u053c\u053d\7\u009f\2\2\u053d\u053e\5@!\2\u053e")
        buf.write("\u053f\7\177\2\2\u053f\u0540\5D#\2\u0540\u0542\3\2\2\2")
        buf.write("\u0541\u0534\3\2\2\2\u0541\u0537\3\2\2\2\u0541\u053c\3")
        buf.write("\2\2\2\u0542\u0544\3\2\2\2\u0543\u0533\3\2\2\2\u0544\u0547")
        buf.write("\3\2\2\2\u0545\u0543\3\2\2\2\u0545\u0546\3\2\2\2\u0546")
        buf.write("?\3\2\2\2\u0547\u0545\3\2\2\2\u0548\u054a\7u\2\2\u0549")
        buf.write("\u0548\3\2\2\2\u0549\u054a\3\2\2\2\u054a\u0558\3\2\2\2")
        buf.write("\u054b\u054d\7\u008c\2\2\u054c\u054e\7\u00b7\2\2\u054d")
        buf.write("\u054c\3\2\2\2\u054d\u054e\3\2\2\2\u054e\u0558\3\2\2\2")
        buf.write("\u054f\u0551\7\u00d7\2\2\u0550\u0552\7\u00b7\2\2\u0551")
        buf.write("\u0550\3\2\2\2\u0551\u0552\3\2\2\2\u0552\u0558\3\2\2\2")
        buf.write("\u0553\u0555\7e\2\2\u0554\u0556\7\u00b7\2\2\u0555\u0554")
        buf.write("\3\2\2\2\u0555\u0556\3\2\2\2\u0556\u0558\3\2\2\2\u0557")
        buf.write("\u0549\3\2\2\2\u0557\u054b\3\2\2\2\u0557\u054f\3\2\2\2")
        buf.write("\u0557\u0553\3\2\2\2\u0558A\3\2\2\2\u0559\u055a\7\u00b0")
        buf.write("\2\2\u055a\u0568\5r:\2\u055b\u055c\7\u010e\2\2\u055c\u055d")
        buf.write("\7\4\2\2\u055d\u0562\5\u00d6l\2\u055e\u055f\7\6\2\2\u055f")
        buf.write("\u0561\5\u00d6l\2\u0560\u055e\3\2\2\2\u0561\u0564\3\2")
        buf.write("\2\2\u0562\u0560\3\2\2\2\u0562\u0563\3\2\2\2\u0563\u0565")
        buf.write("\3\2\2\2\u0564\u0562\3\2\2\2\u0565\u0566\7\5\2\2\u0566")
        buf.write("\u0568\3\2\2\2\u0567\u0559\3\2\2\2\u0567\u055b\3\2\2\2")
        buf.write("\u0568C\3\2\2\2\u0569\u0570\5N(\2\u056a\u056b\7\u00f3")
        buf.write("\2\2\u056b\u056c\5F$\2\u056c\u056d\7\4\2\2\u056d\u056e")
        buf.write("\5p9\2\u056e\u056f\7\5\2\2\u056f\u0571\3\2\2\2\u0570\u056a")
        buf.write("\3\2\2\2\u0570\u0571\3\2\2\2\u0571E\3\2\2\2\u0572\u0573")
        buf.write("\t\16\2\2\u0573G\3\2\2\2\u0574\u0575\t\17\2\2\u0575I\3")
        buf.write("\2\2\2\u0576\u057d\7T\2\2\u0577\u0579\7\u00ff\2\2\u0578")
        buf.write("\u057a\5\u0090I\2\u0579\u0578\3\2\2\2\u0579\u057a\3\2")
        buf.write("\2\2\u057a\u057b\3\2\2\2\u057b\u057d\5L\'\2\u057c\u0576")
        buf.write("\3\2\2\2\u057c\u0577\3\2\2\2\u057dK\3\2\2\2\u057e\u057f")
        buf.write("\7\u011b\2\2\u057f\u0583\7\62\2\2\u0580\u0581\7\u011d")
        buf.write("\2\2\u0581\u0583\7\62\2\2\u0582\u057e\3\2\2\2\u0582\u0580")
        buf.write("\3\2\2\2\u0583M\3\2\2\2\u0584\u05d7\5\\/\2\u0585\u0586")
        buf.write("\7\u0099\2\2\u0586\u0591\7\4\2\2\u0587\u0588\7\u00bb\2")
        buf.write("\2\u0588\u0589\7%\2\2\u0589\u058e\5p9\2\u058a\u058b\7")
        buf.write("\6\2\2\u058b\u058d\5p9\2\u058c\u058a\3\2\2\2\u058d\u0590")
        buf.write("\3\2\2\2\u058e\u058c\3\2\2\2\u058e\u058f\3\2\2\2\u058f")
        buf.write("\u0592\3\2\2\2\u0590\u058e\3\2\2\2\u0591\u0587\3\2\2\2")
        buf.write("\u0591\u0592\3\2\2\2\u0592\u059d\3\2\2\2\u0593\u0594\7")
        buf.write("\u00b5\2\2\u0594\u0595\7%\2\2\u0595\u059a\5*\26\2\u0596")
        buf.write("\u0597\7\6\2\2\u0597\u0599\5*\26\2\u0598\u0596\3\2\2\2")
        buf.write("\u0599\u059c\3\2\2\2\u059a\u0598\3\2\2\2\u059a\u059b\3")
        buf.write("\2\2\2\u059b\u059e\3\2\2\2\u059c\u059a\3\2\2\2\u059d\u0593")
        buf.write("\3\2\2\2\u059d\u059e\3\2\2\2\u059e\u05a8\3\2\2\2\u059f")
        buf.write("\u05a0\7\u009b\2\2\u05a0\u05a5\5P)\2\u05a1\u05a2\7\6\2")
        buf.write("\2\u05a2\u05a4\5P)\2\u05a3\u05a1\3\2\2\2\u05a4\u05a7\3")
        buf.write("\2\2\2\u05a5\u05a3\3\2\2\2\u05a5\u05a6\3\2\2\2\u05a6\u05a9")
        buf.write("\3\2\2\2\u05a7\u05a5\3\2\2\2\u05a8\u059f\3\2\2\2\u05a8")
        buf.write("\u05a9\3\2\2\2\u05a9\u05ab\3\2\2\2\u05aa\u05ac\5R*\2\u05ab")
        buf.write("\u05aa\3\2\2\2\u05ab\u05ac\3\2\2\2\u05ac\u05b0\3\2\2\2")
        buf.write("\u05ad\u05ae\7\27\2\2\u05ae\u05af\7\u0096\2\2\u05af\u05b1")
        buf.write("\5V,\2\u05b0\u05ad\3\2\2\2\u05b0\u05b1\3\2\2\2\u05b1\u05b3")
        buf.write("\3\2\2\2\u05b2\u05b4\t\20\2\2\u05b3\u05b2\3\2\2\2\u05b3")
        buf.write("\u05b4\3\2\2\2\u05b4\u05b5\3\2\2\2\u05b5\u05b6\7\u00c0")
        buf.write("\2\2\u05b6\u05b7\7\4\2\2\u05b7\u05b8\5\u00b4[\2\u05b8")
        buf.write("\u05c2\7\5\2\2\u05b9\u05ba\7\u00ee\2\2\u05ba\u05bf\5X")
        buf.write("-\2\u05bb\u05bc\7\6\2\2\u05bc\u05be\5X-\2\u05bd\u05bb")
        buf.write("\3\2\2\2\u05be\u05c1\3\2\2\2\u05bf\u05bd\3\2\2\2\u05bf")
        buf.write("\u05c0\3\2\2\2\u05c0\u05c3\3\2\2\2\u05c1\u05bf\3\2\2\2")
        buf.write("\u05c2\u05b9\3\2\2\2\u05c2\u05c3\3\2\2\2\u05c3\u05c4\3")
        buf.write("\2\2\2\u05c4\u05c5\7K\2\2\u05c5\u05ca\5Z.\2\u05c6\u05c7")
        buf.write("\7\6\2\2\u05c7\u05c9\5Z.\2\u05c8\u05c6\3\2\2\2\u05c9\u05cc")
        buf.write("\3\2\2\2\u05ca\u05c8\3\2\2\2\u05ca\u05cb\3\2\2\2\u05cb")
        buf.write("\u05cd\3\2\2\2\u05cc\u05ca\3\2\2\2\u05cd\u05d5\7\5\2\2")
        buf.write("\u05ce\u05d0\7\36\2\2\u05cf\u05ce\3\2\2\2\u05cf\u05d0")
        buf.write("\3\2\2\2\u05d0\u05d1\3\2\2\2\u05d1\u05d3\5\u00d6l\2\u05d2")
        buf.write("\u05d4\5^\60\2\u05d3\u05d2\3\2\2\2\u05d3\u05d4\3\2\2\2")
        buf.write("\u05d4\u05d6\3\2\2\2\u05d5\u05cf\3\2\2\2\u05d5\u05d6\3")
        buf.write("\2\2\2\u05d6\u05d8\3\2\2\2\u05d7\u0585\3\2\2\2\u05d7\u05d8")
        buf.write("\3\2\2\2\u05d8O\3\2\2\2\u05d9\u05da\5p9\2\u05da\u05db")
        buf.write("\7\36\2\2\u05db\u05dc\5\u00d6l\2\u05dcQ\3\2\2\2\u05dd")
        buf.write("\u05de\7\u00b1\2\2\u05de\u05df\7\u00dc\2\2\u05df\u05e0")
        buf.write("\7\u00c1\2\2\u05e0\u05e9\7\u0096\2\2\u05e1\u05e2\7\30")
        buf.write("\2\2\u05e2\u05e3\7\u00dd\2\2\u05e3\u05e4\7\u00c1\2\2\u05e4")
        buf.write("\u05e6\7\u0096\2\2\u05e5\u05e7\5T+\2\u05e6\u05e5\3\2\2")
        buf.write("\2\u05e6\u05e7\3\2\2\2\u05e7\u05e9\3\2\2\2\u05e8\u05dd")
        buf.write("\3\2\2\2\u05e8\u05e1\3\2\2\2\u05e9S\3\2\2\2\u05ea\u05eb")
        buf.write("\7\u00ea\2\2\u05eb\u05ec\7Q\2\2\u05ec\u05f4\7\u0098\2")
        buf.write("\2\u05ed\u05ee\7\u00ae\2\2\u05ee\u05ef\7Q\2\2\u05ef\u05f4")
        buf.write("\7\u0098\2\2\u05f0\u05f1\7\u011b\2\2\u05f1\u05f2\7\u0109")
        buf.write("\2\2\u05f2\u05f4\7\u00dd\2\2\u05f3\u05ea\3\2\2\2\u05f3")
        buf.write("\u05ed\3\2\2\2\u05f3\u05f0\3\2\2\2\u05f4U\3\2\2\2\u05f5")
        buf.write("\u05f6\7\7\2\2\u05f6\u05f7\7\u00fa\2\2\u05f7\u05f8\7\u00a0")
        buf.write("\2\2\u05f8\u0609\7\u00dc\2\2\u05f9\u05fa\7\7\2\2\u05fa")
        buf.write("\u05fb\7\u00be\2\2\u05fb\u05fc\7\u0089\2\2\u05fc\u0609")
        buf.write("\7\u00dc\2\2\u05fd\u05fe\7\7\2\2\u05fe\u05ff\7\u00fa\2")
        buf.write("\2\u05ff\u0600\7`\2\2\u0600\u0609\5\u00d6l\2\u0601\u0602")
        buf.write("\7\7\2\2\u0602\u0603\7\u00fa\2\2\u0603\u0604\7\u0089\2")
        buf.write("\2\u0604\u0609\5\u00d6l\2\u0605\u0606\7\7\2\2\u0606\u0607")
        buf.write("\7\u00fa\2\2\u0607\u0609\5\u00d6l\2\u0608\u05f5\3\2\2")
        buf.write("\2\u0608\u05f9\3\2\2\2\u0608\u05fd\3\2\2\2\u0608\u0601")
        buf.write("\3\2\2\2\u0608\u0605\3\2\2\2\u0609W\3\2\2\2\u060a\u060b")
        buf.write("\5\u00d6l\2\u060b\u060c\7\u0123\2\2\u060c\u060d\7\4\2")
        buf.write("\2\u060d\u0612\5\u00d6l\2\u060e\u060f\7\6\2\2\u060f\u0611")
        buf.write("\5\u00d6l\2\u0610\u060e\3\2\2\2\u0611\u0614\3\2\2\2\u0612")
        buf.write("\u0610\3\2\2\2\u0612\u0613\3\2\2\2\u0613\u0615\3\2\2\2")
        buf.write("\u0614\u0612\3\2\2\2\u0615\u0616\7\5\2\2\u0616Y\3\2\2")
        buf.write("\2\u0617\u0618\5\u00d6l\2\u0618\u0619\7\36\2\2\u0619\u061a")
        buf.write("\5p9\2\u061a[\3\2\2\2\u061b\u0623\5`\61\2\u061c\u061e")
        buf.write("\7\36\2\2\u061d\u061c\3\2\2\2\u061d\u061e\3\2\2\2\u061e")
        buf.write("\u061f\3\2\2\2\u061f\u0621\5\u00d6l\2\u0620\u0622\5^\60")
        buf.write("\2\u0621\u0620\3\2\2\2\u0621\u0622\3\2\2\2\u0622\u0624")
        buf.write("\3\2\2\2\u0623\u061d\3\2\2\2\u0623\u0624\3\2\2\2\u0624")
        buf.write("]\3\2\2\2\u0625\u0626\7\4\2\2\u0626\u062b\5\u00d6l\2\u0627")
        buf.write("\u0628\7\6\2\2\u0628\u062a\5\u00d6l\2\u0629\u0627\3\2")
        buf.write("\2\2\u062a\u062d\3\2\2\2\u062b\u0629\3\2\2\2\u062b\u062c")
        buf.write("\3\2\2\2\u062c\u062e\3\2\2\2\u062d\u062b\3\2\2\2\u062e")
        buf.write("\u062f\7\5\2\2\u062f_\3\2\2\2\u0630\u0632\5\u00caf\2\u0631")
        buf.write("\u0633\5\u00ccg\2\u0632\u0631\3\2\2\2\u0632\u0633\3\2")
        buf.write("\2\2\u0633\u0656\3\2\2\2\u0634\u0635\7\4\2\2\u0635\u0636")
        buf.write("\5\16\b\2\u0636\u0637\7\5\2\2\u0637\u0656\3\2\2\2\u0638")
        buf.write("\u0639\7\u010a\2\2\u0639\u063a\7\4\2\2\u063a\u063f\5p")
        buf.write("9\2\u063b\u063c\7\6\2\2\u063c\u063e\5p9\2\u063d\u063b")
        buf.write("\3\2\2\2\u063e\u0641\3\2\2\2\u063f\u063d\3\2\2\2\u063f")
        buf.write("\u0640\3\2\2\2\u0640\u0642\3\2\2\2\u0641\u063f\3\2\2\2")
        buf.write("\u0642\u0645\7\5\2\2\u0643\u0644\7\u011b\2\2\u0644\u0646")
        buf.write("\7\u00b6\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646")
        buf.write("\u0656\3\2\2\2\u0647\u0648\7\u008a\2\2\u0648\u0649\7\4")
        buf.write("\2\2\u0649\u064a\5\16\b\2\u064a\u064b\7\5\2\2\u064b\u0656")
        buf.write("\3\2\2\2\u064c\u064d\7\u00f1\2\2\u064d\u064e\7\4\2\2\u064e")
        buf.write("\u064f\5b\62\2\u064f\u0650\7\5\2\2\u0650\u0656\3\2\2\2")
        buf.write("\u0651\u0652\7\4\2\2\u0652\u0653\5> \2\u0653\u0654\7\5")
        buf.write("\2\2\u0654\u0656\3\2\2\2\u0655\u0630\3\2\2\2\u0655\u0634")
        buf.write("\3\2\2\2\u0655\u0638\3\2\2\2\u0655\u0647\3\2\2\2\u0655")
        buf.write("\u064c\3\2\2\2\u0655\u0651\3\2\2\2\u0656a\3\2\2\2\u0657")
        buf.write("\u0658\5\u00caf\2\u0658\u0661\7\4\2\2\u0659\u065e\5d\63")
        buf.write("\2\u065a\u065b\7\6\2\2\u065b\u065d\5d\63\2\u065c\u065a")
        buf.write("\3\2\2\2\u065d\u0660\3\2\2\2\u065e\u065c\3\2\2\2\u065e")
        buf.write("\u065f\3\2\2\2\u065f\u0662\3\2\2\2\u0660\u065e\3\2\2\2")
        buf.write("\u0661\u0659\3\2\2\2\u0661\u0662\3\2\2\2\u0662\u066c\3")
        buf.write("\2\2\2\u0663\u0664\7\63\2\2\u0664\u0669\5n8\2\u0665\u0666")
        buf.write("\7\6\2\2\u0666\u0668\5n8\2\u0667\u0665\3\2\2\2\u0668\u066b")
        buf.write("\3\2\2\2\u0669\u0667\3\2\2\2\u0669\u066a\3\2\2\2\u066a")
        buf.write("\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066c\u0663\3\2\2\2")
        buf.write("\u066c\u066d\3\2\2\2\u066d\u066e\3\2\2\2\u066e\u066f\7")
        buf.write("\5\2\2\u066fc\3\2\2\2\u0670\u0671\5\u00d6l\2\u0671\u0672")
        buf.write("\7\b\2\2\u0672\u0674\3\2\2\2\u0673\u0670\3\2\2\2\u0673")
        buf.write("\u0674\3\2\2\2\u0674\u0678\3\2\2\2\u0675\u0679\5f\64\2")
        buf.write("\u0676\u0679\5j\66\2\u0677\u0679\5p9\2\u0678\u0675\3\2")
        buf.write("\2\2\u0678\u0676\3\2\2\2\u0678\u0677\3\2\2\2\u0679e\3")
        buf.write("\2\2\2\u067a\u068c\5h\65\2\u067b\u067c\7\u00bb\2\2\u067c")
        buf.write("\u068a\7%\2\2\u067d\u0686\7\4\2\2\u067e\u0683\5p9\2\u067f")
        buf.write("\u0680\7\6\2\2\u0680\u0682\5p9\2\u0681\u067f\3\2\2\2\u0682")
        buf.write("\u0685\3\2\2\2\u0683\u0681\3\2\2\2\u0683\u0684\3\2\2\2")
        buf.write("\u0684\u0687\3\2\2\2\u0685\u0683\3\2\2\2\u0686\u067e\3")
        buf.write("\2\2\2\u0686\u0687\3\2\2\2\u0687\u0688\3\2\2\2\u0688\u068b")
        buf.write("\7\5\2\2\u0689\u068b\5p9\2\u068a\u067d\3\2\2\2\u068a\u0689")
        buf.write("\3\2\2\2\u068b\u068d\3\2\2\2\u068c\u067b\3\2\2\2\u068c")
        buf.write("\u068d\3\2\2\2\u068d\u0694\3\2\2\2\u068e\u068f\7\u00c9")
        buf.write("\2\2\u068f\u0690\7\u0118\2\2\u0690\u0695\7Q\2\2\u0691")
        buf.write("\u0692\7\u0086\2\2\u0692\u0693\7\u0118\2\2\u0693\u0695")
        buf.write("\7Q\2\2\u0694\u068e\3\2\2\2\u0694\u0691\3\2\2\2\u0694")
        buf.write("\u0695\3\2\2\2\u0695\u06a6\3\2\2\2\u0696\u0697\7\u00b5")
        buf.write("\2\2\u0697\u06a4\7%\2\2\u0698\u0699\7\4\2\2\u0699\u069e")
        buf.write("\5*\26\2\u069a\u069b\7\6\2\2\u069b\u069d\5*\26\2\u069c")
        buf.write("\u069a\3\2\2\2\u069d\u06a0\3\2\2\2\u069e\u069c\3\2\2\2")
        buf.write("\u069e\u069f\3\2\2\2\u069f\u06a1\3\2\2\2\u06a0\u069e\3")
        buf.write("\2\2\2\u06a1\u06a2\7\5\2\2\u06a2\u06a5\3\2\2\2\u06a3\u06a5")
        buf.write("\5*\26\2\u06a4\u0698\3\2\2\2\u06a4\u06a3\3\2\2\2\u06a5")
        buf.write("\u06a7\3\2\2\2\u06a6\u0696\3\2\2\2\u06a6\u06a7\3\2\2\2")
        buf.write("\u06a7g\3\2\2\2\u06a8\u06a9\7\u00f1\2\2\u06a9\u06aa\7")
        buf.write("\4\2\2\u06aa\u06ab\5\u00caf\2\u06ab\u06b3\7\5\2\2\u06ac")
        buf.write("\u06ae\7\36\2\2\u06ad\u06ac\3\2\2\2\u06ad\u06ae\3\2\2")
        buf.write("\2\u06ae\u06af\3\2\2\2\u06af\u06b1\5\u00d6l\2\u06b0\u06b2")
        buf.write("\5^\60\2\u06b1\u06b0\3\2\2\2\u06b1\u06b2\3\2\2\2\u06b2")
        buf.write("\u06b4\3\2\2\2\u06b3\u06ad\3\2\2\2\u06b3\u06b4\3\2\2\2")
        buf.write("\u06b4\u06c3\3\2\2\2\u06b5\u06b6\7\u00f1\2\2\u06b6\u06b7")
        buf.write("\7\4\2\2\u06b7\u06b8\5\16\b\2\u06b8\u06c0\7\5\2\2\u06b9")
        buf.write("\u06bb\7\36\2\2\u06ba\u06b9\3\2\2\2\u06ba\u06bb\3\2\2")
        buf.write("\2\u06bb\u06bc\3\2\2\2\u06bc\u06be\5\u00d6l\2\u06bd\u06bf")
        buf.write("\5^\60\2\u06be\u06bd\3\2\2\2\u06be\u06bf\3\2\2\2\u06bf")
        buf.write("\u06c1\3\2\2\2\u06c0\u06ba\3\2\2\2\u06c0\u06c1\3\2\2\2")
        buf.write("\u06c1\u06c3\3\2\2\2\u06c2\u06a8\3\2\2\2\u06c2\u06b5\3")
        buf.write("\2\2\2\u06c3i\3\2\2\2\u06c4\u06c5\7J\2\2\u06c5\u06c6\7")
        buf.write("\4\2\2\u06c6\u06cb\5l\67\2\u06c7\u06c8\7\6\2\2\u06c8\u06ca")
        buf.write("\5l\67\2\u06c9\u06c7\3\2\2\2\u06ca\u06cd\3\2\2\2\u06cb")
        buf.write("\u06c9\3\2\2\2\u06cb\u06cc\3\2\2\2\u06cc\u06ce\3\2\2\2")
        buf.write("\u06cd\u06cb\3\2\2\2\u06ce\u06cf\7\5\2\2\u06cf\u06d7\3")
        buf.write("\2\2\2\u06d0\u06d1\7)\2\2\u06d1\u06d2\7\4\2\2\u06d2\u06d3")
        buf.write("\7\u00a9\2\2\u06d3\u06d4\7\36\2\2\u06d4\u06d5\7J\2\2\u06d5")
        buf.write("\u06d7\7\5\2\2\u06d6\u06c4\3\2\2\2\u06d6\u06d0\3\2\2\2")
        buf.write("\u06d7k\3\2\2\2\u06d8\u06da\5\u00d6l\2\u06d9\u06db\5\u00a0")
        buf.write("Q\2\u06da\u06d9\3\2\2\2\u06da\u06db\3\2\2\2\u06dbm\3\2")
        buf.write("\2\2\u06dc\u06dd\7\4\2\2\u06dd\u06de\5\u00caf\2\u06de")
        buf.write("\u06df\7\6\2\2\u06df\u06e4\5\u00caf\2\u06e0\u06e1\7\6")
        buf.write("\2\2\u06e1\u06e3\5\u00caf\2\u06e2\u06e0\3\2\2\2\u06e3")
        buf.write("\u06e6\3\2\2\2\u06e4\u06e2\3\2\2\2\u06e4\u06e5\3\2\2\2")
        buf.write("\u06e5\u06e7\3\2\2\2\u06e6\u06e4\3\2\2\2\u06e7\u06e8\7")
        buf.write("\5\2\2\u06e8o\3\2\2\2\u06e9\u06ea\5r:\2\u06eaq\3\2\2\2")
        buf.write("\u06eb\u06ec\b:\1\2\u06ec\u06ee\5v<\2\u06ed\u06ef\5t;")
        buf.write("\2\u06ee\u06ed\3\2\2\2\u06ee\u06ef\3\2\2\2\u06ef\u06f3")
        buf.write("\3\2\2\2\u06f0\u06f1\7\u00a8\2\2\u06f1\u06f3\5r:\5\u06f2")
        buf.write("\u06eb\3\2\2\2\u06f2\u06f0\3\2\2\2\u06f3\u06fc\3\2\2\2")
        buf.write("\u06f4\u06f5\f\4\2\2\u06f5\u06f6\7\33\2\2\u06f6\u06fb")
        buf.write("\5r:\5\u06f7\u06f8\f\3\2\2\u06f8\u06f9\7\u00b4\2\2\u06f9")
        buf.write("\u06fb\5r:\4\u06fa\u06f4\3\2\2\2\u06fa\u06f7\3\2\2\2\u06fb")
        buf.write("\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd\3\2\2\2")
        buf.write("\u06fds\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0700\5\u0094")
        buf.write("K\2\u0700\u0701\5v<\2\u0701\u073d\3\2\2\2\u0702\u0703")
        buf.write("\5\u0094K\2\u0703\u0704\5\u0096L\2\u0704\u0705\7\4\2\2")
        buf.write("\u0705\u0706\5\16\b\2\u0706\u0707\7\5\2\2\u0707\u073d")
        buf.write("\3\2\2\2\u0708\u070a\7\u00a8\2\2\u0709\u0708\3\2\2\2\u0709")
        buf.write("\u070a\3\2\2\2\u070a\u070b\3\2\2\2\u070b\u070c\7#\2\2")
        buf.write("\u070c\u070d\5v<\2\u070d\u070e\7\33\2\2\u070e\u070f\5")
        buf.write("v<\2\u070f\u073d\3\2\2\2\u0710\u0712\7\u00a8\2\2\u0711")
        buf.write("\u0710\3\2\2\2\u0711\u0712\3\2\2\2\u0712\u0713\3\2\2\2")
        buf.write("\u0713\u0714\7r\2\2\u0714\u0715\7\4\2\2\u0715\u071a\5")
        buf.write("p9\2\u0716\u0717\7\6\2\2\u0717\u0719\5p9\2\u0718\u0716")
        buf.write("\3\2\2\2\u0719\u071c\3\2\2\2\u071a\u0718\3\2\2\2\u071a")
        buf.write("\u071b\3\2\2\2\u071b\u071d\3\2\2\2\u071c\u071a\3\2\2\2")
        buf.write("\u071d\u071e\7\5\2\2\u071e\u073d\3\2\2\2\u071f\u0721\7")
        buf.write("\u00a8\2\2\u0720\u071f\3\2\2\2\u0720\u0721\3\2\2\2\u0721")
        buf.write("\u0722\3\2\2\2\u0722\u0723\7r\2\2\u0723\u0724\7\4\2\2")
        buf.write("\u0724\u0725\5\16\b\2\u0725\u0726\7\5\2\2\u0726\u073d")
        buf.write("\3\2\2\2\u0727\u0729\7\u00a8\2\2\u0728\u0727\3\2\2\2\u0728")
        buf.write("\u0729\3\2\2\2\u0729\u072a\3\2\2\2\u072a\u072b\7\u008e")
        buf.write("\2\2\u072b\u072e\5v<\2\u072c\u072d\7U\2\2\u072d\u072f")
        buf.write("\5v<\2\u072e\u072c\3\2\2\2\u072e\u072f\3\2\2\2\u072f\u073d")
        buf.write("\3\2\2\2\u0730\u0732\7}\2\2\u0731\u0733\7\u00a8\2\2\u0732")
        buf.write("\u0731\3\2\2\2\u0732\u0733\3\2\2\2\u0733\u0734\3\2\2\2")
        buf.write("\u0734\u073d\7\u00a9\2\2\u0735\u0737\7}\2\2\u0736\u0738")
        buf.write("\7\u00a8\2\2\u0737\u0736\3\2\2\2\u0737\u0738\3\2\2\2\u0738")
        buf.write("\u0739\3\2\2\2\u0739\u073a\7L\2\2\u073a\u073b\7d\2\2\u073b")
        buf.write("\u073d\5v<\2\u073c\u06ff\3\2\2\2\u073c\u0702\3\2\2\2\u073c")
        buf.write("\u0709\3\2\2\2\u073c\u0711\3\2\2\2\u073c\u0720\3\2\2\2")
        buf.write("\u073c\u0728\3\2\2\2\u073c\u0730\3\2\2\2\u073c\u0735\3")
        buf.write("\2\2\2\u073du\3\2\2\2\u073e\u073f\b<\1\2\u073f\u0743\5")
        buf.write("x=\2\u0740\u0741\t\21\2\2\u0741\u0743\5v<\6\u0742\u073e")
        buf.write("\3\2\2\2\u0742\u0740\3\2\2\2\u0743\u0752\3\2\2\2\u0744")
        buf.write("\u0745\f\5\2\2\u0745\u0746\t\22\2\2\u0746\u0751\5v<\6")
        buf.write("\u0747\u0748\f\4\2\2\u0748\u0749\t\21\2\2\u0749\u0751")
        buf.write("\5v<\5\u074a\u074b\f\3\2\2\u074b\u074c\7\u012e\2\2\u074c")
        buf.write("\u0751\5v<\4\u074d\u074e\f\7\2\2\u074e\u074f\7 \2\2\u074f")
        buf.write("\u0751\5\u0092J\2\u0750\u0744\3\2\2\2\u0750\u0747\3\2")
        buf.write("\2\2\u0750\u074a\3\2\2\2\u0750\u074d\3\2\2\2\u0751\u0754")
        buf.write("\3\2\2\2\u0752\u0750\3\2\2\2\u0752\u0753\3\2\2\2\u0753")
        buf.write("w\3\2\2\2\u0754\u0752\3\2\2\2\u0755\u0756\b=\1\2\u0756")
        buf.write("\u0918\7\u00a9\2\2\u0757\u0918\5\u009aN\2\u0758\u0759")
        buf.write("\5\u00d6l\2\u0759\u075a\5\u0090I\2\u075a\u0918\3\2\2\2")
        buf.write("\u075b\u075c\7N\2\2\u075c\u075d\7\u00c5\2\2\u075d\u0918")
        buf.write("\5\u0090I\2\u075e\u0918\5\u00d8m\2\u075f\u0918\5\u0098")
        buf.write("M\2\u0760\u0918\5\u0090I\2\u0761\u0918\7\u0132\2\2\u0762")
        buf.write("\u0918\7\u012f\2\2\u0763\u0764\7\u00c3\2\2\u0764\u0765")
        buf.write("\7\4\2\2\u0765\u0766\5v<\2\u0766\u0767\7r\2\2\u0767\u0768")
        buf.write("\5v<\2\u0768\u0769\7\5\2\2\u0769\u0918\3\2\2\2\u076a\u076b")
        buf.write("\7\4\2\2\u076b\u076e\5p9\2\u076c\u076d\7\6\2\2\u076d\u076f")
        buf.write("\5p9\2\u076e\u076c\3\2\2\2\u076f\u0770\3\2\2\2\u0770\u076e")
        buf.write("\3\2\2\2\u0770\u0771\3\2\2\2\u0771\u0772\3\2\2\2\u0772")
        buf.write("\u0773\7\5\2\2\u0773\u0918\3\2\2\2\u0774\u0775\7\u00dc")
        buf.write("\2\2\u0775\u0776\7\4\2\2\u0776\u077b\5p9\2\u0777\u0778")
        buf.write("\7\6\2\2\u0778\u077a\5p9\2\u0779\u0777\3\2\2\2\u077a\u077d")
        buf.write("\3\2\2\2\u077b\u0779\3\2\2\2\u077b\u077c\3\2\2\2\u077c")
        buf.write("\u077e\3\2\2\2\u077d\u077b\3\2\2\2\u077e\u077f\7\5\2\2")
        buf.write("\u077f\u0918\3\2\2\2\u0780\u0781\7\u0090\2\2\u0781\u0783")
        buf.write("\7\4\2\2\u0782\u0784\5:\36\2\u0783\u0782\3\2\2\2\u0783")
        buf.write("\u0784\3\2\2\2\u0784\u0785\3\2\2\2\u0785\u0788\5p9\2\u0786")
        buf.write("\u0787\7\6\2\2\u0787\u0789\5\u0090I\2\u0788\u0786\3\2")
        buf.write("\2\2\u0788\u0789\3\2\2\2\u0789\u078d\3\2\2\2\u078a\u078b")
        buf.write("\7\u00b0\2\2\u078b\u078c\7\u00ba\2\2\u078c\u078e\5J&\2")
        buf.write("\u078d\u078a\3\2\2\2\u078d\u078e\3\2\2\2\u078e\u078f\3")
        buf.write("\2\2\2\u078f\u0790\7\5\2\2\u0790\u0791\7\u011c\2\2\u0791")
        buf.write("\u0792\7k\2\2\u0792\u0793\7\4\2\2\u0793\u0794\7\u00b5")
        buf.write("\2\2\u0794\u0795\7%\2\2\u0795\u079a\5*\26\2\u0796\u0797")
        buf.write("\7\6\2\2\u0797\u0799\5*\26\2\u0798\u0796\3\2\2\2\u0799")
        buf.write("\u079c\3\2\2\2\u079a\u0798\3\2\2\2\u079a\u079b\3\2\2\2")
        buf.write("\u079b\u079d\3\2\2\2\u079c\u079a\3\2\2\2\u079d\u079e\7")
        buf.write("\5\2\2\u079e\u0918\3\2\2\2\u079f\u07a1\5\u008cG\2\u07a0")
        buf.write("\u079f\3\2\2\2\u07a0\u07a1\3\2\2\2\u07a1\u07a2\3\2\2\2")
        buf.write("\u07a2\u07a3\5\u00caf\2\u07a3\u07a7\7\4\2\2\u07a4\u07a5")
        buf.write("\5\u00d6l\2\u07a5\u07a6\7\3\2\2\u07a6\u07a8\3\2\2\2\u07a7")
        buf.write("\u07a4\3\2\2\2\u07a7\u07a8\3\2\2\2\u07a8\u07a9\3\2\2\2")
        buf.write("\u07a9\u07aa\7\u012b\2\2\u07aa\u07ac\7\5\2\2\u07ab\u07ad")
        buf.write("\5\u00a8U\2\u07ac\u07ab\3\2\2\2\u07ac\u07ad\3\2\2\2\u07ad")
        buf.write("\u07af\3\2\2\2\u07ae\u07b0\5\u00acW\2\u07af\u07ae\3\2")
        buf.write("\2\2\u07af\u07b0\3\2\2\2\u07b0\u0918\3\2\2\2\u07b1\u07b3")
        buf.write("\5\u008cG\2\u07b2\u07b1\3\2\2\2\u07b2\u07b3\3\2\2\2\u07b3")
        buf.write("\u07b4\3\2\2\2\u07b4\u07b5\5\u00caf\2\u07b5\u07c1\7\4")
        buf.write("\2\2\u07b6\u07b8\5:\36\2\u07b7\u07b6\3\2\2\2\u07b7\u07b8")
        buf.write("\3\2\2\2\u07b8\u07b9\3\2\2\2\u07b9\u07be\5p9\2\u07ba\u07bb")
        buf.write("\7\6\2\2\u07bb\u07bd\5p9\2\u07bc\u07ba\3\2\2\2\u07bd\u07c0")
        buf.write("\3\2\2\2\u07be\u07bc\3\2\2\2\u07be\u07bf\3\2\2\2\u07bf")
        buf.write("\u07c2\3\2\2\2\u07c0\u07be\3\2\2\2\u07c1\u07b7\3\2\2\2")
        buf.write("\u07c1\u07c2\3\2\2\2\u07c2\u07cd\3\2\2\2\u07c3\u07c4\7")
        buf.write("\u00b5\2\2\u07c4\u07c5\7%\2\2\u07c5\u07ca\5*\26\2\u07c6")
        buf.write("\u07c7\7\6\2\2\u07c7\u07c9\5*\26\2\u07c8\u07c6\3\2\2\2")
        buf.write("\u07c9\u07cc\3\2\2\2\u07ca\u07c8\3\2\2\2\u07ca\u07cb\3")
        buf.write("\2\2\2\u07cb\u07ce\3\2\2\2\u07cc\u07ca\3\2\2\2\u07cd\u07c3")
        buf.write("\3\2\2\2\u07cd\u07ce\3\2\2\2\u07ce\u07cf\3\2\2\2\u07cf")
        buf.write("\u07d1\7\5\2\2\u07d0\u07d2\5\u00a8U\2\u07d1\u07d0\3\2")
        buf.write("\2\2\u07d1\u07d2\3\2\2\2\u07d2\u07d7\3\2\2\2\u07d3\u07d5")
        buf.write("\5\u008eH\2\u07d4\u07d3\3\2\2\2\u07d4\u07d5\3\2\2\2\u07d5")
        buf.write("\u07d6\3\2\2\2\u07d6\u07d8\5\u00acW\2\u07d7\u07d4\3\2")
        buf.write("\2\2\u07d7\u07d8\3\2\2\2\u07d8\u0918\3\2\2\2\u07d9\u07da")
        buf.write("\5\u00d6l\2\u07da\u07db\5\u00acW\2\u07db\u0918\3\2\2\2")
        buf.write("\u07dc\u07dd\5\u00d6l\2\u07dd\u07de\7\t\2\2\u07de\u07df")
        buf.write("\5p9\2\u07df\u0918\3\2\2\2\u07e0\u07e9\7\4\2\2\u07e1\u07e6")
        buf.write("\5\u00d6l\2\u07e2\u07e3\7\6\2\2\u07e3\u07e5\5\u00d6l\2")
        buf.write("\u07e4\u07e2\3\2\2\2\u07e5\u07e8\3\2\2\2\u07e6\u07e4\3")
        buf.write("\2\2\2\u07e6\u07e7\3\2\2\2\u07e7\u07ea\3\2\2\2\u07e8\u07e6")
        buf.write("\3\2\2\2\u07e9\u07e1\3\2\2\2\u07e9\u07ea\3\2\2\2\u07ea")
        buf.write("\u07eb\3\2\2\2\u07eb\u07ec\7\5\2\2\u07ec\u07ed\7\t\2\2")
        buf.write("\u07ed\u0918\5p9\2\u07ee\u07ef\7\4\2\2\u07ef\u07f0\5\16")
        buf.write("\b\2\u07f0\u07f1\7\5\2\2\u07f1\u0918\3\2\2\2\u07f2\u07f3")
        buf.write("\7Y\2\2\u07f3\u07f4\7\4\2\2\u07f4\u07f5\5\16\b\2\u07f5")
        buf.write("\u07f6\7\5\2\2\u07f6\u0918\3\2\2\2\u07f7\u07f8\7(\2\2")
        buf.write("\u07f8\u07fa\5p9\2\u07f9\u07fb\5\u00a6T\2\u07fa\u07f9")
        buf.write("\3\2\2\2\u07fb\u07fc\3\2\2\2\u07fc\u07fa\3\2\2\2\u07fc")
        buf.write("\u07fd\3\2\2\2\u07fd\u0800\3\2\2\2\u07fe\u07ff\7P\2\2")
        buf.write("\u07ff\u0801\5p9\2\u0800\u07fe\3\2\2\2\u0800\u0801\3\2")
        buf.write("\2\2\u0801\u0802\3\2\2\2\u0802\u0803\7S\2\2\u0803\u0918")
        buf.write("\3\2\2\2\u0804\u0806\7(\2\2\u0805\u0807\5\u00a6T\2\u0806")
        buf.write("\u0805\3\2\2\2\u0807\u0808\3\2\2\2\u0808\u0806\3\2\2\2")
        buf.write("\u0808\u0809\3\2\2\2\u0809\u080c\3\2\2\2\u080a\u080b\7")
        buf.write("P\2\2\u080b\u080d\5p9\2\u080c\u080a\3\2\2\2\u080c\u080d")
        buf.write("\3\2\2\2\u080d\u080e\3\2\2\2\u080e\u080f\7S\2\2\u080f")
        buf.write("\u0918\3\2\2\2\u0810\u0811\7)\2\2\u0811\u0812\7\4\2\2")
        buf.write("\u0812\u0813\5p9\2\u0813\u0814\7\36\2\2\u0814\u0815\5")
        buf.write("\u00a0Q\2\u0815\u0816\7\5\2\2\u0816\u0918\3\2\2\2\u0817")
        buf.write("\u0818\7\u0100\2\2\u0818\u0819\7\4\2\2\u0819\u081a\5p")
        buf.write("9\2\u081a\u081b\7\36\2\2\u081b\u081c\5\u00a0Q\2\u081c")
        buf.write("\u081d\7\5\2\2\u081d\u0918\3\2\2\2\u081e\u081f\7\35\2")
        buf.write("\2\u081f\u0828\7\n\2\2\u0820\u0825\5p9\2\u0821\u0822\7")
        buf.write("\6\2\2\u0822\u0824\5p9\2\u0823\u0821\3\2\2\2\u0824\u0827")
        buf.write("\3\2\2\2\u0825\u0823\3\2\2\2\u0825\u0826\3\2\2\2\u0826")
        buf.write("\u0829\3\2\2\2\u0827\u0825\3\2\2\2\u0828\u0820\3\2\2\2")
        buf.write("\u0828\u0829\3\2\2\2\u0829\u082a\3\2\2\2\u082a\u0918\7")
        buf.write("\13\2\2\u082b\u0918\5\u00d6l\2\u082c\u0918\79\2\2\u082d")
        buf.write("\u0831\7=\2\2\u082e\u082f\7\4\2\2\u082f\u0830\7\u0133")
        buf.write("\2\2\u0830\u0832\7\5\2\2\u0831\u082e\3\2\2\2\u0831\u0832")
        buf.write("\3\2\2\2\u0832\u0918\3\2\2\2\u0833\u0837\7>\2\2\u0834")
        buf.write("\u0835\7\4\2\2\u0835\u0836\7\u0133\2\2\u0836\u0838\7\5")
        buf.write("\2\2\u0837\u0834\3\2\2\2\u0837\u0838\3\2\2\2\u0838\u0918")
        buf.write("\3\2\2\2\u0839\u083d\7\u0092\2\2\u083a\u083b\7\4\2\2\u083b")
        buf.write("\u083c\7\u0133\2\2\u083c\u083e\7\5\2\2\u083d\u083a\3\2")
        buf.write("\2\2\u083d\u083e\3\2\2\2\u083e\u0918\3\2\2\2\u083f\u0843")
        buf.write("\7\u0093\2\2\u0840\u0841\7\4\2\2\u0841\u0842\7\u0133\2")
        buf.write("\2\u0842\u0844\7\5\2\2\u0843\u0840\3\2\2\2\u0843\u0844")
        buf.write("\3\2\2\2\u0844\u0918\3\2\2\2\u0845\u0918\7?\2\2\u0846")
        buf.write("\u0918\78\2\2\u0847\u0918\7<\2\2\u0848\u0918\7:\2\2\u0849")
        buf.write("\u084a\7\u00fd\2\2\u084a\u0852\7\4\2\2\u084b\u084d\5H")
        buf.write("%\2\u084c\u084b\3\2\2\2\u084c\u084d\3\2\2\2\u084d\u084f")
        buf.write("\3\2\2\2\u084e\u0850\5v<\2\u084f\u084e\3\2\2\2\u084f\u0850")
        buf.write("\3\2\2\2\u0850\u0851\3\2\2\2\u0851\u0853\7d\2\2\u0852")
        buf.write("\u084c\3\2\2\2\u0852\u0853\3\2\2\2\u0853\u0854\3\2\2\2")
        buf.write("\u0854\u0855\5v<\2\u0855\u0856\7\5\2\2\u0856\u0918\3\2")
        buf.write("\2\2\u0857\u0858\7\u00fd\2\2\u0858\u0859\7\4\2\2\u0859")
        buf.write("\u085a\5v<\2\u085a\u085b\7\6\2\2\u085b\u085c\5v<\2\u085c")
        buf.write("\u085d\7\5\2\2\u085d\u0918\3\2\2\2\u085e\u085f\7\u00ef")
        buf.write("\2\2\u085f\u0860\7\4\2\2\u0860\u0861\5v<\2\u0861\u0862")
        buf.write("\7d\2\2\u0862\u0865\5v<\2\u0863\u0864\7b\2\2\u0864\u0866")
        buf.write("\5v<\2\u0865\u0863\3\2\2\2\u0865\u0866\3\2\2\2\u0866\u0867")
        buf.write("\3\2\2\2\u0867\u0868\7\5\2\2\u0868\u0918\3\2\2\2\u0869")
        buf.write("\u086a\7\u00a7\2\2\u086a\u086b\7\4\2\2\u086b\u086e\5v")
        buf.write("<\2\u086c\u086d\7\6\2\2\u086d\u086f\5\u009eP\2\u086e\u086c")
        buf.write("\3\2\2\2\u086e\u086f\3\2\2\2\u086f\u0870\3\2\2\2\u0870")
        buf.write("\u0871\7\5\2\2\u0871\u0918\3\2\2\2\u0872\u0873\7[\2\2")
        buf.write("\u0873\u0874\7\4\2\2\u0874\u0875\5\u00d6l\2\u0875\u0876")
        buf.write("\7d\2\2\u0876\u0877\5v<\2\u0877\u0878\7\5\2\2\u0878\u0918")
        buf.write("\3\2\2\2\u0879\u087a\7\4\2\2\u087a\u087b\5p9\2\u087b\u087c")
        buf.write("\7\5\2\2\u087c\u0918\3\2\2\2\u087d\u087e\7l\2\2\u087e")
        buf.write("\u0887\7\4\2\2\u087f\u0884\5\u00caf\2\u0880\u0881\7\6")
        buf.write("\2\2\u0881\u0883\5\u00caf\2\u0882\u0880\3\2\2\2\u0883")
        buf.write("\u0886\3\2\2\2\u0884\u0882\3\2\2\2\u0884\u0885\3\2\2\2")
        buf.write("\u0885\u0888\3\2\2\2\u0886\u0884\3\2\2\2\u0887\u087f\3")
        buf.write("\2\2\2\u0887\u0888\3\2\2\2\u0888\u0889\3\2\2\2\u0889\u0918")
        buf.write("\7\5\2\2\u088a\u088b\7\u0082\2\2\u088b\u088c\7\4\2\2\u088c")
        buf.write("\u0891\5z>\2\u088d\u088e\5\u0082B\2\u088e\u088f\7\u00b0")
        buf.write("\2\2\u088f\u0890\7T\2\2\u0890\u0892\3\2\2\2\u0891\u088d")
        buf.write("\3\2\2\2\u0891\u0892\3\2\2\2\u0892\u0893\3\2\2\2\u0893")
        buf.write("\u0894\7\5\2\2\u0894\u0918\3\2\2\2\u0895\u0896\7\u0085")
        buf.write("\2\2\u0896\u0897\7\4\2\2\u0897\u089a\5z>\2\u0898\u0899")
        buf.write("\7\u00d5\2\2\u0899\u089b\5\u00a0Q\2\u089a\u0898\3\2\2")
        buf.write("\2\u089a\u089b\3\2\2\2\u089b\u08a0\3\2\2\2\u089c\u089d")
        buf.write("\5\u0084C\2\u089d\u089e\7\u00b0\2\2\u089e\u089f\7Q\2\2")
        buf.write("\u089f\u08a1\3\2\2\2\u08a0\u089c\3\2\2\2\u08a0\u08a1\3")
        buf.write("\2\2\2\u08a1\u08a6\3\2\2\2\u08a2\u08a3\5\u0084C\2\u08a3")
        buf.write("\u08a4\7\u00b0\2\2\u08a4\u08a5\7T\2\2\u08a5\u08a7\3\2")
        buf.write("\2\2\u08a6\u08a2\3\2\2\2\u08a6\u08a7\3\2\2\2\u08a7\u08a8")
        buf.write("\3\2\2\2\u08a8\u08a9\7\5\2\2\u08a9\u0918\3\2\2\2\u08aa")
        buf.write("\u08ab\7\u0084\2\2\u08ab\u08ac\7\4\2\2\u08ac\u08b3\5z")
        buf.write(">\2\u08ad\u08ae\7\u00d5\2\2\u08ae\u08b1\5\u00a0Q\2\u08af")
        buf.write("\u08b0\7c\2\2\u08b0\u08b2\5~@\2\u08b1\u08af\3\2\2\2\u08b1")
        buf.write("\u08b2\3\2\2\2\u08b2\u08b4\3\2\2\2\u08b3\u08ad\3\2\2\2")
        buf.write("\u08b3\u08b4\3\2\2\2\u08b4\u08b8\3\2\2\2\u08b5\u08b6\5")
        buf.write("\u0086D\2\u08b6\u08b7\7\u011f\2\2\u08b7\u08b9\3\2\2\2")
        buf.write("\u08b8\u08b5\3\2\2\2\u08b8\u08b9\3\2\2\2\u08b9\u08c1\3")
        buf.write("\2\2\2\u08ba\u08bb\t\23\2\2\u08bb\u08bf\7\u00ca\2\2\u08bc")
        buf.write("\u08bd\7\u00b0\2\2\u08bd\u08be\7\u00df\2\2\u08be\u08c0")
        buf.write("\7\u00f5\2\2\u08bf\u08bc\3\2\2\2\u08bf\u08c0\3\2\2\2\u08c0")
        buf.write("\u08c2\3\2\2\2\u08c1\u08ba\3\2\2\2\u08c1\u08c2\3\2\2\2")
        buf.write("\u08c2\u08c7\3\2\2\2\u08c3\u08c4\5\u0088E\2\u08c4\u08c5")
        buf.write("\7\u00b0\2\2\u08c5\u08c6\7Q\2\2\u08c6\u08c8\3\2\2\2\u08c7")
        buf.write("\u08c3\3\2\2\2\u08c7\u08c8\3\2\2\2\u08c8\u08cd\3\2\2\2")
        buf.write("\u08c9\u08ca\5\u0088E\2\u08ca\u08cb\7\u00b0\2\2\u08cb")
        buf.write("\u08cc\7T\2\2\u08cc\u08ce\3\2\2\2\u08cd\u08c9\3\2\2\2")
        buf.write("\u08cd\u08ce\3\2\2\2\u08ce\u08cf\3\2\2\2\u08cf\u08d0\7")
        buf.write("\5\2\2\u08d0\u0918\3\2\2\2\u08d1\u08d2\7\u0083\2\2\u08d2")
        buf.write("\u08ef\7\4\2\2\u08d3\u08d8\5\u008aF\2\u08d4\u08d5\7\6")
        buf.write("\2\2\u08d5\u08d7\5\u008aF\2\u08d6\u08d4\3\2\2\2\u08d7")
        buf.write("\u08da\3\2\2\2\u08d8\u08d6\3\2\2\2\u08d8\u08d9\3\2\2\2")
        buf.write("\u08d9\u08e1\3\2\2\2\u08da\u08d8\3\2\2\2\u08db\u08dc\7")
        buf.write("\u00a9\2\2\u08dc\u08dd\7\u00b0\2\2\u08dd\u08e2\7\u00a9")
        buf.write("\2\2\u08de\u08df\7\24\2\2\u08df\u08e0\7\u00b0\2\2\u08e0")
        buf.write("\u08e2\7\u00a9\2\2\u08e1\u08db\3\2\2\2\u08e1\u08de\3\2")
        buf.write("\2\2\u08e1\u08e2\3\2\2\2\u08e2\u08ed\3\2\2\2\u08e3\u08e4")
        buf.write("\7\u011b\2\2\u08e4\u08e6\7\u0107\2\2\u08e5\u08e7\7\u0088")
        buf.write("\2\2\u08e6\u08e5\3\2\2\2\u08e6\u08e7\3\2\2\2\u08e7\u08ee")
        buf.write("\3\2\2\2\u08e8\u08e9\7\u011d\2\2\u08e9\u08eb\7\u0107\2")
        buf.write("\2\u08ea\u08ec\7\u0088\2\2\u08eb\u08ea\3\2\2\2\u08eb\u08ec")
        buf.write("\3\2\2\2\u08ec\u08ee\3\2\2\2\u08ed\u08e3\3\2\2\2\u08ed")
        buf.write("\u08e8\3\2\2\2\u08ed\u08ee\3\2\2\2\u08ee\u08f0\3\2\2\2")
        buf.write("\u08ef\u08d3\3\2\2\2\u08ef\u08f0\3\2\2\2\u08f0\u08f7\3")
        buf.write("\2\2\2\u08f1\u08f2\7\u00d5\2\2\u08f2\u08f5\5\u00a0Q\2")
        buf.write("\u08f3\u08f4\7c\2\2\u08f4\u08f6\5~@\2\u08f5\u08f3\3\2")
        buf.write("\2\2\u08f5\u08f6\3\2\2\2\u08f6\u08f8\3\2\2\2\u08f7\u08f1")
        buf.write("\3\2\2\2\u08f7\u08f8\3\2\2\2\u08f8\u08f9\3\2\2\2\u08f9")
        buf.write("\u0918\7\5\2\2\u08fa\u08fb\7\u0081\2\2\u08fb\u090c\7\4")
        buf.write("\2\2\u08fc\u0901\5|?\2\u08fd\u08fe\7\6\2\2\u08fe\u0900")
        buf.write("\5|?\2\u08ff\u08fd\3\2\2\2\u0900\u0903\3\2\2\2\u0901\u08ff")
        buf.write("\3\2\2\2\u0901\u0902\3\2\2\2\u0902\u090a\3\2\2\2\u0903")
        buf.write("\u0901\3\2\2\2\u0904\u0905\7\u00a9\2\2\u0905\u0906\7\u00b0")
        buf.write("\2\2\u0906\u090b\7\u00a9\2\2\u0907\u0908\7\24\2\2\u0908")
        buf.write("\u0909\7\u00b0\2\2\u0909\u090b\7\u00a9\2\2\u090a\u0904")
        buf.write("\3\2\2\2\u090a\u0907\3\2\2\2\u090a\u090b\3\2\2\2\u090b")
        buf.write("\u090d\3\2\2\2\u090c\u08fc\3\2\2\2\u090c\u090d\3\2\2\2")
        buf.write("\u090d\u0914\3\2\2\2\u090e\u090f\7\u00d5\2\2\u090f\u0912")
        buf.write("\5\u00a0Q\2\u0910\u0911\7c\2\2\u0911\u0913\5~@\2\u0912")
        buf.write("\u0910\3\2\2\2\u0912\u0913\3\2\2\2\u0913\u0915\3\2\2\2")
        buf.write("\u0914\u090e\3\2\2\2\u0914\u0915\3\2\2\2\u0915\u0916\3")
        buf.write("\2\2\2\u0916\u0918\7\5\2\2\u0917\u0755\3\2\2\2\u0917\u0757")
        buf.write("\3\2\2\2\u0917\u0758\3\2\2\2\u0917\u075b\3\2\2\2\u0917")
        buf.write("\u075e\3\2\2\2\u0917\u075f\3\2\2\2\u0917\u0760\3\2\2\2")
        buf.write("\u0917\u0761\3\2\2\2\u0917\u0762\3\2\2\2\u0917\u0763\3")
        buf.write("\2\2\2\u0917\u076a\3\2\2\2\u0917\u0774\3\2\2\2\u0917\u0780")
        buf.write("\3\2\2\2\u0917\u07a0\3\2\2\2\u0917\u07b2\3\2\2\2\u0917")
        buf.write("\u07d9\3\2\2\2\u0917\u07dc\3\2\2\2\u0917\u07e0\3\2\2\2")
        buf.write("\u0917\u07ee\3\2\2\2\u0917\u07f2\3\2\2\2\u0917\u07f7\3")
        buf.write("\2\2\2\u0917\u0804\3\2\2\2\u0917\u0810\3\2\2\2\u0917\u0817")
        buf.write("\3\2\2\2\u0917\u081e\3\2\2\2\u0917\u082b\3\2\2\2\u0917")
        buf.write("\u082c\3\2\2\2\u0917\u082d\3\2\2\2\u0917\u0833\3\2\2\2")
        buf.write("\u0917\u0839\3\2\2\2\u0917\u083f\3\2\2\2\u0917\u0845\3")
        buf.write("\2\2\2\u0917\u0846\3\2\2\2\u0917\u0847\3\2\2\2\u0917\u0848")
        buf.write("\3\2\2\2\u0917\u0849\3\2\2\2\u0917\u0857\3\2\2\2\u0917")
        buf.write("\u085e\3\2\2\2\u0917\u0869\3\2\2\2\u0917\u0872\3\2\2\2")
        buf.write("\u0917\u0879\3\2\2\2\u0917\u087d\3\2\2\2\u0917\u088a\3")
        buf.write("\2\2\2\u0917\u0895\3\2\2\2\u0917\u08aa\3\2\2\2\u0917\u08d1")
        buf.write("\3\2\2\2\u0917\u08fa\3\2\2\2\u0918\u0923\3\2\2\2\u0919")
        buf.write("\u091a\f\32\2\2\u091a\u091b\7\n\2\2\u091b\u091c\5v<\2")
        buf.write("\u091c\u091d\7\13\2\2\u091d\u0922\3\2\2\2\u091e\u091f")
        buf.write("\f\30\2\2\u091f\u0920\7\3\2\2\u0920\u0922\5\u00d6l\2\u0921")
        buf.write("\u0919\3\2\2\2\u0921\u091e\3\2\2\2\u0922\u0925\3\2\2\2")
        buf.write("\u0923\u0921\3\2\2\2\u0923\u0924\3\2\2\2\u0924y\3\2\2")
        buf.write("\2\u0925\u0923\3\2\2\2\u0926\u0927\5|?\2\u0927\u0928\7")
        buf.write("\6\2\2\u0928\u0932\5\u0090I\2\u0929\u092a\7\u00bd\2\2")
        buf.write("\u092a\u092f\5\u0080A\2\u092b\u092c\7\6\2\2\u092c\u092e")
        buf.write("\5\u0080A\2\u092d\u092b\3\2\2\2\u092e\u0931\3\2\2\2\u092f")
        buf.write("\u092d\3\2\2\2\u092f\u0930\3\2\2\2\u0930\u0933\3\2\2\2")
        buf.write("\u0931\u092f\3\2\2\2\u0932\u0929\3\2\2\2\u0932\u0933\3")
        buf.write("\2\2\2\u0933{\3\2\2\2\u0934\u0937\5p9\2\u0935\u0936\7")
        buf.write("c\2\2\u0936\u0938\5~@\2\u0937\u0935\3\2\2\2\u0937\u0938")
        buf.write("\3\2\2\2\u0938}\3\2\2\2\u0939\u093c\7\u0080\2\2\u093a")
        buf.write("\u093b\7R\2\2\u093b\u093d\t\24\2\2\u093c\u093a\3\2\2\2")
        buf.write("\u093c\u093d\3\2\2\2\u093d\177\3\2\2\2\u093e\u093f\5|")
        buf.write("?\2\u093f\u0940\7\36\2\2\u0940\u0941\5\u00d6l\2\u0941")
        buf.write("\u0081\3\2\2\2\u0942\u0943\t\25\2\2\u0943\u0083\3\2\2")
        buf.write("\2\u0944\u0949\7T\2\2\u0945\u0949\7\u00a9\2\2\u0946\u0947")
        buf.write("\7D\2\2\u0947\u0949\5p9\2\u0948\u0944\3\2\2\2\u0948\u0945")
        buf.write("\3\2\2\2\u0948\u0946\3\2\2\2\u0949\u0085\3\2\2\2\u094a")
        buf.write("\u094c\7\u011d\2\2\u094b\u094d\7\35\2\2\u094c\u094b\3")
        buf.write("\2\2\2\u094c\u094d\3\2\2\2\u094d\u0956\3\2\2\2\u094e\u0950")
        buf.write("\7\u011b\2\2\u094f\u0951\t\26\2\2\u0950\u094f\3\2\2\2")
        buf.write("\u0950\u0951\3\2\2\2\u0951\u0953\3\2\2\2\u0952\u0954\7")
        buf.write("\35\2\2\u0953\u0952\3\2\2\2\u0953\u0954\3\2\2\2\u0954")
        buf.write("\u0956\3\2\2\2\u0955\u094a\3\2\2\2\u0955\u094e\3\2\2\2")
        buf.write("\u0956\u0087\3\2\2\2\u0957\u095e\7T\2\2\u0958\u095e\7")
        buf.write("\u00a9\2\2\u0959\u095a\7Q\2\2\u095a\u095e\7\35\2\2\u095b")
        buf.write("\u095c\7Q\2\2\u095c\u095e\7\u00ac\2\2\u095d\u0957\3\2")
        buf.write("\2\2\u095d\u0958\3\2\2\2\u095d\u0959\3\2\2\2\u095d\u095b")
        buf.write("\3\2\2\2\u095e\u0089\3\2\2\2\u095f\u0961\7\u0087\2\2\u0960")
        buf.write("\u095f\3\2\2\2\u0960\u0961\3\2\2\2\u0961\u0962\3\2\2\2")
        buf.write("\u0962\u0963\5p9\2\u0963\u0964\7\u0113\2\2\u0964\u0965")
        buf.write("\5|?\2\u0965\u096b\3\2\2\2\u0966\u0967\5p9\2\u0967\u0968")
        buf.write("\7\f\2\2\u0968\u0969\5|?\2\u0969\u096b\3\2\2\2\u096a\u0960")
        buf.write("\3\2\2\2\u096a\u0966\3\2\2\2\u096b\u008b\3\2\2\2\u096c")
        buf.write("\u096d\t\27\2\2\u096d\u008d\3\2\2\2\u096e\u096f\7q\2\2")
        buf.write("\u096f\u0973\7\u00ab\2\2\u0970\u0971\7\u00d3\2\2\u0971")
        buf.write("\u0973\7\u00ab\2\2\u0972\u096e\3\2\2\2\u0972\u0970\3\2")
        buf.write("\2\2\u0973\u008f\3\2\2\2\u0974\u097b\7\u0130\2\2\u0975")
        buf.write("\u0978\7\u0131\2\2\u0976\u0977\7\u0102\2\2\u0977\u0979")
        buf.write("\7\u0130\2\2\u0978\u0976\3\2\2\2\u0978\u0979\3\2\2\2\u0979")
        buf.write("\u097b\3\2\2\2\u097a\u0974\3\2\2\2\u097a\u0975\3\2\2\2")
        buf.write("\u097b\u0091\3\2\2\2\u097c\u097d\7\u00f8\2\2\u097d\u097e")
        buf.write("\7\u0122\2\2\u097e\u0983\5\u009aN\2\u097f\u0980\7\u00f8")
        buf.write("\2\2\u0980\u0981\7\u0122\2\2\u0981\u0983\5\u0090I\2\u0982")
        buf.write("\u097c\3\2\2\2\u0982\u097f\3\2\2\2\u0983\u0093\3\2\2\2")
        buf.write("\u0984\u0985\t\30\2\2\u0985\u0095\3\2\2\2\u0986\u0987")
        buf.write("\t\31\2\2\u0987\u0097\3\2\2\2\u0988\u0989\t\32\2\2\u0989")
        buf.write("\u0099\3\2\2\2\u098a\u098c\7y\2\2\u098b\u098d\t\21\2\2")
        buf.write("\u098c\u098b\3\2\2\2\u098c\u098d\3\2\2\2\u098d\u098e\3")
        buf.write("\2\2\2\u098e\u098f\5\u0090I\2\u098f\u0992\5\u009cO\2\u0990")
        buf.write("\u0991\7\u00fa\2\2\u0991\u0993\5\u009cO\2\u0992\u0990")
        buf.write("\3\2\2\2\u0992\u0993\3\2\2\2\u0993\u009b\3\2\2\2\u0994")
        buf.write("\u0995\t\33\2\2\u0995\u009d\3\2\2\2\u0996\u0997\t\34\2")
        buf.write("\2\u0997\u009f\3\2\2\2\u0998\u0999\bQ\1\2\u0999\u099a")
        buf.write("\7\u00dc\2\2\u099a\u099b\7\4\2\2\u099b\u09a0\5\u00a2R")
        buf.write("\2\u099c\u099d\7\6\2\2\u099d\u099f\5\u00a2R\2\u099e\u099c")
        buf.write("\3\2\2\2\u099f\u09a2\3\2\2\2\u09a0\u099e\3\2\2\2\u09a0")
        buf.write("\u09a1\3\2\2\2\u09a1\u09a3\3\2\2\2\u09a2\u09a0\3\2\2\2")
        buf.write("\u09a3\u09a4\7\5\2\2\u09a4\u09f4\3\2\2\2\u09a5\u09a6\7")
        buf.write("y\2\2\u09a6\u09a9\5\u009cO\2\u09a7\u09a8\7\u00fa\2\2\u09a8")
        buf.write("\u09aa\5\u009cO\2\u09a9\u09a7\3\2\2\2\u09a9\u09aa\3\2")
        buf.write("\2\2\u09aa\u09f4\3\2\2\2\u09ab\u09b0\7\u00f9\2\2\u09ac")
        buf.write("\u09ad\7\4\2\2\u09ad\u09ae\5\u00a4S\2\u09ae\u09af\7\5")
        buf.write("\2\2\u09af\u09b1\3\2\2\2\u09b0\u09ac\3\2\2\2\u09b0\u09b1")
        buf.write("\3\2\2\2\u09b1\u09b5\3\2\2\2\u09b2\u09b3\7\u011d\2\2\u09b3")
        buf.write("\u09b4\7\u00f8\2\2\u09b4\u09b6\7\u0122\2\2\u09b5\u09b2")
        buf.write("\3\2\2\2\u09b5\u09b6\3\2\2\2\u09b6\u09f4\3\2\2\2\u09b7")
        buf.write("\u09bc\7\u00f9\2\2\u09b8\u09b9\7\4\2\2\u09b9\u09ba\5\u00a4")
        buf.write("S\2\u09ba\u09bb\7\5\2\2\u09bb\u09bd\3\2\2\2\u09bc\u09b8")
        buf.write("\3\2\2\2\u09bc\u09bd\3\2\2\2\u09bd\u09be\3\2\2\2\u09be")
        buf.write("\u09bf\7\u011b\2\2\u09bf\u09c0\7\u00f8\2\2\u09c0\u09f4")
        buf.write("\7\u0122\2\2\u09c1\u09c6\7\u00f8\2\2\u09c2\u09c3\7\4\2")
        buf.write("\2\u09c3\u09c4\5\u00a4S\2\u09c4\u09c5\7\5\2\2\u09c5\u09c7")
        buf.write("\3\2\2\2\u09c6\u09c2\3\2\2\2\u09c6\u09c7\3\2\2\2\u09c7")
        buf.write("\u09cb\3\2\2\2\u09c8\u09c9\7\u011d\2\2\u09c9\u09ca\7\u00f8")
        buf.write("\2\2\u09ca\u09cc\7\u0122\2\2\u09cb\u09c8\3\2\2\2\u09cb")
        buf.write("\u09cc\3\2\2\2\u09cc\u09f4\3\2\2\2\u09cd\u09d2\7\u00f8")
        buf.write("\2\2\u09ce\u09cf\7\4\2\2\u09cf\u09d0\5\u00a4S\2\u09d0")
        buf.write("\u09d1\7\5\2\2\u09d1\u09d3\3\2\2\2\u09d2\u09ce\3\2\2\2")
        buf.write("\u09d2\u09d3\3\2\2\2\u09d3\u09d4\3\2\2\2\u09d4\u09d5\7")
        buf.write("\u011b\2\2\u09d5\u09d6\7\u00f8\2\2\u09d6\u09f4\7\u0122")
        buf.write("\2\2\u09d7\u09d8\7N\2\2\u09d8\u09f4\7\u00c5\2\2\u09d9")
        buf.write("\u09da\7\35\2\2\u09da\u09db\7\u0125\2\2\u09db\u09dc\5")
        buf.write("\u00a0Q\2\u09dc\u09dd\7\u0127\2\2\u09dd\u09f4\3\2\2\2")
        buf.write("\u09de\u09df\7\u0095\2\2\u09df\u09e0\7\u0125\2\2\u09e0")
        buf.write("\u09e1\5\u00a0Q\2\u09e1\u09e2\7\6\2\2\u09e2\u09e3\5\u00a0")
        buf.write("Q\2\u09e3\u09e4\7\u0127\2\2\u09e4\u09f4\3\2\2\2\u09e5")
        buf.write("\u09f1\5\u00d6l\2\u09e6\u09e7\7\4\2\2\u09e7\u09ec\5\u00a4")
        buf.write("S\2\u09e8\u09e9\7\6\2\2\u09e9\u09eb\5\u00a4S\2\u09ea\u09e8")
        buf.write("\3\2\2\2\u09eb\u09ee\3\2\2\2\u09ec\u09ea\3\2\2\2\u09ec")
        buf.write("\u09ed\3\2\2\2\u09ed\u09ef\3\2\2\2\u09ee\u09ec\3\2\2\2")
        buf.write("\u09ef\u09f0\7\5\2\2\u09f0\u09f2\3\2\2\2\u09f1\u09e6\3")
        buf.write("\2\2\2\u09f1\u09f2\3\2\2\2\u09f2\u09f4\3\2\2\2\u09f3\u0998")
        buf.write("\3\2\2\2\u09f3\u09a5\3\2\2\2\u09f3\u09ab\3\2\2\2\u09f3")
        buf.write("\u09b7\3\2\2\2\u09f3\u09c1\3\2\2\2\u09f3\u09cd\3\2\2\2")
        buf.write("\u09f3\u09d7\3\2\2\2\u09f3\u09d9\3\2\2\2\u09f3\u09de\3")
        buf.write("\2\2\2\u09f3\u09e5\3\2\2\2\u09f4\u09fe\3\2\2\2\u09f5\u09f6")
        buf.write("\f\4\2\2\u09f6\u09fa\7\35\2\2\u09f7\u09f8\7\n\2\2\u09f8")
        buf.write("\u09f9\7\u0133\2\2\u09f9\u09fb\7\13\2\2\u09fa\u09f7\3")
        buf.write("\2\2\2\u09fa\u09fb\3\2\2\2\u09fb\u09fd\3\2\2\2\u09fc\u09f5")
        buf.write("\3\2\2\2\u09fd\u0a00\3\2\2\2\u09fe\u09fc\3\2\2\2\u09fe")
        buf.write("\u09ff\3\2\2\2\u09ff\u00a1\3\2\2\2\u0a00\u09fe\3\2\2\2")
        buf.write("\u0a01\u0a06\5\u00a0Q\2\u0a02\u0a03\5\u00d6l\2\u0a03\u0a04")
        buf.write("\5\u00a0Q\2\u0a04\u0a06\3\2\2\2\u0a05\u0a01\3\2\2\2\u0a05")
        buf.write("\u0a02\3\2\2\2\u0a06\u00a3\3\2\2\2\u0a07\u0a0a\7\u0133")
        buf.write("\2\2\u0a08\u0a0a\5\u00a0Q\2\u0a09\u0a07\3\2\2\2\u0a09")
        buf.write("\u0a08\3\2\2\2\u0a0a\u00a5\3\2\2\2\u0a0b\u0a0c\7\u0118")
        buf.write("\2\2\u0a0c\u0a0d\5p9\2\u0a0d\u0a0e\7\u00f6\2\2\u0a0e\u0a0f")
        buf.write("\5p9\2\u0a0f\u00a7\3\2\2\2\u0a10\u0a11\7^\2\2\u0a11\u0a12")
        buf.write("\7\4\2\2\u0a12\u0a13\7\u0119\2\2\u0a13\u0a14\5r:\2\u0a14")
        buf.write("\u0a15\7\5\2\2\u0a15\u00a9\3\2\2\2\u0a16\u0a17\7\u0118")
        buf.write("\2\2\u0a17\u0a1a\7\u0097\2\2\u0a18\u0a19\7\33\2\2\u0a19")
        buf.write("\u0a1b\5p9\2\u0a1a\u0a18\3\2\2\2\u0a1a\u0a1b\3\2\2\2\u0a1b")
        buf.write("\u0a1c\3\2\2\2\u0a1c\u0a1d\7\u00f6\2\2\u0a1d\u0a1e\7\u010b")
        buf.write("\2\2\u0a1e\u0a1f\7\u00e8\2\2\u0a1f\u0a20\5\u00d6l\2\u0a20")
        buf.write("\u0a21\7\u0123\2\2\u0a21\u0a29\5p9\2\u0a22\u0a23\7\6\2")
        buf.write("\2\u0a23\u0a24\5\u00d6l\2\u0a24\u0a25\7\u0123\2\2\u0a25")
        buf.write("\u0a26\5p9\2\u0a26\u0a28\3\2\2\2\u0a27\u0a22\3\2\2\2\u0a28")
        buf.write("\u0a2b\3\2\2\2\u0a29\u0a27\3\2\2\2\u0a29\u0a2a\3\2\2\2")
        buf.write("\u0a2a\u0a57\3\2\2\2\u0a2b\u0a29\3\2\2\2\u0a2c\u0a2d\7")
        buf.write("\u0118\2\2\u0a2d\u0a30\7\u0097\2\2\u0a2e\u0a2f\7\33\2")
        buf.write("\2\u0a2f\u0a31\5p9\2\u0a30\u0a2e\3\2\2\2\u0a30\u0a31\3")
        buf.write("\2\2\2\u0a31\u0a32\3\2\2\2\u0a32\u0a33\7\u00f6\2\2\u0a33")
        buf.write("\u0a57\7F\2\2\u0a34\u0a35\7\u0118\2\2\u0a35\u0a36\7\u00a8")
        buf.write("\2\2\u0a36\u0a39\7\u0097\2\2\u0a37\u0a38\7\33\2\2\u0a38")
        buf.write("\u0a3a\5p9\2\u0a39\u0a37\3\2\2\2\u0a39\u0a3a\3\2\2\2\u0a3a")
        buf.write("\u0a3b\3\2\2\2\u0a3b\u0a3c\7\u00f6\2\2\u0a3c\u0a48\7w")
        buf.write("\2\2\u0a3d\u0a3e\7\4\2\2\u0a3e\u0a43\5\u00d6l\2\u0a3f")
        buf.write("\u0a40\7\6\2\2\u0a40\u0a42\5\u00d6l\2\u0a41\u0a3f\3\2")
        buf.write("\2\2\u0a42\u0a45\3\2\2\2\u0a43\u0a41\3\2\2\2\u0a43\u0a44")
        buf.write("\3\2\2\2\u0a44\u0a46\3\2\2\2\u0a45\u0a43\3\2\2\2\u0a46")
        buf.write("\u0a47\7\5\2\2\u0a47\u0a49\3\2\2\2\u0a48\u0a3d\3\2\2\2")
        buf.write("\u0a48\u0a49\3\2\2\2\u0a49\u0a4a\3\2\2\2\u0a4a\u0a4b\7")
        buf.write("\u0114\2\2\u0a4b\u0a4c\7\4\2\2\u0a4c\u0a51\5p9\2\u0a4d")
        buf.write("\u0a4e\7\6\2\2\u0a4e\u0a50\5p9\2\u0a4f\u0a4d\3\2\2\2\u0a50")
        buf.write("\u0a53\3\2\2\2\u0a51\u0a4f\3\2\2\2\u0a51\u0a52\3\2\2\2")
        buf.write("\u0a52\u0a54\3\2\2\2\u0a53\u0a51\3\2\2\2\u0a54\u0a55\7")
        buf.write("\5\2\2\u0a55\u0a57\3\2\2\2\u0a56\u0a16\3\2\2\2\u0a56\u0a2c")
        buf.write("\3\2\2\2\u0a56\u0a34\3\2\2\2\u0a57\u00ab\3\2\2\2\u0a58")
        buf.write("\u0a5e\7\u00b9\2\2\u0a59\u0a5f\5\u00d6l\2\u0a5a\u0a5b")
        buf.write("\7\4\2\2\u0a5b\u0a5c\5\66\34\2\u0a5c\u0a5d\7\5\2\2\u0a5d")
        buf.write("\u0a5f\3\2\2\2\u0a5e\u0a59\3\2\2\2\u0a5e\u0a5a\3\2\2\2")
        buf.write("\u0a5f\u00ad\3\2\2\2\u0a60\u0a61\7\u009b\2\2\u0a61\u0a66")
        buf.write("\5P)\2\u0a62\u0a63\7\6\2\2\u0a63\u0a65\5P)\2\u0a64\u0a62")
        buf.write("\3\2\2\2\u0a65\u0a68\3\2\2\2\u0a66\u0a64\3\2\2\2\u0a66")
        buf.write("\u0a67\3\2\2\2\u0a67\u0a6a\3\2\2\2\u0a68\u0a66\3\2\2\2")
        buf.write("\u0a69\u0a60\3\2\2\2\u0a69\u0a6a\3\2\2\2\u0a6a\u0a6b\3")
        buf.write("\2\2\2\u0a6b\u0a6f\5\u00b0Y\2\u0a6c\u0a6d\7\27\2\2\u0a6d")
        buf.write("\u0a6e\7\u0096\2\2\u0a6e\u0a70\5V,\2\u0a6f\u0a6c\3\2\2")
        buf.write("\2\u0a6f\u0a70\3\2\2\2\u0a70\u0a72\3\2\2\2\u0a71\u0a73")
        buf.write("\t\20\2\2\u0a72\u0a71\3\2\2\2\u0a72\u0a73\3\2\2\2\u0a73")
        buf.write("\u0a79\3\2\2\2\u0a74\u0a75\7\u00c0\2\2\u0a75\u0a76\7\4")
        buf.write("\2\2\u0a76\u0a77\5\u00b4[\2\u0a77\u0a78\7\5\2\2\u0a78")
        buf.write("\u0a7a\3\2\2\2\u0a79\u0a74\3\2\2\2\u0a79\u0a7a\3\2\2\2")
        buf.write("\u0a7a\u0a84\3\2\2\2\u0a7b\u0a7c\7\u00ee\2\2\u0a7c\u0a81")
        buf.write("\5X-\2\u0a7d\u0a7e\7\6\2\2\u0a7e\u0a80\5X-\2\u0a7f\u0a7d")
        buf.write("\3\2\2\2\u0a80\u0a83\3\2\2\2\u0a81\u0a7f\3\2\2\2\u0a81")
        buf.write("\u0a82\3\2\2\2\u0a82\u0a85\3\2\2\2\u0a83\u0a81\3\2\2\2")
        buf.write("\u0a84\u0a7b\3\2\2\2\u0a84\u0a85\3\2\2\2\u0a85\u0a8f\3")
        buf.write("\2\2\2\u0a86\u0a87\7K\2\2\u0a87\u0a8c\5Z.\2\u0a88\u0a89")
        buf.write("\7\6\2\2\u0a89\u0a8b\5Z.\2\u0a8a\u0a88\3\2\2\2\u0a8b\u0a8e")
        buf.write("\3\2\2\2\u0a8c\u0a8a\3\2\2\2\u0a8c\u0a8d\3\2\2\2\u0a8d")
        buf.write("\u0a90\3\2\2\2\u0a8e\u0a8c\3\2\2\2\u0a8f\u0a86\3\2\2\2")
        buf.write("\u0a8f\u0a90\3\2\2\2\u0a90\u00af\3\2\2\2\u0a91\u0a92\7")
        buf.write("\u00cb\2\2\u0a92\u0aaa\5\u00b2Z\2\u0a93\u0a94\7\u00dd")
        buf.write("\2\2\u0a94\u0aaa\5\u00b2Z\2\u0a95\u0a96\7m\2\2\u0a96\u0aaa")
        buf.write("\5\u00b2Z\2\u0a97\u0a98\7\u00cb\2\2\u0a98\u0a99\7#\2\2")
        buf.write("\u0a99\u0a9a\5\u00b2Z\2\u0a9a\u0a9b\7\33\2\2\u0a9b\u0a9c")
        buf.write("\5\u00b2Z\2\u0a9c\u0aaa\3\2\2\2\u0a9d\u0a9e\7\u00dd\2")
        buf.write("\2\u0a9e\u0a9f\7#\2\2\u0a9f\u0aa0\5\u00b2Z\2\u0aa0\u0aa1")
        buf.write("\7\33\2\2\u0aa1\u0aa2\5\u00b2Z\2\u0aa2\u0aaa\3\2\2\2\u0aa3")
        buf.write("\u0aa4\7m\2\2\u0aa4\u0aa5\7#\2\2\u0aa5\u0aa6\5\u00b2Z")
        buf.write("\2\u0aa6\u0aa7\7\33\2\2\u0aa7\u0aa8\5\u00b2Z\2\u0aa8\u0aaa")
        buf.write("\3\2\2\2\u0aa9\u0a91\3\2\2\2\u0aa9\u0a93\3\2\2\2\u0aa9")
        buf.write("\u0a95\3\2\2\2\u0aa9\u0a97\3\2\2\2\u0aa9\u0a9d\3\2\2\2")
        buf.write("\u0aa9\u0aa3\3\2\2\2\u0aaa\u00b1\3\2\2\2\u0aab\u0aac\7")
        buf.write("\u0103\2\2\u0aac\u0ab5\7\u00c4\2\2\u0aad\u0aae\7\u0103")
        buf.write("\2\2\u0aae\u0ab5\7a\2\2\u0aaf\u0ab0\7\67\2\2\u0ab0\u0ab5")
        buf.write("\7\u00dc\2\2\u0ab1\u0ab2\5p9\2\u0ab2\u0ab3\t\35\2\2\u0ab3")
        buf.write("\u0ab5\3\2\2\2\u0ab4\u0aab\3\2\2\2\u0ab4\u0aad\3\2\2\2")
        buf.write("\u0ab4\u0aaf\3\2\2\2\u0ab4\u0ab1\3\2\2\2\u0ab5\u00b3\3")
        buf.write("\2\2\2\u0ab6\u0ab7\b[\1\2\u0ab7\u0ab9\5\u00b6\\\2\u0ab8")
        buf.write("\u0aba\5\u00b8]\2\u0ab9\u0ab8\3\2\2\2\u0ab9\u0aba\3\2")
        buf.write("\2\2\u0aba\u0ac2\3\2\2\2\u0abb\u0abc\f\4\2\2\u0abc\u0ac1")
        buf.write("\5\u00b4[\5\u0abd\u0abe\f\3\2\2\u0abe\u0abf\7\r\2\2\u0abf")
        buf.write("\u0ac1\5\u00b4[\4\u0ac0\u0abb\3\2\2\2\u0ac0\u0abd\3\2")
        buf.write("\2\2\u0ac1\u0ac4\3\2\2\2\u0ac2\u0ac0\3\2\2\2\u0ac2\u0ac3")
        buf.write("\3\2\2\2\u0ac3\u00b5\3\2\2\2\u0ac4\u0ac2\3\2\2\2\u0ac5")
        buf.write("\u0adf\5\u00d6l\2\u0ac6\u0ac7\7\4\2\2\u0ac7\u0adf\7\5")
        buf.write("\2\2\u0ac8\u0ac9\7\u00c2\2\2\u0ac9\u0aca\7\4\2\2\u0aca")
        buf.write("\u0acf\5\u00b4[\2\u0acb\u0acc\7\6\2\2\u0acc\u0ace\5\u00b4")
        buf.write("[\2\u0acd\u0acb\3\2\2\2\u0ace\u0ad1\3\2\2\2\u0acf\u0acd")
        buf.write("\3\2\2\2\u0acf\u0ad0\3\2\2\2\u0ad0\u0ad2\3\2\2\2\u0ad1")
        buf.write("\u0acf\3\2\2\2\u0ad2\u0ad3\7\5\2\2\u0ad3\u0adf\3\2\2\2")
        buf.write("\u0ad4\u0ad5\7\4\2\2\u0ad5\u0ad6\5\u00b4[\2\u0ad6\u0ad7")
        buf.write("\7\5\2\2\u0ad7\u0adf\3\2\2\2\u0ad8\u0adf\7\16\2\2\u0ad9")
        buf.write("\u0adf\7\17\2\2\u0ada\u0adb\7\20\2\2\u0adb\u0adc\5\u00b4")
        buf.write("[\2\u0adc\u0add\7\21\2\2\u0add\u0adf\3\2\2\2\u0ade\u0ac5")
        buf.write("\3\2\2\2\u0ade\u0ac6\3\2\2\2\u0ade\u0ac8\3\2\2\2\u0ade")
        buf.write("\u0ad4\3\2\2\2\u0ade\u0ad8\3\2\2\2\u0ade\u0ad9\3\2\2\2")
        buf.write("\u0ade\u0ada\3\2\2\2\u0adf\u00b7\3\2\2\2\u0ae0\u0ae2\7")
        buf.write("\u012b\2\2\u0ae1\u0ae3\7\u012f\2\2\u0ae2\u0ae1\3\2\2\2")
        buf.write("\u0ae2\u0ae3\3\2\2\2\u0ae3\u0aff\3\2\2\2\u0ae4\u0ae6\7")
        buf.write("\u0129\2\2\u0ae5\u0ae7\7\u012f\2\2\u0ae6\u0ae5\3\2\2\2")
        buf.write("\u0ae6\u0ae7\3\2\2\2\u0ae7\u0aff\3\2\2\2\u0ae8\u0aea\7")
        buf.write("\u012f\2\2\u0ae9\u0aeb\7\u012f\2\2\u0aea\u0ae9\3\2\2\2")
        buf.write("\u0aea\u0aeb\3\2\2\2\u0aeb\u0aff\3\2\2\2\u0aec\u0aed\7")
        buf.write("\22\2\2\u0aed\u0aee\7\u0133\2\2\u0aee\u0af0\7\23\2\2\u0aef")
        buf.write("\u0af1\7\u012f\2\2\u0af0\u0aef\3\2\2\2\u0af0\u0af1\3\2")
        buf.write("\2\2\u0af1\u0aff\3\2\2\2\u0af2\u0af4\7\22\2\2\u0af3\u0af5")
        buf.write("\7\u0133\2\2\u0af4\u0af3\3\2\2\2\u0af4\u0af5\3\2\2\2\u0af5")
        buf.write("\u0af6\3\2\2\2\u0af6\u0af8\7\6\2\2\u0af7\u0af9\7\u0133")
        buf.write("\2\2\u0af8\u0af7\3\2\2\2\u0af8\u0af9\3\2\2\2\u0af9\u0afa")
        buf.write("\3\2\2\2\u0afa\u0afc\7\23\2\2\u0afb\u0afd\7\u012f\2\2")
        buf.write("\u0afc\u0afb\3\2\2\2\u0afc\u0afd\3\2\2\2\u0afd\u0aff\3")
        buf.write("\2\2\2\u0afe\u0ae0\3\2\2\2\u0afe\u0ae4\3\2\2\2\u0afe\u0ae8")
        buf.write("\3\2\2\2\u0afe\u0aec\3\2\2\2\u0afe\u0af2\3\2\2\2\u0aff")
        buf.write("\u00b9\3\2\2\2\u0b00\u0b01\5\u00d6l\2\u0b01\u0b02\7\u0123")
        buf.write("\2\2\u0b02\u0b03\5p9\2\u0b03\u00bb\3\2\2\2\u0b04\u0b05")
        buf.write("\7c\2\2\u0b05\u0b09\t\36\2\2\u0b06\u0b07\7\u0101\2\2\u0b07")
        buf.write("\u0b09\t\37\2\2\u0b08\u0b04\3\2\2\2\u0b08\u0b06\3\2\2")
        buf.write("\2\u0b09\u00bd\3\2\2\2\u0b0a\u0b0b\7~\2\2\u0b0b\u0b0c")
        buf.write("\7\u008d\2\2\u0b0c\u0b10\5\u00c0a\2\u0b0d\u0b0e\7\u00cc")
        buf.write("\2\2\u0b0e\u0b10\t \2\2\u0b0f\u0b0a\3\2\2\2\u0b0f\u0b0d")
        buf.write("\3\2\2\2\u0b10\u00bf\3\2\2\2\u0b11\u0b12\7\u00cc\2\2\u0b12")
        buf.write("\u0b19\7\u0104\2\2\u0b13\u0b14\7\u00cc\2\2\u0b14\u0b19")
        buf.write("\7/\2\2\u0b15\u0b16\7\u00d0\2\2\u0b16\u0b19\7\u00cc\2")
        buf.write("\2\u0b17\u0b19\7\u00e6\2\2\u0b18\u0b11\3\2\2\2\u0b18\u0b13")
        buf.write("\3\2\2\2\u0b18\u0b15\3\2\2\2\u0b18\u0b17\3\2\2\2\u0b19")
        buf.write("\u00c1\3\2\2\2\u0b1a\u0b20\5p9\2\u0b1b\u0b1c\5\u00d6l")
        buf.write("\2\u0b1c\u0b1d\7\b\2\2\u0b1d\u0b1e\5p9\2\u0b1e\u0b20\3")
        buf.write("\2\2\2\u0b1f\u0b1a\3\2\2\2\u0b1f\u0b1b\3\2\2\2\u0b20\u00c3")
        buf.write("\3\2\2\2\u0b21\u0b22\5\u00d6l\2\u0b22\u0b23\7\3\2\2\u0b23")
        buf.write("\u0b24\5\u00d6l\2\u0b24\u0b27\3\2\2\2\u0b25\u0b27\5\u00d6")
        buf.write("l\2\u0b26\u0b21\3\2\2\2\u0b26\u0b25\3\2\2\2\u0b27\u00c5")
        buf.write("\3\2\2\2\u0b28\u0b2d\5\u00c4c\2\u0b29\u0b2a\7\6\2\2\u0b2a")
        buf.write("\u0b2c\5\u00c4c\2\u0b2b\u0b29\3\2\2\2\u0b2c\u0b2f\3\2")
        buf.write("\2\2\u0b2d\u0b2b\3\2\2\2\u0b2d\u0b2e\3\2\2\2\u0b2e\u00c7")
        buf.write("\3\2\2\2\u0b2f\u0b2d\3\2\2\2\u0b30\u0b31\t!\2\2\u0b31")
        buf.write("\u00c9\3\2\2\2\u0b32\u0b37\5\u00d6l\2\u0b33\u0b34\7\3")
        buf.write("\2\2\u0b34\u0b36\5\u00d6l\2\u0b35\u0b33\3\2\2\2\u0b36")
        buf.write("\u0b39\3\2\2\2\u0b37\u0b35\3\2\2\2\u0b37\u0b38\3\2\2\2")
        buf.write("\u0b38\u00cb\3\2\2\2\u0b39\u0b37\3\2\2\2\u0b3a\u0b3b\7")
        buf.write("b\2\2\u0b3b\u0b3c\5\u00ceh\2\u0b3c\u0b3d\7\36\2\2\u0b3d")
        buf.write("\u0b3e\7\u00af\2\2\u0b3e\u0b3f\5v<\2\u0b3f\u00cd\3\2\2")
        buf.write("\2\u0b40\u0b41\t\"\2\2\u0b41\u00cf\3\2\2\2\u0b42\u0b46")
        buf.write("\5\u00d2j\2\u0b43\u0b46\7?\2\2\u0b44\u0b46\7;\2\2\u0b45")
        buf.write("\u0b42\3\2\2\2\u0b45\u0b43\3\2\2\2\u0b45\u0b44\3\2\2\2")
        buf.write("\u0b46\u00d1\3\2\2\2\u0b47\u0b4d\5\u00d6l\2\u0b48\u0b49")
        buf.write("\7\u010d\2\2\u0b49\u0b4d\5\u00d6l\2\u0b4a\u0b4b\7\u00d8")
        buf.write("\2\2\u0b4b\u0b4d\5\u00d6l\2\u0b4c\u0b47\3\2\2\2\u0b4c")
        buf.write("\u0b48\3\2\2\2\u0b4c\u0b4a\3\2\2\2\u0b4d\u00d3\3\2\2\2")
        buf.write("\u0b4e\u0b53\5\u00d6l\2\u0b4f\u0b50\7\6\2\2\u0b50\u0b52")
        buf.write("\5\u00d6l\2\u0b51\u0b4f\3\2\2\2\u0b52\u0b55\3\2\2\2\u0b53")
        buf.write("\u0b51\3\2\2\2\u0b53\u0b54\3\2\2\2\u0b54\u00d5\3\2\2\2")
        buf.write("\u0b55\u0b53\3\2\2\2\u0b56\u0b5c\7\u0136\2\2\u0b57\u0b5c")
        buf.write("\7\u0138\2\2\u0b58\u0b5c\5\u00dan\2\u0b59\u0b5c\7\u0139")
        buf.write("\2\2\u0b5a\u0b5c\7\u0137\2\2\u0b5b\u0b56\3\2\2\2\u0b5b")
        buf.write("\u0b57\3\2\2\2\u0b5b\u0b58\3\2\2\2\u0b5b\u0b59\3\2\2\2")
        buf.write("\u0b5b\u0b5a\3\2\2\2\u0b5c\u00d7\3\2\2\2\u0b5d\u0b5f\7")
        buf.write("\u012a\2\2\u0b5e\u0b5d\3\2\2\2\u0b5e\u0b5f\3\2\2\2\u0b5f")
        buf.write("\u0b60\3\2\2\2\u0b60\u0b6a\7\u0134\2\2\u0b61\u0b63\7\u012a")
        buf.write("\2\2\u0b62\u0b61\3\2\2\2\u0b62\u0b63\3\2\2\2\u0b63\u0b64")
        buf.write("\3\2\2\2\u0b64\u0b6a\7\u0135\2\2\u0b65\u0b67\7\u012a\2")
        buf.write("\2\u0b66\u0b65\3\2\2\2\u0b66\u0b67\3\2\2\2\u0b67\u0b68")
        buf.write("\3\2\2\2\u0b68\u0b6a\7\u0133\2\2\u0b69\u0b5e\3\2\2\2\u0b69")
        buf.write("\u0b62\3\2\2\2\u0b69\u0b66\3\2\2\2\u0b6a\u00d9\3\2\2\2")
        buf.write("\u0b6b\u0b6c\t#\2\2\u0b6c\u00db\3\2\2\2\u0189\u00f8\u00fd")
        buf.write("\u0101\u0107\u010b\u0120\u0124\u0128\u012c\u0134\u0138")
        buf.write("\u013b\u0142\u014b\u0151\u0155\u015b\u0162\u016b\u0177")
        buf.write("\u0180\u0186\u0191\u0199\u01a1\u01a8\u01b2\u01b9\u01d6")
        buf.write("\u01d9\u01dc\u01e0\u01e6\u01eb\u01f2\u01f7\u01fb\u0203")
        buf.write("\u0209\u020d\u021b\u0223\u0236\u024f\u0252\u025c\u0260")
        buf.write("\u0267\u0271\u0277\u027c\u0280\u0286\u028f\u0295\u0299")
        buf.write("\u02a0\u02a4\u02ac\u02b1\u02b5\u02bd\u02c5\u02ca\u02ce")
        buf.write("\u02d8\u02df\u02e4\u02e8\u02f2\u02f5\u02fe\u0303\u0309")
        buf.write("\u0321\u0327\u0329\u032f\u0335\u0337\u033f\u0341\u0347")
        buf.write("\u034d\u034f\u035e\u0363\u036a\u0376\u0378\u0380\u0382")
        buf.write("\u0394\u0397\u039b\u039f\u03b1\u03b4\u03c4\u03ce\u03d3")
        buf.write("\u03d9\u03dc\u03e5\u03e7\u03ea\u03f0\u03f7\u03fc\u0402")
        buf.write("\u0406\u040a\u0410\u041b\u0424\u042e\u0431\u0436\u0438")
        buf.write("\u043f\u0445\u0447\u044b\u0455\u045b\u045e\u0460\u046c")
        buf.write("\u0473\u0477\u047b\u047f\u0486\u048f\u0492\u0496\u049b")
        buf.write("\u049f\u04a7\u04aa\u04ad\u04b4\u04bf\u04c2\u04cc\u04cf")
        buf.write("\u04da\u04df\u04e7\u04ea\u04ee\u04f7\u0500\u0503\u050c")
        buf.write("\u050f\u0512\u0516\u0521\u0524\u052b\u052e\u0541\u0545")
        buf.write("\u0549\u054d\u0551\u0555\u0557\u0562\u0567\u0570\u0579")
        buf.write("\u057c\u0582\u058e\u0591\u059a\u059d\u05a5\u05a8\u05ab")
        buf.write("\u05b0\u05b3\u05bf\u05c2\u05ca\u05cf\u05d3\u05d5\u05d7")
        buf.write("\u05e6\u05e8\u05f3\u0608\u0612\u061d\u0621\u0623\u062b")
        buf.write("\u0632\u063f\u0645\u0655\u065e\u0661\u0669\u066c\u0673")
        buf.write("\u0678\u0683\u0686\u068a\u068c\u0694\u069e\u06a4\u06a6")
        buf.write("\u06ad\u06b1\u06b3\u06ba\u06be\u06c0\u06c2\u06cb\u06d6")
        buf.write("\u06da\u06e4\u06ee\u06f2\u06fa\u06fc\u0709\u0711\u071a")
        buf.write("\u0720\u0728\u072e\u0732\u0737\u073c\u0742\u0750\u0752")
        buf.write("\u0770\u077b\u0783\u0788\u078d\u079a\u07a0\u07a7\u07ac")
        buf.write("\u07af\u07b2\u07b7\u07be\u07c1\u07ca\u07cd\u07d1\u07d4")
        buf.write("\u07d7\u07e6\u07e9\u07fc\u0800\u0808\u080c\u0825\u0828")
        buf.write("\u0831\u0837\u083d\u0843\u084c\u084f\u0852\u0865\u086e")
        buf.write("\u0884\u0887\u0891\u089a\u08a0\u08a6\u08b1\u08b3\u08b8")
        buf.write("\u08bf\u08c1\u08c7\u08cd\u08d8\u08e1\u08e6\u08eb\u08ed")
        buf.write("\u08ef\u08f5\u08f7\u0901\u090a\u090c\u0912\u0914\u0917")
        buf.write("\u0921\u0923\u092f\u0932\u0937\u093c\u0948\u094c\u0950")
        buf.write("\u0953\u0955\u095d\u0960\u096a\u0972\u0978\u097a\u0982")
        buf.write("\u098c\u0992\u09a0\u09a9\u09b0\u09b5\u09bc\u09c6\u09cb")
        buf.write("\u09d2\u09ec\u09f1\u09f3\u09fa\u09fe\u0a05\u0a09\u0a1a")
        buf.write("\u0a29\u0a30\u0a39\u0a43\u0a48\u0a51\u0a56\u0a5e\u0a66")
        buf.write("\u0a69\u0a6f\u0a72\u0a79\u0a81\u0a84\u0a8c\u0a8f\u0aa9")
        buf.write("\u0ab4\u0ab9\u0ac0\u0ac2\u0acf\u0ade\u0ae2\u0ae6\u0aea")
        buf.write("\u0af0\u0af4\u0af8\u0afc\u0afe\u0b08\u0b0f\u0b18\u0b1f")
        buf.write("\u0b26\u0b2d\u0b37\u0b45\u0b4c\u0b53\u0b5b\u0b5e\u0b62")
        buf.write("\u0b66\u0b69")
        return buf.getvalue()


class SqlBaseParser ( Parser ):

    grammarFileName = "SqlBase.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'.'", "'('", "')'", "','", "'SKIP'", 
                     "'=>'", "'->'", "'['", "']'", "':'", "'|'", "'^'", 
                     "'$'", "'{-'", "'-}'", "'{'", "'}'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'NFC'", "'NFD'", 
                     "'NFKC'", "'NFKD'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'STRING'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'UTF16'", "'UTF32'", 
                     "'UTF8'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'='", "<INVALID>", "'<'", "'<='", "'>'", 
                     "'>='", "'+'", "'-'", "'*'", "'/'", "'%'", "'||'", 
                     "'?'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "ABSENT", "ADD", "ADMIN", 
                      "AFTER", "ALL", "ALTER", "ANALYZE", "AND", "ANY", 
                      "ARRAY", "AS", "ASC", "AT", "AUTHORIZATION", "BERNOULLI", 
                      "BETWEEN", "BOTH", "BY", "CALL", "CASCADE", "CASE", 
                      "CAST", "CATALOGS", "COLUMN", "COLUMNS", "COMMENT", 
                      "COMMIT", "COMMITTED", "CONDITIONAL", "CONSTRAINT", 
                      "COUNT", "COPARTITION", "CREATE", "CROSS", "CUBE", 
                      "CURRENT", "CURRENT_CATALOG", "CURRENT_DATE", "CURRENT_PATH", 
                      "CURRENT_ROLE", "CURRENT_SCHEMA", "CURRENT_TIME", 
                      "CURRENT_TIMESTAMP", "CURRENT_USER", "DATA", "DATE", 
                      "DAY", "DEALLOCATE", "DEFAULT", "DEFINER", "DELETE", 
                      "DENY", "DESC", "DESCRIBE", "DESCRIPTOR", "DEFINE", 
                      "DISTINCT", "DISTRIBUTED", "DOUBLE", "DROP", "ELSE", 
                      "EMPTY", "ENCODING", "END", "ERROR", "ESCAPE", "EXCEPT", 
                      "EXCLUDING", "EXECUTE", "EXISTS", "EXPLAIN", "EXTRACT", 
                      "FALSE", "FETCH", "FILTER", "FINAL", "FIRST", "FOLLOWING", 
                      "FOR", "FORMAT", "FROM", "FULL", "FUNCTIONS", "GRANT", 
                      "GRANTED", "GRANTS", "GRAPHVIZ", "GROUP", "GROUPING", 
                      "GROUPS", "HAVING", "HOUR", "IF", "IGNORE", "IN", 
                      "INCLUDING", "INITIAL", "INNER", "INPUT", "INSERT", 
                      "INTERSECT", "INTERVAL", "INTO", "INVOKER", "IO", 
                      "IS", "ISOLATION", "JOIN", "JSON", "JSON_ARRAY", "JSON_EXISTS", 
                      "JSON_OBJECT", "JSON_QUERY", "JSON_VALUE", "KEEP", 
                      "KEY", "KEYS", "LAST", "LATERAL", "LEADING", "LEFT", 
                      "LEVEL", "LIKE", "LIMIT", "LISTAGG", "LOCAL", "LOCALTIME", 
                      "LOCALTIMESTAMP", "LOGICAL", "MAP", "MATCH", "MATCHED", 
                      "MATCHES", "MATCH_RECOGNIZE", "MATERIALIZED", "MEASURES", 
                      "MERGE", "MINUTE", "MONTH", "NATURAL", "NEXT", "NFC", 
                      "NFD", "NFKC", "NFKD", "NO", "NONE", "NORMALIZE", 
                      "NOT", "NULL", "NULLIF", "NULLS", "OBJECT", "OFFSET", 
                      "OMIT", "OF", "ON", "ONE", "ONLY", "OPTION", "OR", 
                      "ORDER", "ORDINALITY", "OUTER", "OUTPUT", "OVER", 
                      "OVERFLOW", "PARTITION", "PARTITIONS", "PASSING", 
                      "PAST", "PATH", "PATTERN", "PER", "PERMUTE", "POSITION", 
                      "PRECEDING", "PRECISION", "PREPARE", "PRIVILEGES", 
                      "PROPERTIES", "PRUNE", "QUOTES", "RANGE", "READ", 
                      "RECURSIVE", "REFRESH", "RENAME", "REPEATABLE", "REPLACE", 
                      "RESET", "RESPECT", "RESTRICT", "RETURNING", "REVOKE", 
                      "RIGHT", "ROLE", "ROLES", "ROLLBACK", "ROLLUP", "ROW", 
                      "ROWS", "RUNNING", "SCALAR", "SCHEMA", "SCHEMAS", 
                      "SECOND", "SECURITY", "SEEK", "SELECT", "SERIALIZABLE", 
                      "SESSION", "SET", "SETS", "SHOW", "SOME", "START", 
                      "STATS", "SUBSET", "SUBSTRING", "SYSTEM", "TABLE", 
                      "TABLES", "TABLESAMPLE", "TEXT", "TEXT_STRING", "THEN", 
                      "TIES", "TIME", "TIMESTAMP", "TO", "TRAILING", "TRANSACTION", 
                      "TRIM", "TRUE", "TRUNCATE", "TRY_CAST", "TYPE", "UESCAPE", 
                      "UNBOUNDED", "UNCOMMITTED", "UNCONDITIONAL", "UNION", 
                      "UNIQUE", "UNKNOWN", "UNMATCHED", "UNNEST", "UPDATE", 
                      "USE", "USER", "USING", "UTF16", "UTF32", "UTF8", 
                      "VALIDATE", "VALUE", "VALUES", "VERBOSE", "VERSION", 
                      "VIEW", "WHEN", "WHERE", "WINDOW", "WITH", "WITHIN", 
                      "WITHOUT", "WORK", "WRAPPER", "WRITE", "YEAR", "ZONE", 
                      "EQ", "NEQ", "LT", "LTE", "GT", "GTE", "PLUS", "MINUS", 
                      "ASTERISK", "SLASH", "PERCENT", "CONCAT", "QUESTION_MARK", 
                      "STRING", "UNICODE_STRING", "BINARY_LITERAL", "INTEGER_VALUE", 
                      "DECIMAL_VALUE", "DOUBLE_VALUE", "IDENTIFIER", "DIGIT_IDENTIFIER", 
                      "QUOTED_IDENTIFIER", "BACKQUOTED_IDENTIFIER", "SIMPLE_COMMENT", 
                      "BRACKETED_COMMENT", "WS", "UNRECOGNIZED", "DELIMITER" ]

    RULE_singleStatement = 0
    RULE_standaloneExpression = 1
    RULE_standalonePathSpecification = 2
    RULE_standaloneType = 3
    RULE_standaloneRowPattern = 4
    RULE_statement = 5
    RULE_query = 6
    RULE_with_ = 7
    RULE_tableElement = 8
    RULE_columnDefinition = 9
    RULE_likeClause = 10
    RULE_properties = 11
    RULE_propertyAssignments = 12
    RULE_property_ = 13
    RULE_propertyValue = 14
    RULE_queryNoWith = 15
    RULE_limitRowCount = 16
    RULE_rowCount = 17
    RULE_queryTerm = 18
    RULE_queryPrimary = 19
    RULE_sortItem = 20
    RULE_querySpecification = 21
    RULE_groupBy = 22
    RULE_groupingElement = 23
    RULE_groupingSet = 24
    RULE_windowDefinition = 25
    RULE_windowSpecification = 26
    RULE_namedQuery = 27
    RULE_setQuantifier = 28
    RULE_selectItem = 29
    RULE_relation = 30
    RULE_joinType = 31
    RULE_joinCriteria = 32
    RULE_sampledRelation = 33
    RULE_sampleType = 34
    RULE_trimsSpecification = 35
    RULE_listAggOverflowBehavior = 36
    RULE_listaggCountIndication = 37
    RULE_patternRecognition = 38
    RULE_measureDefinition = 39
    RULE_rowsPerMatch = 40
    RULE_emptyMatchHandling = 41
    RULE_skipTo = 42
    RULE_subsetDefinition = 43
    RULE_variableDefinition = 44
    RULE_aliasedRelation = 45
    RULE_columnAliases = 46
    RULE_relationPrimary = 47
    RULE_tableFunctionCall = 48
    RULE_tableFunctionArgument = 49
    RULE_tableArgument = 50
    RULE_tableArgumentRelation = 51
    RULE_descriptorArgument = 52
    RULE_descriptorField = 53
    RULE_copartitionTables = 54
    RULE_expression = 55
    RULE_booleanExpression = 56
    RULE_predicate = 57
    RULE_valueExpression = 58
    RULE_primaryExpression = 59
    RULE_jsonPathInvocation = 60
    RULE_jsonValueExpression = 61
    RULE_jsonRepresentation = 62
    RULE_jsonArgument = 63
    RULE_jsonExistsErrorBehavior = 64
    RULE_jsonValueBehavior = 65
    RULE_jsonQueryWrapperBehavior = 66
    RULE_jsonQueryBehavior = 67
    RULE_jsonObjectMember = 68
    RULE_processingMode = 69
    RULE_nullTreatment = 70
    RULE_string = 71
    RULE_timeZoneSpecifier = 72
    RULE_comparisonOperator = 73
    RULE_comparisonQuantifier = 74
    RULE_booleanValue = 75
    RULE_interval = 76
    RULE_intervalField = 77
    RULE_normalForm = 78
    RULE_type_ = 79
    RULE_rowField = 80
    RULE_typeParameter = 81
    RULE_whenClause = 82
    RULE_filter_ = 83
    RULE_mergeCase = 84
    RULE_over = 85
    RULE_windowFrame = 86
    RULE_frameExtent = 87
    RULE_frameBound = 88
    RULE_rowPattern = 89
    RULE_patternPrimary = 90
    RULE_patternQuantifier = 91
    RULE_updateAssignment = 92
    RULE_explainOption = 93
    RULE_transactionMode = 94
    RULE_levelOfIsolation = 95
    RULE_callArgument = 96
    RULE_pathElement = 97
    RULE_pathSpecification = 98
    RULE_privilege = 99
    RULE_qualifiedName = 100
    RULE_queryPeriod = 101
    RULE_rangeType = 102
    RULE_grantor = 103
    RULE_principal = 104
    RULE_roles = 105
    RULE_identifier = 106
    RULE_number = 107
    RULE_nonReserved = 108

    ruleNames =  [ "singleStatement", "standaloneExpression", "standalonePathSpecification", 
                   "standaloneType", "standaloneRowPattern", "statement", 
                   "query", "with_", "tableElement", "columnDefinition", 
                   "likeClause", "properties", "propertyAssignments", "property_", 
                   "propertyValue", "queryNoWith", "limitRowCount", "rowCount", 
                   "queryTerm", "queryPrimary", "sortItem", "querySpecification", 
                   "groupBy", "groupingElement", "groupingSet", "windowDefinition", 
                   "windowSpecification", "namedQuery", "setQuantifier", 
                   "selectItem", "relation", "joinType", "joinCriteria", 
                   "sampledRelation", "sampleType", "trimsSpecification", 
                   "listAggOverflowBehavior", "listaggCountIndication", 
                   "patternRecognition", "measureDefinition", "rowsPerMatch", 
                   "emptyMatchHandling", "skipTo", "subsetDefinition", "variableDefinition", 
                   "aliasedRelation", "columnAliases", "relationPrimary", 
                   "tableFunctionCall", "tableFunctionArgument", "tableArgument", 
                   "tableArgumentRelation", "descriptorArgument", "descriptorField", 
                   "copartitionTables", "expression", "booleanExpression", 
                   "predicate", "valueExpression", "primaryExpression", 
                   "jsonPathInvocation", "jsonValueExpression", "jsonRepresentation", 
                   "jsonArgument", "jsonExistsErrorBehavior", "jsonValueBehavior", 
                   "jsonQueryWrapperBehavior", "jsonQueryBehavior", "jsonObjectMember", 
                   "processingMode", "nullTreatment", "string", "timeZoneSpecifier", 
                   "comparisonOperator", "comparisonQuantifier", "booleanValue", 
                   "interval", "intervalField", "normalForm", "type_", "rowField", 
                   "typeParameter", "whenClause", "filter_", "mergeCase", 
                   "over", "windowFrame", "frameExtent", "frameBound", "rowPattern", 
                   "patternPrimary", "patternQuantifier", "updateAssignment", 
                   "explainOption", "transactionMode", "levelOfIsolation", 
                   "callArgument", "pathElement", "pathSpecification", "privilege", 
                   "qualifiedName", "queryPeriod", "rangeType", "grantor", 
                   "principal", "roles", "identifier", "number", "nonReserved" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    ABSENT=18
    ADD=19
    ADMIN=20
    AFTER=21
    ALL=22
    ALTER=23
    ANALYZE=24
    AND=25
    ANY=26
    ARRAY=27
    AS=28
    ASC=29
    AT=30
    AUTHORIZATION=31
    BERNOULLI=32
    BETWEEN=33
    BOTH=34
    BY=35
    CALL=36
    CASCADE=37
    CASE=38
    CAST=39
    CATALOGS=40
    COLUMN=41
    COLUMNS=42
    COMMENT=43
    COMMIT=44
    COMMITTED=45
    CONDITIONAL=46
    CONSTRAINT=47
    COUNT=48
    COPARTITION=49
    CREATE=50
    CROSS=51
    CUBE=52
    CURRENT=53
    CURRENT_CATALOG=54
    CURRENT_DATE=55
    CURRENT_PATH=56
    CURRENT_ROLE=57
    CURRENT_SCHEMA=58
    CURRENT_TIME=59
    CURRENT_TIMESTAMP=60
    CURRENT_USER=61
    DATA=62
    DATE=63
    DAY=64
    DEALLOCATE=65
    DEFAULT=66
    DEFINER=67
    DELETE=68
    DENY=69
    DESC=70
    DESCRIBE=71
    DESCRIPTOR=72
    DEFINE=73
    DISTINCT=74
    DISTRIBUTED=75
    DOUBLE=76
    DROP=77
    ELSE=78
    EMPTY=79
    ENCODING=80
    END=81
    ERROR=82
    ESCAPE=83
    EXCEPT=84
    EXCLUDING=85
    EXECUTE=86
    EXISTS=87
    EXPLAIN=88
    EXTRACT=89
    FALSE=90
    FETCH=91
    FILTER=92
    FINAL=93
    FIRST=94
    FOLLOWING=95
    FOR=96
    FORMAT=97
    FROM=98
    FULL=99
    FUNCTIONS=100
    GRANT=101
    GRANTED=102
    GRANTS=103
    GRAPHVIZ=104
    GROUP=105
    GROUPING=106
    GROUPS=107
    HAVING=108
    HOUR=109
    IF=110
    IGNORE=111
    IN=112
    INCLUDING=113
    INITIAL=114
    INNER=115
    INPUT=116
    INSERT=117
    INTERSECT=118
    INTERVAL=119
    INTO=120
    INVOKER=121
    IO=122
    IS=123
    ISOLATION=124
    JOIN=125
    JSON=126
    JSON_ARRAY=127
    JSON_EXISTS=128
    JSON_OBJECT=129
    JSON_QUERY=130
    JSON_VALUE=131
    KEEP=132
    KEY=133
    KEYS=134
    LAST=135
    LATERAL=136
    LEADING=137
    LEFT=138
    LEVEL=139
    LIKE=140
    LIMIT=141
    LISTAGG=142
    LOCAL=143
    LOCALTIME=144
    LOCALTIMESTAMP=145
    LOGICAL=146
    MAP=147
    MATCH=148
    MATCHED=149
    MATCHES=150
    MATCH_RECOGNIZE=151
    MATERIALIZED=152
    MEASURES=153
    MERGE=154
    MINUTE=155
    MONTH=156
    NATURAL=157
    NEXT=158
    NFC=159
    NFD=160
    NFKC=161
    NFKD=162
    NO=163
    NONE=164
    NORMALIZE=165
    NOT=166
    NULL=167
    NULLIF=168
    NULLS=169
    OBJECT=170
    OFFSET=171
    OMIT=172
    OF=173
    ON=174
    ONE=175
    ONLY=176
    OPTION=177
    OR=178
    ORDER=179
    ORDINALITY=180
    OUTER=181
    OUTPUT=182
    OVER=183
    OVERFLOW=184
    PARTITION=185
    PARTITIONS=186
    PASSING=187
    PAST=188
    PATH=189
    PATTERN=190
    PER=191
    PERMUTE=192
    POSITION=193
    PRECEDING=194
    PRECISION=195
    PREPARE=196
    PRIVILEGES=197
    PROPERTIES=198
    PRUNE=199
    QUOTES=200
    RANGE=201
    READ=202
    RECURSIVE=203
    REFRESH=204
    RENAME=205
    REPEATABLE=206
    REPLACE=207
    RESET=208
    RESPECT=209
    RESTRICT=210
    RETURNING=211
    REVOKE=212
    RIGHT=213
    ROLE=214
    ROLES=215
    ROLLBACK=216
    ROLLUP=217
    ROW=218
    ROWS=219
    RUNNING=220
    SCALAR=221
    SCHEMA=222
    SCHEMAS=223
    SECOND=224
    SECURITY=225
    SEEK=226
    SELECT=227
    SERIALIZABLE=228
    SESSION=229
    SET=230
    SETS=231
    SHOW=232
    SOME=233
    START=234
    STATS=235
    SUBSET=236
    SUBSTRING=237
    SYSTEM=238
    TABLE=239
    TABLES=240
    TABLESAMPLE=241
    TEXT=242
    TEXT_STRING=243
    THEN=244
    TIES=245
    TIME=246
    TIMESTAMP=247
    TO=248
    TRAILING=249
    TRANSACTION=250
    TRIM=251
    TRUE=252
    TRUNCATE=253
    TRY_CAST=254
    TYPE=255
    UESCAPE=256
    UNBOUNDED=257
    UNCOMMITTED=258
    UNCONDITIONAL=259
    UNION=260
    UNIQUE=261
    UNKNOWN=262
    UNMATCHED=263
    UNNEST=264
    UPDATE=265
    USE=266
    USER=267
    USING=268
    UTF16=269
    UTF32=270
    UTF8=271
    VALIDATE=272
    VALUE=273
    VALUES=274
    VERBOSE=275
    VERSION=276
    VIEW=277
    WHEN=278
    WHERE=279
    WINDOW=280
    WITH=281
    WITHIN=282
    WITHOUT=283
    WORK=284
    WRAPPER=285
    WRITE=286
    YEAR=287
    ZONE=288
    EQ=289
    NEQ=290
    LT=291
    LTE=292
    GT=293
    GTE=294
    PLUS=295
    MINUS=296
    ASTERISK=297
    SLASH=298
    PERCENT=299
    CONCAT=300
    QUESTION_MARK=301
    STRING=302
    UNICODE_STRING=303
    BINARY_LITERAL=304
    INTEGER_VALUE=305
    DECIMAL_VALUE=306
    DOUBLE_VALUE=307
    IDENTIFIER=308
    DIGIT_IDENTIFIER=309
    QUOTED_IDENTIFIER=310
    BACKQUOTED_IDENTIFIER=311
    SIMPLE_COMMENT=312
    BRACKETED_COMMENT=313
    WS=314
    UNRECOGNIZED=315
    DELIMITER=316

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.9.2")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class SingleStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def statement(self):
            return self.getTypedRuleContext(SqlBaseParser.StatementContext,0)


        def EOF(self):
            return self.getToken(SqlBaseParser.EOF, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_singleStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSingleStatement" ):
                listener.enterSingleStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSingleStatement" ):
                listener.exitSingleStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSingleStatement" ):
                return visitor.visitSingleStatement(self)
            else:
                return visitor.visitChildren(self)




    def singleStatement(self):

        localctx = SqlBaseParser.SingleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_singleStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 218
            self.statement()
            self.state = 219
            self.match(SqlBaseParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StandaloneExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def EOF(self):
            return self.getToken(SqlBaseParser.EOF, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_standaloneExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStandaloneExpression" ):
                listener.enterStandaloneExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStandaloneExpression" ):
                listener.exitStandaloneExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStandaloneExpression" ):
                return visitor.visitStandaloneExpression(self)
            else:
                return visitor.visitChildren(self)




    def standaloneExpression(self):

        localctx = SqlBaseParser.StandaloneExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_standaloneExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 221
            self.expression()
            self.state = 222
            self.match(SqlBaseParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StandalonePathSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pathSpecification(self):
            return self.getTypedRuleContext(SqlBaseParser.PathSpecificationContext,0)


        def EOF(self):
            return self.getToken(SqlBaseParser.EOF, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_standalonePathSpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStandalonePathSpecification" ):
                listener.enterStandalonePathSpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStandalonePathSpecification" ):
                listener.exitStandalonePathSpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStandalonePathSpecification" ):
                return visitor.visitStandalonePathSpecification(self)
            else:
                return visitor.visitChildren(self)




    def standalonePathSpecification(self):

        localctx = SqlBaseParser.StandalonePathSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_standalonePathSpecification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 224
            self.pathSpecification()
            self.state = 225
            self.match(SqlBaseParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StandaloneTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def type_(self):
            return self.getTypedRuleContext(SqlBaseParser.Type_Context,0)


        def EOF(self):
            return self.getToken(SqlBaseParser.EOF, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_standaloneType

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStandaloneType" ):
                listener.enterStandaloneType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStandaloneType" ):
                listener.exitStandaloneType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStandaloneType" ):
                return visitor.visitStandaloneType(self)
            else:
                return visitor.visitChildren(self)




    def standaloneType(self):

        localctx = SqlBaseParser.StandaloneTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_standaloneType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 227
            self.type_(0)
            self.state = 228
            self.match(SqlBaseParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StandaloneRowPatternContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def rowPattern(self):
            return self.getTypedRuleContext(SqlBaseParser.RowPatternContext,0)


        def EOF(self):
            return self.getToken(SqlBaseParser.EOF, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_standaloneRowPattern

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStandaloneRowPattern" ):
                listener.enterStandaloneRowPattern(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStandaloneRowPattern" ):
                listener.exitStandaloneRowPattern(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStandaloneRowPattern" ):
                return visitor.visitStandaloneRowPattern(self)
            else:
                return visitor.visitChildren(self)




    def standaloneRowPattern(self):

        localctx = SqlBaseParser.StandaloneRowPatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_standaloneRowPattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 230
            self.rowPattern(0)
            self.state = 231
            self.match(SqlBaseParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_statement

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class ExplainContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def EXPLAIN(self):
            return self.getToken(SqlBaseParser.EXPLAIN, 0)
        def statement(self):
            return self.getTypedRuleContext(SqlBaseParser.StatementContext,0)

        def explainOption(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExplainOptionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExplainOptionContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExplain" ):
                listener.enterExplain(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExplain" ):
                listener.exitExplain(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExplain" ):
                return visitor.visitExplain(self)
            else:
                return visitor.visitChildren(self)


    class PrepareContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def PREPARE(self):
            return self.getToken(SqlBaseParser.PREPARE, 0)
        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def FROM(self):
            return self.getToken(SqlBaseParser.FROM, 0)
        def statement(self):
            return self.getTypedRuleContext(SqlBaseParser.StatementContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPrepare" ):
                listener.enterPrepare(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPrepare" ):
                listener.exitPrepare(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPrepare" ):
                return visitor.visitPrepare(self)
            else:
                return visitor.visitChildren(self)


    class DropMaterializedViewContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DROP(self):
            return self.getToken(SqlBaseParser.DROP, 0)
        def MATERIALIZED(self):
            return self.getToken(SqlBaseParser.MATERIALIZED, 0)
        def VIEW(self):
            return self.getToken(SqlBaseParser.VIEW, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def IF(self):
            return self.getToken(SqlBaseParser.IF, 0)
        def EXISTS(self):
            return self.getToken(SqlBaseParser.EXISTS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDropMaterializedView" ):
                listener.enterDropMaterializedView(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDropMaterializedView" ):
                listener.exitDropMaterializedView(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDropMaterializedView" ):
                return visitor.visitDropMaterializedView(self)
            else:
                return visitor.visitChildren(self)


    class SetMaterializedViewPropertiesContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(SqlBaseParser.ALTER, 0)
        def MATERIALIZED(self):
            return self.getToken(SqlBaseParser.MATERIALIZED, 0)
        def VIEW(self):
            return self.getToken(SqlBaseParser.VIEW, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def SET(self):
            return self.getToken(SqlBaseParser.SET, 0)
        def PROPERTIES(self):
            return self.getToken(SqlBaseParser.PROPERTIES, 0)
        def propertyAssignments(self):
            return self.getTypedRuleContext(SqlBaseParser.PropertyAssignmentsContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSetMaterializedViewProperties" ):
                listener.enterSetMaterializedViewProperties(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSetMaterializedViewProperties" ):
                listener.exitSetMaterializedViewProperties(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetMaterializedViewProperties" ):
                return visitor.visitSetMaterializedViewProperties(self)
            else:
                return visitor.visitChildren(self)


    class UseContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.schema = None # IdentifierContext
            self.catalog = None # IdentifierContext
            self.copyFrom(ctx)

        def USE(self):
            return self.getToken(SqlBaseParser.USE, 0)
        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUse" ):
                listener.enterUse(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUse" ):
                listener.exitUse(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUse" ):
                return visitor.visitUse(self)
            else:
                return visitor.visitChildren(self)


    class DeallocateContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DEALLOCATE(self):
            return self.getToken(SqlBaseParser.DEALLOCATE, 0)
        def PREPARE(self):
            return self.getToken(SqlBaseParser.PREPARE, 0)
        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeallocate" ):
                listener.enterDeallocate(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeallocate" ):
                listener.exitDeallocate(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeallocate" ):
                return visitor.visitDeallocate(self)
            else:
                return visitor.visitChildren(self)


    class RenameTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.from_ = None # QualifiedNameContext
            self.to = None # QualifiedNameContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(SqlBaseParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def RENAME(self):
            return self.getToken(SqlBaseParser.RENAME, 0)
        def TO(self):
            return self.getToken(SqlBaseParser.TO, 0)
        def qualifiedName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.QualifiedNameContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,i)

        def IF(self):
            return self.getToken(SqlBaseParser.IF, 0)
        def EXISTS(self):
            return self.getToken(SqlBaseParser.EXISTS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRenameTable" ):
                listener.enterRenameTable(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRenameTable" ):
                listener.exitRenameTable(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRenameTable" ):
                return visitor.visitRenameTable(self)
            else:
                return visitor.visitChildren(self)


    class CommitContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def COMMIT(self):
            return self.getToken(SqlBaseParser.COMMIT, 0)
        def WORK(self):
            return self.getToken(SqlBaseParser.WORK, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCommit" ):
                listener.enterCommit(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCommit" ):
                listener.exitCommit(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCommit" ):
                return visitor.visitCommit(self)
            else:
                return visitor.visitChildren(self)


    class CreateRoleContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.name = None # IdentifierContext
            self.catalog = None # IdentifierContext
            self.copyFrom(ctx)

        def CREATE(self):
            return self.getToken(SqlBaseParser.CREATE, 0)
        def ROLE(self):
            return self.getToken(SqlBaseParser.ROLE, 0)
        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,i)

        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)
        def ADMIN(self):
            return self.getToken(SqlBaseParser.ADMIN, 0)
        def grantor(self):
            return self.getTypedRuleContext(SqlBaseParser.GrantorContext,0)

        def IN(self):
            return self.getToken(SqlBaseParser.IN, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCreateRole" ):
                listener.enterCreateRole(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCreateRole" ):
                listener.exitCreateRole(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCreateRole" ):
                return visitor.visitCreateRole(self)
            else:
                return visitor.visitChildren(self)


    class DropColumnContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.tableName = None # QualifiedNameContext
            self.column = None # QualifiedNameContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(SqlBaseParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def DROP(self):
            return self.getToken(SqlBaseParser.DROP, 0)
        def COLUMN(self):
            return self.getToken(SqlBaseParser.COLUMN, 0)
        def qualifiedName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.QualifiedNameContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,i)

        def IF(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.IF)
            else:
                return self.getToken(SqlBaseParser.IF, i)
        def EXISTS(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.EXISTS)
            else:
                return self.getToken(SqlBaseParser.EXISTS, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDropColumn" ):
                listener.enterDropColumn(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDropColumn" ):
                listener.exitDropColumn(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDropColumn" ):
                return visitor.visitDropColumn(self)
            else:
                return visitor.visitChildren(self)


    class DropViewContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DROP(self):
            return self.getToken(SqlBaseParser.DROP, 0)
        def VIEW(self):
            return self.getToken(SqlBaseParser.VIEW, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def IF(self):
            return self.getToken(SqlBaseParser.IF, 0)
        def EXISTS(self):
            return self.getToken(SqlBaseParser.EXISTS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDropView" ):
                listener.enterDropView(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDropView" ):
                listener.exitDropView(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDropView" ):
                return visitor.visitDropView(self)
            else:
                return visitor.visitChildren(self)


    class ShowTablesContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.pattern = None # StringContext
            self.escape = None # StringContext
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def TABLES(self):
            return self.getToken(SqlBaseParser.TABLES, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def LIKE(self):
            return self.getToken(SqlBaseParser.LIKE, 0)
        def FROM(self):
            return self.getToken(SqlBaseParser.FROM, 0)
        def IN(self):
            return self.getToken(SqlBaseParser.IN, 0)
        def string(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.StringContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.StringContext,i)

        def ESCAPE(self):
            return self.getToken(SqlBaseParser.ESCAPE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowTables" ):
                listener.enterShowTables(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowTables" ):
                listener.exitShowTables(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowTables" ):
                return visitor.visitShowTables(self)
            else:
                return visitor.visitChildren(self)


    class SetViewAuthorizationContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.from_ = None # QualifiedNameContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(SqlBaseParser.ALTER, 0)
        def VIEW(self):
            return self.getToken(SqlBaseParser.VIEW, 0)
        def SET(self):
            return self.getToken(SqlBaseParser.SET, 0)
        def AUTHORIZATION(self):
            return self.getToken(SqlBaseParser.AUTHORIZATION, 0)
        def principal(self):
            return self.getTypedRuleContext(SqlBaseParser.PrincipalContext,0)

        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSetViewAuthorization" ):
                listener.enterSetViewAuthorization(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSetViewAuthorization" ):
                listener.exitSetViewAuthorization(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetViewAuthorization" ):
                return visitor.visitSetViewAuthorization(self)
            else:
                return visitor.visitChildren(self)


    class ShowCatalogsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.pattern = None # StringContext
            self.escape = None # StringContext
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def CATALOGS(self):
            return self.getToken(SqlBaseParser.CATALOGS, 0)
        def LIKE(self):
            return self.getToken(SqlBaseParser.LIKE, 0)
        def string(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.StringContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.StringContext,i)

        def ESCAPE(self):
            return self.getToken(SqlBaseParser.ESCAPE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowCatalogs" ):
                listener.enterShowCatalogs(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowCatalogs" ):
                listener.exitShowCatalogs(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowCatalogs" ):
                return visitor.visitShowCatalogs(self)
            else:
                return visitor.visitChildren(self)


    class ShowRolesContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def ROLES(self):
            return self.getToken(SqlBaseParser.ROLES, 0)
        def CURRENT(self):
            return self.getToken(SqlBaseParser.CURRENT, 0)
        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def FROM(self):
            return self.getToken(SqlBaseParser.FROM, 0)
        def IN(self):
            return self.getToken(SqlBaseParser.IN, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowRoles" ):
                listener.enterShowRoles(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowRoles" ):
                listener.exitShowRoles(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowRoles" ):
                return visitor.visitShowRoles(self)
            else:
                return visitor.visitChildren(self)


    class MergeContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def MERGE(self):
            return self.getToken(SqlBaseParser.MERGE, 0)
        def INTO(self):
            return self.getToken(SqlBaseParser.INTO, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def USING(self):
            return self.getToken(SqlBaseParser.USING, 0)
        def relation(self):
            return self.getTypedRuleContext(SqlBaseParser.RelationContext,0)

        def ON(self):
            return self.getToken(SqlBaseParser.ON, 0)
        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def mergeCase(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.MergeCaseContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.MergeCaseContext,i)

        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMerge" ):
                listener.enterMerge(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMerge" ):
                listener.exitMerge(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMerge" ):
                return visitor.visitMerge(self)
            else:
                return visitor.visitChildren(self)


    class RenameColumnContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.tableName = None # QualifiedNameContext
            self.from_ = None # IdentifierContext
            self.to = None # IdentifierContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(SqlBaseParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def RENAME(self):
            return self.getToken(SqlBaseParser.RENAME, 0)
        def COLUMN(self):
            return self.getToken(SqlBaseParser.COLUMN, 0)
        def TO(self):
            return self.getToken(SqlBaseParser.TO, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,i)

        def IF(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.IF)
            else:
                return self.getToken(SqlBaseParser.IF, i)
        def EXISTS(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.EXISTS)
            else:
                return self.getToken(SqlBaseParser.EXISTS, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRenameColumn" ):
                listener.enterRenameColumn(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRenameColumn" ):
                listener.exitRenameColumn(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRenameColumn" ):
                return visitor.visitRenameColumn(self)
            else:
                return visitor.visitChildren(self)


    class CommentColumnContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def COMMENT(self):
            return self.getToken(SqlBaseParser.COMMENT, 0)
        def ON(self):
            return self.getToken(SqlBaseParser.ON, 0)
        def COLUMN(self):
            return self.getToken(SqlBaseParser.COLUMN, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def IS(self):
            return self.getToken(SqlBaseParser.IS, 0)
        def string(self):
            return self.getTypedRuleContext(SqlBaseParser.StringContext,0)

        def NULL(self):
            return self.getToken(SqlBaseParser.NULL, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCommentColumn" ):
                listener.enterCommentColumn(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCommentColumn" ):
                listener.exitCommentColumn(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCommentColumn" ):
                return visitor.visitCommentColumn(self)
            else:
                return visitor.visitChildren(self)


    class RevokeRolesContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.catalog = None # IdentifierContext
            self.copyFrom(ctx)

        def REVOKE(self):
            return self.getToken(SqlBaseParser.REVOKE, 0)
        def roles(self):
            return self.getTypedRuleContext(SqlBaseParser.RolesContext,0)

        def FROM(self):
            return self.getToken(SqlBaseParser.FROM, 0)
        def principal(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.PrincipalContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.PrincipalContext,i)

        def ADMIN(self):
            return self.getToken(SqlBaseParser.ADMIN, 0)
        def OPTION(self):
            return self.getToken(SqlBaseParser.OPTION, 0)
        def FOR(self):
            return self.getToken(SqlBaseParser.FOR, 0)
        def GRANTED(self):
            return self.getToken(SqlBaseParser.GRANTED, 0)
        def BY(self):
            return self.getToken(SqlBaseParser.BY, 0)
        def grantor(self):
            return self.getTypedRuleContext(SqlBaseParser.GrantorContext,0)

        def IN(self):
            return self.getToken(SqlBaseParser.IN, 0)
        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRevokeRoles" ):
                listener.enterRevokeRoles(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRevokeRoles" ):
                listener.exitRevokeRoles(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRevokeRoles" ):
                return visitor.visitRevokeRoles(self)
            else:
                return visitor.visitChildren(self)


    class ShowCreateTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def CREATE(self):
            return self.getToken(SqlBaseParser.CREATE, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowCreateTable" ):
                listener.enterShowCreateTable(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowCreateTable" ):
                listener.exitShowCreateTable(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowCreateTable" ):
                return visitor.visitShowCreateTable(self)
            else:
                return visitor.visitChildren(self)


    class ShowColumnsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.pattern = None # StringContext
            self.escape = None # StringContext
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def COLUMNS(self):
            return self.getToken(SqlBaseParser.COLUMNS, 0)
        def FROM(self):
            return self.getToken(SqlBaseParser.FROM, 0)
        def IN(self):
            return self.getToken(SqlBaseParser.IN, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def LIKE(self):
            return self.getToken(SqlBaseParser.LIKE, 0)
        def string(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.StringContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.StringContext,i)

        def ESCAPE(self):
            return self.getToken(SqlBaseParser.ESCAPE, 0)
        def DESCRIBE(self):
            return self.getToken(SqlBaseParser.DESCRIBE, 0)
        def DESC(self):
            return self.getToken(SqlBaseParser.DESC, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowColumns" ):
                listener.enterShowColumns(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowColumns" ):
                listener.exitShowColumns(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowColumns" ):
                return visitor.visitShowColumns(self)
            else:
                return visitor.visitChildren(self)


    class ShowRoleGrantsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def ROLE(self):
            return self.getToken(SqlBaseParser.ROLE, 0)
        def GRANTS(self):
            return self.getToken(SqlBaseParser.GRANTS, 0)
        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def FROM(self):
            return self.getToken(SqlBaseParser.FROM, 0)
        def IN(self):
            return self.getToken(SqlBaseParser.IN, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowRoleGrants" ):
                listener.enterShowRoleGrants(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowRoleGrants" ):
                listener.exitShowRoleGrants(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowRoleGrants" ):
                return visitor.visitShowRoleGrants(self)
            else:
                return visitor.visitChildren(self)


    class AddColumnContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.tableName = None # QualifiedNameContext
            self.column = None # ColumnDefinitionContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(SqlBaseParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def ADD(self):
            return self.getToken(SqlBaseParser.ADD, 0)
        def COLUMN(self):
            return self.getToken(SqlBaseParser.COLUMN, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def columnDefinition(self):
            return self.getTypedRuleContext(SqlBaseParser.ColumnDefinitionContext,0)

        def IF(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.IF)
            else:
                return self.getToken(SqlBaseParser.IF, i)
        def EXISTS(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.EXISTS)
            else:
                return self.getToken(SqlBaseParser.EXISTS, i)
        def NOT(self):
            return self.getToken(SqlBaseParser.NOT, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAddColumn" ):
                listener.enterAddColumn(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAddColumn" ):
                listener.exitAddColumn(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAddColumn" ):
                return visitor.visitAddColumn(self)
            else:
                return visitor.visitChildren(self)


    class DenyContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.grantee = None # PrincipalContext
            self.copyFrom(ctx)

        def DENY(self):
            return self.getToken(SqlBaseParser.DENY, 0)
        def ON(self):
            return self.getToken(SqlBaseParser.ON, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def TO(self):
            return self.getToken(SqlBaseParser.TO, 0)
        def principal(self):
            return self.getTypedRuleContext(SqlBaseParser.PrincipalContext,0)

        def privilege(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.PrivilegeContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.PrivilegeContext,i)

        def ALL(self):
            return self.getToken(SqlBaseParser.ALL, 0)
        def PRIVILEGES(self):
            return self.getToken(SqlBaseParser.PRIVILEGES, 0)
        def SCHEMA(self):
            return self.getToken(SqlBaseParser.SCHEMA, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeny" ):
                listener.enterDeny(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeny" ):
                listener.exitDeny(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeny" ):
                return visitor.visitDeny(self)
            else:
                return visitor.visitChildren(self)


    class ResetSessionContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def RESET(self):
            return self.getToken(SqlBaseParser.RESET, 0)
        def SESSION(self):
            return self.getToken(SqlBaseParser.SESSION, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterResetSession" ):
                listener.enterResetSession(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitResetSession" ):
                listener.exitResetSession(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitResetSession" ):
                return visitor.visitResetSession(self)
            else:
                return visitor.visitChildren(self)


    class InsertIntoContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def INSERT(self):
            return self.getToken(SqlBaseParser.INSERT, 0)
        def INTO(self):
            return self.getToken(SqlBaseParser.INTO, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def query(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryContext,0)

        def columnAliases(self):
            return self.getTypedRuleContext(SqlBaseParser.ColumnAliasesContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInsertInto" ):
                listener.enterInsertInto(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInsertInto" ):
                listener.exitInsertInto(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInsertInto" ):
                return visitor.visitInsertInto(self)
            else:
                return visitor.visitChildren(self)


    class ShowSessionContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.pattern = None # StringContext
            self.escape = None # StringContext
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def SESSION(self):
            return self.getToken(SqlBaseParser.SESSION, 0)
        def LIKE(self):
            return self.getToken(SqlBaseParser.LIKE, 0)
        def string(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.StringContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.StringContext,i)

        def ESCAPE(self):
            return self.getToken(SqlBaseParser.ESCAPE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowSession" ):
                listener.enterShowSession(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowSession" ):
                listener.exitShowSession(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowSession" ):
                return visitor.visitShowSession(self)
            else:
                return visitor.visitChildren(self)


    class CreateSchemaContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CREATE(self):
            return self.getToken(SqlBaseParser.CREATE, 0)
        def SCHEMA(self):
            return self.getToken(SqlBaseParser.SCHEMA, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def IF(self):
            return self.getToken(SqlBaseParser.IF, 0)
        def NOT(self):
            return self.getToken(SqlBaseParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(SqlBaseParser.EXISTS, 0)
        def AUTHORIZATION(self):
            return self.getToken(SqlBaseParser.AUTHORIZATION, 0)
        def principal(self):
            return self.getTypedRuleContext(SqlBaseParser.PrincipalContext,0)

        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)
        def properties(self):
            return self.getTypedRuleContext(SqlBaseParser.PropertiesContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCreateSchema" ):
                listener.enterCreateSchema(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCreateSchema" ):
                listener.exitCreateSchema(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCreateSchema" ):
                return visitor.visitCreateSchema(self)
            else:
                return visitor.visitChildren(self)


    class ExplainAnalyzeContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def EXPLAIN(self):
            return self.getToken(SqlBaseParser.EXPLAIN, 0)
        def ANALYZE(self):
            return self.getToken(SqlBaseParser.ANALYZE, 0)
        def statement(self):
            return self.getTypedRuleContext(SqlBaseParser.StatementContext,0)

        def VERBOSE(self):
            return self.getToken(SqlBaseParser.VERBOSE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExplainAnalyze" ):
                listener.enterExplainAnalyze(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExplainAnalyze" ):
                listener.exitExplainAnalyze(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExplainAnalyze" ):
                return visitor.visitExplainAnalyze(self)
            else:
                return visitor.visitChildren(self)


    class ExecuteContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def EXECUTE(self):
            return self.getToken(SqlBaseParser.EXECUTE, 0)
        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def USING(self):
            return self.getToken(SqlBaseParser.USING, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExecute" ):
                listener.enterExecute(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExecute" ):
                listener.exitExecute(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExecute" ):
                return visitor.visitExecute(self)
            else:
                return visitor.visitChildren(self)


    class RenameSchemaContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(SqlBaseParser.ALTER, 0)
        def SCHEMA(self):
            return self.getToken(SqlBaseParser.SCHEMA, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def RENAME(self):
            return self.getToken(SqlBaseParser.RENAME, 0)
        def TO(self):
            return self.getToken(SqlBaseParser.TO, 0)
        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRenameSchema" ):
                listener.enterRenameSchema(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRenameSchema" ):
                listener.exitRenameSchema(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRenameSchema" ):
                return visitor.visitRenameSchema(self)
            else:
                return visitor.visitChildren(self)


    class DropRoleContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.name = None # IdentifierContext
            self.catalog = None # IdentifierContext
            self.copyFrom(ctx)

        def DROP(self):
            return self.getToken(SqlBaseParser.DROP, 0)
        def ROLE(self):
            return self.getToken(SqlBaseParser.ROLE, 0)
        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,i)

        def IN(self):
            return self.getToken(SqlBaseParser.IN, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDropRole" ):
                listener.enterDropRole(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDropRole" ):
                listener.exitDropRole(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDropRole" ):
                return visitor.visitDropRole(self)
            else:
                return visitor.visitChildren(self)


    class AnalyzeContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ANALYZE(self):
            return self.getToken(SqlBaseParser.ANALYZE, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)
        def properties(self):
            return self.getTypedRuleContext(SqlBaseParser.PropertiesContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAnalyze" ):
                listener.enterAnalyze(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAnalyze" ):
                listener.exitAnalyze(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAnalyze" ):
                return visitor.visitAnalyze(self)
            else:
                return visitor.visitChildren(self)


    class SetRoleContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.role = None # IdentifierContext
            self.catalog = None # IdentifierContext
            self.copyFrom(ctx)

        def SET(self):
            return self.getToken(SqlBaseParser.SET, 0)
        def ROLE(self):
            return self.getToken(SqlBaseParser.ROLE, 0)
        def ALL(self):
            return self.getToken(SqlBaseParser.ALL, 0)
        def NONE(self):
            return self.getToken(SqlBaseParser.NONE, 0)
        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,i)

        def IN(self):
            return self.getToken(SqlBaseParser.IN, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSetRole" ):
                listener.enterSetRole(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSetRole" ):
                listener.exitSetRole(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetRole" ):
                return visitor.visitSetRole(self)
            else:
                return visitor.visitChildren(self)


    class ShowGrantsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def GRANTS(self):
            return self.getToken(SqlBaseParser.GRANTS, 0)
        def ON(self):
            return self.getToken(SqlBaseParser.ON, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowGrants" ):
                listener.enterShowGrants(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowGrants" ):
                listener.exitShowGrants(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowGrants" ):
                return visitor.visitShowGrants(self)
            else:
                return visitor.visitChildren(self)


    class DropSchemaContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DROP(self):
            return self.getToken(SqlBaseParser.DROP, 0)
        def SCHEMA(self):
            return self.getToken(SqlBaseParser.SCHEMA, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def IF(self):
            return self.getToken(SqlBaseParser.IF, 0)
        def EXISTS(self):
            return self.getToken(SqlBaseParser.EXISTS, 0)
        def CASCADE(self):
            return self.getToken(SqlBaseParser.CASCADE, 0)
        def RESTRICT(self):
            return self.getToken(SqlBaseParser.RESTRICT, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDropSchema" ):
                listener.enterDropSchema(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDropSchema" ):
                listener.exitDropSchema(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDropSchema" ):
                return visitor.visitDropSchema(self)
            else:
                return visitor.visitChildren(self)


    class SetTableAuthorizationContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.tableName = None # QualifiedNameContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(SqlBaseParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def SET(self):
            return self.getToken(SqlBaseParser.SET, 0)
        def AUTHORIZATION(self):
            return self.getToken(SqlBaseParser.AUTHORIZATION, 0)
        def principal(self):
            return self.getTypedRuleContext(SqlBaseParser.PrincipalContext,0)

        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSetTableAuthorization" ):
                listener.enterSetTableAuthorization(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSetTableAuthorization" ):
                listener.exitSetTableAuthorization(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetTableAuthorization" ):
                return visitor.visitSetTableAuthorization(self)
            else:
                return visitor.visitChildren(self)


    class ShowCreateViewContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def CREATE(self):
            return self.getToken(SqlBaseParser.CREATE, 0)
        def VIEW(self):
            return self.getToken(SqlBaseParser.VIEW, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowCreateView" ):
                listener.enterShowCreateView(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowCreateView" ):
                listener.exitShowCreateView(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowCreateView" ):
                return visitor.visitShowCreateView(self)
            else:
                return visitor.visitChildren(self)


    class CreateTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CREATE(self):
            return self.getToken(SqlBaseParser.CREATE, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def tableElement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.TableElementContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.TableElementContext,i)

        def IF(self):
            return self.getToken(SqlBaseParser.IF, 0)
        def NOT(self):
            return self.getToken(SqlBaseParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(SqlBaseParser.EXISTS, 0)
        def COMMENT(self):
            return self.getToken(SqlBaseParser.COMMENT, 0)
        def string(self):
            return self.getTypedRuleContext(SqlBaseParser.StringContext,0)

        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)
        def properties(self):
            return self.getTypedRuleContext(SqlBaseParser.PropertiesContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCreateTable" ):
                listener.enterCreateTable(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCreateTable" ):
                listener.exitCreateTable(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCreateTable" ):
                return visitor.visitCreateTable(self)
            else:
                return visitor.visitChildren(self)


    class StartTransactionContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def START(self):
            return self.getToken(SqlBaseParser.START, 0)
        def TRANSACTION(self):
            return self.getToken(SqlBaseParser.TRANSACTION, 0)
        def transactionMode(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.TransactionModeContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.TransactionModeContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStartTransaction" ):
                listener.enterStartTransaction(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStartTransaction" ):
                listener.exitStartTransaction(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStartTransaction" ):
                return visitor.visitStartTransaction(self)
            else:
                return visitor.visitChildren(self)


    class CreateTableAsSelectContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CREATE(self):
            return self.getToken(SqlBaseParser.CREATE, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)
        def query(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryContext,0)

        def IF(self):
            return self.getToken(SqlBaseParser.IF, 0)
        def NOT(self):
            return self.getToken(SqlBaseParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(SqlBaseParser.EXISTS, 0)
        def columnAliases(self):
            return self.getTypedRuleContext(SqlBaseParser.ColumnAliasesContext,0)

        def COMMENT(self):
            return self.getToken(SqlBaseParser.COMMENT, 0)
        def string(self):
            return self.getTypedRuleContext(SqlBaseParser.StringContext,0)

        def WITH(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.WITH)
            else:
                return self.getToken(SqlBaseParser.WITH, i)
        def properties(self):
            return self.getTypedRuleContext(SqlBaseParser.PropertiesContext,0)

        def DATA(self):
            return self.getToken(SqlBaseParser.DATA, 0)
        def NO(self):
            return self.getToken(SqlBaseParser.NO, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCreateTableAsSelect" ):
                listener.enterCreateTableAsSelect(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCreateTableAsSelect" ):
                listener.exitCreateTableAsSelect(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCreateTableAsSelect" ):
                return visitor.visitCreateTableAsSelect(self)
            else:
                return visitor.visitChildren(self)


    class ShowStatsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def STATS(self):
            return self.getToken(SqlBaseParser.STATS, 0)
        def FOR(self):
            return self.getToken(SqlBaseParser.FOR, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowStats" ):
                listener.enterShowStats(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowStats" ):
                listener.exitShowStats(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowStats" ):
                return visitor.visitShowStats(self)
            else:
                return visitor.visitChildren(self)


    class ShowCreateSchemaContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def CREATE(self):
            return self.getToken(SqlBaseParser.CREATE, 0)
        def SCHEMA(self):
            return self.getToken(SqlBaseParser.SCHEMA, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowCreateSchema" ):
                listener.enterShowCreateSchema(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowCreateSchema" ):
                listener.exitShowCreateSchema(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowCreateSchema" ):
                return visitor.visitShowCreateSchema(self)
            else:
                return visitor.visitChildren(self)


    class RevokeContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.grantee = None # PrincipalContext
            self.copyFrom(ctx)

        def REVOKE(self):
            return self.getToken(SqlBaseParser.REVOKE, 0)
        def ON(self):
            return self.getToken(SqlBaseParser.ON, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def FROM(self):
            return self.getToken(SqlBaseParser.FROM, 0)
        def principal(self):
            return self.getTypedRuleContext(SqlBaseParser.PrincipalContext,0)

        def privilege(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.PrivilegeContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.PrivilegeContext,i)

        def ALL(self):
            return self.getToken(SqlBaseParser.ALL, 0)
        def PRIVILEGES(self):
            return self.getToken(SqlBaseParser.PRIVILEGES, 0)
        def GRANT(self):
            return self.getToken(SqlBaseParser.GRANT, 0)
        def OPTION(self):
            return self.getToken(SqlBaseParser.OPTION, 0)
        def FOR(self):
            return self.getToken(SqlBaseParser.FOR, 0)
        def SCHEMA(self):
            return self.getToken(SqlBaseParser.SCHEMA, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRevoke" ):
                listener.enterRevoke(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRevoke" ):
                listener.exitRevoke(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRevoke" ):
                return visitor.visitRevoke(self)
            else:
                return visitor.visitChildren(self)


    class UpdateContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.where = None # BooleanExpressionContext
            self.copyFrom(ctx)

        def UPDATE(self):
            return self.getToken(SqlBaseParser.UPDATE, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def SET(self):
            return self.getToken(SqlBaseParser.SET, 0)
        def updateAssignment(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.UpdateAssignmentContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.UpdateAssignmentContext,i)

        def WHERE(self):
            return self.getToken(SqlBaseParser.WHERE, 0)
        def booleanExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.BooleanExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUpdate" ):
                listener.enterUpdate(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUpdate" ):
                listener.exitUpdate(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUpdate" ):
                return visitor.visitUpdate(self)
            else:
                return visitor.visitChildren(self)


    class TableExecuteContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.tableName = None # QualifiedNameContext
            self.procedureName = None # IdentifierContext
            self.where = None # BooleanExpressionContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(SqlBaseParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def EXECUTE(self):
            return self.getToken(SqlBaseParser.EXECUTE, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def WHERE(self):
            return self.getToken(SqlBaseParser.WHERE, 0)
        def booleanExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.BooleanExpressionContext,0)

        def callArgument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.CallArgumentContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.CallArgumentContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTableExecute" ):
                listener.enterTableExecute(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTableExecute" ):
                listener.exitTableExecute(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableExecute" ):
                return visitor.visitTableExecute(self)
            else:
                return visitor.visitChildren(self)


    class DeleteContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DELETE(self):
            return self.getToken(SqlBaseParser.DELETE, 0)
        def FROM(self):
            return self.getToken(SqlBaseParser.FROM, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def WHERE(self):
            return self.getToken(SqlBaseParser.WHERE, 0)
        def booleanExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.BooleanExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDelete" ):
                listener.enterDelete(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDelete" ):
                listener.exitDelete(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDelete" ):
                return visitor.visitDelete(self)
            else:
                return visitor.visitChildren(self)


    class DescribeInputContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DESCRIBE(self):
            return self.getToken(SqlBaseParser.DESCRIBE, 0)
        def INPUT(self):
            return self.getToken(SqlBaseParser.INPUT, 0)
        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDescribeInput" ):
                listener.enterDescribeInput(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDescribeInput" ):
                listener.exitDescribeInput(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDescribeInput" ):
                return visitor.visitDescribeInput(self)
            else:
                return visitor.visitChildren(self)


    class ShowStatsForQueryContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def STATS(self):
            return self.getToken(SqlBaseParser.STATS, 0)
        def FOR(self):
            return self.getToken(SqlBaseParser.FOR, 0)
        def query(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowStatsForQuery" ):
                listener.enterShowStatsForQuery(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowStatsForQuery" ):
                listener.exitShowStatsForQuery(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowStatsForQuery" ):
                return visitor.visitShowStatsForQuery(self)
            else:
                return visitor.visitChildren(self)


    class StatementDefaultContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def query(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStatementDefault" ):
                listener.enterStatementDefault(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStatementDefault" ):
                listener.exitStatementDefault(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStatementDefault" ):
                return visitor.visitStatementDefault(self)
            else:
                return visitor.visitChildren(self)


    class SetTimeZoneContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SET(self):
            return self.getToken(SqlBaseParser.SET, 0)
        def TIME(self):
            return self.getToken(SqlBaseParser.TIME, 0)
        def ZONE(self):
            return self.getToken(SqlBaseParser.ZONE, 0)
        def LOCAL(self):
            return self.getToken(SqlBaseParser.LOCAL, 0)
        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSetTimeZone" ):
                listener.enterSetTimeZone(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSetTimeZone" ):
                listener.exitSetTimeZone(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetTimeZone" ):
                return visitor.visitSetTimeZone(self)
            else:
                return visitor.visitChildren(self)


    class TruncateTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TRUNCATE(self):
            return self.getToken(SqlBaseParser.TRUNCATE, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTruncateTable" ):
                listener.enterTruncateTable(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTruncateTable" ):
                listener.exitTruncateTable(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTruncateTable" ):
                return visitor.visitTruncateTable(self)
            else:
                return visitor.visitChildren(self)


    class CreateMaterializedViewContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CREATE(self):
            return self.getToken(SqlBaseParser.CREATE, 0)
        def MATERIALIZED(self):
            return self.getToken(SqlBaseParser.MATERIALIZED, 0)
        def VIEW(self):
            return self.getToken(SqlBaseParser.VIEW, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)
        def query(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryContext,0)

        def OR(self):
            return self.getToken(SqlBaseParser.OR, 0)
        def REPLACE(self):
            return self.getToken(SqlBaseParser.REPLACE, 0)
        def IF(self):
            return self.getToken(SqlBaseParser.IF, 0)
        def NOT(self):
            return self.getToken(SqlBaseParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(SqlBaseParser.EXISTS, 0)
        def COMMENT(self):
            return self.getToken(SqlBaseParser.COMMENT, 0)
        def string(self):
            return self.getTypedRuleContext(SqlBaseParser.StringContext,0)

        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)
        def properties(self):
            return self.getTypedRuleContext(SqlBaseParser.PropertiesContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCreateMaterializedView" ):
                listener.enterCreateMaterializedView(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCreateMaterializedView" ):
                listener.exitCreateMaterializedView(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCreateMaterializedView" ):
                return visitor.visitCreateMaterializedView(self)
            else:
                return visitor.visitChildren(self)


    class SetSessionContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SET(self):
            return self.getToken(SqlBaseParser.SET, 0)
        def SESSION(self):
            return self.getToken(SqlBaseParser.SESSION, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def EQ(self):
            return self.getToken(SqlBaseParser.EQ, 0)
        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSetSession" ):
                listener.enterSetSession(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSetSession" ):
                listener.exitSetSession(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetSession" ):
                return visitor.visitSetSession(self)
            else:
                return visitor.visitChildren(self)


    class CreateViewContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CREATE(self):
            return self.getToken(SqlBaseParser.CREATE, 0)
        def VIEW(self):
            return self.getToken(SqlBaseParser.VIEW, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)
        def query(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryContext,0)

        def OR(self):
            return self.getToken(SqlBaseParser.OR, 0)
        def REPLACE(self):
            return self.getToken(SqlBaseParser.REPLACE, 0)
        def COMMENT(self):
            return self.getToken(SqlBaseParser.COMMENT, 0)
        def string(self):
            return self.getTypedRuleContext(SqlBaseParser.StringContext,0)

        def SECURITY(self):
            return self.getToken(SqlBaseParser.SECURITY, 0)
        def DEFINER(self):
            return self.getToken(SqlBaseParser.DEFINER, 0)
        def INVOKER(self):
            return self.getToken(SqlBaseParser.INVOKER, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCreateView" ):
                listener.enterCreateView(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCreateView" ):
                listener.exitCreateView(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCreateView" ):
                return visitor.visitCreateView(self)
            else:
                return visitor.visitChildren(self)


    class RenameMaterializedViewContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.from_ = None # QualifiedNameContext
            self.to = None # QualifiedNameContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(SqlBaseParser.ALTER, 0)
        def MATERIALIZED(self):
            return self.getToken(SqlBaseParser.MATERIALIZED, 0)
        def VIEW(self):
            return self.getToken(SqlBaseParser.VIEW, 0)
        def RENAME(self):
            return self.getToken(SqlBaseParser.RENAME, 0)
        def TO(self):
            return self.getToken(SqlBaseParser.TO, 0)
        def qualifiedName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.QualifiedNameContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,i)

        def IF(self):
            return self.getToken(SqlBaseParser.IF, 0)
        def EXISTS(self):
            return self.getToken(SqlBaseParser.EXISTS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRenameMaterializedView" ):
                listener.enterRenameMaterializedView(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRenameMaterializedView" ):
                listener.exitRenameMaterializedView(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRenameMaterializedView" ):
                return visitor.visitRenameMaterializedView(self)
            else:
                return visitor.visitChildren(self)


    class ShowSchemasContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.pattern = None # StringContext
            self.escape = None # StringContext
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def SCHEMAS(self):
            return self.getToken(SqlBaseParser.SCHEMAS, 0)
        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def LIKE(self):
            return self.getToken(SqlBaseParser.LIKE, 0)
        def FROM(self):
            return self.getToken(SqlBaseParser.FROM, 0)
        def IN(self):
            return self.getToken(SqlBaseParser.IN, 0)
        def string(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.StringContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.StringContext,i)

        def ESCAPE(self):
            return self.getToken(SqlBaseParser.ESCAPE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowSchemas" ):
                listener.enterShowSchemas(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowSchemas" ):
                listener.exitShowSchemas(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowSchemas" ):
                return visitor.visitShowSchemas(self)
            else:
                return visitor.visitChildren(self)


    class DropTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DROP(self):
            return self.getToken(SqlBaseParser.DROP, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def IF(self):
            return self.getToken(SqlBaseParser.IF, 0)
        def EXISTS(self):
            return self.getToken(SqlBaseParser.EXISTS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDropTable" ):
                listener.enterDropTable(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDropTable" ):
                listener.exitDropTable(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDropTable" ):
                return visitor.visitDropTable(self)
            else:
                return visitor.visitChildren(self)


    class SetSchemaAuthorizationContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(SqlBaseParser.ALTER, 0)
        def SCHEMA(self):
            return self.getToken(SqlBaseParser.SCHEMA, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def SET(self):
            return self.getToken(SqlBaseParser.SET, 0)
        def AUTHORIZATION(self):
            return self.getToken(SqlBaseParser.AUTHORIZATION, 0)
        def principal(self):
            return self.getTypedRuleContext(SqlBaseParser.PrincipalContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSetSchemaAuthorization" ):
                listener.enterSetSchemaAuthorization(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSetSchemaAuthorization" ):
                listener.exitSetSchemaAuthorization(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetSchemaAuthorization" ):
                return visitor.visitSetSchemaAuthorization(self)
            else:
                return visitor.visitChildren(self)


    class RollbackContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ROLLBACK(self):
            return self.getToken(SqlBaseParser.ROLLBACK, 0)
        def WORK(self):
            return self.getToken(SqlBaseParser.WORK, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRollback" ):
                listener.enterRollback(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRollback" ):
                listener.exitRollback(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRollback" ):
                return visitor.visitRollback(self)
            else:
                return visitor.visitChildren(self)


    class CommentTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def COMMENT(self):
            return self.getToken(SqlBaseParser.COMMENT, 0)
        def ON(self):
            return self.getToken(SqlBaseParser.ON, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def IS(self):
            return self.getToken(SqlBaseParser.IS, 0)
        def string(self):
            return self.getTypedRuleContext(SqlBaseParser.StringContext,0)

        def NULL(self):
            return self.getToken(SqlBaseParser.NULL, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCommentTable" ):
                listener.enterCommentTable(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCommentTable" ):
                listener.exitCommentTable(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCommentTable" ):
                return visitor.visitCommentTable(self)
            else:
                return visitor.visitChildren(self)


    class RenameViewContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.from_ = None # QualifiedNameContext
            self.to = None # QualifiedNameContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(SqlBaseParser.ALTER, 0)
        def VIEW(self):
            return self.getToken(SqlBaseParser.VIEW, 0)
        def RENAME(self):
            return self.getToken(SqlBaseParser.RENAME, 0)
        def TO(self):
            return self.getToken(SqlBaseParser.TO, 0)
        def qualifiedName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.QualifiedNameContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRenameView" ):
                listener.enterRenameView(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRenameView" ):
                listener.exitRenameView(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRenameView" ):
                return visitor.visitRenameView(self)
            else:
                return visitor.visitChildren(self)


    class SetPathContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SET(self):
            return self.getToken(SqlBaseParser.SET, 0)
        def PATH(self):
            return self.getToken(SqlBaseParser.PATH, 0)
        def pathSpecification(self):
            return self.getTypedRuleContext(SqlBaseParser.PathSpecificationContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSetPath" ):
                listener.enterSetPath(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSetPath" ):
                listener.exitSetPath(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetPath" ):
                return visitor.visitSetPath(self)
            else:
                return visitor.visitChildren(self)


    class GrantRolesContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.catalog = None # IdentifierContext
            self.copyFrom(ctx)

        def GRANT(self):
            return self.getToken(SqlBaseParser.GRANT, 0)
        def roles(self):
            return self.getTypedRuleContext(SqlBaseParser.RolesContext,0)

        def TO(self):
            return self.getToken(SqlBaseParser.TO, 0)
        def principal(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.PrincipalContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.PrincipalContext,i)

        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)
        def ADMIN(self):
            return self.getToken(SqlBaseParser.ADMIN, 0)
        def OPTION(self):
            return self.getToken(SqlBaseParser.OPTION, 0)
        def GRANTED(self):
            return self.getToken(SqlBaseParser.GRANTED, 0)
        def BY(self):
            return self.getToken(SqlBaseParser.BY, 0)
        def grantor(self):
            return self.getTypedRuleContext(SqlBaseParser.GrantorContext,0)

        def IN(self):
            return self.getToken(SqlBaseParser.IN, 0)
        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGrantRoles" ):
                listener.enterGrantRoles(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGrantRoles" ):
                listener.exitGrantRoles(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGrantRoles" ):
                return visitor.visitGrantRoles(self)
            else:
                return visitor.visitChildren(self)


    class CallContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CALL(self):
            return self.getToken(SqlBaseParser.CALL, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def callArgument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.CallArgumentContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.CallArgumentContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCall" ):
                listener.enterCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCall" ):
                listener.exitCall(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCall" ):
                return visitor.visitCall(self)
            else:
                return visitor.visitChildren(self)


    class RefreshMaterializedViewContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def REFRESH(self):
            return self.getToken(SqlBaseParser.REFRESH, 0)
        def MATERIALIZED(self):
            return self.getToken(SqlBaseParser.MATERIALIZED, 0)
        def VIEW(self):
            return self.getToken(SqlBaseParser.VIEW, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRefreshMaterializedView" ):
                listener.enterRefreshMaterializedView(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRefreshMaterializedView" ):
                listener.exitRefreshMaterializedView(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRefreshMaterializedView" ):
                return visitor.visitRefreshMaterializedView(self)
            else:
                return visitor.visitChildren(self)


    class ShowCreateMaterializedViewContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def CREATE(self):
            return self.getToken(SqlBaseParser.CREATE, 0)
        def MATERIALIZED(self):
            return self.getToken(SqlBaseParser.MATERIALIZED, 0)
        def VIEW(self):
            return self.getToken(SqlBaseParser.VIEW, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowCreateMaterializedView" ):
                listener.enterShowCreateMaterializedView(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowCreateMaterializedView" ):
                listener.exitShowCreateMaterializedView(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowCreateMaterializedView" ):
                return visitor.visitShowCreateMaterializedView(self)
            else:
                return visitor.visitChildren(self)


    class ShowFunctionsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.pattern = None # StringContext
            self.escape = None # StringContext
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)
        def FUNCTIONS(self):
            return self.getToken(SqlBaseParser.FUNCTIONS, 0)
        def LIKE(self):
            return self.getToken(SqlBaseParser.LIKE, 0)
        def string(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.StringContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.StringContext,i)

        def ESCAPE(self):
            return self.getToken(SqlBaseParser.ESCAPE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShowFunctions" ):
                listener.enterShowFunctions(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShowFunctions" ):
                listener.exitShowFunctions(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowFunctions" ):
                return visitor.visitShowFunctions(self)
            else:
                return visitor.visitChildren(self)


    class DescribeOutputContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DESCRIBE(self):
            return self.getToken(SqlBaseParser.DESCRIBE, 0)
        def OUTPUT(self):
            return self.getToken(SqlBaseParser.OUTPUT, 0)
        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDescribeOutput" ):
                listener.enterDescribeOutput(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDescribeOutput" ):
                listener.exitDescribeOutput(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDescribeOutput" ):
                return visitor.visitDescribeOutput(self)
            else:
                return visitor.visitChildren(self)


    class GrantContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.grantee = None # PrincipalContext
            self.copyFrom(ctx)

        def GRANT(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.GRANT)
            else:
                return self.getToken(SqlBaseParser.GRANT, i)
        def ON(self):
            return self.getToken(SqlBaseParser.ON, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def TO(self):
            return self.getToken(SqlBaseParser.TO, 0)
        def principal(self):
            return self.getTypedRuleContext(SqlBaseParser.PrincipalContext,0)

        def privilege(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.PrivilegeContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.PrivilegeContext,i)

        def ALL(self):
            return self.getToken(SqlBaseParser.ALL, 0)
        def PRIVILEGES(self):
            return self.getToken(SqlBaseParser.PRIVILEGES, 0)
        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)
        def OPTION(self):
            return self.getToken(SqlBaseParser.OPTION, 0)
        def SCHEMA(self):
            return self.getToken(SqlBaseParser.SCHEMA, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGrant" ):
                listener.enterGrant(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGrant" ):
                listener.exitGrant(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGrant" ):
                return visitor.visitGrant(self)
            else:
                return visitor.visitChildren(self)


    class SetTablePropertiesContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StatementContext
            super().__init__(parser)
            self.tableName = None # QualifiedNameContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(SqlBaseParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def SET(self):
            return self.getToken(SqlBaseParser.SET, 0)
        def PROPERTIES(self):
            return self.getToken(SqlBaseParser.PROPERTIES, 0)
        def propertyAssignments(self):
            return self.getTypedRuleContext(SqlBaseParser.PropertyAssignmentsContext,0)

        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSetTableProperties" ):
                listener.enterSetTableProperties(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSetTableProperties" ):
                listener.exitSetTableProperties(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetTableProperties" ):
                return visitor.visitSetTableProperties(self)
            else:
                return visitor.visitChildren(self)



    def statement(self):

        localctx = SqlBaseParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_statement)
        self._la = 0 # Token type
        try:
            self.state = 997
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.StatementDefaultContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 233
                self.query()

            elif la_ == 2:
                localctx = SqlBaseParser.UseContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 234
                self.match(SqlBaseParser.USE)
                self.state = 235
                localctx.schema = self.identifier()

            elif la_ == 3:
                localctx = SqlBaseParser.UseContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 236
                self.match(SqlBaseParser.USE)
                self.state = 237
                localctx.catalog = self.identifier()
                self.state = 238
                self.match(SqlBaseParser.T__0)
                self.state = 239
                localctx.schema = self.identifier()

            elif la_ == 4:
                localctx = SqlBaseParser.CreateSchemaContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 241
                self.match(SqlBaseParser.CREATE)
                self.state = 242
                self.match(SqlBaseParser.SCHEMA)
                self.state = 246
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
                if la_ == 1:
                    self.state = 243
                    self.match(SqlBaseParser.IF)
                    self.state = 244
                    self.match(SqlBaseParser.NOT)
                    self.state = 245
                    self.match(SqlBaseParser.EXISTS)


                self.state = 248
                self.qualifiedName()
                self.state = 251
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.AUTHORIZATION:
                    self.state = 249
                    self.match(SqlBaseParser.AUTHORIZATION)
                    self.state = 250
                    self.principal()


                self.state = 255
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WITH:
                    self.state = 253
                    self.match(SqlBaseParser.WITH)
                    self.state = 254
                    self.properties()



            elif la_ == 5:
                localctx = SqlBaseParser.DropSchemaContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 257
                self.match(SqlBaseParser.DROP)
                self.state = 258
                self.match(SqlBaseParser.SCHEMA)
                self.state = 261
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
                if la_ == 1:
                    self.state = 259
                    self.match(SqlBaseParser.IF)
                    self.state = 260
                    self.match(SqlBaseParser.EXISTS)


                self.state = 263
                self.qualifiedName()
                self.state = 265
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.CASCADE or _la==SqlBaseParser.RESTRICT:
                    self.state = 264
                    _la = self._input.LA(1)
                    if not(_la==SqlBaseParser.CASCADE or _la==SqlBaseParser.RESTRICT):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()



            elif la_ == 6:
                localctx = SqlBaseParser.RenameSchemaContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 267
                self.match(SqlBaseParser.ALTER)
                self.state = 268
                self.match(SqlBaseParser.SCHEMA)
                self.state = 269
                self.qualifiedName()
                self.state = 270
                self.match(SqlBaseParser.RENAME)
                self.state = 271
                self.match(SqlBaseParser.TO)
                self.state = 272
                self.identifier()

            elif la_ == 7:
                localctx = SqlBaseParser.SetSchemaAuthorizationContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 274
                self.match(SqlBaseParser.ALTER)
                self.state = 275
                self.match(SqlBaseParser.SCHEMA)
                self.state = 276
                self.qualifiedName()
                self.state = 277
                self.match(SqlBaseParser.SET)
                self.state = 278
                self.match(SqlBaseParser.AUTHORIZATION)
                self.state = 279
                self.principal()

            elif la_ == 8:
                localctx = SqlBaseParser.CreateTableAsSelectContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 281
                self.match(SqlBaseParser.CREATE)
                self.state = 282
                self.match(SqlBaseParser.TABLE)
                self.state = 286
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
                if la_ == 1:
                    self.state = 283
                    self.match(SqlBaseParser.IF)
                    self.state = 284
                    self.match(SqlBaseParser.NOT)
                    self.state = 285
                    self.match(SqlBaseParser.EXISTS)


                self.state = 288
                self.qualifiedName()
                self.state = 290
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.T__1:
                    self.state = 289
                    self.columnAliases()


                self.state = 294
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.COMMENT:
                    self.state = 292
                    self.match(SqlBaseParser.COMMENT)
                    self.state = 293
                    self.string()


                self.state = 298
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WITH:
                    self.state = 296
                    self.match(SqlBaseParser.WITH)
                    self.state = 297
                    self.properties()


                self.state = 300
                self.match(SqlBaseParser.AS)
                self.state = 306
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
                if la_ == 1:
                    self.state = 301
                    self.query()

                elif la_ == 2:
                    self.state = 302
                    self.match(SqlBaseParser.T__1)
                    self.state = 303
                    self.query()
                    self.state = 304
                    self.match(SqlBaseParser.T__2)


                self.state = 313
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WITH:
                    self.state = 308
                    self.match(SqlBaseParser.WITH)
                    self.state = 310
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.NO:
                        self.state = 309
                        self.match(SqlBaseParser.NO)


                    self.state = 312
                    self.match(SqlBaseParser.DATA)



            elif la_ == 9:
                localctx = SqlBaseParser.CreateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 315
                self.match(SqlBaseParser.CREATE)
                self.state = 316
                self.match(SqlBaseParser.TABLE)
                self.state = 320
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
                if la_ == 1:
                    self.state = 317
                    self.match(SqlBaseParser.IF)
                    self.state = 318
                    self.match(SqlBaseParser.NOT)
                    self.state = 319
                    self.match(SqlBaseParser.EXISTS)


                self.state = 322
                self.qualifiedName()
                self.state = 323
                self.match(SqlBaseParser.T__1)
                self.state = 324
                self.tableElement()
                self.state = 329
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 325
                    self.match(SqlBaseParser.T__3)
                    self.state = 326
                    self.tableElement()
                    self.state = 331
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 332
                self.match(SqlBaseParser.T__2)
                self.state = 335
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.COMMENT:
                    self.state = 333
                    self.match(SqlBaseParser.COMMENT)
                    self.state = 334
                    self.string()


                self.state = 339
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WITH:
                    self.state = 337
                    self.match(SqlBaseParser.WITH)
                    self.state = 338
                    self.properties()



            elif la_ == 10:
                localctx = SqlBaseParser.DropTableContext(self, localctx)
                self.enterOuterAlt(localctx, 10)
                self.state = 341
                self.match(SqlBaseParser.DROP)
                self.state = 342
                self.match(SqlBaseParser.TABLE)
                self.state = 345
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
                if la_ == 1:
                    self.state = 343
                    self.match(SqlBaseParser.IF)
                    self.state = 344
                    self.match(SqlBaseParser.EXISTS)


                self.state = 347
                self.qualifiedName()

            elif la_ == 11:
                localctx = SqlBaseParser.InsertIntoContext(self, localctx)
                self.enterOuterAlt(localctx, 11)
                self.state = 348
                self.match(SqlBaseParser.INSERT)
                self.state = 349
                self.match(SqlBaseParser.INTO)
                self.state = 350
                self.qualifiedName()
                self.state = 352
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
                if la_ == 1:
                    self.state = 351
                    self.columnAliases()


                self.state = 354
                self.query()

            elif la_ == 12:
                localctx = SqlBaseParser.DeleteContext(self, localctx)
                self.enterOuterAlt(localctx, 12)
                self.state = 356
                self.match(SqlBaseParser.DELETE)
                self.state = 357
                self.match(SqlBaseParser.FROM)
                self.state = 358
                self.qualifiedName()
                self.state = 361
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WHERE:
                    self.state = 359
                    self.match(SqlBaseParser.WHERE)
                    self.state = 360
                    self.booleanExpression(0)



            elif la_ == 13:
                localctx = SqlBaseParser.TruncateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 13)
                self.state = 363
                self.match(SqlBaseParser.TRUNCATE)
                self.state = 364
                self.match(SqlBaseParser.TABLE)
                self.state = 365
                self.qualifiedName()

            elif la_ == 14:
                localctx = SqlBaseParser.CommentTableContext(self, localctx)
                self.enterOuterAlt(localctx, 14)
                self.state = 366
                self.match(SqlBaseParser.COMMENT)
                self.state = 367
                self.match(SqlBaseParser.ON)
                self.state = 368
                self.match(SqlBaseParser.TABLE)
                self.state = 369
                self.qualifiedName()
                self.state = 370
                self.match(SqlBaseParser.IS)
                self.state = 373
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SqlBaseParser.STRING, SqlBaseParser.UNICODE_STRING]:
                    self.state = 371
                    self.string()
                elif token in [SqlBaseParser.NULL]:
                    self.state = 372
                    self.match(SqlBaseParser.NULL)
                else:
                    raise NoViableAltException(self)


            elif la_ == 15:
                localctx = SqlBaseParser.CommentColumnContext(self, localctx)
                self.enterOuterAlt(localctx, 15)
                self.state = 375
                self.match(SqlBaseParser.COMMENT)
                self.state = 376
                self.match(SqlBaseParser.ON)
                self.state = 377
                self.match(SqlBaseParser.COLUMN)
                self.state = 378
                self.qualifiedName()
                self.state = 379
                self.match(SqlBaseParser.IS)
                self.state = 382
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SqlBaseParser.STRING, SqlBaseParser.UNICODE_STRING]:
                    self.state = 380
                    self.string()
                elif token in [SqlBaseParser.NULL]:
                    self.state = 381
                    self.match(SqlBaseParser.NULL)
                else:
                    raise NoViableAltException(self)


            elif la_ == 16:
                localctx = SqlBaseParser.RenameTableContext(self, localctx)
                self.enterOuterAlt(localctx, 16)
                self.state = 384
                self.match(SqlBaseParser.ALTER)
                self.state = 385
                self.match(SqlBaseParser.TABLE)
                self.state = 388
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
                if la_ == 1:
                    self.state = 386
                    self.match(SqlBaseParser.IF)
                    self.state = 387
                    self.match(SqlBaseParser.EXISTS)


                self.state = 390
                localctx.from_ = self.qualifiedName()
                self.state = 391
                self.match(SqlBaseParser.RENAME)
                self.state = 392
                self.match(SqlBaseParser.TO)
                self.state = 393
                localctx.to = self.qualifiedName()

            elif la_ == 17:
                localctx = SqlBaseParser.AddColumnContext(self, localctx)
                self.enterOuterAlt(localctx, 17)
                self.state = 395
                self.match(SqlBaseParser.ALTER)
                self.state = 396
                self.match(SqlBaseParser.TABLE)
                self.state = 399
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
                if la_ == 1:
                    self.state = 397
                    self.match(SqlBaseParser.IF)
                    self.state = 398
                    self.match(SqlBaseParser.EXISTS)


                self.state = 401
                localctx.tableName = self.qualifiedName()
                self.state = 402
                self.match(SqlBaseParser.ADD)
                self.state = 403
                self.match(SqlBaseParser.COLUMN)
                self.state = 407
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
                if la_ == 1:
                    self.state = 404
                    self.match(SqlBaseParser.IF)
                    self.state = 405
                    self.match(SqlBaseParser.NOT)
                    self.state = 406
                    self.match(SqlBaseParser.EXISTS)


                self.state = 409
                localctx.column = self.columnDefinition()

            elif la_ == 18:
                localctx = SqlBaseParser.RenameColumnContext(self, localctx)
                self.enterOuterAlt(localctx, 18)
                self.state = 411
                self.match(SqlBaseParser.ALTER)
                self.state = 412
                self.match(SqlBaseParser.TABLE)
                self.state = 415
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
                if la_ == 1:
                    self.state = 413
                    self.match(SqlBaseParser.IF)
                    self.state = 414
                    self.match(SqlBaseParser.EXISTS)


                self.state = 417
                localctx.tableName = self.qualifiedName()
                self.state = 418
                self.match(SqlBaseParser.RENAME)
                self.state = 419
                self.match(SqlBaseParser.COLUMN)
                self.state = 422
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
                if la_ == 1:
                    self.state = 420
                    self.match(SqlBaseParser.IF)
                    self.state = 421
                    self.match(SqlBaseParser.EXISTS)


                self.state = 424
                localctx.from_ = self.identifier()
                self.state = 425
                self.match(SqlBaseParser.TO)
                self.state = 426
                localctx.to = self.identifier()

            elif la_ == 19:
                localctx = SqlBaseParser.DropColumnContext(self, localctx)
                self.enterOuterAlt(localctx, 19)
                self.state = 428
                self.match(SqlBaseParser.ALTER)
                self.state = 429
                self.match(SqlBaseParser.TABLE)
                self.state = 432
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,26,self._ctx)
                if la_ == 1:
                    self.state = 430
                    self.match(SqlBaseParser.IF)
                    self.state = 431
                    self.match(SqlBaseParser.EXISTS)


                self.state = 434
                localctx.tableName = self.qualifiedName()
                self.state = 435
                self.match(SqlBaseParser.DROP)
                self.state = 436
                self.match(SqlBaseParser.COLUMN)
                self.state = 439
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
                if la_ == 1:
                    self.state = 437
                    self.match(SqlBaseParser.IF)
                    self.state = 438
                    self.match(SqlBaseParser.EXISTS)


                self.state = 441
                localctx.column = self.qualifiedName()

            elif la_ == 20:
                localctx = SqlBaseParser.SetTableAuthorizationContext(self, localctx)
                self.enterOuterAlt(localctx, 20)
                self.state = 443
                self.match(SqlBaseParser.ALTER)
                self.state = 444
                self.match(SqlBaseParser.TABLE)
                self.state = 445
                localctx.tableName = self.qualifiedName()
                self.state = 446
                self.match(SqlBaseParser.SET)
                self.state = 447
                self.match(SqlBaseParser.AUTHORIZATION)
                self.state = 448
                self.principal()

            elif la_ == 21:
                localctx = SqlBaseParser.SetTablePropertiesContext(self, localctx)
                self.enterOuterAlt(localctx, 21)
                self.state = 450
                self.match(SqlBaseParser.ALTER)
                self.state = 451
                self.match(SqlBaseParser.TABLE)
                self.state = 452
                localctx.tableName = self.qualifiedName()
                self.state = 453
                self.match(SqlBaseParser.SET)
                self.state = 454
                self.match(SqlBaseParser.PROPERTIES)
                self.state = 455
                self.propertyAssignments()

            elif la_ == 22:
                localctx = SqlBaseParser.TableExecuteContext(self, localctx)
                self.enterOuterAlt(localctx, 22)
                self.state = 457
                self.match(SqlBaseParser.ALTER)
                self.state = 458
                self.match(SqlBaseParser.TABLE)
                self.state = 459
                localctx.tableName = self.qualifiedName()
                self.state = 460
                self.match(SqlBaseParser.EXECUTE)
                self.state = 461
                localctx.procedureName = self.identifier()
                self.state = 474
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.T__1:
                    self.state = 462
                    self.match(SqlBaseParser.T__1)
                    self.state = 471
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.T__1) | (1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CASE) | (1 << SqlBaseParser.CAST) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.CURRENT_CATALOG) | (1 << SqlBaseParser.CURRENT_DATE) | (1 << SqlBaseParser.CURRENT_PATH) | (1 << SqlBaseParser.CURRENT_SCHEMA) | (1 << SqlBaseParser.CURRENT_TIME) | (1 << SqlBaseParser.CURRENT_TIMESTAMP) | (1 << SqlBaseParser.CURRENT_USER) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXISTS - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.EXTRACT - 64)) | (1 << (SqlBaseParser.FALSE - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPING - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)) | (1 << (SqlBaseParser.JSON_ARRAY - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SqlBaseParser.JSON_EXISTS - 128)) | (1 << (SqlBaseParser.JSON_OBJECT - 128)) | (1 << (SqlBaseParser.JSON_QUERY - 128)) | (1 << (SqlBaseParser.JSON_VALUE - 128)) | (1 << (SqlBaseParser.KEEP - 128)) | (1 << (SqlBaseParser.KEY - 128)) | (1 << (SqlBaseParser.KEYS - 128)) | (1 << (SqlBaseParser.LAST - 128)) | (1 << (SqlBaseParser.LATERAL - 128)) | (1 << (SqlBaseParser.LEADING - 128)) | (1 << (SqlBaseParser.LEVEL - 128)) | (1 << (SqlBaseParser.LIMIT - 128)) | (1 << (SqlBaseParser.LISTAGG - 128)) | (1 << (SqlBaseParser.LOCAL - 128)) | (1 << (SqlBaseParser.LOCALTIME - 128)) | (1 << (SqlBaseParser.LOCALTIMESTAMP - 128)) | (1 << (SqlBaseParser.LOGICAL - 128)) | (1 << (SqlBaseParser.MAP - 128)) | (1 << (SqlBaseParser.MATCH - 128)) | (1 << (SqlBaseParser.MATCHED - 128)) | (1 << (SqlBaseParser.MATCHES - 128)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 128)) | (1 << (SqlBaseParser.MATERIALIZED - 128)) | (1 << (SqlBaseParser.MEASURES - 128)) | (1 << (SqlBaseParser.MERGE - 128)) | (1 << (SqlBaseParser.MINUTE - 128)) | (1 << (SqlBaseParser.MONTH - 128)) | (1 << (SqlBaseParser.NEXT - 128)) | (1 << (SqlBaseParser.NFC - 128)) | (1 << (SqlBaseParser.NFD - 128)) | (1 << (SqlBaseParser.NFKC - 128)) | (1 << (SqlBaseParser.NFKD - 128)) | (1 << (SqlBaseParser.NO - 128)) | (1 << (SqlBaseParser.NONE - 128)) | (1 << (SqlBaseParser.NORMALIZE - 128)) | (1 << (SqlBaseParser.NOT - 128)) | (1 << (SqlBaseParser.NULL - 128)) | (1 << (SqlBaseParser.NULLIF - 128)) | (1 << (SqlBaseParser.NULLS - 128)) | (1 << (SqlBaseParser.OBJECT - 128)) | (1 << (SqlBaseParser.OFFSET - 128)) | (1 << (SqlBaseParser.OMIT - 128)) | (1 << (SqlBaseParser.OF - 128)) | (1 << (SqlBaseParser.ONE - 128)) | (1 << (SqlBaseParser.ONLY - 128)) | (1 << (SqlBaseParser.OPTION - 128)) | (1 << (SqlBaseParser.ORDINALITY - 128)) | (1 << (SqlBaseParser.OUTPUT - 128)) | (1 << (SqlBaseParser.OVER - 128)) | (1 << (SqlBaseParser.OVERFLOW - 128)) | (1 << (SqlBaseParser.PARTITION - 128)) | (1 << (SqlBaseParser.PARTITIONS - 128)) | (1 << (SqlBaseParser.PASSING - 128)) | (1 << (SqlBaseParser.PAST - 128)) | (1 << (SqlBaseParser.PATH - 128)) | (1 << (SqlBaseParser.PATTERN - 128)) | (1 << (SqlBaseParser.PER - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (SqlBaseParser.PERMUTE - 192)) | (1 << (SqlBaseParser.POSITION - 192)) | (1 << (SqlBaseParser.PRECEDING - 192)) | (1 << (SqlBaseParser.PRECISION - 192)) | (1 << (SqlBaseParser.PRIVILEGES - 192)) | (1 << (SqlBaseParser.PROPERTIES - 192)) | (1 << (SqlBaseParser.PRUNE - 192)) | (1 << (SqlBaseParser.QUOTES - 192)) | (1 << (SqlBaseParser.RANGE - 192)) | (1 << (SqlBaseParser.READ - 192)) | (1 << (SqlBaseParser.REFRESH - 192)) | (1 << (SqlBaseParser.RENAME - 192)) | (1 << (SqlBaseParser.REPEATABLE - 192)) | (1 << (SqlBaseParser.REPLACE - 192)) | (1 << (SqlBaseParser.RESET - 192)) | (1 << (SqlBaseParser.RESPECT - 192)) | (1 << (SqlBaseParser.RESTRICT - 192)) | (1 << (SqlBaseParser.RETURNING - 192)) | (1 << (SqlBaseParser.REVOKE - 192)) | (1 << (SqlBaseParser.ROLE - 192)) | (1 << (SqlBaseParser.ROLES - 192)) | (1 << (SqlBaseParser.ROLLBACK - 192)) | (1 << (SqlBaseParser.ROW - 192)) | (1 << (SqlBaseParser.ROWS - 192)) | (1 << (SqlBaseParser.RUNNING - 192)) | (1 << (SqlBaseParser.SCALAR - 192)) | (1 << (SqlBaseParser.SCHEMA - 192)) | (1 << (SqlBaseParser.SCHEMAS - 192)) | (1 << (SqlBaseParser.SECOND - 192)) | (1 << (SqlBaseParser.SECURITY - 192)) | (1 << (SqlBaseParser.SEEK - 192)) | (1 << (SqlBaseParser.SERIALIZABLE - 192)) | (1 << (SqlBaseParser.SESSION - 192)) | (1 << (SqlBaseParser.SET - 192)) | (1 << (SqlBaseParser.SETS - 192)) | (1 << (SqlBaseParser.SHOW - 192)) | (1 << (SqlBaseParser.SOME - 192)) | (1 << (SqlBaseParser.START - 192)) | (1 << (SqlBaseParser.STATS - 192)) | (1 << (SqlBaseParser.SUBSET - 192)) | (1 << (SqlBaseParser.SUBSTRING - 192)) | (1 << (SqlBaseParser.SYSTEM - 192)) | (1 << (SqlBaseParser.TABLES - 192)) | (1 << (SqlBaseParser.TABLESAMPLE - 192)) | (1 << (SqlBaseParser.TEXT - 192)) | (1 << (SqlBaseParser.TEXT_STRING - 192)) | (1 << (SqlBaseParser.TIES - 192)) | (1 << (SqlBaseParser.TIME - 192)) | (1 << (SqlBaseParser.TIMESTAMP - 192)) | (1 << (SqlBaseParser.TO - 192)) | (1 << (SqlBaseParser.TRAILING - 192)) | (1 << (SqlBaseParser.TRANSACTION - 192)) | (1 << (SqlBaseParser.TRIM - 192)) | (1 << (SqlBaseParser.TRUE - 192)) | (1 << (SqlBaseParser.TRUNCATE - 192)) | (1 << (SqlBaseParser.TRY_CAST - 192)) | (1 << (SqlBaseParser.TYPE - 192)))) != 0) or ((((_la - 257)) & ~0x3f) == 0 and ((1 << (_la - 257)) & ((1 << (SqlBaseParser.UNBOUNDED - 257)) | (1 << (SqlBaseParser.UNCOMMITTED - 257)) | (1 << (SqlBaseParser.UNCONDITIONAL - 257)) | (1 << (SqlBaseParser.UNIQUE - 257)) | (1 << (SqlBaseParser.UNKNOWN - 257)) | (1 << (SqlBaseParser.UNMATCHED - 257)) | (1 << (SqlBaseParser.UPDATE - 257)) | (1 << (SqlBaseParser.USE - 257)) | (1 << (SqlBaseParser.USER - 257)) | (1 << (SqlBaseParser.UTF16 - 257)) | (1 << (SqlBaseParser.UTF32 - 257)) | (1 << (SqlBaseParser.UTF8 - 257)) | (1 << (SqlBaseParser.VALIDATE - 257)) | (1 << (SqlBaseParser.VALUE - 257)) | (1 << (SqlBaseParser.VERBOSE - 257)) | (1 << (SqlBaseParser.VERSION - 257)) | (1 << (SqlBaseParser.VIEW - 257)) | (1 << (SqlBaseParser.WINDOW - 257)) | (1 << (SqlBaseParser.WITHIN - 257)) | (1 << (SqlBaseParser.WITHOUT - 257)) | (1 << (SqlBaseParser.WORK - 257)) | (1 << (SqlBaseParser.WRAPPER - 257)) | (1 << (SqlBaseParser.WRITE - 257)) | (1 << (SqlBaseParser.YEAR - 257)) | (1 << (SqlBaseParser.ZONE - 257)) | (1 << (SqlBaseParser.PLUS - 257)) | (1 << (SqlBaseParser.MINUS - 257)) | (1 << (SqlBaseParser.QUESTION_MARK - 257)) | (1 << (SqlBaseParser.STRING - 257)) | (1 << (SqlBaseParser.UNICODE_STRING - 257)) | (1 << (SqlBaseParser.BINARY_LITERAL - 257)) | (1 << (SqlBaseParser.INTEGER_VALUE - 257)) | (1 << (SqlBaseParser.DECIMAL_VALUE - 257)) | (1 << (SqlBaseParser.DOUBLE_VALUE - 257)) | (1 << (SqlBaseParser.IDENTIFIER - 257)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 257)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 257)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 257)))) != 0):
                        self.state = 463
                        self.callArgument()
                        self.state = 468
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==SqlBaseParser.T__3:
                            self.state = 464
                            self.match(SqlBaseParser.T__3)
                            self.state = 465
                            self.callArgument()
                            self.state = 470
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)



                    self.state = 473
                    self.match(SqlBaseParser.T__2)


                self.state = 478
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WHERE:
                    self.state = 476
                    self.match(SqlBaseParser.WHERE)
                    self.state = 477
                    localctx.where = self.booleanExpression(0)



            elif la_ == 23:
                localctx = SqlBaseParser.AnalyzeContext(self, localctx)
                self.enterOuterAlt(localctx, 23)
                self.state = 480
                self.match(SqlBaseParser.ANALYZE)
                self.state = 481
                self.qualifiedName()
                self.state = 484
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WITH:
                    self.state = 482
                    self.match(SqlBaseParser.WITH)
                    self.state = 483
                    self.properties()



            elif la_ == 24:
                localctx = SqlBaseParser.CreateMaterializedViewContext(self, localctx)
                self.enterOuterAlt(localctx, 24)
                self.state = 486
                self.match(SqlBaseParser.CREATE)
                self.state = 489
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.OR:
                    self.state = 487
                    self.match(SqlBaseParser.OR)
                    self.state = 488
                    self.match(SqlBaseParser.REPLACE)


                self.state = 491
                self.match(SqlBaseParser.MATERIALIZED)
                self.state = 492
                self.match(SqlBaseParser.VIEW)
                self.state = 496
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
                if la_ == 1:
                    self.state = 493
                    self.match(SqlBaseParser.IF)
                    self.state = 494
                    self.match(SqlBaseParser.NOT)
                    self.state = 495
                    self.match(SqlBaseParser.EXISTS)


                self.state = 498
                self.qualifiedName()
                self.state = 501
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.COMMENT:
                    self.state = 499
                    self.match(SqlBaseParser.COMMENT)
                    self.state = 500
                    self.string()


                self.state = 505
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WITH:
                    self.state = 503
                    self.match(SqlBaseParser.WITH)
                    self.state = 504
                    self.properties()


                self.state = 507
                self.match(SqlBaseParser.AS)
                self.state = 508
                self.query()

            elif la_ == 25:
                localctx = SqlBaseParser.CreateViewContext(self, localctx)
                self.enterOuterAlt(localctx, 25)
                self.state = 510
                self.match(SqlBaseParser.CREATE)
                self.state = 513
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.OR:
                    self.state = 511
                    self.match(SqlBaseParser.OR)
                    self.state = 512
                    self.match(SqlBaseParser.REPLACE)


                self.state = 515
                self.match(SqlBaseParser.VIEW)
                self.state = 516
                self.qualifiedName()
                self.state = 519
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.COMMENT:
                    self.state = 517
                    self.match(SqlBaseParser.COMMENT)
                    self.state = 518
                    self.string()


                self.state = 523
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.SECURITY:
                    self.state = 521
                    self.match(SqlBaseParser.SECURITY)
                    self.state = 522
                    _la = self._input.LA(1)
                    if not(_la==SqlBaseParser.DEFINER or _la==SqlBaseParser.INVOKER):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 525
                self.match(SqlBaseParser.AS)
                self.state = 526
                self.query()

            elif la_ == 26:
                localctx = SqlBaseParser.RefreshMaterializedViewContext(self, localctx)
                self.enterOuterAlt(localctx, 26)
                self.state = 528
                self.match(SqlBaseParser.REFRESH)
                self.state = 529
                self.match(SqlBaseParser.MATERIALIZED)
                self.state = 530
                self.match(SqlBaseParser.VIEW)
                self.state = 531
                self.qualifiedName()

            elif la_ == 27:
                localctx = SqlBaseParser.DropMaterializedViewContext(self, localctx)
                self.enterOuterAlt(localctx, 27)
                self.state = 532
                self.match(SqlBaseParser.DROP)
                self.state = 533
                self.match(SqlBaseParser.MATERIALIZED)
                self.state = 534
                self.match(SqlBaseParser.VIEW)
                self.state = 537
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
                if la_ == 1:
                    self.state = 535
                    self.match(SqlBaseParser.IF)
                    self.state = 536
                    self.match(SqlBaseParser.EXISTS)


                self.state = 539
                self.qualifiedName()

            elif la_ == 28:
                localctx = SqlBaseParser.RenameMaterializedViewContext(self, localctx)
                self.enterOuterAlt(localctx, 28)
                self.state = 540
                self.match(SqlBaseParser.ALTER)
                self.state = 541
                self.match(SqlBaseParser.MATERIALIZED)
                self.state = 542
                self.match(SqlBaseParser.VIEW)
                self.state = 545
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
                if la_ == 1:
                    self.state = 543
                    self.match(SqlBaseParser.IF)
                    self.state = 544
                    self.match(SqlBaseParser.EXISTS)


                self.state = 547
                localctx.from_ = self.qualifiedName()
                self.state = 548
                self.match(SqlBaseParser.RENAME)
                self.state = 549
                self.match(SqlBaseParser.TO)
                self.state = 550
                localctx.to = self.qualifiedName()

            elif la_ == 29:
                localctx = SqlBaseParser.SetMaterializedViewPropertiesContext(self, localctx)
                self.enterOuterAlt(localctx, 29)
                self.state = 552
                self.match(SqlBaseParser.ALTER)
                self.state = 553
                self.match(SqlBaseParser.MATERIALIZED)
                self.state = 554
                self.match(SqlBaseParser.VIEW)
                self.state = 555
                self.qualifiedName()
                self.state = 556
                self.match(SqlBaseParser.SET)
                self.state = 557
                self.match(SqlBaseParser.PROPERTIES)
                self.state = 558
                self.propertyAssignments()

            elif la_ == 30:
                localctx = SqlBaseParser.DropViewContext(self, localctx)
                self.enterOuterAlt(localctx, 30)
                self.state = 560
                self.match(SqlBaseParser.DROP)
                self.state = 561
                self.match(SqlBaseParser.VIEW)
                self.state = 564
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
                if la_ == 1:
                    self.state = 562
                    self.match(SqlBaseParser.IF)
                    self.state = 563
                    self.match(SqlBaseParser.EXISTS)


                self.state = 566
                self.qualifiedName()

            elif la_ == 31:
                localctx = SqlBaseParser.RenameViewContext(self, localctx)
                self.enterOuterAlt(localctx, 31)
                self.state = 567
                self.match(SqlBaseParser.ALTER)
                self.state = 568
                self.match(SqlBaseParser.VIEW)
                self.state = 569
                localctx.from_ = self.qualifiedName()
                self.state = 570
                self.match(SqlBaseParser.RENAME)
                self.state = 571
                self.match(SqlBaseParser.TO)
                self.state = 572
                localctx.to = self.qualifiedName()

            elif la_ == 32:
                localctx = SqlBaseParser.SetViewAuthorizationContext(self, localctx)
                self.enterOuterAlt(localctx, 32)
                self.state = 574
                self.match(SqlBaseParser.ALTER)
                self.state = 575
                self.match(SqlBaseParser.VIEW)
                self.state = 576
                localctx.from_ = self.qualifiedName()
                self.state = 577
                self.match(SqlBaseParser.SET)
                self.state = 578
                self.match(SqlBaseParser.AUTHORIZATION)
                self.state = 579
                self.principal()

            elif la_ == 33:
                localctx = SqlBaseParser.CallContext(self, localctx)
                self.enterOuterAlt(localctx, 33)
                self.state = 581
                self.match(SqlBaseParser.CALL)
                self.state = 582
                self.qualifiedName()
                self.state = 583
                self.match(SqlBaseParser.T__1)
                self.state = 592
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.T__1) | (1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CASE) | (1 << SqlBaseParser.CAST) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.CURRENT_CATALOG) | (1 << SqlBaseParser.CURRENT_DATE) | (1 << SqlBaseParser.CURRENT_PATH) | (1 << SqlBaseParser.CURRENT_SCHEMA) | (1 << SqlBaseParser.CURRENT_TIME) | (1 << SqlBaseParser.CURRENT_TIMESTAMP) | (1 << SqlBaseParser.CURRENT_USER) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXISTS - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.EXTRACT - 64)) | (1 << (SqlBaseParser.FALSE - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPING - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)) | (1 << (SqlBaseParser.JSON_ARRAY - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SqlBaseParser.JSON_EXISTS - 128)) | (1 << (SqlBaseParser.JSON_OBJECT - 128)) | (1 << (SqlBaseParser.JSON_QUERY - 128)) | (1 << (SqlBaseParser.JSON_VALUE - 128)) | (1 << (SqlBaseParser.KEEP - 128)) | (1 << (SqlBaseParser.KEY - 128)) | (1 << (SqlBaseParser.KEYS - 128)) | (1 << (SqlBaseParser.LAST - 128)) | (1 << (SqlBaseParser.LATERAL - 128)) | (1 << (SqlBaseParser.LEADING - 128)) | (1 << (SqlBaseParser.LEVEL - 128)) | (1 << (SqlBaseParser.LIMIT - 128)) | (1 << (SqlBaseParser.LISTAGG - 128)) | (1 << (SqlBaseParser.LOCAL - 128)) | (1 << (SqlBaseParser.LOCALTIME - 128)) | (1 << (SqlBaseParser.LOCALTIMESTAMP - 128)) | (1 << (SqlBaseParser.LOGICAL - 128)) | (1 << (SqlBaseParser.MAP - 128)) | (1 << (SqlBaseParser.MATCH - 128)) | (1 << (SqlBaseParser.MATCHED - 128)) | (1 << (SqlBaseParser.MATCHES - 128)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 128)) | (1 << (SqlBaseParser.MATERIALIZED - 128)) | (1 << (SqlBaseParser.MEASURES - 128)) | (1 << (SqlBaseParser.MERGE - 128)) | (1 << (SqlBaseParser.MINUTE - 128)) | (1 << (SqlBaseParser.MONTH - 128)) | (1 << (SqlBaseParser.NEXT - 128)) | (1 << (SqlBaseParser.NFC - 128)) | (1 << (SqlBaseParser.NFD - 128)) | (1 << (SqlBaseParser.NFKC - 128)) | (1 << (SqlBaseParser.NFKD - 128)) | (1 << (SqlBaseParser.NO - 128)) | (1 << (SqlBaseParser.NONE - 128)) | (1 << (SqlBaseParser.NORMALIZE - 128)) | (1 << (SqlBaseParser.NOT - 128)) | (1 << (SqlBaseParser.NULL - 128)) | (1 << (SqlBaseParser.NULLIF - 128)) | (1 << (SqlBaseParser.NULLS - 128)) | (1 << (SqlBaseParser.OBJECT - 128)) | (1 << (SqlBaseParser.OFFSET - 128)) | (1 << (SqlBaseParser.OMIT - 128)) | (1 << (SqlBaseParser.OF - 128)) | (1 << (SqlBaseParser.ONE - 128)) | (1 << (SqlBaseParser.ONLY - 128)) | (1 << (SqlBaseParser.OPTION - 128)) | (1 << (SqlBaseParser.ORDINALITY - 128)) | (1 << (SqlBaseParser.OUTPUT - 128)) | (1 << (SqlBaseParser.OVER - 128)) | (1 << (SqlBaseParser.OVERFLOW - 128)) | (1 << (SqlBaseParser.PARTITION - 128)) | (1 << (SqlBaseParser.PARTITIONS - 128)) | (1 << (SqlBaseParser.PASSING - 128)) | (1 << (SqlBaseParser.PAST - 128)) | (1 << (SqlBaseParser.PATH - 128)) | (1 << (SqlBaseParser.PATTERN - 128)) | (1 << (SqlBaseParser.PER - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (SqlBaseParser.PERMUTE - 192)) | (1 << (SqlBaseParser.POSITION - 192)) | (1 << (SqlBaseParser.PRECEDING - 192)) | (1 << (SqlBaseParser.PRECISION - 192)) | (1 << (SqlBaseParser.PRIVILEGES - 192)) | (1 << (SqlBaseParser.PROPERTIES - 192)) | (1 << (SqlBaseParser.PRUNE - 192)) | (1 << (SqlBaseParser.QUOTES - 192)) | (1 << (SqlBaseParser.RANGE - 192)) | (1 << (SqlBaseParser.READ - 192)) | (1 << (SqlBaseParser.REFRESH - 192)) | (1 << (SqlBaseParser.RENAME - 192)) | (1 << (SqlBaseParser.REPEATABLE - 192)) | (1 << (SqlBaseParser.REPLACE - 192)) | (1 << (SqlBaseParser.RESET - 192)) | (1 << (SqlBaseParser.RESPECT - 192)) | (1 << (SqlBaseParser.RESTRICT - 192)) | (1 << (SqlBaseParser.RETURNING - 192)) | (1 << (SqlBaseParser.REVOKE - 192)) | (1 << (SqlBaseParser.ROLE - 192)) | (1 << (SqlBaseParser.ROLES - 192)) | (1 << (SqlBaseParser.ROLLBACK - 192)) | (1 << (SqlBaseParser.ROW - 192)) | (1 << (SqlBaseParser.ROWS - 192)) | (1 << (SqlBaseParser.RUNNING - 192)) | (1 << (SqlBaseParser.SCALAR - 192)) | (1 << (SqlBaseParser.SCHEMA - 192)) | (1 << (SqlBaseParser.SCHEMAS - 192)) | (1 << (SqlBaseParser.SECOND - 192)) | (1 << (SqlBaseParser.SECURITY - 192)) | (1 << (SqlBaseParser.SEEK - 192)) | (1 << (SqlBaseParser.SERIALIZABLE - 192)) | (1 << (SqlBaseParser.SESSION - 192)) | (1 << (SqlBaseParser.SET - 192)) | (1 << (SqlBaseParser.SETS - 192)) | (1 << (SqlBaseParser.SHOW - 192)) | (1 << (SqlBaseParser.SOME - 192)) | (1 << (SqlBaseParser.START - 192)) | (1 << (SqlBaseParser.STATS - 192)) | (1 << (SqlBaseParser.SUBSET - 192)) | (1 << (SqlBaseParser.SUBSTRING - 192)) | (1 << (SqlBaseParser.SYSTEM - 192)) | (1 << (SqlBaseParser.TABLES - 192)) | (1 << (SqlBaseParser.TABLESAMPLE - 192)) | (1 << (SqlBaseParser.TEXT - 192)) | (1 << (SqlBaseParser.TEXT_STRING - 192)) | (1 << (SqlBaseParser.TIES - 192)) | (1 << (SqlBaseParser.TIME - 192)) | (1 << (SqlBaseParser.TIMESTAMP - 192)) | (1 << (SqlBaseParser.TO - 192)) | (1 << (SqlBaseParser.TRAILING - 192)) | (1 << (SqlBaseParser.TRANSACTION - 192)) | (1 << (SqlBaseParser.TRIM - 192)) | (1 << (SqlBaseParser.TRUE - 192)) | (1 << (SqlBaseParser.TRUNCATE - 192)) | (1 << (SqlBaseParser.TRY_CAST - 192)) | (1 << (SqlBaseParser.TYPE - 192)))) != 0) or ((((_la - 257)) & ~0x3f) == 0 and ((1 << (_la - 257)) & ((1 << (SqlBaseParser.UNBOUNDED - 257)) | (1 << (SqlBaseParser.UNCOMMITTED - 257)) | (1 << (SqlBaseParser.UNCONDITIONAL - 257)) | (1 << (SqlBaseParser.UNIQUE - 257)) | (1 << (SqlBaseParser.UNKNOWN - 257)) | (1 << (SqlBaseParser.UNMATCHED - 257)) | (1 << (SqlBaseParser.UPDATE - 257)) | (1 << (SqlBaseParser.USE - 257)) | (1 << (SqlBaseParser.USER - 257)) | (1 << (SqlBaseParser.UTF16 - 257)) | (1 << (SqlBaseParser.UTF32 - 257)) | (1 << (SqlBaseParser.UTF8 - 257)) | (1 << (SqlBaseParser.VALIDATE - 257)) | (1 << (SqlBaseParser.VALUE - 257)) | (1 << (SqlBaseParser.VERBOSE - 257)) | (1 << (SqlBaseParser.VERSION - 257)) | (1 << (SqlBaseParser.VIEW - 257)) | (1 << (SqlBaseParser.WINDOW - 257)) | (1 << (SqlBaseParser.WITHIN - 257)) | (1 << (SqlBaseParser.WITHOUT - 257)) | (1 << (SqlBaseParser.WORK - 257)) | (1 << (SqlBaseParser.WRAPPER - 257)) | (1 << (SqlBaseParser.WRITE - 257)) | (1 << (SqlBaseParser.YEAR - 257)) | (1 << (SqlBaseParser.ZONE - 257)) | (1 << (SqlBaseParser.PLUS - 257)) | (1 << (SqlBaseParser.MINUS - 257)) | (1 << (SqlBaseParser.QUESTION_MARK - 257)) | (1 << (SqlBaseParser.STRING - 257)) | (1 << (SqlBaseParser.UNICODE_STRING - 257)) | (1 << (SqlBaseParser.BINARY_LITERAL - 257)) | (1 << (SqlBaseParser.INTEGER_VALUE - 257)) | (1 << (SqlBaseParser.DECIMAL_VALUE - 257)) | (1 << (SqlBaseParser.DOUBLE_VALUE - 257)) | (1 << (SqlBaseParser.IDENTIFIER - 257)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 257)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 257)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 257)))) != 0):
                    self.state = 584
                    self.callArgument()
                    self.state = 589
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 585
                        self.match(SqlBaseParser.T__3)
                        self.state = 586
                        self.callArgument()
                        self.state = 591
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 594
                self.match(SqlBaseParser.T__2)

            elif la_ == 34:
                localctx = SqlBaseParser.CreateRoleContext(self, localctx)
                self.enterOuterAlt(localctx, 34)
                self.state = 596
                self.match(SqlBaseParser.CREATE)
                self.state = 597
                self.match(SqlBaseParser.ROLE)
                self.state = 598
                localctx.name = self.identifier()
                self.state = 602
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WITH:
                    self.state = 599
                    self.match(SqlBaseParser.WITH)
                    self.state = 600
                    self.match(SqlBaseParser.ADMIN)
                    self.state = 601
                    self.grantor()


                self.state = 606
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.IN:
                    self.state = 604
                    self.match(SqlBaseParser.IN)
                    self.state = 605
                    localctx.catalog = self.identifier()



            elif la_ == 35:
                localctx = SqlBaseParser.DropRoleContext(self, localctx)
                self.enterOuterAlt(localctx, 35)
                self.state = 608
                self.match(SqlBaseParser.DROP)
                self.state = 609
                self.match(SqlBaseParser.ROLE)
                self.state = 610
                localctx.name = self.identifier()
                self.state = 613
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.IN:
                    self.state = 611
                    self.match(SqlBaseParser.IN)
                    self.state = 612
                    localctx.catalog = self.identifier()



            elif la_ == 36:
                localctx = SqlBaseParser.GrantRolesContext(self, localctx)
                self.enterOuterAlt(localctx, 36)
                self.state = 615
                self.match(SqlBaseParser.GRANT)
                self.state = 616
                self.roles()
                self.state = 617
                self.match(SqlBaseParser.TO)
                self.state = 618
                self.principal()
                self.state = 623
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 619
                    self.match(SqlBaseParser.T__3)
                    self.state = 620
                    self.principal()
                    self.state = 625
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 629
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WITH:
                    self.state = 626
                    self.match(SqlBaseParser.WITH)
                    self.state = 627
                    self.match(SqlBaseParser.ADMIN)
                    self.state = 628
                    self.match(SqlBaseParser.OPTION)


                self.state = 634
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.GRANTED:
                    self.state = 631
                    self.match(SqlBaseParser.GRANTED)
                    self.state = 632
                    self.match(SqlBaseParser.BY)
                    self.state = 633
                    self.grantor()


                self.state = 638
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.IN:
                    self.state = 636
                    self.match(SqlBaseParser.IN)
                    self.state = 637
                    localctx.catalog = self.identifier()



            elif la_ == 37:
                localctx = SqlBaseParser.RevokeRolesContext(self, localctx)
                self.enterOuterAlt(localctx, 37)
                self.state = 640
                self.match(SqlBaseParser.REVOKE)
                self.state = 644
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
                if la_ == 1:
                    self.state = 641
                    self.match(SqlBaseParser.ADMIN)
                    self.state = 642
                    self.match(SqlBaseParser.OPTION)
                    self.state = 643
                    self.match(SqlBaseParser.FOR)


                self.state = 646
                self.roles()
                self.state = 647
                self.match(SqlBaseParser.FROM)
                self.state = 648
                self.principal()
                self.state = 653
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 649
                    self.match(SqlBaseParser.T__3)
                    self.state = 650
                    self.principal()
                    self.state = 655
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 659
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.GRANTED:
                    self.state = 656
                    self.match(SqlBaseParser.GRANTED)
                    self.state = 657
                    self.match(SqlBaseParser.BY)
                    self.state = 658
                    self.grantor()


                self.state = 663
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.IN:
                    self.state = 661
                    self.match(SqlBaseParser.IN)
                    self.state = 662
                    localctx.catalog = self.identifier()



            elif la_ == 38:
                localctx = SqlBaseParser.SetRoleContext(self, localctx)
                self.enterOuterAlt(localctx, 38)
                self.state = 665
                self.match(SqlBaseParser.SET)
                self.state = 666
                self.match(SqlBaseParser.ROLE)
                self.state = 670
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,56,self._ctx)
                if la_ == 1:
                    self.state = 667
                    self.match(SqlBaseParser.ALL)

                elif la_ == 2:
                    self.state = 668
                    self.match(SqlBaseParser.NONE)

                elif la_ == 3:
                    self.state = 669
                    localctx.role = self.identifier()


                self.state = 674
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.IN:
                    self.state = 672
                    self.match(SqlBaseParser.IN)
                    self.state = 673
                    localctx.catalog = self.identifier()



            elif la_ == 39:
                localctx = SqlBaseParser.GrantContext(self, localctx)
                self.enterOuterAlt(localctx, 39)
                self.state = 676
                self.match(SqlBaseParser.GRANT)
                self.state = 687
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SqlBaseParser.CREATE, SqlBaseParser.DELETE, SqlBaseParser.INSERT, SqlBaseParser.SELECT, SqlBaseParser.UPDATE]:
                    self.state = 677
                    self.privilege()
                    self.state = 682
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 678
                        self.match(SqlBaseParser.T__3)
                        self.state = 679
                        self.privilege()
                        self.state = 684
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                elif token in [SqlBaseParser.ALL]:
                    self.state = 685
                    self.match(SqlBaseParser.ALL)
                    self.state = 686
                    self.match(SqlBaseParser.PRIVILEGES)
                else:
                    raise NoViableAltException(self)

                self.state = 689
                self.match(SqlBaseParser.ON)
                self.state = 691
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,60,self._ctx)
                if la_ == 1:
                    self.state = 690
                    _la = self._input.LA(1)
                    if not(_la==SqlBaseParser.SCHEMA or _la==SqlBaseParser.TABLE):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 693
                self.qualifiedName()
                self.state = 694
                self.match(SqlBaseParser.TO)
                self.state = 695
                localctx.grantee = self.principal()
                self.state = 699
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WITH:
                    self.state = 696
                    self.match(SqlBaseParser.WITH)
                    self.state = 697
                    self.match(SqlBaseParser.GRANT)
                    self.state = 698
                    self.match(SqlBaseParser.OPTION)



            elif la_ == 40:
                localctx = SqlBaseParser.DenyContext(self, localctx)
                self.enterOuterAlt(localctx, 40)
                self.state = 701
                self.match(SqlBaseParser.DENY)
                self.state = 712
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SqlBaseParser.CREATE, SqlBaseParser.DELETE, SqlBaseParser.INSERT, SqlBaseParser.SELECT, SqlBaseParser.UPDATE]:
                    self.state = 702
                    self.privilege()
                    self.state = 707
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 703
                        self.match(SqlBaseParser.T__3)
                        self.state = 704
                        self.privilege()
                        self.state = 709
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                elif token in [SqlBaseParser.ALL]:
                    self.state = 710
                    self.match(SqlBaseParser.ALL)
                    self.state = 711
                    self.match(SqlBaseParser.PRIVILEGES)
                else:
                    raise NoViableAltException(self)

                self.state = 714
                self.match(SqlBaseParser.ON)
                self.state = 716
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,64,self._ctx)
                if la_ == 1:
                    self.state = 715
                    _la = self._input.LA(1)
                    if not(_la==SqlBaseParser.SCHEMA or _la==SqlBaseParser.TABLE):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 718
                self.qualifiedName()
                self.state = 719
                self.match(SqlBaseParser.TO)
                self.state = 720
                localctx.grantee = self.principal()

            elif la_ == 41:
                localctx = SqlBaseParser.RevokeContext(self, localctx)
                self.enterOuterAlt(localctx, 41)
                self.state = 722
                self.match(SqlBaseParser.REVOKE)
                self.state = 726
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.GRANT:
                    self.state = 723
                    self.match(SqlBaseParser.GRANT)
                    self.state = 724
                    self.match(SqlBaseParser.OPTION)
                    self.state = 725
                    self.match(SqlBaseParser.FOR)


                self.state = 738
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SqlBaseParser.CREATE, SqlBaseParser.DELETE, SqlBaseParser.INSERT, SqlBaseParser.SELECT, SqlBaseParser.UPDATE]:
                    self.state = 728
                    self.privilege()
                    self.state = 733
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 729
                        self.match(SqlBaseParser.T__3)
                        self.state = 730
                        self.privilege()
                        self.state = 735
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                elif token in [SqlBaseParser.ALL]:
                    self.state = 736
                    self.match(SqlBaseParser.ALL)
                    self.state = 737
                    self.match(SqlBaseParser.PRIVILEGES)
                else:
                    raise NoViableAltException(self)

                self.state = 740
                self.match(SqlBaseParser.ON)
                self.state = 742
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
                if la_ == 1:
                    self.state = 741
                    _la = self._input.LA(1)
                    if not(_la==SqlBaseParser.SCHEMA or _la==SqlBaseParser.TABLE):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 744
                self.qualifiedName()
                self.state = 745
                self.match(SqlBaseParser.FROM)
                self.state = 746
                localctx.grantee = self.principal()

            elif la_ == 42:
                localctx = SqlBaseParser.ShowGrantsContext(self, localctx)
                self.enterOuterAlt(localctx, 42)
                self.state = 748
                self.match(SqlBaseParser.SHOW)
                self.state = 749
                self.match(SqlBaseParser.GRANTS)
                self.state = 755
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.ON:
                    self.state = 750
                    self.match(SqlBaseParser.ON)
                    self.state = 752
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.TABLE:
                        self.state = 751
                        self.match(SqlBaseParser.TABLE)


                    self.state = 754
                    self.qualifiedName()



            elif la_ == 43:
                localctx = SqlBaseParser.ExplainContext(self, localctx)
                self.enterOuterAlt(localctx, 43)
                self.state = 757
                self.match(SqlBaseParser.EXPLAIN)
                self.state = 769
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
                if la_ == 1:
                    self.state = 758
                    self.match(SqlBaseParser.T__1)
                    self.state = 759
                    self.explainOption()
                    self.state = 764
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 760
                        self.match(SqlBaseParser.T__3)
                        self.state = 761
                        self.explainOption()
                        self.state = 766
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 767
                    self.match(SqlBaseParser.T__2)


                self.state = 771
                self.statement()

            elif la_ == 44:
                localctx = SqlBaseParser.ExplainAnalyzeContext(self, localctx)
                self.enterOuterAlt(localctx, 44)
                self.state = 772
                self.match(SqlBaseParser.EXPLAIN)
                self.state = 773
                self.match(SqlBaseParser.ANALYZE)
                self.state = 775
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.VERBOSE:
                    self.state = 774
                    self.match(SqlBaseParser.VERBOSE)


                self.state = 777
                self.statement()

            elif la_ == 45:
                localctx = SqlBaseParser.ShowCreateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 45)
                self.state = 778
                self.match(SqlBaseParser.SHOW)
                self.state = 779
                self.match(SqlBaseParser.CREATE)
                self.state = 780
                self.match(SqlBaseParser.TABLE)
                self.state = 781
                self.qualifiedName()

            elif la_ == 46:
                localctx = SqlBaseParser.ShowCreateSchemaContext(self, localctx)
                self.enterOuterAlt(localctx, 46)
                self.state = 782
                self.match(SqlBaseParser.SHOW)
                self.state = 783
                self.match(SqlBaseParser.CREATE)
                self.state = 784
                self.match(SqlBaseParser.SCHEMA)
                self.state = 785
                self.qualifiedName()

            elif la_ == 47:
                localctx = SqlBaseParser.ShowCreateViewContext(self, localctx)
                self.enterOuterAlt(localctx, 47)
                self.state = 786
                self.match(SqlBaseParser.SHOW)
                self.state = 787
                self.match(SqlBaseParser.CREATE)
                self.state = 788
                self.match(SqlBaseParser.VIEW)
                self.state = 789
                self.qualifiedName()

            elif la_ == 48:
                localctx = SqlBaseParser.ShowCreateMaterializedViewContext(self, localctx)
                self.enterOuterAlt(localctx, 48)
                self.state = 790
                self.match(SqlBaseParser.SHOW)
                self.state = 791
                self.match(SqlBaseParser.CREATE)
                self.state = 792
                self.match(SqlBaseParser.MATERIALIZED)
                self.state = 793
                self.match(SqlBaseParser.VIEW)
                self.state = 794
                self.qualifiedName()

            elif la_ == 49:
                localctx = SqlBaseParser.ShowTablesContext(self, localctx)
                self.enterOuterAlt(localctx, 49)
                self.state = 795
                self.match(SqlBaseParser.SHOW)
                self.state = 796
                self.match(SqlBaseParser.TABLES)
                self.state = 799
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.FROM or _la==SqlBaseParser.IN:
                    self.state = 797
                    _la = self._input.LA(1)
                    if not(_la==SqlBaseParser.FROM or _la==SqlBaseParser.IN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 798
                    self.qualifiedName()


                self.state = 807
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.LIKE:
                    self.state = 801
                    self.match(SqlBaseParser.LIKE)
                    self.state = 802
                    localctx.pattern = self.string()
                    self.state = 805
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.ESCAPE:
                        self.state = 803
                        self.match(SqlBaseParser.ESCAPE)
                        self.state = 804
                        localctx.escape = self.string()





            elif la_ == 50:
                localctx = SqlBaseParser.ShowSchemasContext(self, localctx)
                self.enterOuterAlt(localctx, 50)
                self.state = 809
                self.match(SqlBaseParser.SHOW)
                self.state = 810
                self.match(SqlBaseParser.SCHEMAS)
                self.state = 813
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.FROM or _la==SqlBaseParser.IN:
                    self.state = 811
                    _la = self._input.LA(1)
                    if not(_la==SqlBaseParser.FROM or _la==SqlBaseParser.IN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 812
                    self.identifier()


                self.state = 821
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.LIKE:
                    self.state = 815
                    self.match(SqlBaseParser.LIKE)
                    self.state = 816
                    localctx.pattern = self.string()
                    self.state = 819
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.ESCAPE:
                        self.state = 817
                        self.match(SqlBaseParser.ESCAPE)
                        self.state = 818
                        localctx.escape = self.string()





            elif la_ == 51:
                localctx = SqlBaseParser.ShowCatalogsContext(self, localctx)
                self.enterOuterAlt(localctx, 51)
                self.state = 823
                self.match(SqlBaseParser.SHOW)
                self.state = 824
                self.match(SqlBaseParser.CATALOGS)
                self.state = 831
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.LIKE:
                    self.state = 825
                    self.match(SqlBaseParser.LIKE)
                    self.state = 826
                    localctx.pattern = self.string()
                    self.state = 829
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.ESCAPE:
                        self.state = 827
                        self.match(SqlBaseParser.ESCAPE)
                        self.state = 828
                        localctx.escape = self.string()





            elif la_ == 52:
                localctx = SqlBaseParser.ShowColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 52)
                self.state = 833
                self.match(SqlBaseParser.SHOW)
                self.state = 834
                self.match(SqlBaseParser.COLUMNS)
                self.state = 835
                _la = self._input.LA(1)
                if not(_la==SqlBaseParser.FROM or _la==SqlBaseParser.IN):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 837
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (SqlBaseParser.KEEP - 132)) | (1 << (SqlBaseParser.KEY - 132)) | (1 << (SqlBaseParser.KEYS - 132)) | (1 << (SqlBaseParser.LAST - 132)) | (1 << (SqlBaseParser.LATERAL - 132)) | (1 << (SqlBaseParser.LEADING - 132)) | (1 << (SqlBaseParser.LEVEL - 132)) | (1 << (SqlBaseParser.LIMIT - 132)) | (1 << (SqlBaseParser.LOCAL - 132)) | (1 << (SqlBaseParser.LOGICAL - 132)) | (1 << (SqlBaseParser.MAP - 132)) | (1 << (SqlBaseParser.MATCH - 132)) | (1 << (SqlBaseParser.MATCHED - 132)) | (1 << (SqlBaseParser.MATCHES - 132)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 132)) | (1 << (SqlBaseParser.MATERIALIZED - 132)) | (1 << (SqlBaseParser.MEASURES - 132)) | (1 << (SqlBaseParser.MERGE - 132)) | (1 << (SqlBaseParser.MINUTE - 132)) | (1 << (SqlBaseParser.MONTH - 132)) | (1 << (SqlBaseParser.NEXT - 132)) | (1 << (SqlBaseParser.NFC - 132)) | (1 << (SqlBaseParser.NFD - 132)) | (1 << (SqlBaseParser.NFKC - 132)) | (1 << (SqlBaseParser.NFKD - 132)) | (1 << (SqlBaseParser.NO - 132)) | (1 << (SqlBaseParser.NONE - 132)) | (1 << (SqlBaseParser.NULLIF - 132)) | (1 << (SqlBaseParser.NULLS - 132)) | (1 << (SqlBaseParser.OBJECT - 132)) | (1 << (SqlBaseParser.OFFSET - 132)) | (1 << (SqlBaseParser.OMIT - 132)) | (1 << (SqlBaseParser.OF - 132)) | (1 << (SqlBaseParser.ONE - 132)) | (1 << (SqlBaseParser.ONLY - 132)) | (1 << (SqlBaseParser.OPTION - 132)) | (1 << (SqlBaseParser.ORDINALITY - 132)) | (1 << (SqlBaseParser.OUTPUT - 132)) | (1 << (SqlBaseParser.OVER - 132)) | (1 << (SqlBaseParser.OVERFLOW - 132)) | (1 << (SqlBaseParser.PARTITION - 132)) | (1 << (SqlBaseParser.PARTITIONS - 132)) | (1 << (SqlBaseParser.PASSING - 132)) | (1 << (SqlBaseParser.PAST - 132)) | (1 << (SqlBaseParser.PATH - 132)) | (1 << (SqlBaseParser.PATTERN - 132)) | (1 << (SqlBaseParser.PER - 132)) | (1 << (SqlBaseParser.PERMUTE - 132)) | (1 << (SqlBaseParser.POSITION - 132)) | (1 << (SqlBaseParser.PRECEDING - 132)) | (1 << (SqlBaseParser.PRECISION - 132)))) != 0) or ((((_la - 197)) & ~0x3f) == 0 and ((1 << (_la - 197)) & ((1 << (SqlBaseParser.PRIVILEGES - 197)) | (1 << (SqlBaseParser.PROPERTIES - 197)) | (1 << (SqlBaseParser.PRUNE - 197)) | (1 << (SqlBaseParser.QUOTES - 197)) | (1 << (SqlBaseParser.RANGE - 197)) | (1 << (SqlBaseParser.READ - 197)) | (1 << (SqlBaseParser.REFRESH - 197)) | (1 << (SqlBaseParser.RENAME - 197)) | (1 << (SqlBaseParser.REPEATABLE - 197)) | (1 << (SqlBaseParser.REPLACE - 197)) | (1 << (SqlBaseParser.RESET - 197)) | (1 << (SqlBaseParser.RESPECT - 197)) | (1 << (SqlBaseParser.RESTRICT - 197)) | (1 << (SqlBaseParser.RETURNING - 197)) | (1 << (SqlBaseParser.REVOKE - 197)) | (1 << (SqlBaseParser.ROLE - 197)) | (1 << (SqlBaseParser.ROLES - 197)) | (1 << (SqlBaseParser.ROLLBACK - 197)) | (1 << (SqlBaseParser.ROW - 197)) | (1 << (SqlBaseParser.ROWS - 197)) | (1 << (SqlBaseParser.RUNNING - 197)) | (1 << (SqlBaseParser.SCALAR - 197)) | (1 << (SqlBaseParser.SCHEMA - 197)) | (1 << (SqlBaseParser.SCHEMAS - 197)) | (1 << (SqlBaseParser.SECOND - 197)) | (1 << (SqlBaseParser.SECURITY - 197)) | (1 << (SqlBaseParser.SEEK - 197)) | (1 << (SqlBaseParser.SERIALIZABLE - 197)) | (1 << (SqlBaseParser.SESSION - 197)) | (1 << (SqlBaseParser.SET - 197)) | (1 << (SqlBaseParser.SETS - 197)) | (1 << (SqlBaseParser.SHOW - 197)) | (1 << (SqlBaseParser.SOME - 197)) | (1 << (SqlBaseParser.START - 197)) | (1 << (SqlBaseParser.STATS - 197)) | (1 << (SqlBaseParser.SUBSET - 197)) | (1 << (SqlBaseParser.SUBSTRING - 197)) | (1 << (SqlBaseParser.SYSTEM - 197)) | (1 << (SqlBaseParser.TABLES - 197)) | (1 << (SqlBaseParser.TABLESAMPLE - 197)) | (1 << (SqlBaseParser.TEXT - 197)) | (1 << (SqlBaseParser.TEXT_STRING - 197)) | (1 << (SqlBaseParser.TIES - 197)) | (1 << (SqlBaseParser.TIME - 197)) | (1 << (SqlBaseParser.TIMESTAMP - 197)) | (1 << (SqlBaseParser.TO - 197)) | (1 << (SqlBaseParser.TRAILING - 197)) | (1 << (SqlBaseParser.TRANSACTION - 197)) | (1 << (SqlBaseParser.TRUNCATE - 197)) | (1 << (SqlBaseParser.TRY_CAST - 197)) | (1 << (SqlBaseParser.TYPE - 197)) | (1 << (SqlBaseParser.UNBOUNDED - 197)) | (1 << (SqlBaseParser.UNCOMMITTED - 197)) | (1 << (SqlBaseParser.UNCONDITIONAL - 197)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (SqlBaseParser.UNIQUE - 261)) | (1 << (SqlBaseParser.UNKNOWN - 261)) | (1 << (SqlBaseParser.UNMATCHED - 261)) | (1 << (SqlBaseParser.UPDATE - 261)) | (1 << (SqlBaseParser.USE - 261)) | (1 << (SqlBaseParser.USER - 261)) | (1 << (SqlBaseParser.UTF16 - 261)) | (1 << (SqlBaseParser.UTF32 - 261)) | (1 << (SqlBaseParser.UTF8 - 261)) | (1 << (SqlBaseParser.VALIDATE - 261)) | (1 << (SqlBaseParser.VALUE - 261)) | (1 << (SqlBaseParser.VERBOSE - 261)) | (1 << (SqlBaseParser.VERSION - 261)) | (1 << (SqlBaseParser.VIEW - 261)) | (1 << (SqlBaseParser.WINDOW - 261)) | (1 << (SqlBaseParser.WITHIN - 261)) | (1 << (SqlBaseParser.WITHOUT - 261)) | (1 << (SqlBaseParser.WORK - 261)) | (1 << (SqlBaseParser.WRAPPER - 261)) | (1 << (SqlBaseParser.WRITE - 261)) | (1 << (SqlBaseParser.YEAR - 261)) | (1 << (SqlBaseParser.ZONE - 261)) | (1 << (SqlBaseParser.IDENTIFIER - 261)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 261)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 261)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 261)))) != 0):
                    self.state = 836
                    self.qualifiedName()


                self.state = 845
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.LIKE:
                    self.state = 839
                    self.match(SqlBaseParser.LIKE)
                    self.state = 840
                    localctx.pattern = self.string()
                    self.state = 843
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.ESCAPE:
                        self.state = 841
                        self.match(SqlBaseParser.ESCAPE)
                        self.state = 842
                        localctx.escape = self.string()





            elif la_ == 53:
                localctx = SqlBaseParser.ShowStatsContext(self, localctx)
                self.enterOuterAlt(localctx, 53)
                self.state = 847
                self.match(SqlBaseParser.SHOW)
                self.state = 848
                self.match(SqlBaseParser.STATS)
                self.state = 849
                self.match(SqlBaseParser.FOR)
                self.state = 850
                self.qualifiedName()

            elif la_ == 54:
                localctx = SqlBaseParser.ShowStatsForQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 54)
                self.state = 851
                self.match(SqlBaseParser.SHOW)
                self.state = 852
                self.match(SqlBaseParser.STATS)
                self.state = 853
                self.match(SqlBaseParser.FOR)
                self.state = 854
                self.match(SqlBaseParser.T__1)
                self.state = 855
                self.query()
                self.state = 856
                self.match(SqlBaseParser.T__2)

            elif la_ == 55:
                localctx = SqlBaseParser.ShowRolesContext(self, localctx)
                self.enterOuterAlt(localctx, 55)
                self.state = 858
                self.match(SqlBaseParser.SHOW)
                self.state = 860
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.CURRENT:
                    self.state = 859
                    self.match(SqlBaseParser.CURRENT)


                self.state = 862
                self.match(SqlBaseParser.ROLES)
                self.state = 865
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.FROM or _la==SqlBaseParser.IN:
                    self.state = 863
                    _la = self._input.LA(1)
                    if not(_la==SqlBaseParser.FROM or _la==SqlBaseParser.IN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 864
                    self.identifier()



            elif la_ == 56:
                localctx = SqlBaseParser.ShowRoleGrantsContext(self, localctx)
                self.enterOuterAlt(localctx, 56)
                self.state = 867
                self.match(SqlBaseParser.SHOW)
                self.state = 868
                self.match(SqlBaseParser.ROLE)
                self.state = 869
                self.match(SqlBaseParser.GRANTS)
                self.state = 872
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.FROM or _la==SqlBaseParser.IN:
                    self.state = 870
                    _la = self._input.LA(1)
                    if not(_la==SqlBaseParser.FROM or _la==SqlBaseParser.IN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 871
                    self.identifier()



            elif la_ == 57:
                localctx = SqlBaseParser.ShowColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 57)
                self.state = 874
                self.match(SqlBaseParser.DESCRIBE)
                self.state = 875
                self.qualifiedName()

            elif la_ == 58:
                localctx = SqlBaseParser.ShowColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 58)
                self.state = 876
                self.match(SqlBaseParser.DESC)
                self.state = 877
                self.qualifiedName()

            elif la_ == 59:
                localctx = SqlBaseParser.ShowFunctionsContext(self, localctx)
                self.enterOuterAlt(localctx, 59)
                self.state = 878
                self.match(SqlBaseParser.SHOW)
                self.state = 879
                self.match(SqlBaseParser.FUNCTIONS)
                self.state = 886
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.LIKE:
                    self.state = 880
                    self.match(SqlBaseParser.LIKE)
                    self.state = 881
                    localctx.pattern = self.string()
                    self.state = 884
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.ESCAPE:
                        self.state = 882
                        self.match(SqlBaseParser.ESCAPE)
                        self.state = 883
                        localctx.escape = self.string()





            elif la_ == 60:
                localctx = SqlBaseParser.ShowSessionContext(self, localctx)
                self.enterOuterAlt(localctx, 60)
                self.state = 888
                self.match(SqlBaseParser.SHOW)
                self.state = 889
                self.match(SqlBaseParser.SESSION)
                self.state = 896
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.LIKE:
                    self.state = 890
                    self.match(SqlBaseParser.LIKE)
                    self.state = 891
                    localctx.pattern = self.string()
                    self.state = 894
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.ESCAPE:
                        self.state = 892
                        self.match(SqlBaseParser.ESCAPE)
                        self.state = 893
                        localctx.escape = self.string()





            elif la_ == 61:
                localctx = SqlBaseParser.SetSessionContext(self, localctx)
                self.enterOuterAlt(localctx, 61)
                self.state = 898
                self.match(SqlBaseParser.SET)
                self.state = 899
                self.match(SqlBaseParser.SESSION)
                self.state = 900
                self.qualifiedName()
                self.state = 901
                self.match(SqlBaseParser.EQ)
                self.state = 902
                self.expression()

            elif la_ == 62:
                localctx = SqlBaseParser.ResetSessionContext(self, localctx)
                self.enterOuterAlt(localctx, 62)
                self.state = 904
                self.match(SqlBaseParser.RESET)
                self.state = 905
                self.match(SqlBaseParser.SESSION)
                self.state = 906
                self.qualifiedName()

            elif la_ == 63:
                localctx = SqlBaseParser.StartTransactionContext(self, localctx)
                self.enterOuterAlt(localctx, 63)
                self.state = 907
                self.match(SqlBaseParser.START)
                self.state = 908
                self.match(SqlBaseParser.TRANSACTION)
                self.state = 917
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.ISOLATION or _la==SqlBaseParser.READ:
                    self.state = 909
                    self.transactionMode()
                    self.state = 914
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 910
                        self.match(SqlBaseParser.T__3)
                        self.state = 911
                        self.transactionMode()
                        self.state = 916
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)




            elif la_ == 64:
                localctx = SqlBaseParser.CommitContext(self, localctx)
                self.enterOuterAlt(localctx, 64)
                self.state = 919
                self.match(SqlBaseParser.COMMIT)
                self.state = 921
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WORK:
                    self.state = 920
                    self.match(SqlBaseParser.WORK)



            elif la_ == 65:
                localctx = SqlBaseParser.RollbackContext(self, localctx)
                self.enterOuterAlt(localctx, 65)
                self.state = 923
                self.match(SqlBaseParser.ROLLBACK)
                self.state = 925
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WORK:
                    self.state = 924
                    self.match(SqlBaseParser.WORK)



            elif la_ == 66:
                localctx = SqlBaseParser.PrepareContext(self, localctx)
                self.enterOuterAlt(localctx, 66)
                self.state = 927
                self.match(SqlBaseParser.PREPARE)
                self.state = 928
                self.identifier()
                self.state = 929
                self.match(SqlBaseParser.FROM)
                self.state = 930
                self.statement()

            elif la_ == 67:
                localctx = SqlBaseParser.DeallocateContext(self, localctx)
                self.enterOuterAlt(localctx, 67)
                self.state = 932
                self.match(SqlBaseParser.DEALLOCATE)
                self.state = 933
                self.match(SqlBaseParser.PREPARE)
                self.state = 934
                self.identifier()

            elif la_ == 68:
                localctx = SqlBaseParser.ExecuteContext(self, localctx)
                self.enterOuterAlt(localctx, 68)
                self.state = 935
                self.match(SqlBaseParser.EXECUTE)
                self.state = 936
                self.identifier()
                self.state = 946
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.USING:
                    self.state = 937
                    self.match(SqlBaseParser.USING)
                    self.state = 938
                    self.expression()
                    self.state = 943
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 939
                        self.match(SqlBaseParser.T__3)
                        self.state = 940
                        self.expression()
                        self.state = 945
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)




            elif la_ == 69:
                localctx = SqlBaseParser.DescribeInputContext(self, localctx)
                self.enterOuterAlt(localctx, 69)
                self.state = 948
                self.match(SqlBaseParser.DESCRIBE)
                self.state = 949
                self.match(SqlBaseParser.INPUT)
                self.state = 950
                self.identifier()

            elif la_ == 70:
                localctx = SqlBaseParser.DescribeOutputContext(self, localctx)
                self.enterOuterAlt(localctx, 70)
                self.state = 951
                self.match(SqlBaseParser.DESCRIBE)
                self.state = 952
                self.match(SqlBaseParser.OUTPUT)
                self.state = 953
                self.identifier()

            elif la_ == 71:
                localctx = SqlBaseParser.SetPathContext(self, localctx)
                self.enterOuterAlt(localctx, 71)
                self.state = 954
                self.match(SqlBaseParser.SET)
                self.state = 955
                self.match(SqlBaseParser.PATH)
                self.state = 956
                self.pathSpecification()

            elif la_ == 72:
                localctx = SqlBaseParser.SetTimeZoneContext(self, localctx)
                self.enterOuterAlt(localctx, 72)
                self.state = 957
                self.match(SqlBaseParser.SET)
                self.state = 958
                self.match(SqlBaseParser.TIME)
                self.state = 959
                self.match(SqlBaseParser.ZONE)
                self.state = 962
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
                if la_ == 1:
                    self.state = 960
                    self.match(SqlBaseParser.LOCAL)

                elif la_ == 2:
                    self.state = 961
                    self.expression()



            elif la_ == 73:
                localctx = SqlBaseParser.UpdateContext(self, localctx)
                self.enterOuterAlt(localctx, 73)
                self.state = 964
                self.match(SqlBaseParser.UPDATE)
                self.state = 965
                self.qualifiedName()
                self.state = 966
                self.match(SqlBaseParser.SET)
                self.state = 967
                self.updateAssignment()
                self.state = 972
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 968
                    self.match(SqlBaseParser.T__3)
                    self.state = 969
                    self.updateAssignment()
                    self.state = 974
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 977
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WHERE:
                    self.state = 975
                    self.match(SqlBaseParser.WHERE)
                    self.state = 976
                    localctx.where = self.booleanExpression(0)



            elif la_ == 74:
                localctx = SqlBaseParser.MergeContext(self, localctx)
                self.enterOuterAlt(localctx, 74)
                self.state = 979
                self.match(SqlBaseParser.MERGE)
                self.state = 980
                self.match(SqlBaseParser.INTO)
                self.state = 981
                self.qualifiedName()
                self.state = 986
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.AS) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (SqlBaseParser.KEEP - 132)) | (1 << (SqlBaseParser.KEY - 132)) | (1 << (SqlBaseParser.KEYS - 132)) | (1 << (SqlBaseParser.LAST - 132)) | (1 << (SqlBaseParser.LATERAL - 132)) | (1 << (SqlBaseParser.LEADING - 132)) | (1 << (SqlBaseParser.LEVEL - 132)) | (1 << (SqlBaseParser.LIMIT - 132)) | (1 << (SqlBaseParser.LOCAL - 132)) | (1 << (SqlBaseParser.LOGICAL - 132)) | (1 << (SqlBaseParser.MAP - 132)) | (1 << (SqlBaseParser.MATCH - 132)) | (1 << (SqlBaseParser.MATCHED - 132)) | (1 << (SqlBaseParser.MATCHES - 132)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 132)) | (1 << (SqlBaseParser.MATERIALIZED - 132)) | (1 << (SqlBaseParser.MEASURES - 132)) | (1 << (SqlBaseParser.MERGE - 132)) | (1 << (SqlBaseParser.MINUTE - 132)) | (1 << (SqlBaseParser.MONTH - 132)) | (1 << (SqlBaseParser.NEXT - 132)) | (1 << (SqlBaseParser.NFC - 132)) | (1 << (SqlBaseParser.NFD - 132)) | (1 << (SqlBaseParser.NFKC - 132)) | (1 << (SqlBaseParser.NFKD - 132)) | (1 << (SqlBaseParser.NO - 132)) | (1 << (SqlBaseParser.NONE - 132)) | (1 << (SqlBaseParser.NULLIF - 132)) | (1 << (SqlBaseParser.NULLS - 132)) | (1 << (SqlBaseParser.OBJECT - 132)) | (1 << (SqlBaseParser.OFFSET - 132)) | (1 << (SqlBaseParser.OMIT - 132)) | (1 << (SqlBaseParser.OF - 132)) | (1 << (SqlBaseParser.ONE - 132)) | (1 << (SqlBaseParser.ONLY - 132)) | (1 << (SqlBaseParser.OPTION - 132)) | (1 << (SqlBaseParser.ORDINALITY - 132)) | (1 << (SqlBaseParser.OUTPUT - 132)) | (1 << (SqlBaseParser.OVER - 132)) | (1 << (SqlBaseParser.OVERFLOW - 132)) | (1 << (SqlBaseParser.PARTITION - 132)) | (1 << (SqlBaseParser.PARTITIONS - 132)) | (1 << (SqlBaseParser.PASSING - 132)) | (1 << (SqlBaseParser.PAST - 132)) | (1 << (SqlBaseParser.PATH - 132)) | (1 << (SqlBaseParser.PATTERN - 132)) | (1 << (SqlBaseParser.PER - 132)) | (1 << (SqlBaseParser.PERMUTE - 132)) | (1 << (SqlBaseParser.POSITION - 132)) | (1 << (SqlBaseParser.PRECEDING - 132)) | (1 << (SqlBaseParser.PRECISION - 132)))) != 0) or ((((_la - 197)) & ~0x3f) == 0 and ((1 << (_la - 197)) & ((1 << (SqlBaseParser.PRIVILEGES - 197)) | (1 << (SqlBaseParser.PROPERTIES - 197)) | (1 << (SqlBaseParser.PRUNE - 197)) | (1 << (SqlBaseParser.QUOTES - 197)) | (1 << (SqlBaseParser.RANGE - 197)) | (1 << (SqlBaseParser.READ - 197)) | (1 << (SqlBaseParser.REFRESH - 197)) | (1 << (SqlBaseParser.RENAME - 197)) | (1 << (SqlBaseParser.REPEATABLE - 197)) | (1 << (SqlBaseParser.REPLACE - 197)) | (1 << (SqlBaseParser.RESET - 197)) | (1 << (SqlBaseParser.RESPECT - 197)) | (1 << (SqlBaseParser.RESTRICT - 197)) | (1 << (SqlBaseParser.RETURNING - 197)) | (1 << (SqlBaseParser.REVOKE - 197)) | (1 << (SqlBaseParser.ROLE - 197)) | (1 << (SqlBaseParser.ROLES - 197)) | (1 << (SqlBaseParser.ROLLBACK - 197)) | (1 << (SqlBaseParser.ROW - 197)) | (1 << (SqlBaseParser.ROWS - 197)) | (1 << (SqlBaseParser.RUNNING - 197)) | (1 << (SqlBaseParser.SCALAR - 197)) | (1 << (SqlBaseParser.SCHEMA - 197)) | (1 << (SqlBaseParser.SCHEMAS - 197)) | (1 << (SqlBaseParser.SECOND - 197)) | (1 << (SqlBaseParser.SECURITY - 197)) | (1 << (SqlBaseParser.SEEK - 197)) | (1 << (SqlBaseParser.SERIALIZABLE - 197)) | (1 << (SqlBaseParser.SESSION - 197)) | (1 << (SqlBaseParser.SET - 197)) | (1 << (SqlBaseParser.SETS - 197)) | (1 << (SqlBaseParser.SHOW - 197)) | (1 << (SqlBaseParser.SOME - 197)) | (1 << (SqlBaseParser.START - 197)) | (1 << (SqlBaseParser.STATS - 197)) | (1 << (SqlBaseParser.SUBSET - 197)) | (1 << (SqlBaseParser.SUBSTRING - 197)) | (1 << (SqlBaseParser.SYSTEM - 197)) | (1 << (SqlBaseParser.TABLES - 197)) | (1 << (SqlBaseParser.TABLESAMPLE - 197)) | (1 << (SqlBaseParser.TEXT - 197)) | (1 << (SqlBaseParser.TEXT_STRING - 197)) | (1 << (SqlBaseParser.TIES - 197)) | (1 << (SqlBaseParser.TIME - 197)) | (1 << (SqlBaseParser.TIMESTAMP - 197)) | (1 << (SqlBaseParser.TO - 197)) | (1 << (SqlBaseParser.TRAILING - 197)) | (1 << (SqlBaseParser.TRANSACTION - 197)) | (1 << (SqlBaseParser.TRUNCATE - 197)) | (1 << (SqlBaseParser.TRY_CAST - 197)) | (1 << (SqlBaseParser.TYPE - 197)) | (1 << (SqlBaseParser.UNBOUNDED - 197)) | (1 << (SqlBaseParser.UNCOMMITTED - 197)) | (1 << (SqlBaseParser.UNCONDITIONAL - 197)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (SqlBaseParser.UNIQUE - 261)) | (1 << (SqlBaseParser.UNKNOWN - 261)) | (1 << (SqlBaseParser.UNMATCHED - 261)) | (1 << (SqlBaseParser.UPDATE - 261)) | (1 << (SqlBaseParser.USE - 261)) | (1 << (SqlBaseParser.USER - 261)) | (1 << (SqlBaseParser.UTF16 - 261)) | (1 << (SqlBaseParser.UTF32 - 261)) | (1 << (SqlBaseParser.UTF8 - 261)) | (1 << (SqlBaseParser.VALIDATE - 261)) | (1 << (SqlBaseParser.VALUE - 261)) | (1 << (SqlBaseParser.VERBOSE - 261)) | (1 << (SqlBaseParser.VERSION - 261)) | (1 << (SqlBaseParser.VIEW - 261)) | (1 << (SqlBaseParser.WINDOW - 261)) | (1 << (SqlBaseParser.WITHIN - 261)) | (1 << (SqlBaseParser.WITHOUT - 261)) | (1 << (SqlBaseParser.WORK - 261)) | (1 << (SqlBaseParser.WRAPPER - 261)) | (1 << (SqlBaseParser.WRITE - 261)) | (1 << (SqlBaseParser.YEAR - 261)) | (1 << (SqlBaseParser.ZONE - 261)) | (1 << (SqlBaseParser.IDENTIFIER - 261)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 261)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 261)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 261)))) != 0):
                    self.state = 983
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.AS:
                        self.state = 982
                        self.match(SqlBaseParser.AS)


                    self.state = 985
                    self.identifier()


                self.state = 988
                self.match(SqlBaseParser.USING)
                self.state = 989
                self.relation(0)
                self.state = 990
                self.match(SqlBaseParser.ON)
                self.state = 991
                self.expression()
                self.state = 993 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 992
                    self.mergeCase()
                    self.state = 995 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==SqlBaseParser.WHEN):
                        break



        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QueryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def queryNoWith(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryNoWithContext,0)


        def with_(self):
            return self.getTypedRuleContext(SqlBaseParser.With_Context,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_query

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQuery" ):
                listener.enterQuery(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQuery" ):
                listener.exitQuery(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQuery" ):
                return visitor.visitQuery(self)
            else:
                return visitor.visitChildren(self)




    def query(self):

        localctx = SqlBaseParser.QueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_query)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1000
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.WITH:
                self.state = 999
                self.with_()


            self.state = 1002
            self.queryNoWith()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class With_Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)

        def namedQuery(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.NamedQueryContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.NamedQueryContext,i)


        def RECURSIVE(self):
            return self.getToken(SqlBaseParser.RECURSIVE, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_with_

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWith_" ):
                listener.enterWith_(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWith_" ):
                listener.exitWith_(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWith_" ):
                return visitor.visitWith_(self)
            else:
                return visitor.visitChildren(self)




    def with_(self):

        localctx = SqlBaseParser.With_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_with_)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1004
            self.match(SqlBaseParser.WITH)
            self.state = 1006
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.RECURSIVE:
                self.state = 1005
                self.match(SqlBaseParser.RECURSIVE)


            self.state = 1008
            self.namedQuery()
            self.state = 1013
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SqlBaseParser.T__3:
                self.state = 1009
                self.match(SqlBaseParser.T__3)
                self.state = 1010
                self.namedQuery()
                self.state = 1015
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TableElementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def columnDefinition(self):
            return self.getTypedRuleContext(SqlBaseParser.ColumnDefinitionContext,0)


        def likeClause(self):
            return self.getTypedRuleContext(SqlBaseParser.LikeClauseContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_tableElement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTableElement" ):
                listener.enterTableElement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTableElement" ):
                listener.exitTableElement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableElement" ):
                return visitor.visitTableElement(self)
            else:
                return visitor.visitChildren(self)




    def tableElement(self):

        localctx = SqlBaseParser.TableElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_tableElement)
        try:
            self.state = 1018
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.ABSENT, SqlBaseParser.ADD, SqlBaseParser.ADMIN, SqlBaseParser.AFTER, SqlBaseParser.ALL, SqlBaseParser.ANALYZE, SqlBaseParser.ANY, SqlBaseParser.ARRAY, SqlBaseParser.ASC, SqlBaseParser.AT, SqlBaseParser.AUTHORIZATION, SqlBaseParser.BERNOULLI, SqlBaseParser.BOTH, SqlBaseParser.CALL, SqlBaseParser.CASCADE, SqlBaseParser.CATALOGS, SqlBaseParser.COLUMN, SqlBaseParser.COLUMNS, SqlBaseParser.COMMENT, SqlBaseParser.COMMIT, SqlBaseParser.COMMITTED, SqlBaseParser.CONDITIONAL, SqlBaseParser.COUNT, SqlBaseParser.COPARTITION, SqlBaseParser.CURRENT, SqlBaseParser.DATA, SqlBaseParser.DATE, SqlBaseParser.DAY, SqlBaseParser.DEFAULT, SqlBaseParser.DEFINER, SqlBaseParser.DENY, SqlBaseParser.DESC, SqlBaseParser.DESCRIPTOR, SqlBaseParser.DEFINE, SqlBaseParser.DISTRIBUTED, SqlBaseParser.DOUBLE, SqlBaseParser.EMPTY, SqlBaseParser.ENCODING, SqlBaseParser.ERROR, SqlBaseParser.EXCLUDING, SqlBaseParser.EXPLAIN, SqlBaseParser.FETCH, SqlBaseParser.FILTER, SqlBaseParser.FINAL, SqlBaseParser.FIRST, SqlBaseParser.FOLLOWING, SqlBaseParser.FORMAT, SqlBaseParser.FUNCTIONS, SqlBaseParser.GRANT, SqlBaseParser.GRANTED, SqlBaseParser.GRANTS, SqlBaseParser.GRAPHVIZ, SqlBaseParser.GROUPS, SqlBaseParser.HOUR, SqlBaseParser.IF, SqlBaseParser.IGNORE, SqlBaseParser.INCLUDING, SqlBaseParser.INITIAL, SqlBaseParser.INPUT, SqlBaseParser.INTERVAL, SqlBaseParser.INVOKER, SqlBaseParser.IO, SqlBaseParser.ISOLATION, SqlBaseParser.JSON, SqlBaseParser.KEEP, SqlBaseParser.KEY, SqlBaseParser.KEYS, SqlBaseParser.LAST, SqlBaseParser.LATERAL, SqlBaseParser.LEADING, SqlBaseParser.LEVEL, SqlBaseParser.LIMIT, SqlBaseParser.LOCAL, SqlBaseParser.LOGICAL, SqlBaseParser.MAP, SqlBaseParser.MATCH, SqlBaseParser.MATCHED, SqlBaseParser.MATCHES, SqlBaseParser.MATCH_RECOGNIZE, SqlBaseParser.MATERIALIZED, SqlBaseParser.MEASURES, SqlBaseParser.MERGE, SqlBaseParser.MINUTE, SqlBaseParser.MONTH, SqlBaseParser.NEXT, SqlBaseParser.NFC, SqlBaseParser.NFD, SqlBaseParser.NFKC, SqlBaseParser.NFKD, SqlBaseParser.NO, SqlBaseParser.NONE, SqlBaseParser.NULLIF, SqlBaseParser.NULLS, SqlBaseParser.OBJECT, SqlBaseParser.OFFSET, SqlBaseParser.OMIT, SqlBaseParser.OF, SqlBaseParser.ONE, SqlBaseParser.ONLY, SqlBaseParser.OPTION, SqlBaseParser.ORDINALITY, SqlBaseParser.OUTPUT, SqlBaseParser.OVER, SqlBaseParser.OVERFLOW, SqlBaseParser.PARTITION, SqlBaseParser.PARTITIONS, SqlBaseParser.PASSING, SqlBaseParser.PAST, SqlBaseParser.PATH, SqlBaseParser.PATTERN, SqlBaseParser.PER, SqlBaseParser.PERMUTE, SqlBaseParser.POSITION, SqlBaseParser.PRECEDING, SqlBaseParser.PRECISION, SqlBaseParser.PRIVILEGES, SqlBaseParser.PROPERTIES, SqlBaseParser.PRUNE, SqlBaseParser.QUOTES, SqlBaseParser.RANGE, SqlBaseParser.READ, SqlBaseParser.REFRESH, SqlBaseParser.RENAME, SqlBaseParser.REPEATABLE, SqlBaseParser.REPLACE, SqlBaseParser.RESET, SqlBaseParser.RESPECT, SqlBaseParser.RESTRICT, SqlBaseParser.RETURNING, SqlBaseParser.REVOKE, SqlBaseParser.ROLE, SqlBaseParser.ROLES, SqlBaseParser.ROLLBACK, SqlBaseParser.ROW, SqlBaseParser.ROWS, SqlBaseParser.RUNNING, SqlBaseParser.SCALAR, SqlBaseParser.SCHEMA, SqlBaseParser.SCHEMAS, SqlBaseParser.SECOND, SqlBaseParser.SECURITY, SqlBaseParser.SEEK, SqlBaseParser.SERIALIZABLE, SqlBaseParser.SESSION, SqlBaseParser.SET, SqlBaseParser.SETS, SqlBaseParser.SHOW, SqlBaseParser.SOME, SqlBaseParser.START, SqlBaseParser.STATS, SqlBaseParser.SUBSET, SqlBaseParser.SUBSTRING, SqlBaseParser.SYSTEM, SqlBaseParser.TABLES, SqlBaseParser.TABLESAMPLE, SqlBaseParser.TEXT, SqlBaseParser.TEXT_STRING, SqlBaseParser.TIES, SqlBaseParser.TIME, SqlBaseParser.TIMESTAMP, SqlBaseParser.TO, SqlBaseParser.TRAILING, SqlBaseParser.TRANSACTION, SqlBaseParser.TRUNCATE, SqlBaseParser.TRY_CAST, SqlBaseParser.TYPE, SqlBaseParser.UNBOUNDED, SqlBaseParser.UNCOMMITTED, SqlBaseParser.UNCONDITIONAL, SqlBaseParser.UNIQUE, SqlBaseParser.UNKNOWN, SqlBaseParser.UNMATCHED, SqlBaseParser.UPDATE, SqlBaseParser.USE, SqlBaseParser.USER, SqlBaseParser.UTF16, SqlBaseParser.UTF32, SqlBaseParser.UTF8, SqlBaseParser.VALIDATE, SqlBaseParser.VALUE, SqlBaseParser.VERBOSE, SqlBaseParser.VERSION, SqlBaseParser.VIEW, SqlBaseParser.WINDOW, SqlBaseParser.WITHIN, SqlBaseParser.WITHOUT, SqlBaseParser.WORK, SqlBaseParser.WRAPPER, SqlBaseParser.WRITE, SqlBaseParser.YEAR, SqlBaseParser.ZONE, SqlBaseParser.IDENTIFIER, SqlBaseParser.DIGIT_IDENTIFIER, SqlBaseParser.QUOTED_IDENTIFIER, SqlBaseParser.BACKQUOTED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1016
                self.columnDefinition()
            elif token in [SqlBaseParser.LIKE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1017
                self.likeClause()
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ColumnDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def type_(self):
            return self.getTypedRuleContext(SqlBaseParser.Type_Context,0)


        def NOT(self):
            return self.getToken(SqlBaseParser.NOT, 0)

        def NULL(self):
            return self.getToken(SqlBaseParser.NULL, 0)

        def COMMENT(self):
            return self.getToken(SqlBaseParser.COMMENT, 0)

        def string(self):
            return self.getTypedRuleContext(SqlBaseParser.StringContext,0)


        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)

        def properties(self):
            return self.getTypedRuleContext(SqlBaseParser.PropertiesContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_columnDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterColumnDefinition" ):
                listener.enterColumnDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitColumnDefinition" ):
                listener.exitColumnDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitColumnDefinition" ):
                return visitor.visitColumnDefinition(self)
            else:
                return visitor.visitChildren(self)




    def columnDefinition(self):

        localctx = SqlBaseParser.ColumnDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_columnDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1020
            self.identifier()
            self.state = 1021
            self.type_(0)
            self.state = 1024
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.NOT:
                self.state = 1022
                self.match(SqlBaseParser.NOT)
                self.state = 1023
                self.match(SqlBaseParser.NULL)


            self.state = 1028
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.COMMENT:
                self.state = 1026
                self.match(SqlBaseParser.COMMENT)
                self.state = 1027
                self.string()


            self.state = 1032
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.WITH:
                self.state = 1030
                self.match(SqlBaseParser.WITH)
                self.state = 1031
                self.properties()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LikeClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.optionType = None # Token

        def LIKE(self):
            return self.getToken(SqlBaseParser.LIKE, 0)

        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)


        def PROPERTIES(self):
            return self.getToken(SqlBaseParser.PROPERTIES, 0)

        def INCLUDING(self):
            return self.getToken(SqlBaseParser.INCLUDING, 0)

        def EXCLUDING(self):
            return self.getToken(SqlBaseParser.EXCLUDING, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_likeClause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLikeClause" ):
                listener.enterLikeClause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLikeClause" ):
                listener.exitLikeClause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLikeClause" ):
                return visitor.visitLikeClause(self)
            else:
                return visitor.visitChildren(self)




    def likeClause(self):

        localctx = SqlBaseParser.LikeClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_likeClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1034
            self.match(SqlBaseParser.LIKE)
            self.state = 1035
            self.qualifiedName()
            self.state = 1038
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.EXCLUDING or _la==SqlBaseParser.INCLUDING:
                self.state = 1036
                localctx.optionType = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==SqlBaseParser.EXCLUDING or _la==SqlBaseParser.INCLUDING):
                    localctx.optionType = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1037
                self.match(SqlBaseParser.PROPERTIES)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PropertiesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def propertyAssignments(self):
            return self.getTypedRuleContext(SqlBaseParser.PropertyAssignmentsContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_properties

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProperties" ):
                listener.enterProperties(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProperties" ):
                listener.exitProperties(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitProperties" ):
                return visitor.visitProperties(self)
            else:
                return visitor.visitChildren(self)




    def properties(self):

        localctx = SqlBaseParser.PropertiesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_properties)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1040
            self.match(SqlBaseParser.T__1)
            self.state = 1041
            self.propertyAssignments()
            self.state = 1042
            self.match(SqlBaseParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PropertyAssignmentsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def property_(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.Property_Context)
            else:
                return self.getTypedRuleContext(SqlBaseParser.Property_Context,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_propertyAssignments

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPropertyAssignments" ):
                listener.enterPropertyAssignments(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPropertyAssignments" ):
                listener.exitPropertyAssignments(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPropertyAssignments" ):
                return visitor.visitPropertyAssignments(self)
            else:
                return visitor.visitChildren(self)




    def propertyAssignments(self):

        localctx = SqlBaseParser.PropertyAssignmentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_propertyAssignments)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1044
            self.property_()
            self.state = 1049
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SqlBaseParser.T__3:
                self.state = 1045
                self.match(SqlBaseParser.T__3)
                self.state = 1046
                self.property_()
                self.state = 1051
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Property_Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def EQ(self):
            return self.getToken(SqlBaseParser.EQ, 0)

        def propertyValue(self):
            return self.getTypedRuleContext(SqlBaseParser.PropertyValueContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_property_

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProperty_" ):
                listener.enterProperty_(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProperty_" ):
                listener.exitProperty_(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitProperty_" ):
                return visitor.visitProperty_(self)
            else:
                return visitor.visitChildren(self)




    def property_(self):

        localctx = SqlBaseParser.Property_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_property_)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1052
            self.identifier()
            self.state = 1053
            self.match(SqlBaseParser.EQ)
            self.state = 1054
            self.propertyValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PropertyValueContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_propertyValue

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class DefaultPropertyValueContext(PropertyValueContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PropertyValueContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DEFAULT(self):
            return self.getToken(SqlBaseParser.DEFAULT, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDefaultPropertyValue" ):
                listener.enterDefaultPropertyValue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDefaultPropertyValue" ):
                listener.exitDefaultPropertyValue(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDefaultPropertyValue" ):
                return visitor.visitDefaultPropertyValue(self)
            else:
                return visitor.visitChildren(self)


    class NonDefaultPropertyValueContext(PropertyValueContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PropertyValueContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNonDefaultPropertyValue" ):
                listener.enterNonDefaultPropertyValue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNonDefaultPropertyValue" ):
                listener.exitNonDefaultPropertyValue(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNonDefaultPropertyValue" ):
                return visitor.visitNonDefaultPropertyValue(self)
            else:
                return visitor.visitChildren(self)



    def propertyValue(self):

        localctx = SqlBaseParser.PropertyValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_propertyValue)
        try:
            self.state = 1058
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.DefaultPropertyValueContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1056
                self.match(SqlBaseParser.DEFAULT)

            elif la_ == 2:
                localctx = SqlBaseParser.NonDefaultPropertyValueContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1057
                self.expression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QueryNoWithContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.offset = None # RowCountContext
            self.limit = None # LimitRowCountContext
            self.fetchFirst = None # RowCountContext

        def queryTerm(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryTermContext,0)


        def ORDER(self):
            return self.getToken(SqlBaseParser.ORDER, 0)

        def BY(self):
            return self.getToken(SqlBaseParser.BY, 0)

        def sortItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.SortItemContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.SortItemContext,i)


        def OFFSET(self):
            return self.getToken(SqlBaseParser.OFFSET, 0)

        def rowCount(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.RowCountContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.RowCountContext,i)


        def LIMIT(self):
            return self.getToken(SqlBaseParser.LIMIT, 0)

        def FETCH(self):
            return self.getToken(SqlBaseParser.FETCH, 0)

        def limitRowCount(self):
            return self.getTypedRuleContext(SqlBaseParser.LimitRowCountContext,0)


        def FIRST(self):
            return self.getToken(SqlBaseParser.FIRST, 0)

        def NEXT(self):
            return self.getToken(SqlBaseParser.NEXT, 0)

        def ROW(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.ROW)
            else:
                return self.getToken(SqlBaseParser.ROW, i)

        def ROWS(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.ROWS)
            else:
                return self.getToken(SqlBaseParser.ROWS, i)

        def ONLY(self):
            return self.getToken(SqlBaseParser.ONLY, 0)

        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)

        def TIES(self):
            return self.getToken(SqlBaseParser.TIES, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_queryNoWith

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQueryNoWith" ):
                listener.enterQueryNoWith(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQueryNoWith" ):
                listener.exitQueryNoWith(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQueryNoWith" ):
                return visitor.visitQueryNoWith(self)
            else:
                return visitor.visitChildren(self)




    def queryNoWith(self):

        localctx = SqlBaseParser.QueryNoWithContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_queryNoWith)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1060
            self.queryTerm(0)
            self.state = 1071
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.ORDER:
                self.state = 1061
                self.match(SqlBaseParser.ORDER)
                self.state = 1062
                self.match(SqlBaseParser.BY)
                self.state = 1063
                self.sortItem()
                self.state = 1068
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 1064
                    self.match(SqlBaseParser.T__3)
                    self.state = 1065
                    self.sortItem()
                    self.state = 1070
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1078
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.OFFSET:
                self.state = 1073
                self.match(SqlBaseParser.OFFSET)
                self.state = 1074
                localctx.offset = self.rowCount()
                self.state = 1076
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.ROW or _la==SqlBaseParser.ROWS:
                    self.state = 1075
                    _la = self._input.LA(1)
                    if not(_la==SqlBaseParser.ROW or _la==SqlBaseParser.ROWS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()




            self.state = 1093
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.LIMIT]:
                self.state = 1080
                self.match(SqlBaseParser.LIMIT)
                self.state = 1081
                localctx.limit = self.limitRowCount()
            elif token in [SqlBaseParser.FETCH]:
                self.state = 1082
                self.match(SqlBaseParser.FETCH)
                self.state = 1083
                _la = self._input.LA(1)
                if not(_la==SqlBaseParser.FIRST or _la==SqlBaseParser.NEXT):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1085
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.QUESTION_MARK or _la==SqlBaseParser.INTEGER_VALUE:
                    self.state = 1084
                    localctx.fetchFirst = self.rowCount()


                self.state = 1087
                _la = self._input.LA(1)
                if not(_la==SqlBaseParser.ROW or _la==SqlBaseParser.ROWS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1091
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SqlBaseParser.ONLY]:
                    self.state = 1088
                    self.match(SqlBaseParser.ONLY)
                elif token in [SqlBaseParser.WITH]:
                    self.state = 1089
                    self.match(SqlBaseParser.WITH)
                    self.state = 1090
                    self.match(SqlBaseParser.TIES)
                else:
                    raise NoViableAltException(self)

            elif token in [SqlBaseParser.EOF, SqlBaseParser.T__2, SqlBaseParser.WITH]:
                pass
            else:
                pass
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LimitRowCountContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ALL(self):
            return self.getToken(SqlBaseParser.ALL, 0)

        def rowCount(self):
            return self.getTypedRuleContext(SqlBaseParser.RowCountContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_limitRowCount

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLimitRowCount" ):
                listener.enterLimitRowCount(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLimitRowCount" ):
                listener.exitLimitRowCount(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLimitRowCount" ):
                return visitor.visitLimitRowCount(self)
            else:
                return visitor.visitChildren(self)




    def limitRowCount(self):

        localctx = SqlBaseParser.LimitRowCountContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_limitRowCount)
        try:
            self.state = 1097
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.ALL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1095
                self.match(SqlBaseParser.ALL)
            elif token in [SqlBaseParser.QUESTION_MARK, SqlBaseParser.INTEGER_VALUE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1096
                self.rowCount()
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RowCountContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INTEGER_VALUE(self):
            return self.getToken(SqlBaseParser.INTEGER_VALUE, 0)

        def QUESTION_MARK(self):
            return self.getToken(SqlBaseParser.QUESTION_MARK, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_rowCount

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRowCount" ):
                listener.enterRowCount(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRowCount" ):
                listener.exitRowCount(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRowCount" ):
                return visitor.visitRowCount(self)
            else:
                return visitor.visitChildren(self)




    def rowCount(self):

        localctx = SqlBaseParser.RowCountContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_rowCount)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1099
            _la = self._input.LA(1)
            if not(_la==SqlBaseParser.QUESTION_MARK or _la==SqlBaseParser.INTEGER_VALUE):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QueryTermContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_queryTerm

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class QueryTermDefaultContext(QueryTermContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.QueryTermContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def queryPrimary(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryPrimaryContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQueryTermDefault" ):
                listener.enterQueryTermDefault(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQueryTermDefault" ):
                listener.exitQueryTermDefault(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQueryTermDefault" ):
                return visitor.visitQueryTermDefault(self)
            else:
                return visitor.visitChildren(self)


    class SetOperationContext(QueryTermContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.QueryTermContext
            super().__init__(parser)
            self.left = None # QueryTermContext
            self.operator = None # Token
            self.right = None # QueryTermContext
            self.copyFrom(ctx)

        def queryTerm(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.QueryTermContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.QueryTermContext,i)

        def INTERSECT(self):
            return self.getToken(SqlBaseParser.INTERSECT, 0)
        def setQuantifier(self):
            return self.getTypedRuleContext(SqlBaseParser.SetQuantifierContext,0)

        def UNION(self):
            return self.getToken(SqlBaseParser.UNION, 0)
        def EXCEPT(self):
            return self.getToken(SqlBaseParser.EXCEPT, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSetOperation" ):
                listener.enterSetOperation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSetOperation" ):
                listener.exitSetOperation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetOperation" ):
                return visitor.visitSetOperation(self)
            else:
                return visitor.visitChildren(self)



    def queryTerm(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SqlBaseParser.QueryTermContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 36
        self.enterRecursionRule(localctx, 36, self.RULE_queryTerm, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            localctx = SqlBaseParser.QueryTermDefaultContext(self, localctx)
            self._ctx = localctx
            _prevctx = localctx

            self.state = 1102
            self.queryPrimary()
            self._ctx.stop = self._input.LT(-1)
            self.state = 1118
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,126,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 1116
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,125,self._ctx)
                    if la_ == 1:
                        localctx = SqlBaseParser.SetOperationContext(self, SqlBaseParser.QueryTermContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_queryTerm)
                        self.state = 1104
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import (
                                FailedPredicateException,
                            )
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 1105
                        localctx.operator = self.match(SqlBaseParser.INTERSECT)
                        self.state = 1107
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==SqlBaseParser.ALL or _la==SqlBaseParser.DISTINCT:
                            self.state = 1106
                            self.setQuantifier()


                        self.state = 1109
                        localctx.right = self.queryTerm(3)

                    elif la_ == 2:
                        localctx = SqlBaseParser.SetOperationContext(self, SqlBaseParser.QueryTermContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_queryTerm)
                        self.state = 1110
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import (
                                FailedPredicateException,
                            )
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 1111
                        localctx.operator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==SqlBaseParser.EXCEPT or _la==SqlBaseParser.UNION):
                            localctx.operator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1113
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==SqlBaseParser.ALL or _la==SqlBaseParser.DISTINCT:
                            self.state = 1112
                            self.setQuantifier()


                        self.state = 1115
                        localctx.right = self.queryTerm(2)

             
                self.state = 1120
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,126,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class QueryPrimaryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_queryPrimary

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class SubqueryContext(QueryPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.QueryPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def queryNoWith(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryNoWithContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubquery" ):
                listener.enterSubquery(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubquery" ):
                listener.exitSubquery(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubquery" ):
                return visitor.visitSubquery(self)
            else:
                return visitor.visitChildren(self)


    class QueryPrimaryDefaultContext(QueryPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.QueryPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def querySpecification(self):
            return self.getTypedRuleContext(SqlBaseParser.QuerySpecificationContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQueryPrimaryDefault" ):
                listener.enterQueryPrimaryDefault(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQueryPrimaryDefault" ):
                listener.exitQueryPrimaryDefault(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQueryPrimaryDefault" ):
                return visitor.visitQueryPrimaryDefault(self)
            else:
                return visitor.visitChildren(self)


    class TableContext(QueryPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.QueryPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTable" ):
                listener.enterTable(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTable" ):
                listener.exitTable(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTable" ):
                return visitor.visitTable(self)
            else:
                return visitor.visitChildren(self)


    class InlineTableContext(QueryPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.QueryPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def VALUES(self):
            return self.getToken(SqlBaseParser.VALUES, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInlineTable" ):
                listener.enterInlineTable(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInlineTable" ):
                listener.exitInlineTable(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInlineTable" ):
                return visitor.visitInlineTable(self)
            else:
                return visitor.visitChildren(self)



    def queryPrimary(self):

        localctx = SqlBaseParser.QueryPrimaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_queryPrimary)
        try:
            self.state = 1137
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.SELECT]:
                localctx = SqlBaseParser.QueryPrimaryDefaultContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1121
                self.querySpecification()
            elif token in [SqlBaseParser.TABLE]:
                localctx = SqlBaseParser.TableContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1122
                self.match(SqlBaseParser.TABLE)
                self.state = 1123
                self.qualifiedName()
            elif token in [SqlBaseParser.VALUES]:
                localctx = SqlBaseParser.InlineTableContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1124
                self.match(SqlBaseParser.VALUES)
                self.state = 1125
                self.expression()
                self.state = 1130
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,127,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1126
                        self.match(SqlBaseParser.T__3)
                        self.state = 1127
                        self.expression() 
                    self.state = 1132
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,127,self._ctx)

            elif token in [SqlBaseParser.T__1]:
                localctx = SqlBaseParser.SubqueryContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 1133
                self.match(SqlBaseParser.T__1)
                self.state = 1134
                self.queryNoWith()
                self.state = 1135
                self.match(SqlBaseParser.T__2)
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SortItemContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.ordering = None # Token
            self.nullOrdering = None # Token

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def NULLS(self):
            return self.getToken(SqlBaseParser.NULLS, 0)

        def ASC(self):
            return self.getToken(SqlBaseParser.ASC, 0)

        def DESC(self):
            return self.getToken(SqlBaseParser.DESC, 0)

        def FIRST(self):
            return self.getToken(SqlBaseParser.FIRST, 0)

        def LAST(self):
            return self.getToken(SqlBaseParser.LAST, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_sortItem

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSortItem" ):
                listener.enterSortItem(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSortItem" ):
                listener.exitSortItem(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSortItem" ):
                return visitor.visitSortItem(self)
            else:
                return visitor.visitChildren(self)




    def sortItem(self):

        localctx = SqlBaseParser.SortItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_sortItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1139
            self.expression()
            self.state = 1141
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.ASC or _la==SqlBaseParser.DESC:
                self.state = 1140
                localctx.ordering = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==SqlBaseParser.ASC or _la==SqlBaseParser.DESC):
                    localctx.ordering = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1145
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.NULLS:
                self.state = 1143
                self.match(SqlBaseParser.NULLS)
                self.state = 1144
                localctx.nullOrdering = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==SqlBaseParser.FIRST or _la==SqlBaseParser.LAST):
                    localctx.nullOrdering = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QuerySpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.where = None # BooleanExpressionContext
            self.having = None # BooleanExpressionContext

        def SELECT(self):
            return self.getToken(SqlBaseParser.SELECT, 0)

        def selectItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.SelectItemContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.SelectItemContext,i)


        def setQuantifier(self):
            return self.getTypedRuleContext(SqlBaseParser.SetQuantifierContext,0)


        def FROM(self):
            return self.getToken(SqlBaseParser.FROM, 0)

        def relation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.RelationContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.RelationContext,i)


        def WHERE(self):
            return self.getToken(SqlBaseParser.WHERE, 0)

        def GROUP(self):
            return self.getToken(SqlBaseParser.GROUP, 0)

        def BY(self):
            return self.getToken(SqlBaseParser.BY, 0)

        def groupBy(self):
            return self.getTypedRuleContext(SqlBaseParser.GroupByContext,0)


        def HAVING(self):
            return self.getToken(SqlBaseParser.HAVING, 0)

        def WINDOW(self):
            return self.getToken(SqlBaseParser.WINDOW, 0)

        def windowDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.WindowDefinitionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.WindowDefinitionContext,i)


        def booleanExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.BooleanExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.BooleanExpressionContext,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_querySpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQuerySpecification" ):
                listener.enterQuerySpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQuerySpecification" ):
                listener.exitQuerySpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQuerySpecification" ):
                return visitor.visitQuerySpecification(self)
            else:
                return visitor.visitChildren(self)




    def querySpecification(self):

        localctx = SqlBaseParser.QuerySpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_querySpecification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1147
            self.match(SqlBaseParser.SELECT)
            self.state = 1149
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,131,self._ctx)
            if la_ == 1:
                self.state = 1148
                self.setQuantifier()


            self.state = 1151
            self.selectItem()
            self.state = 1156
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,132,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1152
                    self.match(SqlBaseParser.T__3)
                    self.state = 1153
                    self.selectItem() 
                self.state = 1158
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,132,self._ctx)

            self.state = 1168
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,134,self._ctx)
            if la_ == 1:
                self.state = 1159
                self.match(SqlBaseParser.FROM)
                self.state = 1160
                self.relation(0)
                self.state = 1165
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,133,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1161
                        self.match(SqlBaseParser.T__3)
                        self.state = 1162
                        self.relation(0) 
                    self.state = 1167
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,133,self._ctx)



            self.state = 1172
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
            if la_ == 1:
                self.state = 1170
                self.match(SqlBaseParser.WHERE)
                self.state = 1171
                localctx.where = self.booleanExpression(0)


            self.state = 1177
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,136,self._ctx)
            if la_ == 1:
                self.state = 1174
                self.match(SqlBaseParser.GROUP)
                self.state = 1175
                self.match(SqlBaseParser.BY)
                self.state = 1176
                self.groupBy()


            self.state = 1181
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,137,self._ctx)
            if la_ == 1:
                self.state = 1179
                self.match(SqlBaseParser.HAVING)
                self.state = 1180
                localctx.having = self.booleanExpression(0)


            self.state = 1192
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,139,self._ctx)
            if la_ == 1:
                self.state = 1183
                self.match(SqlBaseParser.WINDOW)
                self.state = 1184
                self.windowDefinition()
                self.state = 1189
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,138,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1185
                        self.match(SqlBaseParser.T__3)
                        self.state = 1186
                        self.windowDefinition() 
                    self.state = 1191
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,138,self._ctx)



        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GroupByContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def groupingElement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.GroupingElementContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.GroupingElementContext,i)


        def setQuantifier(self):
            return self.getTypedRuleContext(SqlBaseParser.SetQuantifierContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_groupBy

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGroupBy" ):
                listener.enterGroupBy(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGroupBy" ):
                listener.exitGroupBy(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGroupBy" ):
                return visitor.visitGroupBy(self)
            else:
                return visitor.visitChildren(self)




    def groupBy(self):

        localctx = SqlBaseParser.GroupByContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_groupBy)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1195
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,140,self._ctx)
            if la_ == 1:
                self.state = 1194
                self.setQuantifier()


            self.state = 1197
            self.groupingElement()
            self.state = 1202
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,141,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1198
                    self.match(SqlBaseParser.T__3)
                    self.state = 1199
                    self.groupingElement() 
                self.state = 1204
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,141,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GroupingElementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_groupingElement

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class MultipleGroupingSetsContext(GroupingElementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.GroupingElementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def GROUPING(self):
            return self.getToken(SqlBaseParser.GROUPING, 0)
        def SETS(self):
            return self.getToken(SqlBaseParser.SETS, 0)
        def groupingSet(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.GroupingSetContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.GroupingSetContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMultipleGroupingSets" ):
                listener.enterMultipleGroupingSets(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMultipleGroupingSets" ):
                listener.exitMultipleGroupingSets(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMultipleGroupingSets" ):
                return visitor.visitMultipleGroupingSets(self)
            else:
                return visitor.visitChildren(self)


    class SingleGroupingSetContext(GroupingElementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.GroupingElementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def groupingSet(self):
            return self.getTypedRuleContext(SqlBaseParser.GroupingSetContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSingleGroupingSet" ):
                listener.enterSingleGroupingSet(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSingleGroupingSet" ):
                listener.exitSingleGroupingSet(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSingleGroupingSet" ):
                return visitor.visitSingleGroupingSet(self)
            else:
                return visitor.visitChildren(self)


    class CubeContext(GroupingElementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.GroupingElementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CUBE(self):
            return self.getToken(SqlBaseParser.CUBE, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCube" ):
                listener.enterCube(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCube" ):
                listener.exitCube(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCube" ):
                return visitor.visitCube(self)
            else:
                return visitor.visitChildren(self)


    class RollupContext(GroupingElementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.GroupingElementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ROLLUP(self):
            return self.getToken(SqlBaseParser.ROLLUP, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRollup" ):
                listener.enterRollup(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRollup" ):
                listener.exitRollup(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRollup" ):
                return visitor.visitRollup(self)
            else:
                return visitor.visitChildren(self)



    def groupingElement(self):

        localctx = SqlBaseParser.GroupingElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_groupingElement)
        self._la = 0 # Token type
        try:
            self.state = 1245
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,147,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.SingleGroupingSetContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1205
                self.groupingSet()

            elif la_ == 2:
                localctx = SqlBaseParser.RollupContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1206
                self.match(SqlBaseParser.ROLLUP)
                self.state = 1207
                self.match(SqlBaseParser.T__1)
                self.state = 1216
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.T__1) | (1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CASE) | (1 << SqlBaseParser.CAST) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.CURRENT_CATALOG) | (1 << SqlBaseParser.CURRENT_DATE) | (1 << SqlBaseParser.CURRENT_PATH) | (1 << SqlBaseParser.CURRENT_SCHEMA) | (1 << SqlBaseParser.CURRENT_TIME) | (1 << SqlBaseParser.CURRENT_TIMESTAMP) | (1 << SqlBaseParser.CURRENT_USER) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXISTS - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.EXTRACT - 64)) | (1 << (SqlBaseParser.FALSE - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPING - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)) | (1 << (SqlBaseParser.JSON_ARRAY - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SqlBaseParser.JSON_EXISTS - 128)) | (1 << (SqlBaseParser.JSON_OBJECT - 128)) | (1 << (SqlBaseParser.JSON_QUERY - 128)) | (1 << (SqlBaseParser.JSON_VALUE - 128)) | (1 << (SqlBaseParser.KEEP - 128)) | (1 << (SqlBaseParser.KEY - 128)) | (1 << (SqlBaseParser.KEYS - 128)) | (1 << (SqlBaseParser.LAST - 128)) | (1 << (SqlBaseParser.LATERAL - 128)) | (1 << (SqlBaseParser.LEADING - 128)) | (1 << (SqlBaseParser.LEVEL - 128)) | (1 << (SqlBaseParser.LIMIT - 128)) | (1 << (SqlBaseParser.LISTAGG - 128)) | (1 << (SqlBaseParser.LOCAL - 128)) | (1 << (SqlBaseParser.LOCALTIME - 128)) | (1 << (SqlBaseParser.LOCALTIMESTAMP - 128)) | (1 << (SqlBaseParser.LOGICAL - 128)) | (1 << (SqlBaseParser.MAP - 128)) | (1 << (SqlBaseParser.MATCH - 128)) | (1 << (SqlBaseParser.MATCHED - 128)) | (1 << (SqlBaseParser.MATCHES - 128)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 128)) | (1 << (SqlBaseParser.MATERIALIZED - 128)) | (1 << (SqlBaseParser.MEASURES - 128)) | (1 << (SqlBaseParser.MERGE - 128)) | (1 << (SqlBaseParser.MINUTE - 128)) | (1 << (SqlBaseParser.MONTH - 128)) | (1 << (SqlBaseParser.NEXT - 128)) | (1 << (SqlBaseParser.NFC - 128)) | (1 << (SqlBaseParser.NFD - 128)) | (1 << (SqlBaseParser.NFKC - 128)) | (1 << (SqlBaseParser.NFKD - 128)) | (1 << (SqlBaseParser.NO - 128)) | (1 << (SqlBaseParser.NONE - 128)) | (1 << (SqlBaseParser.NORMALIZE - 128)) | (1 << (SqlBaseParser.NOT - 128)) | (1 << (SqlBaseParser.NULL - 128)) | (1 << (SqlBaseParser.NULLIF - 128)) | (1 << (SqlBaseParser.NULLS - 128)) | (1 << (SqlBaseParser.OBJECT - 128)) | (1 << (SqlBaseParser.OFFSET - 128)) | (1 << (SqlBaseParser.OMIT - 128)) | (1 << (SqlBaseParser.OF - 128)) | (1 << (SqlBaseParser.ONE - 128)) | (1 << (SqlBaseParser.ONLY - 128)) | (1 << (SqlBaseParser.OPTION - 128)) | (1 << (SqlBaseParser.ORDINALITY - 128)) | (1 << (SqlBaseParser.OUTPUT - 128)) | (1 << (SqlBaseParser.OVER - 128)) | (1 << (SqlBaseParser.OVERFLOW - 128)) | (1 << (SqlBaseParser.PARTITION - 128)) | (1 << (SqlBaseParser.PARTITIONS - 128)) | (1 << (SqlBaseParser.PASSING - 128)) | (1 << (SqlBaseParser.PAST - 128)) | (1 << (SqlBaseParser.PATH - 128)) | (1 << (SqlBaseParser.PATTERN - 128)) | (1 << (SqlBaseParser.PER - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (SqlBaseParser.PERMUTE - 192)) | (1 << (SqlBaseParser.POSITION - 192)) | (1 << (SqlBaseParser.PRECEDING - 192)) | (1 << (SqlBaseParser.PRECISION - 192)) | (1 << (SqlBaseParser.PRIVILEGES - 192)) | (1 << (SqlBaseParser.PROPERTIES - 192)) | (1 << (SqlBaseParser.PRUNE - 192)) | (1 << (SqlBaseParser.QUOTES - 192)) | (1 << (SqlBaseParser.RANGE - 192)) | (1 << (SqlBaseParser.READ - 192)) | (1 << (SqlBaseParser.REFRESH - 192)) | (1 << (SqlBaseParser.RENAME - 192)) | (1 << (SqlBaseParser.REPEATABLE - 192)) | (1 << (SqlBaseParser.REPLACE - 192)) | (1 << (SqlBaseParser.RESET - 192)) | (1 << (SqlBaseParser.RESPECT - 192)) | (1 << (SqlBaseParser.RESTRICT - 192)) | (1 << (SqlBaseParser.RETURNING - 192)) | (1 << (SqlBaseParser.REVOKE - 192)) | (1 << (SqlBaseParser.ROLE - 192)) | (1 << (SqlBaseParser.ROLES - 192)) | (1 << (SqlBaseParser.ROLLBACK - 192)) | (1 << (SqlBaseParser.ROW - 192)) | (1 << (SqlBaseParser.ROWS - 192)) | (1 << (SqlBaseParser.RUNNING - 192)) | (1 << (SqlBaseParser.SCALAR - 192)) | (1 << (SqlBaseParser.SCHEMA - 192)) | (1 << (SqlBaseParser.SCHEMAS - 192)) | (1 << (SqlBaseParser.SECOND - 192)) | (1 << (SqlBaseParser.SECURITY - 192)) | (1 << (SqlBaseParser.SEEK - 192)) | (1 << (SqlBaseParser.SERIALIZABLE - 192)) | (1 << (SqlBaseParser.SESSION - 192)) | (1 << (SqlBaseParser.SET - 192)) | (1 << (SqlBaseParser.SETS - 192)) | (1 << (SqlBaseParser.SHOW - 192)) | (1 << (SqlBaseParser.SOME - 192)) | (1 << (SqlBaseParser.START - 192)) | (1 << (SqlBaseParser.STATS - 192)) | (1 << (SqlBaseParser.SUBSET - 192)) | (1 << (SqlBaseParser.SUBSTRING - 192)) | (1 << (SqlBaseParser.SYSTEM - 192)) | (1 << (SqlBaseParser.TABLES - 192)) | (1 << (SqlBaseParser.TABLESAMPLE - 192)) | (1 << (SqlBaseParser.TEXT - 192)) | (1 << (SqlBaseParser.TEXT_STRING - 192)) | (1 << (SqlBaseParser.TIES - 192)) | (1 << (SqlBaseParser.TIME - 192)) | (1 << (SqlBaseParser.TIMESTAMP - 192)) | (1 << (SqlBaseParser.TO - 192)) | (1 << (SqlBaseParser.TRAILING - 192)) | (1 << (SqlBaseParser.TRANSACTION - 192)) | (1 << (SqlBaseParser.TRIM - 192)) | (1 << (SqlBaseParser.TRUE - 192)) | (1 << (SqlBaseParser.TRUNCATE - 192)) | (1 << (SqlBaseParser.TRY_CAST - 192)) | (1 << (SqlBaseParser.TYPE - 192)))) != 0) or ((((_la - 257)) & ~0x3f) == 0 and ((1 << (_la - 257)) & ((1 << (SqlBaseParser.UNBOUNDED - 257)) | (1 << (SqlBaseParser.UNCOMMITTED - 257)) | (1 << (SqlBaseParser.UNCONDITIONAL - 257)) | (1 << (SqlBaseParser.UNIQUE - 257)) | (1 << (SqlBaseParser.UNKNOWN - 257)) | (1 << (SqlBaseParser.UNMATCHED - 257)) | (1 << (SqlBaseParser.UPDATE - 257)) | (1 << (SqlBaseParser.USE - 257)) | (1 << (SqlBaseParser.USER - 257)) | (1 << (SqlBaseParser.UTF16 - 257)) | (1 << (SqlBaseParser.UTF32 - 257)) | (1 << (SqlBaseParser.UTF8 - 257)) | (1 << (SqlBaseParser.VALIDATE - 257)) | (1 << (SqlBaseParser.VALUE - 257)) | (1 << (SqlBaseParser.VERBOSE - 257)) | (1 << (SqlBaseParser.VERSION - 257)) | (1 << (SqlBaseParser.VIEW - 257)) | (1 << (SqlBaseParser.WINDOW - 257)) | (1 << (SqlBaseParser.WITHIN - 257)) | (1 << (SqlBaseParser.WITHOUT - 257)) | (1 << (SqlBaseParser.WORK - 257)) | (1 << (SqlBaseParser.WRAPPER - 257)) | (1 << (SqlBaseParser.WRITE - 257)) | (1 << (SqlBaseParser.YEAR - 257)) | (1 << (SqlBaseParser.ZONE - 257)) | (1 << (SqlBaseParser.PLUS - 257)) | (1 << (SqlBaseParser.MINUS - 257)) | (1 << (SqlBaseParser.QUESTION_MARK - 257)) | (1 << (SqlBaseParser.STRING - 257)) | (1 << (SqlBaseParser.UNICODE_STRING - 257)) | (1 << (SqlBaseParser.BINARY_LITERAL - 257)) | (1 << (SqlBaseParser.INTEGER_VALUE - 257)) | (1 << (SqlBaseParser.DECIMAL_VALUE - 257)) | (1 << (SqlBaseParser.DOUBLE_VALUE - 257)) | (1 << (SqlBaseParser.IDENTIFIER - 257)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 257)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 257)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 257)))) != 0):
                    self.state = 1208
                    self.expression()
                    self.state = 1213
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 1209
                        self.match(SqlBaseParser.T__3)
                        self.state = 1210
                        self.expression()
                        self.state = 1215
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1218
                self.match(SqlBaseParser.T__2)

            elif la_ == 3:
                localctx = SqlBaseParser.CubeContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1219
                self.match(SqlBaseParser.CUBE)
                self.state = 1220
                self.match(SqlBaseParser.T__1)
                self.state = 1229
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.T__1) | (1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CASE) | (1 << SqlBaseParser.CAST) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.CURRENT_CATALOG) | (1 << SqlBaseParser.CURRENT_DATE) | (1 << SqlBaseParser.CURRENT_PATH) | (1 << SqlBaseParser.CURRENT_SCHEMA) | (1 << SqlBaseParser.CURRENT_TIME) | (1 << SqlBaseParser.CURRENT_TIMESTAMP) | (1 << SqlBaseParser.CURRENT_USER) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXISTS - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.EXTRACT - 64)) | (1 << (SqlBaseParser.FALSE - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPING - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)) | (1 << (SqlBaseParser.JSON_ARRAY - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SqlBaseParser.JSON_EXISTS - 128)) | (1 << (SqlBaseParser.JSON_OBJECT - 128)) | (1 << (SqlBaseParser.JSON_QUERY - 128)) | (1 << (SqlBaseParser.JSON_VALUE - 128)) | (1 << (SqlBaseParser.KEEP - 128)) | (1 << (SqlBaseParser.KEY - 128)) | (1 << (SqlBaseParser.KEYS - 128)) | (1 << (SqlBaseParser.LAST - 128)) | (1 << (SqlBaseParser.LATERAL - 128)) | (1 << (SqlBaseParser.LEADING - 128)) | (1 << (SqlBaseParser.LEVEL - 128)) | (1 << (SqlBaseParser.LIMIT - 128)) | (1 << (SqlBaseParser.LISTAGG - 128)) | (1 << (SqlBaseParser.LOCAL - 128)) | (1 << (SqlBaseParser.LOCALTIME - 128)) | (1 << (SqlBaseParser.LOCALTIMESTAMP - 128)) | (1 << (SqlBaseParser.LOGICAL - 128)) | (1 << (SqlBaseParser.MAP - 128)) | (1 << (SqlBaseParser.MATCH - 128)) | (1 << (SqlBaseParser.MATCHED - 128)) | (1 << (SqlBaseParser.MATCHES - 128)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 128)) | (1 << (SqlBaseParser.MATERIALIZED - 128)) | (1 << (SqlBaseParser.MEASURES - 128)) | (1 << (SqlBaseParser.MERGE - 128)) | (1 << (SqlBaseParser.MINUTE - 128)) | (1 << (SqlBaseParser.MONTH - 128)) | (1 << (SqlBaseParser.NEXT - 128)) | (1 << (SqlBaseParser.NFC - 128)) | (1 << (SqlBaseParser.NFD - 128)) | (1 << (SqlBaseParser.NFKC - 128)) | (1 << (SqlBaseParser.NFKD - 128)) | (1 << (SqlBaseParser.NO - 128)) | (1 << (SqlBaseParser.NONE - 128)) | (1 << (SqlBaseParser.NORMALIZE - 128)) | (1 << (SqlBaseParser.NOT - 128)) | (1 << (SqlBaseParser.NULL - 128)) | (1 << (SqlBaseParser.NULLIF - 128)) | (1 << (SqlBaseParser.NULLS - 128)) | (1 << (SqlBaseParser.OBJECT - 128)) | (1 << (SqlBaseParser.OFFSET - 128)) | (1 << (SqlBaseParser.OMIT - 128)) | (1 << (SqlBaseParser.OF - 128)) | (1 << (SqlBaseParser.ONE - 128)) | (1 << (SqlBaseParser.ONLY - 128)) | (1 << (SqlBaseParser.OPTION - 128)) | (1 << (SqlBaseParser.ORDINALITY - 128)) | (1 << (SqlBaseParser.OUTPUT - 128)) | (1 << (SqlBaseParser.OVER - 128)) | (1 << (SqlBaseParser.OVERFLOW - 128)) | (1 << (SqlBaseParser.PARTITION - 128)) | (1 << (SqlBaseParser.PARTITIONS - 128)) | (1 << (SqlBaseParser.PASSING - 128)) | (1 << (SqlBaseParser.PAST - 128)) | (1 << (SqlBaseParser.PATH - 128)) | (1 << (SqlBaseParser.PATTERN - 128)) | (1 << (SqlBaseParser.PER - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (SqlBaseParser.PERMUTE - 192)) | (1 << (SqlBaseParser.POSITION - 192)) | (1 << (SqlBaseParser.PRECEDING - 192)) | (1 << (SqlBaseParser.PRECISION - 192)) | (1 << (SqlBaseParser.PRIVILEGES - 192)) | (1 << (SqlBaseParser.PROPERTIES - 192)) | (1 << (SqlBaseParser.PRUNE - 192)) | (1 << (SqlBaseParser.QUOTES - 192)) | (1 << (SqlBaseParser.RANGE - 192)) | (1 << (SqlBaseParser.READ - 192)) | (1 << (SqlBaseParser.REFRESH - 192)) | (1 << (SqlBaseParser.RENAME - 192)) | (1 << (SqlBaseParser.REPEATABLE - 192)) | (1 << (SqlBaseParser.REPLACE - 192)) | (1 << (SqlBaseParser.RESET - 192)) | (1 << (SqlBaseParser.RESPECT - 192)) | (1 << (SqlBaseParser.RESTRICT - 192)) | (1 << (SqlBaseParser.RETURNING - 192)) | (1 << (SqlBaseParser.REVOKE - 192)) | (1 << (SqlBaseParser.ROLE - 192)) | (1 << (SqlBaseParser.ROLES - 192)) | (1 << (SqlBaseParser.ROLLBACK - 192)) | (1 << (SqlBaseParser.ROW - 192)) | (1 << (SqlBaseParser.ROWS - 192)) | (1 << (SqlBaseParser.RUNNING - 192)) | (1 << (SqlBaseParser.SCALAR - 192)) | (1 << (SqlBaseParser.SCHEMA - 192)) | (1 << (SqlBaseParser.SCHEMAS - 192)) | (1 << (SqlBaseParser.SECOND - 192)) | (1 << (SqlBaseParser.SECURITY - 192)) | (1 << (SqlBaseParser.SEEK - 192)) | (1 << (SqlBaseParser.SERIALIZABLE - 192)) | (1 << (SqlBaseParser.SESSION - 192)) | (1 << (SqlBaseParser.SET - 192)) | (1 << (SqlBaseParser.SETS - 192)) | (1 << (SqlBaseParser.SHOW - 192)) | (1 << (SqlBaseParser.SOME - 192)) | (1 << (SqlBaseParser.START - 192)) | (1 << (SqlBaseParser.STATS - 192)) | (1 << (SqlBaseParser.SUBSET - 192)) | (1 << (SqlBaseParser.SUBSTRING - 192)) | (1 << (SqlBaseParser.SYSTEM - 192)) | (1 << (SqlBaseParser.TABLES - 192)) | (1 << (SqlBaseParser.TABLESAMPLE - 192)) | (1 << (SqlBaseParser.TEXT - 192)) | (1 << (SqlBaseParser.TEXT_STRING - 192)) | (1 << (SqlBaseParser.TIES - 192)) | (1 << (SqlBaseParser.TIME - 192)) | (1 << (SqlBaseParser.TIMESTAMP - 192)) | (1 << (SqlBaseParser.TO - 192)) | (1 << (SqlBaseParser.TRAILING - 192)) | (1 << (SqlBaseParser.TRANSACTION - 192)) | (1 << (SqlBaseParser.TRIM - 192)) | (1 << (SqlBaseParser.TRUE - 192)) | (1 << (SqlBaseParser.TRUNCATE - 192)) | (1 << (SqlBaseParser.TRY_CAST - 192)) | (1 << (SqlBaseParser.TYPE - 192)))) != 0) or ((((_la - 257)) & ~0x3f) == 0 and ((1 << (_la - 257)) & ((1 << (SqlBaseParser.UNBOUNDED - 257)) | (1 << (SqlBaseParser.UNCOMMITTED - 257)) | (1 << (SqlBaseParser.UNCONDITIONAL - 257)) | (1 << (SqlBaseParser.UNIQUE - 257)) | (1 << (SqlBaseParser.UNKNOWN - 257)) | (1 << (SqlBaseParser.UNMATCHED - 257)) | (1 << (SqlBaseParser.UPDATE - 257)) | (1 << (SqlBaseParser.USE - 257)) | (1 << (SqlBaseParser.USER - 257)) | (1 << (SqlBaseParser.UTF16 - 257)) | (1 << (SqlBaseParser.UTF32 - 257)) | (1 << (SqlBaseParser.UTF8 - 257)) | (1 << (SqlBaseParser.VALIDATE - 257)) | (1 << (SqlBaseParser.VALUE - 257)) | (1 << (SqlBaseParser.VERBOSE - 257)) | (1 << (SqlBaseParser.VERSION - 257)) | (1 << (SqlBaseParser.VIEW - 257)) | (1 << (SqlBaseParser.WINDOW - 257)) | (1 << (SqlBaseParser.WITHIN - 257)) | (1 << (SqlBaseParser.WITHOUT - 257)) | (1 << (SqlBaseParser.WORK - 257)) | (1 << (SqlBaseParser.WRAPPER - 257)) | (1 << (SqlBaseParser.WRITE - 257)) | (1 << (SqlBaseParser.YEAR - 257)) | (1 << (SqlBaseParser.ZONE - 257)) | (1 << (SqlBaseParser.PLUS - 257)) | (1 << (SqlBaseParser.MINUS - 257)) | (1 << (SqlBaseParser.QUESTION_MARK - 257)) | (1 << (SqlBaseParser.STRING - 257)) | (1 << (SqlBaseParser.UNICODE_STRING - 257)) | (1 << (SqlBaseParser.BINARY_LITERAL - 257)) | (1 << (SqlBaseParser.INTEGER_VALUE - 257)) | (1 << (SqlBaseParser.DECIMAL_VALUE - 257)) | (1 << (SqlBaseParser.DOUBLE_VALUE - 257)) | (1 << (SqlBaseParser.IDENTIFIER - 257)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 257)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 257)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 257)))) != 0):
                    self.state = 1221
                    self.expression()
                    self.state = 1226
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 1222
                        self.match(SqlBaseParser.T__3)
                        self.state = 1223
                        self.expression()
                        self.state = 1228
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1231
                self.match(SqlBaseParser.T__2)

            elif la_ == 4:
                localctx = SqlBaseParser.MultipleGroupingSetsContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 1232
                self.match(SqlBaseParser.GROUPING)
                self.state = 1233
                self.match(SqlBaseParser.SETS)
                self.state = 1234
                self.match(SqlBaseParser.T__1)
                self.state = 1235
                self.groupingSet()
                self.state = 1240
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 1236
                    self.match(SqlBaseParser.T__3)
                    self.state = 1237
                    self.groupingSet()
                    self.state = 1242
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1243
                self.match(SqlBaseParser.T__2)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GroupingSetContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_groupingSet

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGroupingSet" ):
                listener.enterGroupingSet(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGroupingSet" ):
                listener.exitGroupingSet(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGroupingSet" ):
                return visitor.visitGroupingSet(self)
            else:
                return visitor.visitChildren(self)




    def groupingSet(self):

        localctx = SqlBaseParser.GroupingSetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_groupingSet)
        self._la = 0 # Token type
        try:
            self.state = 1260
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,150,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1247
                self.match(SqlBaseParser.T__1)
                self.state = 1256
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.T__1) | (1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CASE) | (1 << SqlBaseParser.CAST) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.CURRENT_CATALOG) | (1 << SqlBaseParser.CURRENT_DATE) | (1 << SqlBaseParser.CURRENT_PATH) | (1 << SqlBaseParser.CURRENT_SCHEMA) | (1 << SqlBaseParser.CURRENT_TIME) | (1 << SqlBaseParser.CURRENT_TIMESTAMP) | (1 << SqlBaseParser.CURRENT_USER) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXISTS - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.EXTRACT - 64)) | (1 << (SqlBaseParser.FALSE - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPING - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)) | (1 << (SqlBaseParser.JSON_ARRAY - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SqlBaseParser.JSON_EXISTS - 128)) | (1 << (SqlBaseParser.JSON_OBJECT - 128)) | (1 << (SqlBaseParser.JSON_QUERY - 128)) | (1 << (SqlBaseParser.JSON_VALUE - 128)) | (1 << (SqlBaseParser.KEEP - 128)) | (1 << (SqlBaseParser.KEY - 128)) | (1 << (SqlBaseParser.KEYS - 128)) | (1 << (SqlBaseParser.LAST - 128)) | (1 << (SqlBaseParser.LATERAL - 128)) | (1 << (SqlBaseParser.LEADING - 128)) | (1 << (SqlBaseParser.LEVEL - 128)) | (1 << (SqlBaseParser.LIMIT - 128)) | (1 << (SqlBaseParser.LISTAGG - 128)) | (1 << (SqlBaseParser.LOCAL - 128)) | (1 << (SqlBaseParser.LOCALTIME - 128)) | (1 << (SqlBaseParser.LOCALTIMESTAMP - 128)) | (1 << (SqlBaseParser.LOGICAL - 128)) | (1 << (SqlBaseParser.MAP - 128)) | (1 << (SqlBaseParser.MATCH - 128)) | (1 << (SqlBaseParser.MATCHED - 128)) | (1 << (SqlBaseParser.MATCHES - 128)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 128)) | (1 << (SqlBaseParser.MATERIALIZED - 128)) | (1 << (SqlBaseParser.MEASURES - 128)) | (1 << (SqlBaseParser.MERGE - 128)) | (1 << (SqlBaseParser.MINUTE - 128)) | (1 << (SqlBaseParser.MONTH - 128)) | (1 << (SqlBaseParser.NEXT - 128)) | (1 << (SqlBaseParser.NFC - 128)) | (1 << (SqlBaseParser.NFD - 128)) | (1 << (SqlBaseParser.NFKC - 128)) | (1 << (SqlBaseParser.NFKD - 128)) | (1 << (SqlBaseParser.NO - 128)) | (1 << (SqlBaseParser.NONE - 128)) | (1 << (SqlBaseParser.NORMALIZE - 128)) | (1 << (SqlBaseParser.NOT - 128)) | (1 << (SqlBaseParser.NULL - 128)) | (1 << (SqlBaseParser.NULLIF - 128)) | (1 << (SqlBaseParser.NULLS - 128)) | (1 << (SqlBaseParser.OBJECT - 128)) | (1 << (SqlBaseParser.OFFSET - 128)) | (1 << (SqlBaseParser.OMIT - 128)) | (1 << (SqlBaseParser.OF - 128)) | (1 << (SqlBaseParser.ONE - 128)) | (1 << (SqlBaseParser.ONLY - 128)) | (1 << (SqlBaseParser.OPTION - 128)) | (1 << (SqlBaseParser.ORDINALITY - 128)) | (1 << (SqlBaseParser.OUTPUT - 128)) | (1 << (SqlBaseParser.OVER - 128)) | (1 << (SqlBaseParser.OVERFLOW - 128)) | (1 << (SqlBaseParser.PARTITION - 128)) | (1 << (SqlBaseParser.PARTITIONS - 128)) | (1 << (SqlBaseParser.PASSING - 128)) | (1 << (SqlBaseParser.PAST - 128)) | (1 << (SqlBaseParser.PATH - 128)) | (1 << (SqlBaseParser.PATTERN - 128)) | (1 << (SqlBaseParser.PER - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (SqlBaseParser.PERMUTE - 192)) | (1 << (SqlBaseParser.POSITION - 192)) | (1 << (SqlBaseParser.PRECEDING - 192)) | (1 << (SqlBaseParser.PRECISION - 192)) | (1 << (SqlBaseParser.PRIVILEGES - 192)) | (1 << (SqlBaseParser.PROPERTIES - 192)) | (1 << (SqlBaseParser.PRUNE - 192)) | (1 << (SqlBaseParser.QUOTES - 192)) | (1 << (SqlBaseParser.RANGE - 192)) | (1 << (SqlBaseParser.READ - 192)) | (1 << (SqlBaseParser.REFRESH - 192)) | (1 << (SqlBaseParser.RENAME - 192)) | (1 << (SqlBaseParser.REPEATABLE - 192)) | (1 << (SqlBaseParser.REPLACE - 192)) | (1 << (SqlBaseParser.RESET - 192)) | (1 << (SqlBaseParser.RESPECT - 192)) | (1 << (SqlBaseParser.RESTRICT - 192)) | (1 << (SqlBaseParser.RETURNING - 192)) | (1 << (SqlBaseParser.REVOKE - 192)) | (1 << (SqlBaseParser.ROLE - 192)) | (1 << (SqlBaseParser.ROLES - 192)) | (1 << (SqlBaseParser.ROLLBACK - 192)) | (1 << (SqlBaseParser.ROW - 192)) | (1 << (SqlBaseParser.ROWS - 192)) | (1 << (SqlBaseParser.RUNNING - 192)) | (1 << (SqlBaseParser.SCALAR - 192)) | (1 << (SqlBaseParser.SCHEMA - 192)) | (1 << (SqlBaseParser.SCHEMAS - 192)) | (1 << (SqlBaseParser.SECOND - 192)) | (1 << (SqlBaseParser.SECURITY - 192)) | (1 << (SqlBaseParser.SEEK - 192)) | (1 << (SqlBaseParser.SERIALIZABLE - 192)) | (1 << (SqlBaseParser.SESSION - 192)) | (1 << (SqlBaseParser.SET - 192)) | (1 << (SqlBaseParser.SETS - 192)) | (1 << (SqlBaseParser.SHOW - 192)) | (1 << (SqlBaseParser.SOME - 192)) | (1 << (SqlBaseParser.START - 192)) | (1 << (SqlBaseParser.STATS - 192)) | (1 << (SqlBaseParser.SUBSET - 192)) | (1 << (SqlBaseParser.SUBSTRING - 192)) | (1 << (SqlBaseParser.SYSTEM - 192)) | (1 << (SqlBaseParser.TABLES - 192)) | (1 << (SqlBaseParser.TABLESAMPLE - 192)) | (1 << (SqlBaseParser.TEXT - 192)) | (1 << (SqlBaseParser.TEXT_STRING - 192)) | (1 << (SqlBaseParser.TIES - 192)) | (1 << (SqlBaseParser.TIME - 192)) | (1 << (SqlBaseParser.TIMESTAMP - 192)) | (1 << (SqlBaseParser.TO - 192)) | (1 << (SqlBaseParser.TRAILING - 192)) | (1 << (SqlBaseParser.TRANSACTION - 192)) | (1 << (SqlBaseParser.TRIM - 192)) | (1 << (SqlBaseParser.TRUE - 192)) | (1 << (SqlBaseParser.TRUNCATE - 192)) | (1 << (SqlBaseParser.TRY_CAST - 192)) | (1 << (SqlBaseParser.TYPE - 192)))) != 0) or ((((_la - 257)) & ~0x3f) == 0 and ((1 << (_la - 257)) & ((1 << (SqlBaseParser.UNBOUNDED - 257)) | (1 << (SqlBaseParser.UNCOMMITTED - 257)) | (1 << (SqlBaseParser.UNCONDITIONAL - 257)) | (1 << (SqlBaseParser.UNIQUE - 257)) | (1 << (SqlBaseParser.UNKNOWN - 257)) | (1 << (SqlBaseParser.UNMATCHED - 257)) | (1 << (SqlBaseParser.UPDATE - 257)) | (1 << (SqlBaseParser.USE - 257)) | (1 << (SqlBaseParser.USER - 257)) | (1 << (SqlBaseParser.UTF16 - 257)) | (1 << (SqlBaseParser.UTF32 - 257)) | (1 << (SqlBaseParser.UTF8 - 257)) | (1 << (SqlBaseParser.VALIDATE - 257)) | (1 << (SqlBaseParser.VALUE - 257)) | (1 << (SqlBaseParser.VERBOSE - 257)) | (1 << (SqlBaseParser.VERSION - 257)) | (1 << (SqlBaseParser.VIEW - 257)) | (1 << (SqlBaseParser.WINDOW - 257)) | (1 << (SqlBaseParser.WITHIN - 257)) | (1 << (SqlBaseParser.WITHOUT - 257)) | (1 << (SqlBaseParser.WORK - 257)) | (1 << (SqlBaseParser.WRAPPER - 257)) | (1 << (SqlBaseParser.WRITE - 257)) | (1 << (SqlBaseParser.YEAR - 257)) | (1 << (SqlBaseParser.ZONE - 257)) | (1 << (SqlBaseParser.PLUS - 257)) | (1 << (SqlBaseParser.MINUS - 257)) | (1 << (SqlBaseParser.QUESTION_MARK - 257)) | (1 << (SqlBaseParser.STRING - 257)) | (1 << (SqlBaseParser.UNICODE_STRING - 257)) | (1 << (SqlBaseParser.BINARY_LITERAL - 257)) | (1 << (SqlBaseParser.INTEGER_VALUE - 257)) | (1 << (SqlBaseParser.DECIMAL_VALUE - 257)) | (1 << (SqlBaseParser.DOUBLE_VALUE - 257)) | (1 << (SqlBaseParser.IDENTIFIER - 257)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 257)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 257)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 257)))) != 0):
                    self.state = 1248
                    self.expression()
                    self.state = 1253
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 1249
                        self.match(SqlBaseParser.T__3)
                        self.state = 1250
                        self.expression()
                        self.state = 1255
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1258
                self.match(SqlBaseParser.T__2)

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1259
                self.expression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WindowDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.name = None # IdentifierContext

        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)

        def windowSpecification(self):
            return self.getTypedRuleContext(SqlBaseParser.WindowSpecificationContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_windowDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWindowDefinition" ):
                listener.enterWindowDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWindowDefinition" ):
                listener.exitWindowDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWindowDefinition" ):
                return visitor.visitWindowDefinition(self)
            else:
                return visitor.visitChildren(self)




    def windowDefinition(self):

        localctx = SqlBaseParser.WindowDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_windowDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1262
            localctx.name = self.identifier()
            self.state = 1263
            self.match(SqlBaseParser.AS)
            self.state = 1264
            self.match(SqlBaseParser.T__1)
            self.state = 1265
            self.windowSpecification()
            self.state = 1266
            self.match(SqlBaseParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WindowSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.existingWindowName = None # IdentifierContext
            self._expression = None # ExpressionContext
            self.partition = list() # of ExpressionContexts

        def PARTITION(self):
            return self.getToken(SqlBaseParser.PARTITION, 0)

        def BY(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.BY)
            else:
                return self.getToken(SqlBaseParser.BY, i)

        def ORDER(self):
            return self.getToken(SqlBaseParser.ORDER, 0)

        def sortItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.SortItemContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.SortItemContext,i)


        def windowFrame(self):
            return self.getTypedRuleContext(SqlBaseParser.WindowFrameContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_windowSpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWindowSpecification" ):
                listener.enterWindowSpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWindowSpecification" ):
                listener.exitWindowSpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWindowSpecification" ):
                return visitor.visitWindowSpecification(self)
            else:
                return visitor.visitChildren(self)




    def windowSpecification(self):

        localctx = SqlBaseParser.WindowSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_windowSpecification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1269
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,151,self._ctx)
            if la_ == 1:
                self.state = 1268
                localctx.existingWindowName = self.identifier()


            self.state = 1281
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.PARTITION:
                self.state = 1271
                self.match(SqlBaseParser.PARTITION)
                self.state = 1272
                self.match(SqlBaseParser.BY)
                self.state = 1273
                localctx._expression = self.expression()
                localctx.partition.append(localctx._expression)
                self.state = 1278
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 1274
                    self.match(SqlBaseParser.T__3)
                    self.state = 1275
                    localctx._expression = self.expression()
                    localctx.partition.append(localctx._expression)
                    self.state = 1280
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1293
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.ORDER:
                self.state = 1283
                self.match(SqlBaseParser.ORDER)
                self.state = 1284
                self.match(SqlBaseParser.BY)
                self.state = 1285
                self.sortItem()
                self.state = 1290
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 1286
                    self.match(SqlBaseParser.T__3)
                    self.state = 1287
                    self.sortItem()
                    self.state = 1292
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1296
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.GROUPS or _la==SqlBaseParser.MEASURES or _la==SqlBaseParser.RANGE or _la==SqlBaseParser.ROWS:
                self.state = 1295
                self.windowFrame()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamedQueryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.name = None # IdentifierContext

        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)

        def query(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def columnAliases(self):
            return self.getTypedRuleContext(SqlBaseParser.ColumnAliasesContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_namedQuery

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamedQuery" ):
                listener.enterNamedQuery(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamedQuery" ):
                listener.exitNamedQuery(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamedQuery" ):
                return visitor.visitNamedQuery(self)
            else:
                return visitor.visitChildren(self)




    def namedQuery(self):

        localctx = SqlBaseParser.NamedQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_namedQuery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1298
            localctx.name = self.identifier()
            self.state = 1300
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.T__1:
                self.state = 1299
                self.columnAliases()


            self.state = 1302
            self.match(SqlBaseParser.AS)
            self.state = 1303
            self.match(SqlBaseParser.T__1)
            self.state = 1304
            self.query()
            self.state = 1305
            self.match(SqlBaseParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SetQuantifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DISTINCT(self):
            return self.getToken(SqlBaseParser.DISTINCT, 0)

        def ALL(self):
            return self.getToken(SqlBaseParser.ALL, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_setQuantifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSetQuantifier" ):
                listener.enterSetQuantifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSetQuantifier" ):
                listener.exitSetQuantifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetQuantifier" ):
                return visitor.visitSetQuantifier(self)
            else:
                return visitor.visitChildren(self)




    def setQuantifier(self):

        localctx = SqlBaseParser.SetQuantifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_setQuantifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1307
            _la = self._input.LA(1)
            if not(_la==SqlBaseParser.ALL or _la==SqlBaseParser.DISTINCT):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SelectItemContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_selectItem

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class SelectAllContext(SelectItemContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.SelectItemContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def primaryExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.PrimaryExpressionContext,0)

        def ASTERISK(self):
            return self.getToken(SqlBaseParser.ASTERISK, 0)
        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)
        def columnAliases(self):
            return self.getTypedRuleContext(SqlBaseParser.ColumnAliasesContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSelectAll" ):
                listener.enterSelectAll(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSelectAll" ):
                listener.exitSelectAll(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSelectAll" ):
                return visitor.visitSelectAll(self)
            else:
                return visitor.visitChildren(self)


    class SelectSingleContext(SelectItemContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.SelectItemContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSelectSingle" ):
                listener.enterSelectSingle(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSelectSingle" ):
                listener.exitSelectSingle(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSelectSingle" ):
                return visitor.visitSelectSingle(self)
            else:
                return visitor.visitChildren(self)



    def selectItem(self):

        localctx = SqlBaseParser.SelectItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_selectItem)
        self._la = 0 # Token type
        try:
            self.state = 1324
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,161,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.SelectSingleContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1309
                self.expression()
                self.state = 1314
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,159,self._ctx)
                if la_ == 1:
                    self.state = 1311
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.AS:
                        self.state = 1310
                        self.match(SqlBaseParser.AS)


                    self.state = 1313
                    self.identifier()



            elif la_ == 2:
                localctx = SqlBaseParser.SelectAllContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1316
                self.primaryExpression(0)
                self.state = 1317
                self.match(SqlBaseParser.T__0)
                self.state = 1318
                self.match(SqlBaseParser.ASTERISK)
                self.state = 1321
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
                if la_ == 1:
                    self.state = 1319
                    self.match(SqlBaseParser.AS)
                    self.state = 1320
                    self.columnAliases()



            elif la_ == 3:
                localctx = SqlBaseParser.SelectAllContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1323
                self.match(SqlBaseParser.ASTERISK)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RelationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_relation

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class RelationDefaultContext(RelationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.RelationContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def sampledRelation(self):
            return self.getTypedRuleContext(SqlBaseParser.SampledRelationContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRelationDefault" ):
                listener.enterRelationDefault(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRelationDefault" ):
                listener.exitRelationDefault(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRelationDefault" ):
                return visitor.visitRelationDefault(self)
            else:
                return visitor.visitChildren(self)


    class JoinRelationContext(RelationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.RelationContext
            super().__init__(parser)
            self.left = None # RelationContext
            self.right = None # SampledRelationContext
            self.rightRelation = None # RelationContext
            self.copyFrom(ctx)

        def relation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.RelationContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.RelationContext,i)

        def CROSS(self):
            return self.getToken(SqlBaseParser.CROSS, 0)
        def JOIN(self):
            return self.getToken(SqlBaseParser.JOIN, 0)
        def joinType(self):
            return self.getTypedRuleContext(SqlBaseParser.JoinTypeContext,0)

        def joinCriteria(self):
            return self.getTypedRuleContext(SqlBaseParser.JoinCriteriaContext,0)

        def NATURAL(self):
            return self.getToken(SqlBaseParser.NATURAL, 0)
        def sampledRelation(self):
            return self.getTypedRuleContext(SqlBaseParser.SampledRelationContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJoinRelation" ):
                listener.enterJoinRelation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJoinRelation" ):
                listener.exitJoinRelation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJoinRelation" ):
                return visitor.visitJoinRelation(self)
            else:
                return visitor.visitChildren(self)



    def relation(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SqlBaseParser.RelationContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 60
        self.enterRecursionRule(localctx, 60, self.RULE_relation, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            localctx = SqlBaseParser.RelationDefaultContext(self, localctx)
            self._ctx = localctx
            _prevctx = localctx

            self.state = 1327
            self.sampledRelation()
            self._ctx.stop = self._input.LT(-1)
            self.state = 1347
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,163,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = SqlBaseParser.JoinRelationContext(self, SqlBaseParser.RelationContext(self, _parentctx, _parentState))
                    localctx.left = _prevctx
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_relation)
                    self.state = 1329
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 1343
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [SqlBaseParser.CROSS]:
                        self.state = 1330
                        self.match(SqlBaseParser.CROSS)
                        self.state = 1331
                        self.match(SqlBaseParser.JOIN)
                        self.state = 1332
                        localctx.right = self.sampledRelation()
                    elif token in [SqlBaseParser.FULL, SqlBaseParser.INNER, SqlBaseParser.JOIN, SqlBaseParser.LEFT, SqlBaseParser.RIGHT]:
                        self.state = 1333
                        self.joinType()
                        self.state = 1334
                        self.match(SqlBaseParser.JOIN)
                        self.state = 1335
                        localctx.rightRelation = self.relation(0)
                        self.state = 1336
                        self.joinCriteria()
                    elif token in [SqlBaseParser.NATURAL]:
                        self.state = 1338
                        self.match(SqlBaseParser.NATURAL)
                        self.state = 1339
                        self.joinType()
                        self.state = 1340
                        self.match(SqlBaseParser.JOIN)
                        self.state = 1341
                        localctx.right = self.sampledRelation()
                    else:
                        raise NoViableAltException(self)
             
                self.state = 1349
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,163,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class JoinTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INNER(self):
            return self.getToken(SqlBaseParser.INNER, 0)

        def LEFT(self):
            return self.getToken(SqlBaseParser.LEFT, 0)

        def OUTER(self):
            return self.getToken(SqlBaseParser.OUTER, 0)

        def RIGHT(self):
            return self.getToken(SqlBaseParser.RIGHT, 0)

        def FULL(self):
            return self.getToken(SqlBaseParser.FULL, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_joinType

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJoinType" ):
                listener.enterJoinType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJoinType" ):
                listener.exitJoinType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJoinType" ):
                return visitor.visitJoinType(self)
            else:
                return visitor.visitChildren(self)




    def joinType(self):

        localctx = SqlBaseParser.JoinTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_joinType)
        self._la = 0 # Token type
        try:
            self.state = 1365
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.INNER, SqlBaseParser.JOIN]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1351
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.INNER:
                    self.state = 1350
                    self.match(SqlBaseParser.INNER)


            elif token in [SqlBaseParser.LEFT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1353
                self.match(SqlBaseParser.LEFT)
                self.state = 1355
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.OUTER:
                    self.state = 1354
                    self.match(SqlBaseParser.OUTER)


            elif token in [SqlBaseParser.RIGHT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1357
                self.match(SqlBaseParser.RIGHT)
                self.state = 1359
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.OUTER:
                    self.state = 1358
                    self.match(SqlBaseParser.OUTER)


            elif token in [SqlBaseParser.FULL]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1361
                self.match(SqlBaseParser.FULL)
                self.state = 1363
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.OUTER:
                    self.state = 1362
                    self.match(SqlBaseParser.OUTER)


            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JoinCriteriaContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ON(self):
            return self.getToken(SqlBaseParser.ON, 0)

        def booleanExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.BooleanExpressionContext,0)


        def USING(self):
            return self.getToken(SqlBaseParser.USING, 0)

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_joinCriteria

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJoinCriteria" ):
                listener.enterJoinCriteria(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJoinCriteria" ):
                listener.exitJoinCriteria(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJoinCriteria" ):
                return visitor.visitJoinCriteria(self)
            else:
                return visitor.visitChildren(self)




    def joinCriteria(self):

        localctx = SqlBaseParser.JoinCriteriaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_joinCriteria)
        self._la = 0 # Token type
        try:
            self.state = 1381
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.ON]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1367
                self.match(SqlBaseParser.ON)
                self.state = 1368
                self.booleanExpression(0)
            elif token in [SqlBaseParser.USING]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1369
                self.match(SqlBaseParser.USING)
                self.state = 1370
                self.match(SqlBaseParser.T__1)
                self.state = 1371
                self.identifier()
                self.state = 1376
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 1372
                    self.match(SqlBaseParser.T__3)
                    self.state = 1373
                    self.identifier()
                    self.state = 1378
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1379
                self.match(SqlBaseParser.T__2)
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SampledRelationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.percentage = None # ExpressionContext

        def patternRecognition(self):
            return self.getTypedRuleContext(SqlBaseParser.PatternRecognitionContext,0)


        def TABLESAMPLE(self):
            return self.getToken(SqlBaseParser.TABLESAMPLE, 0)

        def sampleType(self):
            return self.getTypedRuleContext(SqlBaseParser.SampleTypeContext,0)


        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_sampledRelation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSampledRelation" ):
                listener.enterSampledRelation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSampledRelation" ):
                listener.exitSampledRelation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSampledRelation" ):
                return visitor.visitSampledRelation(self)
            else:
                return visitor.visitChildren(self)




    def sampledRelation(self):

        localctx = SqlBaseParser.SampledRelationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_sampledRelation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1383
            self.patternRecognition()
            self.state = 1390
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
            if la_ == 1:
                self.state = 1384
                self.match(SqlBaseParser.TABLESAMPLE)
                self.state = 1385
                self.sampleType()
                self.state = 1386
                self.match(SqlBaseParser.T__1)
                self.state = 1387
                localctx.percentage = self.expression()
                self.state = 1388
                self.match(SqlBaseParser.T__2)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SampleTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def BERNOULLI(self):
            return self.getToken(SqlBaseParser.BERNOULLI, 0)

        def SYSTEM(self):
            return self.getToken(SqlBaseParser.SYSTEM, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_sampleType

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSampleType" ):
                listener.enterSampleType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSampleType" ):
                listener.exitSampleType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSampleType" ):
                return visitor.visitSampleType(self)
            else:
                return visitor.visitChildren(self)




    def sampleType(self):

        localctx = SqlBaseParser.SampleTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_sampleType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1392
            _la = self._input.LA(1)
            if not(_la==SqlBaseParser.BERNOULLI or _la==SqlBaseParser.SYSTEM):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TrimsSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LEADING(self):
            return self.getToken(SqlBaseParser.LEADING, 0)

        def TRAILING(self):
            return self.getToken(SqlBaseParser.TRAILING, 0)

        def BOTH(self):
            return self.getToken(SqlBaseParser.BOTH, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_trimsSpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTrimsSpecification" ):
                listener.enterTrimsSpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTrimsSpecification" ):
                listener.exitTrimsSpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTrimsSpecification" ):
                return visitor.visitTrimsSpecification(self)
            else:
                return visitor.visitChildren(self)




    def trimsSpecification(self):

        localctx = SqlBaseParser.TrimsSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_trimsSpecification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1394
            _la = self._input.LA(1)
            if not(_la==SqlBaseParser.BOTH or _la==SqlBaseParser.LEADING or _la==SqlBaseParser.TRAILING):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ListAggOverflowBehaviorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ERROR(self):
            return self.getToken(SqlBaseParser.ERROR, 0)

        def TRUNCATE(self):
            return self.getToken(SqlBaseParser.TRUNCATE, 0)

        def listaggCountIndication(self):
            return self.getTypedRuleContext(SqlBaseParser.ListaggCountIndicationContext,0)


        def string(self):
            return self.getTypedRuleContext(SqlBaseParser.StringContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_listAggOverflowBehavior

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterListAggOverflowBehavior" ):
                listener.enterListAggOverflowBehavior(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitListAggOverflowBehavior" ):
                listener.exitListAggOverflowBehavior(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitListAggOverflowBehavior" ):
                return visitor.visitListAggOverflowBehavior(self)
            else:
                return visitor.visitChildren(self)




    def listAggOverflowBehavior(self):

        localctx = SqlBaseParser.ListAggOverflowBehaviorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_listAggOverflowBehavior)
        self._la = 0 # Token type
        try:
            self.state = 1402
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.ERROR]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1396
                self.match(SqlBaseParser.ERROR)
            elif token in [SqlBaseParser.TRUNCATE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1397
                self.match(SqlBaseParser.TRUNCATE)
                self.state = 1399
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.STRING or _la==SqlBaseParser.UNICODE_STRING:
                    self.state = 1398
                    self.string()


                self.state = 1401
                self.listaggCountIndication()
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ListaggCountIndicationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)

        def COUNT(self):
            return self.getToken(SqlBaseParser.COUNT, 0)

        def WITHOUT(self):
            return self.getToken(SqlBaseParser.WITHOUT, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_listaggCountIndication

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterListaggCountIndication" ):
                listener.enterListaggCountIndication(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitListaggCountIndication" ):
                listener.exitListaggCountIndication(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitListaggCountIndication" ):
                return visitor.visitListaggCountIndication(self)
            else:
                return visitor.visitChildren(self)




    def listaggCountIndication(self):

        localctx = SqlBaseParser.ListaggCountIndicationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_listaggCountIndication)
        try:
            self.state = 1408
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.WITH]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1404
                self.match(SqlBaseParser.WITH)
                self.state = 1405
                self.match(SqlBaseParser.COUNT)
            elif token in [SqlBaseParser.WITHOUT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1406
                self.match(SqlBaseParser.WITHOUT)
                self.state = 1407
                self.match(SqlBaseParser.COUNT)
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PatternRecognitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._expression = None # ExpressionContext
            self.partition = list() # of ExpressionContexts

        def aliasedRelation(self):
            return self.getTypedRuleContext(SqlBaseParser.AliasedRelationContext,0)


        def MATCH_RECOGNIZE(self):
            return self.getToken(SqlBaseParser.MATCH_RECOGNIZE, 0)

        def PATTERN(self):
            return self.getToken(SqlBaseParser.PATTERN, 0)

        def rowPattern(self):
            return self.getTypedRuleContext(SqlBaseParser.RowPatternContext,0)


        def DEFINE(self):
            return self.getToken(SqlBaseParser.DEFINE, 0)

        def variableDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.VariableDefinitionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.VariableDefinitionContext,i)


        def PARTITION(self):
            return self.getToken(SqlBaseParser.PARTITION, 0)

        def BY(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.BY)
            else:
                return self.getToken(SqlBaseParser.BY, i)

        def ORDER(self):
            return self.getToken(SqlBaseParser.ORDER, 0)

        def sortItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.SortItemContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.SortItemContext,i)


        def MEASURES(self):
            return self.getToken(SqlBaseParser.MEASURES, 0)

        def measureDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.MeasureDefinitionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.MeasureDefinitionContext,i)


        def rowsPerMatch(self):
            return self.getTypedRuleContext(SqlBaseParser.RowsPerMatchContext,0)


        def AFTER(self):
            return self.getToken(SqlBaseParser.AFTER, 0)

        def MATCH(self):
            return self.getToken(SqlBaseParser.MATCH, 0)

        def skipTo(self):
            return self.getTypedRuleContext(SqlBaseParser.SkipToContext,0)


        def SUBSET(self):
            return self.getToken(SqlBaseParser.SUBSET, 0)

        def subsetDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.SubsetDefinitionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.SubsetDefinitionContext,i)


        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)


        def INITIAL(self):
            return self.getToken(SqlBaseParser.INITIAL, 0)

        def SEEK(self):
            return self.getToken(SqlBaseParser.SEEK, 0)

        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)

        def columnAliases(self):
            return self.getTypedRuleContext(SqlBaseParser.ColumnAliasesContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_patternRecognition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPatternRecognition" ):
                listener.enterPatternRecognition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPatternRecognition" ):
                listener.exitPatternRecognition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPatternRecognition" ):
                return visitor.visitPatternRecognition(self)
            else:
                return visitor.visitChildren(self)




    def patternRecognition(self):

        localctx = SqlBaseParser.PatternRecognitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_patternRecognition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1410
            self.aliasedRelation()
            self.state = 1493
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,190,self._ctx)
            if la_ == 1:
                self.state = 1411
                self.match(SqlBaseParser.MATCH_RECOGNIZE)
                self.state = 1412
                self.match(SqlBaseParser.T__1)
                self.state = 1423
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.PARTITION:
                    self.state = 1413
                    self.match(SqlBaseParser.PARTITION)
                    self.state = 1414
                    self.match(SqlBaseParser.BY)
                    self.state = 1415
                    localctx._expression = self.expression()
                    localctx.partition.append(localctx._expression)
                    self.state = 1420
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 1416
                        self.match(SqlBaseParser.T__3)
                        self.state = 1417
                        localctx._expression = self.expression()
                        localctx.partition.append(localctx._expression)
                        self.state = 1422
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1435
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.ORDER:
                    self.state = 1425
                    self.match(SqlBaseParser.ORDER)
                    self.state = 1426
                    self.match(SqlBaseParser.BY)
                    self.state = 1427
                    self.sortItem()
                    self.state = 1432
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 1428
                        self.match(SqlBaseParser.T__3)
                        self.state = 1429
                        self.sortItem()
                        self.state = 1434
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1446
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.MEASURES:
                    self.state = 1437
                    self.match(SqlBaseParser.MEASURES)
                    self.state = 1438
                    self.measureDefinition()
                    self.state = 1443
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 1439
                        self.match(SqlBaseParser.T__3)
                        self.state = 1440
                        self.measureDefinition()
                        self.state = 1445
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1449
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.ALL or _la==SqlBaseParser.ONE:
                    self.state = 1448
                    self.rowsPerMatch()


                self.state = 1454
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.AFTER:
                    self.state = 1451
                    self.match(SqlBaseParser.AFTER)
                    self.state = 1452
                    self.match(SqlBaseParser.MATCH)
                    self.state = 1453
                    self.skipTo()


                self.state = 1457
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.INITIAL or _la==SqlBaseParser.SEEK:
                    self.state = 1456
                    _la = self._input.LA(1)
                    if not(_la==SqlBaseParser.INITIAL or _la==SqlBaseParser.SEEK):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 1459
                self.match(SqlBaseParser.PATTERN)
                self.state = 1460
                self.match(SqlBaseParser.T__1)
                self.state = 1461
                self.rowPattern(0)
                self.state = 1462
                self.match(SqlBaseParser.T__2)
                self.state = 1472
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.SUBSET:
                    self.state = 1463
                    self.match(SqlBaseParser.SUBSET)
                    self.state = 1464
                    self.subsetDefinition()
                    self.state = 1469
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 1465
                        self.match(SqlBaseParser.T__3)
                        self.state = 1466
                        self.subsetDefinition()
                        self.state = 1471
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1474
                self.match(SqlBaseParser.DEFINE)
                self.state = 1475
                self.variableDefinition()
                self.state = 1480
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 1476
                    self.match(SqlBaseParser.T__3)
                    self.state = 1477
                    self.variableDefinition()
                    self.state = 1482
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1483
                self.match(SqlBaseParser.T__2)
                self.state = 1491
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,189,self._ctx)
                if la_ == 1:
                    self.state = 1485
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.AS:
                        self.state = 1484
                        self.match(SqlBaseParser.AS)


                    self.state = 1487
                    self.identifier()
                    self.state = 1489
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,188,self._ctx)
                    if la_ == 1:
                        self.state = 1488
                        self.columnAliases()






        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MeasureDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_measureDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMeasureDefinition" ):
                listener.enterMeasureDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMeasureDefinition" ):
                listener.exitMeasureDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMeasureDefinition" ):
                return visitor.visitMeasureDefinition(self)
            else:
                return visitor.visitChildren(self)




    def measureDefinition(self):

        localctx = SqlBaseParser.MeasureDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_measureDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1495
            self.expression()
            self.state = 1496
            self.match(SqlBaseParser.AS)
            self.state = 1497
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RowsPerMatchContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ONE(self):
            return self.getToken(SqlBaseParser.ONE, 0)

        def ROW(self):
            return self.getToken(SqlBaseParser.ROW, 0)

        def PER(self):
            return self.getToken(SqlBaseParser.PER, 0)

        def MATCH(self):
            return self.getToken(SqlBaseParser.MATCH, 0)

        def ALL(self):
            return self.getToken(SqlBaseParser.ALL, 0)

        def ROWS(self):
            return self.getToken(SqlBaseParser.ROWS, 0)

        def emptyMatchHandling(self):
            return self.getTypedRuleContext(SqlBaseParser.EmptyMatchHandlingContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_rowsPerMatch

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRowsPerMatch" ):
                listener.enterRowsPerMatch(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRowsPerMatch" ):
                listener.exitRowsPerMatch(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRowsPerMatch" ):
                return visitor.visitRowsPerMatch(self)
            else:
                return visitor.visitChildren(self)




    def rowsPerMatch(self):

        localctx = SqlBaseParser.RowsPerMatchContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_rowsPerMatch)
        self._la = 0 # Token type
        try:
            self.state = 1510
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.ONE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1499
                self.match(SqlBaseParser.ONE)
                self.state = 1500
                self.match(SqlBaseParser.ROW)
                self.state = 1501
                self.match(SqlBaseParser.PER)
                self.state = 1502
                self.match(SqlBaseParser.MATCH)
            elif token in [SqlBaseParser.ALL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1503
                self.match(SqlBaseParser.ALL)
                self.state = 1504
                self.match(SqlBaseParser.ROWS)
                self.state = 1505
                self.match(SqlBaseParser.PER)
                self.state = 1506
                self.match(SqlBaseParser.MATCH)
                self.state = 1508
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.OMIT or _la==SqlBaseParser.SHOW or _la==SqlBaseParser.WITH:
                    self.state = 1507
                    self.emptyMatchHandling()


            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EmptyMatchHandlingContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)

        def EMPTY(self):
            return self.getToken(SqlBaseParser.EMPTY, 0)

        def MATCHES(self):
            return self.getToken(SqlBaseParser.MATCHES, 0)

        def OMIT(self):
            return self.getToken(SqlBaseParser.OMIT, 0)

        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)

        def UNMATCHED(self):
            return self.getToken(SqlBaseParser.UNMATCHED, 0)

        def ROWS(self):
            return self.getToken(SqlBaseParser.ROWS, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_emptyMatchHandling

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEmptyMatchHandling" ):
                listener.enterEmptyMatchHandling(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEmptyMatchHandling" ):
                listener.exitEmptyMatchHandling(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEmptyMatchHandling" ):
                return visitor.visitEmptyMatchHandling(self)
            else:
                return visitor.visitChildren(self)




    def emptyMatchHandling(self):

        localctx = SqlBaseParser.EmptyMatchHandlingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_emptyMatchHandling)
        try:
            self.state = 1521
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.SHOW]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1512
                self.match(SqlBaseParser.SHOW)
                self.state = 1513
                self.match(SqlBaseParser.EMPTY)
                self.state = 1514
                self.match(SqlBaseParser.MATCHES)
            elif token in [SqlBaseParser.OMIT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1515
                self.match(SqlBaseParser.OMIT)
                self.state = 1516
                self.match(SqlBaseParser.EMPTY)
                self.state = 1517
                self.match(SqlBaseParser.MATCHES)
            elif token in [SqlBaseParser.WITH]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1518
                self.match(SqlBaseParser.WITH)
                self.state = 1519
                self.match(SqlBaseParser.UNMATCHED)
                self.state = 1520
                self.match(SqlBaseParser.ROWS)
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SkipToContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TO(self):
            return self.getToken(SqlBaseParser.TO, 0)

        def NEXT(self):
            return self.getToken(SqlBaseParser.NEXT, 0)

        def ROW(self):
            return self.getToken(SqlBaseParser.ROW, 0)

        def PAST(self):
            return self.getToken(SqlBaseParser.PAST, 0)

        def LAST(self):
            return self.getToken(SqlBaseParser.LAST, 0)

        def FIRST(self):
            return self.getToken(SqlBaseParser.FIRST, 0)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_skipTo

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSkipTo" ):
                listener.enterSkipTo(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSkipTo" ):
                listener.exitSkipTo(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSkipTo" ):
                return visitor.visitSkipTo(self)
            else:
                return visitor.visitChildren(self)




    def skipTo(self):

        localctx = SqlBaseParser.SkipToContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_skipTo)
        try:
            self.state = 1542
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,194,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1523
                self.match(SqlBaseParser.T__4)
                self.state = 1524
                self.match(SqlBaseParser.TO)
                self.state = 1525
                self.match(SqlBaseParser.NEXT)
                self.state = 1526
                self.match(SqlBaseParser.ROW)

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1527
                self.match(SqlBaseParser.T__4)
                self.state = 1528
                self.match(SqlBaseParser.PAST)
                self.state = 1529
                self.match(SqlBaseParser.LAST)
                self.state = 1530
                self.match(SqlBaseParser.ROW)

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1531
                self.match(SqlBaseParser.T__4)
                self.state = 1532
                self.match(SqlBaseParser.TO)
                self.state = 1533
                self.match(SqlBaseParser.FIRST)
                self.state = 1534
                self.identifier()

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1535
                self.match(SqlBaseParser.T__4)
                self.state = 1536
                self.match(SqlBaseParser.TO)
                self.state = 1537
                self.match(SqlBaseParser.LAST)
                self.state = 1538
                self.identifier()

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1539
                self.match(SqlBaseParser.T__4)
                self.state = 1540
                self.match(SqlBaseParser.TO)
                self.state = 1541
                self.identifier()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SubsetDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.name = None # IdentifierContext
            self._identifier = None # IdentifierContext
            self.union = list() # of IdentifierContexts

        def EQ(self):
            return self.getToken(SqlBaseParser.EQ, 0)

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_subsetDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubsetDefinition" ):
                listener.enterSubsetDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubsetDefinition" ):
                listener.exitSubsetDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubsetDefinition" ):
                return visitor.visitSubsetDefinition(self)
            else:
                return visitor.visitChildren(self)




    def subsetDefinition(self):

        localctx = SqlBaseParser.SubsetDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_subsetDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1544
            localctx.name = self.identifier()
            self.state = 1545
            self.match(SqlBaseParser.EQ)
            self.state = 1546
            self.match(SqlBaseParser.T__1)
            self.state = 1547
            localctx._identifier = self.identifier()
            localctx.union.append(localctx._identifier)
            self.state = 1552
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SqlBaseParser.T__3:
                self.state = 1548
                self.match(SqlBaseParser.T__3)
                self.state = 1549
                localctx._identifier = self.identifier()
                localctx.union.append(localctx._identifier)
                self.state = 1554
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1555
            self.match(SqlBaseParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_variableDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariableDefinition" ):
                listener.enterVariableDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariableDefinition" ):
                listener.exitVariableDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariableDefinition" ):
                return visitor.visitVariableDefinition(self)
            else:
                return visitor.visitChildren(self)




    def variableDefinition(self):

        localctx = SqlBaseParser.VariableDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_variableDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1557
            self.identifier()
            self.state = 1558
            self.match(SqlBaseParser.AS)
            self.state = 1559
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AliasedRelationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def relationPrimary(self):
            return self.getTypedRuleContext(SqlBaseParser.RelationPrimaryContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)

        def columnAliases(self):
            return self.getTypedRuleContext(SqlBaseParser.ColumnAliasesContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_aliasedRelation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAliasedRelation" ):
                listener.enterAliasedRelation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAliasedRelation" ):
                listener.exitAliasedRelation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAliasedRelation" ):
                return visitor.visitAliasedRelation(self)
            else:
                return visitor.visitChildren(self)




    def aliasedRelation(self):

        localctx = SqlBaseParser.AliasedRelationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_aliasedRelation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1561
            self.relationPrimary()
            self.state = 1569
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
            if la_ == 1:
                self.state = 1563
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.AS:
                    self.state = 1562
                    self.match(SqlBaseParser.AS)


                self.state = 1565
                self.identifier()
                self.state = 1567
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,197,self._ctx)
                if la_ == 1:
                    self.state = 1566
                    self.columnAliases()




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ColumnAliasesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_columnAliases

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterColumnAliases" ):
                listener.enterColumnAliases(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitColumnAliases" ):
                listener.exitColumnAliases(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitColumnAliases" ):
                return visitor.visitColumnAliases(self)
            else:
                return visitor.visitChildren(self)




    def columnAliases(self):

        localctx = SqlBaseParser.ColumnAliasesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_columnAliases)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1571
            self.match(SqlBaseParser.T__1)
            self.state = 1572
            self.identifier()
            self.state = 1577
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SqlBaseParser.T__3:
                self.state = 1573
                self.match(SqlBaseParser.T__3)
                self.state = 1574
                self.identifier()
                self.state = 1579
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1580
            self.match(SqlBaseParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RelationPrimaryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_relationPrimary

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class SubqueryRelationContext(RelationPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.RelationPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def query(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubqueryRelation" ):
                listener.enterSubqueryRelation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubqueryRelation" ):
                listener.exitSubqueryRelation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubqueryRelation" ):
                return visitor.visitSubqueryRelation(self)
            else:
                return visitor.visitChildren(self)


    class ParenthesizedRelationContext(RelationPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.RelationPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def relation(self):
            return self.getTypedRuleContext(SqlBaseParser.RelationContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParenthesizedRelation" ):
                listener.enterParenthesizedRelation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParenthesizedRelation" ):
                listener.exitParenthesizedRelation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParenthesizedRelation" ):
                return visitor.visitParenthesizedRelation(self)
            else:
                return visitor.visitChildren(self)


    class UnnestContext(RelationPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.RelationPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def UNNEST(self):
            return self.getToken(SqlBaseParser.UNNEST, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)

        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)
        def ORDINALITY(self):
            return self.getToken(SqlBaseParser.ORDINALITY, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnnest" ):
                listener.enterUnnest(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnnest" ):
                listener.exitUnnest(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnnest" ):
                return visitor.visitUnnest(self)
            else:
                return visitor.visitChildren(self)


    class TableFunctionInvocationContext(RelationPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.RelationPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def tableFunctionCall(self):
            return self.getTypedRuleContext(SqlBaseParser.TableFunctionCallContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTableFunctionInvocation" ):
                listener.enterTableFunctionInvocation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTableFunctionInvocation" ):
                listener.exitTableFunctionInvocation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableFunctionInvocation" ):
                return visitor.visitTableFunctionInvocation(self)
            else:
                return visitor.visitChildren(self)


    class LateralContext(RelationPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.RelationPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def LATERAL(self):
            return self.getToken(SqlBaseParser.LATERAL, 0)
        def query(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLateral" ):
                listener.enterLateral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLateral" ):
                listener.exitLateral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLateral" ):
                return visitor.visitLateral(self)
            else:
                return visitor.visitChildren(self)


    class TableNameContext(RelationPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.RelationPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def queryPeriod(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryPeriodContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTableName" ):
                listener.enterTableName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTableName" ):
                listener.exitTableName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableName" ):
                return visitor.visitTableName(self)
            else:
                return visitor.visitChildren(self)



    def relationPrimary(self):

        localctx = SqlBaseParser.RelationPrimaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_relationPrimary)
        self._la = 0 # Token type
        try:
            self.state = 1619
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,203,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.TableNameContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1582
                self.qualifiedName()
                self.state = 1584
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,200,self._ctx)
                if la_ == 1:
                    self.state = 1583
                    self.queryPeriod()



            elif la_ == 2:
                localctx = SqlBaseParser.SubqueryRelationContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1586
                self.match(SqlBaseParser.T__1)
                self.state = 1587
                self.query()
                self.state = 1588
                self.match(SqlBaseParser.T__2)

            elif la_ == 3:
                localctx = SqlBaseParser.UnnestContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1590
                self.match(SqlBaseParser.UNNEST)
                self.state = 1591
                self.match(SqlBaseParser.T__1)
                self.state = 1592
                self.expression()
                self.state = 1597
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 1593
                    self.match(SqlBaseParser.T__3)
                    self.state = 1594
                    self.expression()
                    self.state = 1599
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1600
                self.match(SqlBaseParser.T__2)
                self.state = 1603
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,202,self._ctx)
                if la_ == 1:
                    self.state = 1601
                    self.match(SqlBaseParser.WITH)
                    self.state = 1602
                    self.match(SqlBaseParser.ORDINALITY)



            elif la_ == 4:
                localctx = SqlBaseParser.LateralContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 1605
                self.match(SqlBaseParser.LATERAL)
                self.state = 1606
                self.match(SqlBaseParser.T__1)
                self.state = 1607
                self.query()
                self.state = 1608
                self.match(SqlBaseParser.T__2)

            elif la_ == 5:
                localctx = SqlBaseParser.TableFunctionInvocationContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 1610
                self.match(SqlBaseParser.TABLE)
                self.state = 1611
                self.match(SqlBaseParser.T__1)
                self.state = 1612
                self.tableFunctionCall()
                self.state = 1613
                self.match(SqlBaseParser.T__2)

            elif la_ == 6:
                localctx = SqlBaseParser.ParenthesizedRelationContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 1615
                self.match(SqlBaseParser.T__1)
                self.state = 1616
                self.relation(0)
                self.state = 1617
                self.match(SqlBaseParser.T__2)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TableFunctionCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)


        def tableFunctionArgument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.TableFunctionArgumentContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.TableFunctionArgumentContext,i)


        def COPARTITION(self):
            return self.getToken(SqlBaseParser.COPARTITION, 0)

        def copartitionTables(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.CopartitionTablesContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.CopartitionTablesContext,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_tableFunctionCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTableFunctionCall" ):
                listener.enterTableFunctionCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTableFunctionCall" ):
                listener.exitTableFunctionCall(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableFunctionCall" ):
                return visitor.visitTableFunctionCall(self)
            else:
                return visitor.visitChildren(self)




    def tableFunctionCall(self):

        localctx = SqlBaseParser.TableFunctionCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_tableFunctionCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1621
            self.qualifiedName()
            self.state = 1622
            self.match(SqlBaseParser.T__1)
            self.state = 1631
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,205,self._ctx)
            if la_ == 1:
                self.state = 1623
                self.tableFunctionArgument()
                self.state = 1628
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 1624
                    self.match(SqlBaseParser.T__3)
                    self.state = 1625
                    self.tableFunctionArgument()
                    self.state = 1630
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1642
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.COPARTITION:
                self.state = 1633
                self.match(SqlBaseParser.COPARTITION)
                self.state = 1634
                self.copartitionTables()
                self.state = 1639
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 1635
                    self.match(SqlBaseParser.T__3)
                    self.state = 1636
                    self.copartitionTables()
                    self.state = 1641
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1644
            self.match(SqlBaseParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TableFunctionArgumentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def tableArgument(self):
            return self.getTypedRuleContext(SqlBaseParser.TableArgumentContext,0)


        def descriptorArgument(self):
            return self.getTypedRuleContext(SqlBaseParser.DescriptorArgumentContext,0)


        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_tableFunctionArgument

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTableFunctionArgument" ):
                listener.enterTableFunctionArgument(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTableFunctionArgument" ):
                listener.exitTableFunctionArgument(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableFunctionArgument" ):
                return visitor.visitTableFunctionArgument(self)
            else:
                return visitor.visitChildren(self)




    def tableFunctionArgument(self):

        localctx = SqlBaseParser.TableFunctionArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_tableFunctionArgument)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1649
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,208,self._ctx)
            if la_ == 1:
                self.state = 1646
                self.identifier()
                self.state = 1647
                self.match(SqlBaseParser.T__5)


            self.state = 1654
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,209,self._ctx)
            if la_ == 1:
                self.state = 1651
                self.tableArgument()

            elif la_ == 2:
                self.state = 1652
                self.descriptorArgument()

            elif la_ == 3:
                self.state = 1653
                self.expression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TableArgumentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def tableArgumentRelation(self):
            return self.getTypedRuleContext(SqlBaseParser.TableArgumentRelationContext,0)


        def PARTITION(self):
            return self.getToken(SqlBaseParser.PARTITION, 0)

        def BY(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.BY)
            else:
                return self.getToken(SqlBaseParser.BY, i)

        def PRUNE(self):
            return self.getToken(SqlBaseParser.PRUNE, 0)

        def WHEN(self):
            return self.getToken(SqlBaseParser.WHEN, 0)

        def EMPTY(self):
            return self.getToken(SqlBaseParser.EMPTY, 0)

        def KEEP(self):
            return self.getToken(SqlBaseParser.KEEP, 0)

        def ORDER(self):
            return self.getToken(SqlBaseParser.ORDER, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)


        def sortItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.SortItemContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.SortItemContext,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_tableArgument

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTableArgument" ):
                listener.enterTableArgument(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTableArgument" ):
                listener.exitTableArgument(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableArgument" ):
                return visitor.visitTableArgument(self)
            else:
                return visitor.visitChildren(self)




    def tableArgument(self):

        localctx = SqlBaseParser.TableArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_tableArgument)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1656
            self.tableArgumentRelation()
            self.state = 1674
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.PARTITION:
                self.state = 1657
                self.match(SqlBaseParser.PARTITION)
                self.state = 1658
                self.match(SqlBaseParser.BY)
                self.state = 1672
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,212,self._ctx)
                if la_ == 1:
                    self.state = 1659
                    self.match(SqlBaseParser.T__1)
                    self.state = 1668
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.T__1) | (1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CASE) | (1 << SqlBaseParser.CAST) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.CURRENT_CATALOG) | (1 << SqlBaseParser.CURRENT_DATE) | (1 << SqlBaseParser.CURRENT_PATH) | (1 << SqlBaseParser.CURRENT_SCHEMA) | (1 << SqlBaseParser.CURRENT_TIME) | (1 << SqlBaseParser.CURRENT_TIMESTAMP) | (1 << SqlBaseParser.CURRENT_USER) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXISTS - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.EXTRACT - 64)) | (1 << (SqlBaseParser.FALSE - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPING - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)) | (1 << (SqlBaseParser.JSON_ARRAY - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SqlBaseParser.JSON_EXISTS - 128)) | (1 << (SqlBaseParser.JSON_OBJECT - 128)) | (1 << (SqlBaseParser.JSON_QUERY - 128)) | (1 << (SqlBaseParser.JSON_VALUE - 128)) | (1 << (SqlBaseParser.KEEP - 128)) | (1 << (SqlBaseParser.KEY - 128)) | (1 << (SqlBaseParser.KEYS - 128)) | (1 << (SqlBaseParser.LAST - 128)) | (1 << (SqlBaseParser.LATERAL - 128)) | (1 << (SqlBaseParser.LEADING - 128)) | (1 << (SqlBaseParser.LEVEL - 128)) | (1 << (SqlBaseParser.LIMIT - 128)) | (1 << (SqlBaseParser.LISTAGG - 128)) | (1 << (SqlBaseParser.LOCAL - 128)) | (1 << (SqlBaseParser.LOCALTIME - 128)) | (1 << (SqlBaseParser.LOCALTIMESTAMP - 128)) | (1 << (SqlBaseParser.LOGICAL - 128)) | (1 << (SqlBaseParser.MAP - 128)) | (1 << (SqlBaseParser.MATCH - 128)) | (1 << (SqlBaseParser.MATCHED - 128)) | (1 << (SqlBaseParser.MATCHES - 128)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 128)) | (1 << (SqlBaseParser.MATERIALIZED - 128)) | (1 << (SqlBaseParser.MEASURES - 128)) | (1 << (SqlBaseParser.MERGE - 128)) | (1 << (SqlBaseParser.MINUTE - 128)) | (1 << (SqlBaseParser.MONTH - 128)) | (1 << (SqlBaseParser.NEXT - 128)) | (1 << (SqlBaseParser.NFC - 128)) | (1 << (SqlBaseParser.NFD - 128)) | (1 << (SqlBaseParser.NFKC - 128)) | (1 << (SqlBaseParser.NFKD - 128)) | (1 << (SqlBaseParser.NO - 128)) | (1 << (SqlBaseParser.NONE - 128)) | (1 << (SqlBaseParser.NORMALIZE - 128)) | (1 << (SqlBaseParser.NOT - 128)) | (1 << (SqlBaseParser.NULL - 128)) | (1 << (SqlBaseParser.NULLIF - 128)) | (1 << (SqlBaseParser.NULLS - 128)) | (1 << (SqlBaseParser.OBJECT - 128)) | (1 << (SqlBaseParser.OFFSET - 128)) | (1 << (SqlBaseParser.OMIT - 128)) | (1 << (SqlBaseParser.OF - 128)) | (1 << (SqlBaseParser.ONE - 128)) | (1 << (SqlBaseParser.ONLY - 128)) | (1 << (SqlBaseParser.OPTION - 128)) | (1 << (SqlBaseParser.ORDINALITY - 128)) | (1 << (SqlBaseParser.OUTPUT - 128)) | (1 << (SqlBaseParser.OVER - 128)) | (1 << (SqlBaseParser.OVERFLOW - 128)) | (1 << (SqlBaseParser.PARTITION - 128)) | (1 << (SqlBaseParser.PARTITIONS - 128)) | (1 << (SqlBaseParser.PASSING - 128)) | (1 << (SqlBaseParser.PAST - 128)) | (1 << (SqlBaseParser.PATH - 128)) | (1 << (SqlBaseParser.PATTERN - 128)) | (1 << (SqlBaseParser.PER - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (SqlBaseParser.PERMUTE - 192)) | (1 << (SqlBaseParser.POSITION - 192)) | (1 << (SqlBaseParser.PRECEDING - 192)) | (1 << (SqlBaseParser.PRECISION - 192)) | (1 << (SqlBaseParser.PRIVILEGES - 192)) | (1 << (SqlBaseParser.PROPERTIES - 192)) | (1 << (SqlBaseParser.PRUNE - 192)) | (1 << (SqlBaseParser.QUOTES - 192)) | (1 << (SqlBaseParser.RANGE - 192)) | (1 << (SqlBaseParser.READ - 192)) | (1 << (SqlBaseParser.REFRESH - 192)) | (1 << (SqlBaseParser.RENAME - 192)) | (1 << (SqlBaseParser.REPEATABLE - 192)) | (1 << (SqlBaseParser.REPLACE - 192)) | (1 << (SqlBaseParser.RESET - 192)) | (1 << (SqlBaseParser.RESPECT - 192)) | (1 << (SqlBaseParser.RESTRICT - 192)) | (1 << (SqlBaseParser.RETURNING - 192)) | (1 << (SqlBaseParser.REVOKE - 192)) | (1 << (SqlBaseParser.ROLE - 192)) | (1 << (SqlBaseParser.ROLES - 192)) | (1 << (SqlBaseParser.ROLLBACK - 192)) | (1 << (SqlBaseParser.ROW - 192)) | (1 << (SqlBaseParser.ROWS - 192)) | (1 << (SqlBaseParser.RUNNING - 192)) | (1 << (SqlBaseParser.SCALAR - 192)) | (1 << (SqlBaseParser.SCHEMA - 192)) | (1 << (SqlBaseParser.SCHEMAS - 192)) | (1 << (SqlBaseParser.SECOND - 192)) | (1 << (SqlBaseParser.SECURITY - 192)) | (1 << (SqlBaseParser.SEEK - 192)) | (1 << (SqlBaseParser.SERIALIZABLE - 192)) | (1 << (SqlBaseParser.SESSION - 192)) | (1 << (SqlBaseParser.SET - 192)) | (1 << (SqlBaseParser.SETS - 192)) | (1 << (SqlBaseParser.SHOW - 192)) | (1 << (SqlBaseParser.SOME - 192)) | (1 << (SqlBaseParser.START - 192)) | (1 << (SqlBaseParser.STATS - 192)) | (1 << (SqlBaseParser.SUBSET - 192)) | (1 << (SqlBaseParser.SUBSTRING - 192)) | (1 << (SqlBaseParser.SYSTEM - 192)) | (1 << (SqlBaseParser.TABLES - 192)) | (1 << (SqlBaseParser.TABLESAMPLE - 192)) | (1 << (SqlBaseParser.TEXT - 192)) | (1 << (SqlBaseParser.TEXT_STRING - 192)) | (1 << (SqlBaseParser.TIES - 192)) | (1 << (SqlBaseParser.TIME - 192)) | (1 << (SqlBaseParser.TIMESTAMP - 192)) | (1 << (SqlBaseParser.TO - 192)) | (1 << (SqlBaseParser.TRAILING - 192)) | (1 << (SqlBaseParser.TRANSACTION - 192)) | (1 << (SqlBaseParser.TRIM - 192)) | (1 << (SqlBaseParser.TRUE - 192)) | (1 << (SqlBaseParser.TRUNCATE - 192)) | (1 << (SqlBaseParser.TRY_CAST - 192)) | (1 << (SqlBaseParser.TYPE - 192)))) != 0) or ((((_la - 257)) & ~0x3f) == 0 and ((1 << (_la - 257)) & ((1 << (SqlBaseParser.UNBOUNDED - 257)) | (1 << (SqlBaseParser.UNCOMMITTED - 257)) | (1 << (SqlBaseParser.UNCONDITIONAL - 257)) | (1 << (SqlBaseParser.UNIQUE - 257)) | (1 << (SqlBaseParser.UNKNOWN - 257)) | (1 << (SqlBaseParser.UNMATCHED - 257)) | (1 << (SqlBaseParser.UPDATE - 257)) | (1 << (SqlBaseParser.USE - 257)) | (1 << (SqlBaseParser.USER - 257)) | (1 << (SqlBaseParser.UTF16 - 257)) | (1 << (SqlBaseParser.UTF32 - 257)) | (1 << (SqlBaseParser.UTF8 - 257)) | (1 << (SqlBaseParser.VALIDATE - 257)) | (1 << (SqlBaseParser.VALUE - 257)) | (1 << (SqlBaseParser.VERBOSE - 257)) | (1 << (SqlBaseParser.VERSION - 257)) | (1 << (SqlBaseParser.VIEW - 257)) | (1 << (SqlBaseParser.WINDOW - 257)) | (1 << (SqlBaseParser.WITHIN - 257)) | (1 << (SqlBaseParser.WITHOUT - 257)) | (1 << (SqlBaseParser.WORK - 257)) | (1 << (SqlBaseParser.WRAPPER - 257)) | (1 << (SqlBaseParser.WRITE - 257)) | (1 << (SqlBaseParser.YEAR - 257)) | (1 << (SqlBaseParser.ZONE - 257)) | (1 << (SqlBaseParser.PLUS - 257)) | (1 << (SqlBaseParser.MINUS - 257)) | (1 << (SqlBaseParser.QUESTION_MARK - 257)) | (1 << (SqlBaseParser.STRING - 257)) | (1 << (SqlBaseParser.UNICODE_STRING - 257)) | (1 << (SqlBaseParser.BINARY_LITERAL - 257)) | (1 << (SqlBaseParser.INTEGER_VALUE - 257)) | (1 << (SqlBaseParser.DECIMAL_VALUE - 257)) | (1 << (SqlBaseParser.DOUBLE_VALUE - 257)) | (1 << (SqlBaseParser.IDENTIFIER - 257)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 257)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 257)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 257)))) != 0):
                        self.state = 1660
                        self.expression()
                        self.state = 1665
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==SqlBaseParser.T__3:
                            self.state = 1661
                            self.match(SqlBaseParser.T__3)
                            self.state = 1662
                            self.expression()
                            self.state = 1667
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)



                    self.state = 1670
                    self.match(SqlBaseParser.T__2)

                elif la_ == 2:
                    self.state = 1671
                    self.expression()




            self.state = 1682
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.PRUNE]:
                self.state = 1676
                self.match(SqlBaseParser.PRUNE)
                self.state = 1677
                self.match(SqlBaseParser.WHEN)
                self.state = 1678
                self.match(SqlBaseParser.EMPTY)
            elif token in [SqlBaseParser.KEEP]:
                self.state = 1679
                self.match(SqlBaseParser.KEEP)
                self.state = 1680
                self.match(SqlBaseParser.WHEN)
                self.state = 1681
                self.match(SqlBaseParser.EMPTY)
            elif token in [SqlBaseParser.T__2, SqlBaseParser.T__3, SqlBaseParser.COPARTITION, SqlBaseParser.ORDER]:
                pass
            else:
                pass
            self.state = 1700
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.ORDER:
                self.state = 1684
                self.match(SqlBaseParser.ORDER)
                self.state = 1685
                self.match(SqlBaseParser.BY)
                self.state = 1698
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,216,self._ctx)
                if la_ == 1:
                    self.state = 1686
                    self.match(SqlBaseParser.T__1)
                    self.state = 1687
                    self.sortItem()
                    self.state = 1692
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 1688
                        self.match(SqlBaseParser.T__3)
                        self.state = 1689
                        self.sortItem()
                        self.state = 1694
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1695
                    self.match(SqlBaseParser.T__2)

                elif la_ == 2:
                    self.state = 1697
                    self.sortItem()




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TableArgumentRelationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_tableArgumentRelation

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class TableArgumentQueryContext(TableArgumentRelationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.TableArgumentRelationContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def query(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryContext,0)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)
        def columnAliases(self):
            return self.getTypedRuleContext(SqlBaseParser.ColumnAliasesContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTableArgumentQuery" ):
                listener.enterTableArgumentQuery(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTableArgumentQuery" ):
                listener.exitTableArgumentQuery(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableArgumentQuery" ):
                return visitor.visitTableArgumentQuery(self)
            else:
                return visitor.visitChildren(self)


    class TableArgumentTableContext(TableArgumentRelationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.TableArgumentRelationContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TABLE(self):
            return self.getToken(SqlBaseParser.TABLE, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)
        def columnAliases(self):
            return self.getTypedRuleContext(SqlBaseParser.ColumnAliasesContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTableArgumentTable" ):
                listener.enterTableArgumentTable(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTableArgumentTable" ):
                listener.exitTableArgumentTable(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableArgumentTable" ):
                return visitor.visitTableArgumentTable(self)
            else:
                return visitor.visitChildren(self)



    def tableArgumentRelation(self):

        localctx = SqlBaseParser.TableArgumentRelationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_tableArgumentRelation)
        self._la = 0 # Token type
        try:
            self.state = 1728
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,224,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.TableArgumentTableContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1702
                self.match(SqlBaseParser.TABLE)
                self.state = 1703
                self.match(SqlBaseParser.T__1)
                self.state = 1704
                self.qualifiedName()
                self.state = 1705
                self.match(SqlBaseParser.T__2)
                self.state = 1713
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,220,self._ctx)
                if la_ == 1:
                    self.state = 1707
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.AS:
                        self.state = 1706
                        self.match(SqlBaseParser.AS)


                    self.state = 1709
                    self.identifier()
                    self.state = 1711
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.T__1:
                        self.state = 1710
                        self.columnAliases()





            elif la_ == 2:
                localctx = SqlBaseParser.TableArgumentQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1715
                self.match(SqlBaseParser.TABLE)
                self.state = 1716
                self.match(SqlBaseParser.T__1)
                self.state = 1717
                self.query()
                self.state = 1718
                self.match(SqlBaseParser.T__2)
                self.state = 1726
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,223,self._ctx)
                if la_ == 1:
                    self.state = 1720
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.AS:
                        self.state = 1719
                        self.match(SqlBaseParser.AS)


                    self.state = 1722
                    self.identifier()
                    self.state = 1724
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.T__1:
                        self.state = 1723
                        self.columnAliases()






        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DescriptorArgumentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DESCRIPTOR(self):
            return self.getToken(SqlBaseParser.DESCRIPTOR, 0)

        def descriptorField(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.DescriptorFieldContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.DescriptorFieldContext,i)


        def CAST(self):
            return self.getToken(SqlBaseParser.CAST, 0)

        def NULL(self):
            return self.getToken(SqlBaseParser.NULL, 0)

        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_descriptorArgument

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDescriptorArgument" ):
                listener.enterDescriptorArgument(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDescriptorArgument" ):
                listener.exitDescriptorArgument(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDescriptorArgument" ):
                return visitor.visitDescriptorArgument(self)
            else:
                return visitor.visitChildren(self)




    def descriptorArgument(self):

        localctx = SqlBaseParser.DescriptorArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_descriptorArgument)
        self._la = 0 # Token type
        try:
            self.state = 1748
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.DESCRIPTOR]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1730
                self.match(SqlBaseParser.DESCRIPTOR)
                self.state = 1731
                self.match(SqlBaseParser.T__1)
                self.state = 1732
                self.descriptorField()
                self.state = 1737
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 1733
                    self.match(SqlBaseParser.T__3)
                    self.state = 1734
                    self.descriptorField()
                    self.state = 1739
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1740
                self.match(SqlBaseParser.T__2)
            elif token in [SqlBaseParser.CAST]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1742
                self.match(SqlBaseParser.CAST)
                self.state = 1743
                self.match(SqlBaseParser.T__1)
                self.state = 1744
                self.match(SqlBaseParser.NULL)
                self.state = 1745
                self.match(SqlBaseParser.AS)
                self.state = 1746
                self.match(SqlBaseParser.DESCRIPTOR)
                self.state = 1747
                self.match(SqlBaseParser.T__2)
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DescriptorFieldContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def type_(self):
            return self.getTypedRuleContext(SqlBaseParser.Type_Context,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_descriptorField

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDescriptorField" ):
                listener.enterDescriptorField(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDescriptorField" ):
                listener.exitDescriptorField(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDescriptorField" ):
                return visitor.visitDescriptorField(self)
            else:
                return visitor.visitChildren(self)




    def descriptorField(self):

        localctx = SqlBaseParser.DescriptorFieldContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_descriptorField)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1750
            self.identifier()
            self.state = 1752
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (SqlBaseParser.KEEP - 132)) | (1 << (SqlBaseParser.KEY - 132)) | (1 << (SqlBaseParser.KEYS - 132)) | (1 << (SqlBaseParser.LAST - 132)) | (1 << (SqlBaseParser.LATERAL - 132)) | (1 << (SqlBaseParser.LEADING - 132)) | (1 << (SqlBaseParser.LEVEL - 132)) | (1 << (SqlBaseParser.LIMIT - 132)) | (1 << (SqlBaseParser.LOCAL - 132)) | (1 << (SqlBaseParser.LOGICAL - 132)) | (1 << (SqlBaseParser.MAP - 132)) | (1 << (SqlBaseParser.MATCH - 132)) | (1 << (SqlBaseParser.MATCHED - 132)) | (1 << (SqlBaseParser.MATCHES - 132)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 132)) | (1 << (SqlBaseParser.MATERIALIZED - 132)) | (1 << (SqlBaseParser.MEASURES - 132)) | (1 << (SqlBaseParser.MERGE - 132)) | (1 << (SqlBaseParser.MINUTE - 132)) | (1 << (SqlBaseParser.MONTH - 132)) | (1 << (SqlBaseParser.NEXT - 132)) | (1 << (SqlBaseParser.NFC - 132)) | (1 << (SqlBaseParser.NFD - 132)) | (1 << (SqlBaseParser.NFKC - 132)) | (1 << (SqlBaseParser.NFKD - 132)) | (1 << (SqlBaseParser.NO - 132)) | (1 << (SqlBaseParser.NONE - 132)) | (1 << (SqlBaseParser.NULLIF - 132)) | (1 << (SqlBaseParser.NULLS - 132)) | (1 << (SqlBaseParser.OBJECT - 132)) | (1 << (SqlBaseParser.OFFSET - 132)) | (1 << (SqlBaseParser.OMIT - 132)) | (1 << (SqlBaseParser.OF - 132)) | (1 << (SqlBaseParser.ONE - 132)) | (1 << (SqlBaseParser.ONLY - 132)) | (1 << (SqlBaseParser.OPTION - 132)) | (1 << (SqlBaseParser.ORDINALITY - 132)) | (1 << (SqlBaseParser.OUTPUT - 132)) | (1 << (SqlBaseParser.OVER - 132)) | (1 << (SqlBaseParser.OVERFLOW - 132)) | (1 << (SqlBaseParser.PARTITION - 132)) | (1 << (SqlBaseParser.PARTITIONS - 132)) | (1 << (SqlBaseParser.PASSING - 132)) | (1 << (SqlBaseParser.PAST - 132)) | (1 << (SqlBaseParser.PATH - 132)) | (1 << (SqlBaseParser.PATTERN - 132)) | (1 << (SqlBaseParser.PER - 132)) | (1 << (SqlBaseParser.PERMUTE - 132)) | (1 << (SqlBaseParser.POSITION - 132)) | (1 << (SqlBaseParser.PRECEDING - 132)) | (1 << (SqlBaseParser.PRECISION - 132)))) != 0) or ((((_la - 197)) & ~0x3f) == 0 and ((1 << (_la - 197)) & ((1 << (SqlBaseParser.PRIVILEGES - 197)) | (1 << (SqlBaseParser.PROPERTIES - 197)) | (1 << (SqlBaseParser.PRUNE - 197)) | (1 << (SqlBaseParser.QUOTES - 197)) | (1 << (SqlBaseParser.RANGE - 197)) | (1 << (SqlBaseParser.READ - 197)) | (1 << (SqlBaseParser.REFRESH - 197)) | (1 << (SqlBaseParser.RENAME - 197)) | (1 << (SqlBaseParser.REPEATABLE - 197)) | (1 << (SqlBaseParser.REPLACE - 197)) | (1 << (SqlBaseParser.RESET - 197)) | (1 << (SqlBaseParser.RESPECT - 197)) | (1 << (SqlBaseParser.RESTRICT - 197)) | (1 << (SqlBaseParser.RETURNING - 197)) | (1 << (SqlBaseParser.REVOKE - 197)) | (1 << (SqlBaseParser.ROLE - 197)) | (1 << (SqlBaseParser.ROLES - 197)) | (1 << (SqlBaseParser.ROLLBACK - 197)) | (1 << (SqlBaseParser.ROW - 197)) | (1 << (SqlBaseParser.ROWS - 197)) | (1 << (SqlBaseParser.RUNNING - 197)) | (1 << (SqlBaseParser.SCALAR - 197)) | (1 << (SqlBaseParser.SCHEMA - 197)) | (1 << (SqlBaseParser.SCHEMAS - 197)) | (1 << (SqlBaseParser.SECOND - 197)) | (1 << (SqlBaseParser.SECURITY - 197)) | (1 << (SqlBaseParser.SEEK - 197)) | (1 << (SqlBaseParser.SERIALIZABLE - 197)) | (1 << (SqlBaseParser.SESSION - 197)) | (1 << (SqlBaseParser.SET - 197)) | (1 << (SqlBaseParser.SETS - 197)) | (1 << (SqlBaseParser.SHOW - 197)) | (1 << (SqlBaseParser.SOME - 197)) | (1 << (SqlBaseParser.START - 197)) | (1 << (SqlBaseParser.STATS - 197)) | (1 << (SqlBaseParser.SUBSET - 197)) | (1 << (SqlBaseParser.SUBSTRING - 197)) | (1 << (SqlBaseParser.SYSTEM - 197)) | (1 << (SqlBaseParser.TABLES - 197)) | (1 << (SqlBaseParser.TABLESAMPLE - 197)) | (1 << (SqlBaseParser.TEXT - 197)) | (1 << (SqlBaseParser.TEXT_STRING - 197)) | (1 << (SqlBaseParser.TIES - 197)) | (1 << (SqlBaseParser.TIME - 197)) | (1 << (SqlBaseParser.TIMESTAMP - 197)) | (1 << (SqlBaseParser.TO - 197)) | (1 << (SqlBaseParser.TRAILING - 197)) | (1 << (SqlBaseParser.TRANSACTION - 197)) | (1 << (SqlBaseParser.TRUNCATE - 197)) | (1 << (SqlBaseParser.TRY_CAST - 197)) | (1 << (SqlBaseParser.TYPE - 197)) | (1 << (SqlBaseParser.UNBOUNDED - 197)) | (1 << (SqlBaseParser.UNCOMMITTED - 197)) | (1 << (SqlBaseParser.UNCONDITIONAL - 197)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (SqlBaseParser.UNIQUE - 261)) | (1 << (SqlBaseParser.UNKNOWN - 261)) | (1 << (SqlBaseParser.UNMATCHED - 261)) | (1 << (SqlBaseParser.UPDATE - 261)) | (1 << (SqlBaseParser.USE - 261)) | (1 << (SqlBaseParser.USER - 261)) | (1 << (SqlBaseParser.UTF16 - 261)) | (1 << (SqlBaseParser.UTF32 - 261)) | (1 << (SqlBaseParser.UTF8 - 261)) | (1 << (SqlBaseParser.VALIDATE - 261)) | (1 << (SqlBaseParser.VALUE - 261)) | (1 << (SqlBaseParser.VERBOSE - 261)) | (1 << (SqlBaseParser.VERSION - 261)) | (1 << (SqlBaseParser.VIEW - 261)) | (1 << (SqlBaseParser.WINDOW - 261)) | (1 << (SqlBaseParser.WITHIN - 261)) | (1 << (SqlBaseParser.WITHOUT - 261)) | (1 << (SqlBaseParser.WORK - 261)) | (1 << (SqlBaseParser.WRAPPER - 261)) | (1 << (SqlBaseParser.WRITE - 261)) | (1 << (SqlBaseParser.YEAR - 261)) | (1 << (SqlBaseParser.ZONE - 261)) | (1 << (SqlBaseParser.IDENTIFIER - 261)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 261)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 261)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 261)))) != 0):
                self.state = 1751
                self.type_(0)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CopartitionTablesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def qualifiedName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.QualifiedNameContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_copartitionTables

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCopartitionTables" ):
                listener.enterCopartitionTables(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCopartitionTables" ):
                listener.exitCopartitionTables(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCopartitionTables" ):
                return visitor.visitCopartitionTables(self)
            else:
                return visitor.visitChildren(self)




    def copartitionTables(self):

        localctx = SqlBaseParser.CopartitionTablesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_copartitionTables)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1754
            self.match(SqlBaseParser.T__1)
            self.state = 1755
            self.qualifiedName()
            self.state = 1756
            self.match(SqlBaseParser.T__3)
            self.state = 1757
            self.qualifiedName()
            self.state = 1762
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SqlBaseParser.T__3:
                self.state = 1758
                self.match(SqlBaseParser.T__3)
                self.state = 1759
                self.qualifiedName()
                self.state = 1764
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1765
            self.match(SqlBaseParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def booleanExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpression" ):
                listener.enterExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpression" ):
                listener.exitExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpression" ):
                return visitor.visitExpression(self)
            else:
                return visitor.visitChildren(self)




    def expression(self):

        localctx = SqlBaseParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1767
            self.booleanExpression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BooleanExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_booleanExpression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class LogicalNotContext(BooleanExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.BooleanExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def NOT(self):
            return self.getToken(SqlBaseParser.NOT, 0)
        def booleanExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.BooleanExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLogicalNot" ):
                listener.enterLogicalNot(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLogicalNot" ):
                listener.exitLogicalNot(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLogicalNot" ):
                return visitor.visitLogicalNot(self)
            else:
                return visitor.visitChildren(self)


    class PredicatedContext(BooleanExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.BooleanExpressionContext
            super().__init__(parser)
            self._valueExpression = None # ValueExpressionContext
            self.copyFrom(ctx)

        def valueExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,0)

        def predicate(self):
            return self.getTypedRuleContext(SqlBaseParser.PredicateContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPredicated" ):
                listener.enterPredicated(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPredicated" ):
                listener.exitPredicated(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPredicated" ):
                return visitor.visitPredicated(self)
            else:
                return visitor.visitChildren(self)


    class And_Context(BooleanExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.BooleanExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def booleanExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.BooleanExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.BooleanExpressionContext,i)

        def AND(self):
            return self.getToken(SqlBaseParser.AND, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAnd_" ):
                listener.enterAnd_(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAnd_" ):
                listener.exitAnd_(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAnd_" ):
                return visitor.visitAnd_(self)
            else:
                return visitor.visitChildren(self)


    class Or_Context(BooleanExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.BooleanExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def booleanExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.BooleanExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.BooleanExpressionContext,i)

        def OR(self):
            return self.getToken(SqlBaseParser.OR, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOr_" ):
                listener.enterOr_(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOr_" ):
                listener.exitOr_(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOr_" ):
                return visitor.visitOr_(self)
            else:
                return visitor.visitChildren(self)



    def booleanExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SqlBaseParser.BooleanExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 112
        self.enterRecursionRule(localctx, 112, self.RULE_booleanExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1776
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.T__1, SqlBaseParser.ABSENT, SqlBaseParser.ADD, SqlBaseParser.ADMIN, SqlBaseParser.AFTER, SqlBaseParser.ALL, SqlBaseParser.ANALYZE, SqlBaseParser.ANY, SqlBaseParser.ARRAY, SqlBaseParser.ASC, SqlBaseParser.AT, SqlBaseParser.AUTHORIZATION, SqlBaseParser.BERNOULLI, SqlBaseParser.BOTH, SqlBaseParser.CALL, SqlBaseParser.CASCADE, SqlBaseParser.CASE, SqlBaseParser.CAST, SqlBaseParser.CATALOGS, SqlBaseParser.COLUMN, SqlBaseParser.COLUMNS, SqlBaseParser.COMMENT, SqlBaseParser.COMMIT, SqlBaseParser.COMMITTED, SqlBaseParser.CONDITIONAL, SqlBaseParser.COUNT, SqlBaseParser.COPARTITION, SqlBaseParser.CURRENT, SqlBaseParser.CURRENT_CATALOG, SqlBaseParser.CURRENT_DATE, SqlBaseParser.CURRENT_PATH, SqlBaseParser.CURRENT_SCHEMA, SqlBaseParser.CURRENT_TIME, SqlBaseParser.CURRENT_TIMESTAMP, SqlBaseParser.CURRENT_USER, SqlBaseParser.DATA, SqlBaseParser.DATE, SqlBaseParser.DAY, SqlBaseParser.DEFAULT, SqlBaseParser.DEFINER, SqlBaseParser.DENY, SqlBaseParser.DESC, SqlBaseParser.DESCRIPTOR, SqlBaseParser.DEFINE, SqlBaseParser.DISTRIBUTED, SqlBaseParser.DOUBLE, SqlBaseParser.EMPTY, SqlBaseParser.ENCODING, SqlBaseParser.ERROR, SqlBaseParser.EXCLUDING, SqlBaseParser.EXISTS, SqlBaseParser.EXPLAIN, SqlBaseParser.EXTRACT, SqlBaseParser.FALSE, SqlBaseParser.FETCH, SqlBaseParser.FILTER, SqlBaseParser.FINAL, SqlBaseParser.FIRST, SqlBaseParser.FOLLOWING, SqlBaseParser.FORMAT, SqlBaseParser.FUNCTIONS, SqlBaseParser.GRANT, SqlBaseParser.GRANTED, SqlBaseParser.GRANTS, SqlBaseParser.GRAPHVIZ, SqlBaseParser.GROUPING, SqlBaseParser.GROUPS, SqlBaseParser.HOUR, SqlBaseParser.IF, SqlBaseParser.IGNORE, SqlBaseParser.INCLUDING, SqlBaseParser.INITIAL, SqlBaseParser.INPUT, SqlBaseParser.INTERVAL, SqlBaseParser.INVOKER, SqlBaseParser.IO, SqlBaseParser.ISOLATION, SqlBaseParser.JSON, SqlBaseParser.JSON_ARRAY, SqlBaseParser.JSON_EXISTS, SqlBaseParser.JSON_OBJECT, SqlBaseParser.JSON_QUERY, SqlBaseParser.JSON_VALUE, SqlBaseParser.KEEP, SqlBaseParser.KEY, SqlBaseParser.KEYS, SqlBaseParser.LAST, SqlBaseParser.LATERAL, SqlBaseParser.LEADING, SqlBaseParser.LEVEL, SqlBaseParser.LIMIT, SqlBaseParser.LISTAGG, SqlBaseParser.LOCAL, SqlBaseParser.LOCALTIME, SqlBaseParser.LOCALTIMESTAMP, SqlBaseParser.LOGICAL, SqlBaseParser.MAP, SqlBaseParser.MATCH, SqlBaseParser.MATCHED, SqlBaseParser.MATCHES, SqlBaseParser.MATCH_RECOGNIZE, SqlBaseParser.MATERIALIZED, SqlBaseParser.MEASURES, SqlBaseParser.MERGE, SqlBaseParser.MINUTE, SqlBaseParser.MONTH, SqlBaseParser.NEXT, SqlBaseParser.NFC, SqlBaseParser.NFD, SqlBaseParser.NFKC, SqlBaseParser.NFKD, SqlBaseParser.NO, SqlBaseParser.NONE, SqlBaseParser.NORMALIZE, SqlBaseParser.NULL, SqlBaseParser.NULLIF, SqlBaseParser.NULLS, SqlBaseParser.OBJECT, SqlBaseParser.OFFSET, SqlBaseParser.OMIT, SqlBaseParser.OF, SqlBaseParser.ONE, SqlBaseParser.ONLY, SqlBaseParser.OPTION, SqlBaseParser.ORDINALITY, SqlBaseParser.OUTPUT, SqlBaseParser.OVER, SqlBaseParser.OVERFLOW, SqlBaseParser.PARTITION, SqlBaseParser.PARTITIONS, SqlBaseParser.PASSING, SqlBaseParser.PAST, SqlBaseParser.PATH, SqlBaseParser.PATTERN, SqlBaseParser.PER, SqlBaseParser.PERMUTE, SqlBaseParser.POSITION, SqlBaseParser.PRECEDING, SqlBaseParser.PRECISION, SqlBaseParser.PRIVILEGES, SqlBaseParser.PROPERTIES, SqlBaseParser.PRUNE, SqlBaseParser.QUOTES, SqlBaseParser.RANGE, SqlBaseParser.READ, SqlBaseParser.REFRESH, SqlBaseParser.RENAME, SqlBaseParser.REPEATABLE, SqlBaseParser.REPLACE, SqlBaseParser.RESET, SqlBaseParser.RESPECT, SqlBaseParser.RESTRICT, SqlBaseParser.RETURNING, SqlBaseParser.REVOKE, SqlBaseParser.ROLE, SqlBaseParser.ROLES, SqlBaseParser.ROLLBACK, SqlBaseParser.ROW, SqlBaseParser.ROWS, SqlBaseParser.RUNNING, SqlBaseParser.SCALAR, SqlBaseParser.SCHEMA, SqlBaseParser.SCHEMAS, SqlBaseParser.SECOND, SqlBaseParser.SECURITY, SqlBaseParser.SEEK, SqlBaseParser.SERIALIZABLE, SqlBaseParser.SESSION, SqlBaseParser.SET, SqlBaseParser.SETS, SqlBaseParser.SHOW, SqlBaseParser.SOME, SqlBaseParser.START, SqlBaseParser.STATS, SqlBaseParser.SUBSET, SqlBaseParser.SUBSTRING, SqlBaseParser.SYSTEM, SqlBaseParser.TABLES, SqlBaseParser.TABLESAMPLE, SqlBaseParser.TEXT, SqlBaseParser.TEXT_STRING, SqlBaseParser.TIES, SqlBaseParser.TIME, SqlBaseParser.TIMESTAMP, SqlBaseParser.TO, SqlBaseParser.TRAILING, SqlBaseParser.TRANSACTION, SqlBaseParser.TRIM, SqlBaseParser.TRUE, SqlBaseParser.TRUNCATE, SqlBaseParser.TRY_CAST, SqlBaseParser.TYPE, SqlBaseParser.UNBOUNDED, SqlBaseParser.UNCOMMITTED, SqlBaseParser.UNCONDITIONAL, SqlBaseParser.UNIQUE, SqlBaseParser.UNKNOWN, SqlBaseParser.UNMATCHED, SqlBaseParser.UPDATE, SqlBaseParser.USE, SqlBaseParser.USER, SqlBaseParser.UTF16, SqlBaseParser.UTF32, SqlBaseParser.UTF8, SqlBaseParser.VALIDATE, SqlBaseParser.VALUE, SqlBaseParser.VERBOSE, SqlBaseParser.VERSION, SqlBaseParser.VIEW, SqlBaseParser.WINDOW, SqlBaseParser.WITHIN, SqlBaseParser.WITHOUT, SqlBaseParser.WORK, SqlBaseParser.WRAPPER, SqlBaseParser.WRITE, SqlBaseParser.YEAR, SqlBaseParser.ZONE, SqlBaseParser.PLUS, SqlBaseParser.MINUS, SqlBaseParser.QUESTION_MARK, SqlBaseParser.STRING, SqlBaseParser.UNICODE_STRING, SqlBaseParser.BINARY_LITERAL, SqlBaseParser.INTEGER_VALUE, SqlBaseParser.DECIMAL_VALUE, SqlBaseParser.DOUBLE_VALUE, SqlBaseParser.IDENTIFIER, SqlBaseParser.DIGIT_IDENTIFIER, SqlBaseParser.QUOTED_IDENTIFIER, SqlBaseParser.BACKQUOTED_IDENTIFIER]:
                localctx = SqlBaseParser.PredicatedContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 1770
                localctx._valueExpression = self.valueExpression(0)
                self.state = 1772
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,229,self._ctx)
                if la_ == 1:
                    self.state = 1771
                    self.predicate(localctx._valueExpression)


            elif token in [SqlBaseParser.NOT]:
                localctx = SqlBaseParser.LogicalNotContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1774
                self.match(SqlBaseParser.NOT)
                self.state = 1775
                self.booleanExpression(3)
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 1786
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,232,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 1784
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,231,self._ctx)
                    if la_ == 1:
                        localctx = SqlBaseParser.And_Context(self, SqlBaseParser.BooleanExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_booleanExpression)
                        self.state = 1778
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import (
                                FailedPredicateException,
                            )
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 1779
                        self.match(SqlBaseParser.AND)
                        self.state = 1780
                        self.booleanExpression(3)

                    elif la_ == 2:
                        localctx = SqlBaseParser.Or_Context(self, SqlBaseParser.BooleanExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_booleanExpression)
                        self.state = 1781
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import (
                                FailedPredicateException,
                            )
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 1782
                        self.match(SqlBaseParser.OR)
                        self.state = 1783
                        self.booleanExpression(2)

             
                self.state = 1788
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,232,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class PredicateContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, value:ParserRuleContext=None):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.value = None
            self.value = value


        def getRuleIndex(self):
            return SqlBaseParser.RULE_predicate

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)
            self.value = ctx.value



    class ComparisonContext(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PredicateContext
            super().__init__(parser)
            self.right = None # ValueExpressionContext
            self.copyFrom(ctx)

        def comparisonOperator(self):
            return self.getTypedRuleContext(SqlBaseParser.ComparisonOperatorContext,0)

        def valueExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterComparison" ):
                listener.enterComparison(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitComparison" ):
                listener.exitComparison(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitComparison" ):
                return visitor.visitComparison(self)
            else:
                return visitor.visitChildren(self)


    class LikeContext(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PredicateContext
            super().__init__(parser)
            self.pattern = None # ValueExpressionContext
            self.escape = None # ValueExpressionContext
            self.copyFrom(ctx)

        def LIKE(self):
            return self.getToken(SqlBaseParser.LIKE, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,i)

        def NOT(self):
            return self.getToken(SqlBaseParser.NOT, 0)
        def ESCAPE(self):
            return self.getToken(SqlBaseParser.ESCAPE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLike" ):
                listener.enterLike(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLike" ):
                listener.exitLike(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLike" ):
                return visitor.visitLike(self)
            else:
                return visitor.visitChildren(self)


    class InSubqueryContext(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PredicateContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def IN(self):
            return self.getToken(SqlBaseParser.IN, 0)
        def query(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryContext,0)

        def NOT(self):
            return self.getToken(SqlBaseParser.NOT, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInSubquery" ):
                listener.enterInSubquery(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInSubquery" ):
                listener.exitInSubquery(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInSubquery" ):
                return visitor.visitInSubquery(self)
            else:
                return visitor.visitChildren(self)


    class DistinctFromContext(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PredicateContext
            super().__init__(parser)
            self.right = None # ValueExpressionContext
            self.copyFrom(ctx)

        def IS(self):
            return self.getToken(SqlBaseParser.IS, 0)
        def DISTINCT(self):
            return self.getToken(SqlBaseParser.DISTINCT, 0)
        def FROM(self):
            return self.getToken(SqlBaseParser.FROM, 0)
        def valueExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,0)

        def NOT(self):
            return self.getToken(SqlBaseParser.NOT, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDistinctFrom" ):
                listener.enterDistinctFrom(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDistinctFrom" ):
                listener.exitDistinctFrom(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDistinctFrom" ):
                return visitor.visitDistinctFrom(self)
            else:
                return visitor.visitChildren(self)


    class InListContext(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PredicateContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def IN(self):
            return self.getToken(SqlBaseParser.IN, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)

        def NOT(self):
            return self.getToken(SqlBaseParser.NOT, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInList" ):
                listener.enterInList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInList" ):
                listener.exitInList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInList" ):
                return visitor.visitInList(self)
            else:
                return visitor.visitChildren(self)


    class NullPredicateContext(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PredicateContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def IS(self):
            return self.getToken(SqlBaseParser.IS, 0)
        def NULL(self):
            return self.getToken(SqlBaseParser.NULL, 0)
        def NOT(self):
            return self.getToken(SqlBaseParser.NOT, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNullPredicate" ):
                listener.enterNullPredicate(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNullPredicate" ):
                listener.exitNullPredicate(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNullPredicate" ):
                return visitor.visitNullPredicate(self)
            else:
                return visitor.visitChildren(self)


    class BetweenContext(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PredicateContext
            super().__init__(parser)
            self.lower = None # ValueExpressionContext
            self.upper = None # ValueExpressionContext
            self.copyFrom(ctx)

        def BETWEEN(self):
            return self.getToken(SqlBaseParser.BETWEEN, 0)
        def AND(self):
            return self.getToken(SqlBaseParser.AND, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,i)

        def NOT(self):
            return self.getToken(SqlBaseParser.NOT, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBetween" ):
                listener.enterBetween(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBetween" ):
                listener.exitBetween(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBetween" ):
                return visitor.visitBetween(self)
            else:
                return visitor.visitChildren(self)


    class QuantifiedComparisonContext(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PredicateContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def comparisonOperator(self):
            return self.getTypedRuleContext(SqlBaseParser.ComparisonOperatorContext,0)

        def comparisonQuantifier(self):
            return self.getTypedRuleContext(SqlBaseParser.ComparisonQuantifierContext,0)

        def query(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQuantifiedComparison" ):
                listener.enterQuantifiedComparison(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQuantifiedComparison" ):
                listener.exitQuantifiedComparison(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQuantifiedComparison" ):
                return visitor.visitQuantifiedComparison(self)
            else:
                return visitor.visitChildren(self)



    def predicate(self, value:ParserRuleContext):

        localctx = SqlBaseParser.PredicateContext(self, self._ctx, self.state, value)
        self.enterRule(localctx, 114, self.RULE_predicate)
        self._la = 0 # Token type
        try:
            self.state = 1850
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,241,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.ComparisonContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1789
                self.comparisonOperator()
                self.state = 1790
                localctx.right = self.valueExpression(0)

            elif la_ == 2:
                localctx = SqlBaseParser.QuantifiedComparisonContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1792
                self.comparisonOperator()
                self.state = 1793
                self.comparisonQuantifier()
                self.state = 1794
                self.match(SqlBaseParser.T__1)
                self.state = 1795
                self.query()
                self.state = 1796
                self.match(SqlBaseParser.T__2)

            elif la_ == 3:
                localctx = SqlBaseParser.BetweenContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1799
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.NOT:
                    self.state = 1798
                    self.match(SqlBaseParser.NOT)


                self.state = 1801
                self.match(SqlBaseParser.BETWEEN)
                self.state = 1802
                localctx.lower = self.valueExpression(0)
                self.state = 1803
                self.match(SqlBaseParser.AND)
                self.state = 1804
                localctx.upper = self.valueExpression(0)

            elif la_ == 4:
                localctx = SqlBaseParser.InListContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 1807
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.NOT:
                    self.state = 1806
                    self.match(SqlBaseParser.NOT)


                self.state = 1809
                self.match(SqlBaseParser.IN)
                self.state = 1810
                self.match(SqlBaseParser.T__1)
                self.state = 1811
                self.expression()
                self.state = 1816
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 1812
                    self.match(SqlBaseParser.T__3)
                    self.state = 1813
                    self.expression()
                    self.state = 1818
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1819
                self.match(SqlBaseParser.T__2)

            elif la_ == 5:
                localctx = SqlBaseParser.InSubqueryContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 1822
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.NOT:
                    self.state = 1821
                    self.match(SqlBaseParser.NOT)


                self.state = 1824
                self.match(SqlBaseParser.IN)
                self.state = 1825
                self.match(SqlBaseParser.T__1)
                self.state = 1826
                self.query()
                self.state = 1827
                self.match(SqlBaseParser.T__2)

            elif la_ == 6:
                localctx = SqlBaseParser.LikeContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 1830
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.NOT:
                    self.state = 1829
                    self.match(SqlBaseParser.NOT)


                self.state = 1832
                self.match(SqlBaseParser.LIKE)
                self.state = 1833
                localctx.pattern = self.valueExpression(0)
                self.state = 1836
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,238,self._ctx)
                if la_ == 1:
                    self.state = 1834
                    self.match(SqlBaseParser.ESCAPE)
                    self.state = 1835
                    localctx.escape = self.valueExpression(0)



            elif la_ == 7:
                localctx = SqlBaseParser.NullPredicateContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 1838
                self.match(SqlBaseParser.IS)
                self.state = 1840
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.NOT:
                    self.state = 1839
                    self.match(SqlBaseParser.NOT)


                self.state = 1842
                self.match(SqlBaseParser.NULL)

            elif la_ == 8:
                localctx = SqlBaseParser.DistinctFromContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 1843
                self.match(SqlBaseParser.IS)
                self.state = 1845
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.NOT:
                    self.state = 1844
                    self.match(SqlBaseParser.NOT)


                self.state = 1847
                self.match(SqlBaseParser.DISTINCT)
                self.state = 1848
                self.match(SqlBaseParser.FROM)
                self.state = 1849
                localctx.right = self.valueExpression(0)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ValueExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_valueExpression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class ValueExpressionDefaultContext(ValueExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.ValueExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def primaryExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.PrimaryExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterValueExpressionDefault" ):
                listener.enterValueExpressionDefault(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitValueExpressionDefault" ):
                listener.exitValueExpressionDefault(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitValueExpressionDefault" ):
                return visitor.visitValueExpressionDefault(self)
            else:
                return visitor.visitChildren(self)


    class ConcatenationContext(ValueExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.ValueExpressionContext
            super().__init__(parser)
            self.left = None # ValueExpressionContext
            self.right = None # ValueExpressionContext
            self.copyFrom(ctx)

        def CONCAT(self):
            return self.getToken(SqlBaseParser.CONCAT, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConcatenation" ):
                listener.enterConcatenation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConcatenation" ):
                listener.exitConcatenation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConcatenation" ):
                return visitor.visitConcatenation(self)
            else:
                return visitor.visitChildren(self)


    class ArithmeticBinaryContext(ValueExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.ValueExpressionContext
            super().__init__(parser)
            self.left = None # ValueExpressionContext
            self.operator = None # Token
            self.right = None # ValueExpressionContext
            self.copyFrom(ctx)

        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,i)

        def ASTERISK(self):
            return self.getToken(SqlBaseParser.ASTERISK, 0)
        def SLASH(self):
            return self.getToken(SqlBaseParser.SLASH, 0)
        def PERCENT(self):
            return self.getToken(SqlBaseParser.PERCENT, 0)
        def PLUS(self):
            return self.getToken(SqlBaseParser.PLUS, 0)
        def MINUS(self):
            return self.getToken(SqlBaseParser.MINUS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArithmeticBinary" ):
                listener.enterArithmeticBinary(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArithmeticBinary" ):
                listener.exitArithmeticBinary(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArithmeticBinary" ):
                return visitor.visitArithmeticBinary(self)
            else:
                return visitor.visitChildren(self)


    class ArithmeticUnaryContext(ValueExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.ValueExpressionContext
            super().__init__(parser)
            self.operator = None # Token
            self.copyFrom(ctx)

        def valueExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,0)

        def MINUS(self):
            return self.getToken(SqlBaseParser.MINUS, 0)
        def PLUS(self):
            return self.getToken(SqlBaseParser.PLUS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArithmeticUnary" ):
                listener.enterArithmeticUnary(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArithmeticUnary" ):
                listener.exitArithmeticUnary(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArithmeticUnary" ):
                return visitor.visitArithmeticUnary(self)
            else:
                return visitor.visitChildren(self)


    class AtTimeZoneContext(ValueExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.ValueExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def valueExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,0)

        def AT(self):
            return self.getToken(SqlBaseParser.AT, 0)
        def timeZoneSpecifier(self):
            return self.getTypedRuleContext(SqlBaseParser.TimeZoneSpecifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAtTimeZone" ):
                listener.enterAtTimeZone(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAtTimeZone" ):
                listener.exitAtTimeZone(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAtTimeZone" ):
                return visitor.visitAtTimeZone(self)
            else:
                return visitor.visitChildren(self)



    def valueExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SqlBaseParser.ValueExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 116
        self.enterRecursionRule(localctx, 116, self.RULE_valueExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1856
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,242,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.ValueExpressionDefaultContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 1853
                self.primaryExpression(0)

            elif la_ == 2:
                localctx = SqlBaseParser.ArithmeticUnaryContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1854
                localctx.operator = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==SqlBaseParser.PLUS or _la==SqlBaseParser.MINUS):
                    localctx.operator = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1855
                self.valueExpression(4)


            self._ctx.stop = self._input.LT(-1)
            self.state = 1872
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,244,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 1870
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,243,self._ctx)
                    if la_ == 1:
                        localctx = SqlBaseParser.ArithmeticBinaryContext(self, SqlBaseParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 1858
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import (
                                FailedPredicateException,
                            )
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 1859
                        localctx.operator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 297)) & ~0x3f) == 0 and ((1 << (_la - 297)) & ((1 << (SqlBaseParser.ASTERISK - 297)) | (1 << (SqlBaseParser.SLASH - 297)) | (1 << (SqlBaseParser.PERCENT - 297)))) != 0)):
                            localctx.operator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1860
                        localctx.right = self.valueExpression(4)

                    elif la_ == 2:
                        localctx = SqlBaseParser.ArithmeticBinaryContext(self, SqlBaseParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 1861
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import (
                                FailedPredicateException,
                            )
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 1862
                        localctx.operator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==SqlBaseParser.PLUS or _la==SqlBaseParser.MINUS):
                            localctx.operator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1863
                        localctx.right = self.valueExpression(3)

                    elif la_ == 3:
                        localctx = SqlBaseParser.ConcatenationContext(self, SqlBaseParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 1864
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import (
                                FailedPredicateException,
                            )
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 1865
                        self.match(SqlBaseParser.CONCAT)
                        self.state = 1866
                        localctx.right = self.valueExpression(2)

                    elif la_ == 4:
                        localctx = SqlBaseParser.AtTimeZoneContext(self, SqlBaseParser.ValueExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 1867
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import (
                                FailedPredicateException,
                            )
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 1868
                        self.match(SqlBaseParser.AT)
                        self.state = 1869
                        self.timeZoneSpecifier()

             
                self.state = 1874
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,244,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class PrimaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_primaryExpression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class DereferenceContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.base = None # PrimaryExpressionContext
            self.fieldName = None # IdentifierContext
            self.copyFrom(ctx)

        def primaryExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.PrimaryExpressionContext,0)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDereference" ):
                listener.enterDereference(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDereference" ):
                listener.exitDereference(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDereference" ):
                return visitor.visitDereference(self)
            else:
                return visitor.visitChildren(self)


    class TypeConstructorContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def string(self):
            return self.getTypedRuleContext(SqlBaseParser.StringContext,0)

        def DOUBLE(self):
            return self.getToken(SqlBaseParser.DOUBLE, 0)
        def PRECISION(self):
            return self.getToken(SqlBaseParser.PRECISION, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeConstructor" ):
                listener.enterTypeConstructor(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeConstructor" ):
                listener.exitTypeConstructor(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeConstructor" ):
                return visitor.visitTypeConstructor(self)
            else:
                return visitor.visitChildren(self)


    class JsonValueContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.emptyBehavior = None # JsonValueBehaviorContext
            self.errorBehavior = None # JsonValueBehaviorContext
            self.copyFrom(ctx)

        def JSON_VALUE(self):
            return self.getToken(SqlBaseParser.JSON_VALUE, 0)
        def jsonPathInvocation(self):
            return self.getTypedRuleContext(SqlBaseParser.JsonPathInvocationContext,0)

        def RETURNING(self):
            return self.getToken(SqlBaseParser.RETURNING, 0)
        def type_(self):
            return self.getTypedRuleContext(SqlBaseParser.Type_Context,0)

        def ON(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.ON)
            else:
                return self.getToken(SqlBaseParser.ON, i)
        def EMPTY(self):
            return self.getToken(SqlBaseParser.EMPTY, 0)
        def ERROR(self):
            return self.getToken(SqlBaseParser.ERROR, 0)
        def jsonValueBehavior(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.JsonValueBehaviorContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.JsonValueBehaviorContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJsonValue" ):
                listener.enterJsonValue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJsonValue" ):
                listener.exitJsonValue(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJsonValue" ):
                return visitor.visitJsonValue(self)
            else:
                return visitor.visitChildren(self)


    class SpecialDateTimeFunctionContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.name = None # Token
            self.precision = None # Token
            self.copyFrom(ctx)

        def CURRENT_DATE(self):
            return self.getToken(SqlBaseParser.CURRENT_DATE, 0)
        def CURRENT_TIME(self):
            return self.getToken(SqlBaseParser.CURRENT_TIME, 0)
        def INTEGER_VALUE(self):
            return self.getToken(SqlBaseParser.INTEGER_VALUE, 0)
        def CURRENT_TIMESTAMP(self):
            return self.getToken(SqlBaseParser.CURRENT_TIMESTAMP, 0)
        def LOCALTIME(self):
            return self.getToken(SqlBaseParser.LOCALTIME, 0)
        def LOCALTIMESTAMP(self):
            return self.getToken(SqlBaseParser.LOCALTIMESTAMP, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSpecialDateTimeFunction" ):
                listener.enterSpecialDateTimeFunction(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSpecialDateTimeFunction" ):
                listener.exitSpecialDateTimeFunction(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSpecialDateTimeFunction" ):
                return visitor.visitSpecialDateTimeFunction(self)
            else:
                return visitor.visitChildren(self)


    class SubstringContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SUBSTRING(self):
            return self.getToken(SqlBaseParser.SUBSTRING, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,i)

        def FROM(self):
            return self.getToken(SqlBaseParser.FROM, 0)
        def FOR(self):
            return self.getToken(SqlBaseParser.FOR, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubstring" ):
                listener.enterSubstring(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubstring" ):
                listener.exitSubstring(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubstring" ):
                return visitor.visitSubstring(self)
            else:
                return visitor.visitChildren(self)


    class CastContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CAST(self):
            return self.getToken(SqlBaseParser.CAST, 0)
        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)

        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)
        def type_(self):
            return self.getTypedRuleContext(SqlBaseParser.Type_Context,0)

        def TRY_CAST(self):
            return self.getToken(SqlBaseParser.TRY_CAST, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCast" ):
                listener.enterCast(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCast" ):
                listener.exitCast(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCast" ):
                return visitor.visitCast(self)
            else:
                return visitor.visitChildren(self)


    class ParenthesizedExpressionContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParenthesizedExpression" ):
                listener.enterParenthesizedExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParenthesizedExpression" ):
                listener.exitParenthesizedExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParenthesizedExpression" ):
                return visitor.visitParenthesizedExpression(self)
            else:
                return visitor.visitChildren(self)


    class TrimContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.trimChar = None # ValueExpressionContext
            self.trimSource = None # ValueExpressionContext
            self.copyFrom(ctx)

        def TRIM(self):
            return self.getToken(SqlBaseParser.TRIM, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,i)

        def FROM(self):
            return self.getToken(SqlBaseParser.FROM, 0)
        def trimsSpecification(self):
            return self.getTypedRuleContext(SqlBaseParser.TrimsSpecificationContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTrim" ):
                listener.enterTrim(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTrim" ):
                listener.exitTrim(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTrim" ):
                return visitor.visitTrim(self)
            else:
                return visitor.visitChildren(self)


    class ParameterContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def QUESTION_MARK(self):
            return self.getToken(SqlBaseParser.QUESTION_MARK, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParameter" ):
                listener.enterParameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParameter" ):
                listener.exitParameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParameter" ):
                return visitor.visitParameter(self)
            else:
                return visitor.visitChildren(self)


    class NormalizeContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def NORMALIZE(self):
            return self.getToken(SqlBaseParser.NORMALIZE, 0)
        def valueExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,0)

        def normalForm(self):
            return self.getTypedRuleContext(SqlBaseParser.NormalFormContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNormalize" ):
                listener.enterNormalize(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNormalize" ):
                listener.exitNormalize(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNormalize" ):
                return visitor.visitNormalize(self)
            else:
                return visitor.visitChildren(self)


    class JsonObjectContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def JSON_OBJECT(self):
            return self.getToken(SqlBaseParser.JSON_OBJECT, 0)
        def jsonObjectMember(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.JsonObjectMemberContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.JsonObjectMemberContext,i)

        def RETURNING(self):
            return self.getToken(SqlBaseParser.RETURNING, 0)
        def type_(self):
            return self.getTypedRuleContext(SqlBaseParser.Type_Context,0)

        def NULL(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.NULL)
            else:
                return self.getToken(SqlBaseParser.NULL, i)
        def ON(self):
            return self.getToken(SqlBaseParser.ON, 0)
        def ABSENT(self):
            return self.getToken(SqlBaseParser.ABSENT, 0)
        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)
        def UNIQUE(self):
            return self.getToken(SqlBaseParser.UNIQUE, 0)
        def WITHOUT(self):
            return self.getToken(SqlBaseParser.WITHOUT, 0)
        def FORMAT(self):
            return self.getToken(SqlBaseParser.FORMAT, 0)
        def jsonRepresentation(self):
            return self.getTypedRuleContext(SqlBaseParser.JsonRepresentationContext,0)

        def KEYS(self):
            return self.getToken(SqlBaseParser.KEYS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJsonObject" ):
                listener.enterJsonObject(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJsonObject" ):
                listener.exitJsonObject(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJsonObject" ):
                return visitor.visitJsonObject(self)
            else:
                return visitor.visitChildren(self)


    class IntervalLiteralContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def interval(self):
            return self.getTypedRuleContext(SqlBaseParser.IntervalContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIntervalLiteral" ):
                listener.enterIntervalLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIntervalLiteral" ):
                listener.exitIntervalLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIntervalLiteral" ):
                return visitor.visitIntervalLiteral(self)
            else:
                return visitor.visitChildren(self)


    class NumericLiteralContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def number(self):
            return self.getTypedRuleContext(SqlBaseParser.NumberContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumericLiteral" ):
                listener.enterNumericLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumericLiteral" ):
                listener.exitNumericLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNumericLiteral" ):
                return visitor.visitNumericLiteral(self)
            else:
                return visitor.visitChildren(self)


    class BooleanLiteralContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def booleanValue(self):
            return self.getTypedRuleContext(SqlBaseParser.BooleanValueContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBooleanLiteral" ):
                listener.enterBooleanLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBooleanLiteral" ):
                listener.exitBooleanLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBooleanLiteral" ):
                return visitor.visitBooleanLiteral(self)
            else:
                return visitor.visitChildren(self)


    class JsonArrayContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def JSON_ARRAY(self):
            return self.getToken(SqlBaseParser.JSON_ARRAY, 0)
        def jsonValueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.JsonValueExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.JsonValueExpressionContext,i)

        def RETURNING(self):
            return self.getToken(SqlBaseParser.RETURNING, 0)
        def type_(self):
            return self.getTypedRuleContext(SqlBaseParser.Type_Context,0)

        def NULL(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.NULL)
            else:
                return self.getToken(SqlBaseParser.NULL, i)
        def ON(self):
            return self.getToken(SqlBaseParser.ON, 0)
        def ABSENT(self):
            return self.getToken(SqlBaseParser.ABSENT, 0)
        def FORMAT(self):
            return self.getToken(SqlBaseParser.FORMAT, 0)
        def jsonRepresentation(self):
            return self.getTypedRuleContext(SqlBaseParser.JsonRepresentationContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJsonArray" ):
                listener.enterJsonArray(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJsonArray" ):
                listener.exitJsonArray(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJsonArray" ):
                return visitor.visitJsonArray(self)
            else:
                return visitor.visitChildren(self)


    class SimpleCaseContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.operand = None # ExpressionContext
            self.elseExpression = None # ExpressionContext
            self.copyFrom(ctx)

        def CASE(self):
            return self.getToken(SqlBaseParser.CASE, 0)
        def END(self):
            return self.getToken(SqlBaseParser.END, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)

        def whenClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.WhenClauseContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.WhenClauseContext,i)

        def ELSE(self):
            return self.getToken(SqlBaseParser.ELSE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleCase" ):
                listener.enterSimpleCase(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleCase" ):
                listener.exitSimpleCase(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleCase" ):
                return visitor.visitSimpleCase(self)
            else:
                return visitor.visitChildren(self)


    class ColumnReferenceContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterColumnReference" ):
                listener.enterColumnReference(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitColumnReference" ):
                listener.exitColumnReference(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitColumnReference" ):
                return visitor.visitColumnReference(self)
            else:
                return visitor.visitChildren(self)


    class NullLiteralContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def NULL(self):
            return self.getToken(SqlBaseParser.NULL, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNullLiteral" ):
                listener.enterNullLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNullLiteral" ):
                listener.exitNullLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNullLiteral" ):
                return visitor.visitNullLiteral(self)
            else:
                return visitor.visitChildren(self)


    class RowConstructorContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)

        def ROW(self):
            return self.getToken(SqlBaseParser.ROW, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRowConstructor" ):
                listener.enterRowConstructor(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRowConstructor" ):
                listener.exitRowConstructor(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRowConstructor" ):
                return visitor.visitRowConstructor(self)
            else:
                return visitor.visitChildren(self)


    class SubscriptContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.value = None # PrimaryExpressionContext
            self.index = None # ValueExpressionContext
            self.copyFrom(ctx)

        def primaryExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.PrimaryExpressionContext,0)

        def valueExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubscript" ):
                listener.enterSubscript(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubscript" ):
                listener.exitSubscript(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubscript" ):
                return visitor.visitSubscript(self)
            else:
                return visitor.visitChildren(self)


    class JsonExistsContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def JSON_EXISTS(self):
            return self.getToken(SqlBaseParser.JSON_EXISTS, 0)
        def jsonPathInvocation(self):
            return self.getTypedRuleContext(SqlBaseParser.JsonPathInvocationContext,0)

        def jsonExistsErrorBehavior(self):
            return self.getTypedRuleContext(SqlBaseParser.JsonExistsErrorBehaviorContext,0)

        def ON(self):
            return self.getToken(SqlBaseParser.ON, 0)
        def ERROR(self):
            return self.getToken(SqlBaseParser.ERROR, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJsonExists" ):
                listener.enterJsonExists(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJsonExists" ):
                listener.exitJsonExists(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJsonExists" ):
                return visitor.visitJsonExists(self)
            else:
                return visitor.visitChildren(self)


    class CurrentPathContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.name = None # Token
            self.copyFrom(ctx)

        def CURRENT_PATH(self):
            return self.getToken(SqlBaseParser.CURRENT_PATH, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCurrentPath" ):
                listener.enterCurrentPath(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCurrentPath" ):
                listener.exitCurrentPath(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCurrentPath" ):
                return visitor.visitCurrentPath(self)
            else:
                return visitor.visitChildren(self)


    class SubqueryExpressionContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def query(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubqueryExpression" ):
                listener.enterSubqueryExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubqueryExpression" ):
                listener.exitSubqueryExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubqueryExpression" ):
                return visitor.visitSubqueryExpression(self)
            else:
                return visitor.visitChildren(self)


    class Lambda_Context(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,i)

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLambda_" ):
                listener.enterLambda_(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLambda_" ):
                listener.exitLambda_(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLambda_" ):
                return visitor.visitLambda_(self)
            else:
                return visitor.visitChildren(self)


    class BinaryLiteralContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def BINARY_LITERAL(self):
            return self.getToken(SqlBaseParser.BINARY_LITERAL, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBinaryLiteral" ):
                listener.enterBinaryLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBinaryLiteral" ):
                listener.exitBinaryLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBinaryLiteral" ):
                return visitor.visitBinaryLiteral(self)
            else:
                return visitor.visitChildren(self)


    class CurrentUserContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.name = None # Token
            self.copyFrom(ctx)

        def CURRENT_USER(self):
            return self.getToken(SqlBaseParser.CURRENT_USER, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCurrentUser" ):
                listener.enterCurrentUser(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCurrentUser" ):
                listener.exitCurrentUser(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCurrentUser" ):
                return visitor.visitCurrentUser(self)
            else:
                return visitor.visitChildren(self)


    class JsonQueryContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.emptyBehavior = None # JsonQueryBehaviorContext
            self.errorBehavior = None # JsonQueryBehaviorContext
            self.copyFrom(ctx)

        def JSON_QUERY(self):
            return self.getToken(SqlBaseParser.JSON_QUERY, 0)
        def jsonPathInvocation(self):
            return self.getTypedRuleContext(SqlBaseParser.JsonPathInvocationContext,0)

        def RETURNING(self):
            return self.getToken(SqlBaseParser.RETURNING, 0)
        def type_(self):
            return self.getTypedRuleContext(SqlBaseParser.Type_Context,0)

        def jsonQueryWrapperBehavior(self):
            return self.getTypedRuleContext(SqlBaseParser.JsonQueryWrapperBehaviorContext,0)

        def WRAPPER(self):
            return self.getToken(SqlBaseParser.WRAPPER, 0)
        def QUOTES(self):
            return self.getToken(SqlBaseParser.QUOTES, 0)
        def ON(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.ON)
            else:
                return self.getToken(SqlBaseParser.ON, i)
        def EMPTY(self):
            return self.getToken(SqlBaseParser.EMPTY, 0)
        def ERROR(self):
            return self.getToken(SqlBaseParser.ERROR, 0)
        def KEEP(self):
            return self.getToken(SqlBaseParser.KEEP, 0)
        def OMIT(self):
            return self.getToken(SqlBaseParser.OMIT, 0)
        def jsonQueryBehavior(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.JsonQueryBehaviorContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.JsonQueryBehaviorContext,i)

        def FORMAT(self):
            return self.getToken(SqlBaseParser.FORMAT, 0)
        def jsonRepresentation(self):
            return self.getTypedRuleContext(SqlBaseParser.JsonRepresentationContext,0)

        def SCALAR(self):
            return self.getToken(SqlBaseParser.SCALAR, 0)
        def TEXT_STRING(self):
            return self.getToken(SqlBaseParser.TEXT_STRING, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJsonQuery" ):
                listener.enterJsonQuery(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJsonQuery" ):
                listener.exitJsonQuery(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJsonQuery" ):
                return visitor.visitJsonQuery(self)
            else:
                return visitor.visitChildren(self)


    class MeasureContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def over(self):
            return self.getTypedRuleContext(SqlBaseParser.OverContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMeasure" ):
                listener.enterMeasure(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMeasure" ):
                listener.exitMeasure(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMeasure" ):
                return visitor.visitMeasure(self)
            else:
                return visitor.visitChildren(self)


    class ExtractContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def EXTRACT(self):
            return self.getToken(SqlBaseParser.EXTRACT, 0)
        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def FROM(self):
            return self.getToken(SqlBaseParser.FROM, 0)
        def valueExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExtract" ):
                listener.enterExtract(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExtract" ):
                listener.exitExtract(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExtract" ):
                return visitor.visitExtract(self)
            else:
                return visitor.visitChildren(self)


    class StringLiteralContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def string(self):
            return self.getTypedRuleContext(SqlBaseParser.StringContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStringLiteral" ):
                listener.enterStringLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStringLiteral" ):
                listener.exitStringLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStringLiteral" ):
                return visitor.visitStringLiteral(self)
            else:
                return visitor.visitChildren(self)


    class ArrayConstructorContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ARRAY(self):
            return self.getToken(SqlBaseParser.ARRAY, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArrayConstructor" ):
                listener.enterArrayConstructor(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArrayConstructor" ):
                listener.exitArrayConstructor(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArrayConstructor" ):
                return visitor.visitArrayConstructor(self)
            else:
                return visitor.visitChildren(self)


    class FunctionCallContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.label = None # IdentifierContext
            self.copyFrom(ctx)

        def qualifiedName(self):
            return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,0)

        def ASTERISK(self):
            return self.getToken(SqlBaseParser.ASTERISK, 0)
        def processingMode(self):
            return self.getTypedRuleContext(SqlBaseParser.ProcessingModeContext,0)

        def filter_(self):
            return self.getTypedRuleContext(SqlBaseParser.Filter_Context,0)

        def over(self):
            return self.getTypedRuleContext(SqlBaseParser.OverContext,0)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)

        def ORDER(self):
            return self.getToken(SqlBaseParser.ORDER, 0)
        def BY(self):
            return self.getToken(SqlBaseParser.BY, 0)
        def sortItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.SortItemContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.SortItemContext,i)

        def setQuantifier(self):
            return self.getTypedRuleContext(SqlBaseParser.SetQuantifierContext,0)

        def nullTreatment(self):
            return self.getTypedRuleContext(SqlBaseParser.NullTreatmentContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionCall" ):
                listener.enterFunctionCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionCall" ):
                listener.exitFunctionCall(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionCall" ):
                return visitor.visitFunctionCall(self)
            else:
                return visitor.visitChildren(self)


    class CurrentSchemaContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.name = None # Token
            self.copyFrom(ctx)

        def CURRENT_SCHEMA(self):
            return self.getToken(SqlBaseParser.CURRENT_SCHEMA, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCurrentSchema" ):
                listener.enterCurrentSchema(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCurrentSchema" ):
                listener.exitCurrentSchema(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCurrentSchema" ):
                return visitor.visitCurrentSchema(self)
            else:
                return visitor.visitChildren(self)


    class ExistsContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def EXISTS(self):
            return self.getToken(SqlBaseParser.EXISTS, 0)
        def query(self):
            return self.getTypedRuleContext(SqlBaseParser.QueryContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExists" ):
                listener.enterExists(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExists" ):
                listener.exitExists(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExists" ):
                return visitor.visitExists(self)
            else:
                return visitor.visitChildren(self)


    class PositionContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def POSITION(self):
            return self.getToken(SqlBaseParser.POSITION, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,i)

        def IN(self):
            return self.getToken(SqlBaseParser.IN, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPosition" ):
                listener.enterPosition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPosition" ):
                listener.exitPosition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPosition" ):
                return visitor.visitPosition(self)
            else:
                return visitor.visitChildren(self)


    class ListaggContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.name = None # Token
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)

        def LISTAGG(self):
            return self.getToken(SqlBaseParser.LISTAGG, 0)
        def WITHIN(self):
            return self.getToken(SqlBaseParser.WITHIN, 0)
        def GROUP(self):
            return self.getToken(SqlBaseParser.GROUP, 0)
        def ORDER(self):
            return self.getToken(SqlBaseParser.ORDER, 0)
        def BY(self):
            return self.getToken(SqlBaseParser.BY, 0)
        def sortItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.SortItemContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.SortItemContext,i)

        def setQuantifier(self):
            return self.getTypedRuleContext(SqlBaseParser.SetQuantifierContext,0)

        def string(self):
            return self.getTypedRuleContext(SqlBaseParser.StringContext,0)

        def ON(self):
            return self.getToken(SqlBaseParser.ON, 0)
        def OVERFLOW(self):
            return self.getToken(SqlBaseParser.OVERFLOW, 0)
        def listAggOverflowBehavior(self):
            return self.getTypedRuleContext(SqlBaseParser.ListAggOverflowBehaviorContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterListagg" ):
                listener.enterListagg(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitListagg" ):
                listener.exitListagg(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitListagg" ):
                return visitor.visitListagg(self)
            else:
                return visitor.visitChildren(self)


    class SearchedCaseContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.elseExpression = None # ExpressionContext
            self.copyFrom(ctx)

        def CASE(self):
            return self.getToken(SqlBaseParser.CASE, 0)
        def END(self):
            return self.getToken(SqlBaseParser.END, 0)
        def whenClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.WhenClauseContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.WhenClauseContext,i)

        def ELSE(self):
            return self.getToken(SqlBaseParser.ELSE, 0)
        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSearchedCase" ):
                listener.enterSearchedCase(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSearchedCase" ):
                listener.exitSearchedCase(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSearchedCase" ):
                return visitor.visitSearchedCase(self)
            else:
                return visitor.visitChildren(self)


    class CurrentCatalogContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.name = None # Token
            self.copyFrom(ctx)

        def CURRENT_CATALOG(self):
            return self.getToken(SqlBaseParser.CURRENT_CATALOG, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCurrentCatalog" ):
                listener.enterCurrentCatalog(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCurrentCatalog" ):
                listener.exitCurrentCatalog(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCurrentCatalog" ):
                return visitor.visitCurrentCatalog(self)
            else:
                return visitor.visitChildren(self)


    class GroupingOperationContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def GROUPING(self):
            return self.getToken(SqlBaseParser.GROUPING, 0)
        def qualifiedName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.QualifiedNameContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.QualifiedNameContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGroupingOperation" ):
                listener.enterGroupingOperation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGroupingOperation" ):
                listener.exitGroupingOperation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGroupingOperation" ):
                return visitor.visitGroupingOperation(self)
            else:
                return visitor.visitChildren(self)



    def primaryExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SqlBaseParser.PrimaryExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 118
        self.enterRecursionRule(localctx, 118, self.RULE_primaryExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2325
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,307,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.NullLiteralContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 1876
                self.match(SqlBaseParser.NULL)

            elif la_ == 2:
                localctx = SqlBaseParser.IntervalLiteralContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1877
                self.interval()

            elif la_ == 3:
                localctx = SqlBaseParser.TypeConstructorContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1878
                self.identifier()
                self.state = 1879
                self.string()

            elif la_ == 4:
                localctx = SqlBaseParser.TypeConstructorContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1881
                self.match(SqlBaseParser.DOUBLE)
                self.state = 1882
                self.match(SqlBaseParser.PRECISION)
                self.state = 1883
                self.string()

            elif la_ == 5:
                localctx = SqlBaseParser.NumericLiteralContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1884
                self.number()

            elif la_ == 6:
                localctx = SqlBaseParser.BooleanLiteralContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1885
                self.booleanValue()

            elif la_ == 7:
                localctx = SqlBaseParser.StringLiteralContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1886
                self.string()

            elif la_ == 8:
                localctx = SqlBaseParser.BinaryLiteralContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1887
                self.match(SqlBaseParser.BINARY_LITERAL)

            elif la_ == 9:
                localctx = SqlBaseParser.ParameterContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1888
                self.match(SqlBaseParser.QUESTION_MARK)

            elif la_ == 10:
                localctx = SqlBaseParser.PositionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1889
                self.match(SqlBaseParser.POSITION)
                self.state = 1890
                self.match(SqlBaseParser.T__1)
                self.state = 1891
                self.valueExpression(0)
                self.state = 1892
                self.match(SqlBaseParser.IN)
                self.state = 1893
                self.valueExpression(0)
                self.state = 1894
                self.match(SqlBaseParser.T__2)

            elif la_ == 11:
                localctx = SqlBaseParser.RowConstructorContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1896
                self.match(SqlBaseParser.T__1)
                self.state = 1897
                self.expression()
                self.state = 1900 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1898
                    self.match(SqlBaseParser.T__3)
                    self.state = 1899
                    self.expression()
                    self.state = 1902 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==SqlBaseParser.T__3):
                        break

                self.state = 1904
                self.match(SqlBaseParser.T__2)

            elif la_ == 12:
                localctx = SqlBaseParser.RowConstructorContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1906
                self.match(SqlBaseParser.ROW)
                self.state = 1907
                self.match(SqlBaseParser.T__1)
                self.state = 1908
                self.expression()
                self.state = 1913
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 1909
                    self.match(SqlBaseParser.T__3)
                    self.state = 1910
                    self.expression()
                    self.state = 1915
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1916
                self.match(SqlBaseParser.T__2)

            elif la_ == 13:
                localctx = SqlBaseParser.ListaggContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1918
                localctx.name = self.match(SqlBaseParser.LISTAGG)
                self.state = 1919
                self.match(SqlBaseParser.T__1)
                self.state = 1921
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,247,self._ctx)
                if la_ == 1:
                    self.state = 1920
                    self.setQuantifier()


                self.state = 1923
                self.expression()
                self.state = 1926
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.T__3:
                    self.state = 1924
                    self.match(SqlBaseParser.T__3)
                    self.state = 1925
                    self.string()


                self.state = 1931
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.ON:
                    self.state = 1928
                    self.match(SqlBaseParser.ON)
                    self.state = 1929
                    self.match(SqlBaseParser.OVERFLOW)
                    self.state = 1930
                    self.listAggOverflowBehavior()


                self.state = 1933
                self.match(SqlBaseParser.T__2)

                self.state = 1934
                self.match(SqlBaseParser.WITHIN)
                self.state = 1935
                self.match(SqlBaseParser.GROUP)
                self.state = 1936
                self.match(SqlBaseParser.T__1)
                self.state = 1937
                self.match(SqlBaseParser.ORDER)
                self.state = 1938
                self.match(SqlBaseParser.BY)
                self.state = 1939
                self.sortItem()
                self.state = 1944
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 1940
                    self.match(SqlBaseParser.T__3)
                    self.state = 1941
                    self.sortItem()
                    self.state = 1946
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1947
                self.match(SqlBaseParser.T__2)

            elif la_ == 14:
                localctx = SqlBaseParser.FunctionCallContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1950
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,251,self._ctx)
                if la_ == 1:
                    self.state = 1949
                    self.processingMode()


                self.state = 1952
                self.qualifiedName()
                self.state = 1953
                self.match(SqlBaseParser.T__1)
                self.state = 1957
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (SqlBaseParser.KEEP - 132)) | (1 << (SqlBaseParser.KEY - 132)) | (1 << (SqlBaseParser.KEYS - 132)) | (1 << (SqlBaseParser.LAST - 132)) | (1 << (SqlBaseParser.LATERAL - 132)) | (1 << (SqlBaseParser.LEADING - 132)) | (1 << (SqlBaseParser.LEVEL - 132)) | (1 << (SqlBaseParser.LIMIT - 132)) | (1 << (SqlBaseParser.LOCAL - 132)) | (1 << (SqlBaseParser.LOGICAL - 132)) | (1 << (SqlBaseParser.MAP - 132)) | (1 << (SqlBaseParser.MATCH - 132)) | (1 << (SqlBaseParser.MATCHED - 132)) | (1 << (SqlBaseParser.MATCHES - 132)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 132)) | (1 << (SqlBaseParser.MATERIALIZED - 132)) | (1 << (SqlBaseParser.MEASURES - 132)) | (1 << (SqlBaseParser.MERGE - 132)) | (1 << (SqlBaseParser.MINUTE - 132)) | (1 << (SqlBaseParser.MONTH - 132)) | (1 << (SqlBaseParser.NEXT - 132)) | (1 << (SqlBaseParser.NFC - 132)) | (1 << (SqlBaseParser.NFD - 132)) | (1 << (SqlBaseParser.NFKC - 132)) | (1 << (SqlBaseParser.NFKD - 132)) | (1 << (SqlBaseParser.NO - 132)) | (1 << (SqlBaseParser.NONE - 132)) | (1 << (SqlBaseParser.NULLIF - 132)) | (1 << (SqlBaseParser.NULLS - 132)) | (1 << (SqlBaseParser.OBJECT - 132)) | (1 << (SqlBaseParser.OFFSET - 132)) | (1 << (SqlBaseParser.OMIT - 132)) | (1 << (SqlBaseParser.OF - 132)) | (1 << (SqlBaseParser.ONE - 132)) | (1 << (SqlBaseParser.ONLY - 132)) | (1 << (SqlBaseParser.OPTION - 132)) | (1 << (SqlBaseParser.ORDINALITY - 132)) | (1 << (SqlBaseParser.OUTPUT - 132)) | (1 << (SqlBaseParser.OVER - 132)) | (1 << (SqlBaseParser.OVERFLOW - 132)) | (1 << (SqlBaseParser.PARTITION - 132)) | (1 << (SqlBaseParser.PARTITIONS - 132)) | (1 << (SqlBaseParser.PASSING - 132)) | (1 << (SqlBaseParser.PAST - 132)) | (1 << (SqlBaseParser.PATH - 132)) | (1 << (SqlBaseParser.PATTERN - 132)) | (1 << (SqlBaseParser.PER - 132)) | (1 << (SqlBaseParser.PERMUTE - 132)) | (1 << (SqlBaseParser.POSITION - 132)) | (1 << (SqlBaseParser.PRECEDING - 132)) | (1 << (SqlBaseParser.PRECISION - 132)))) != 0) or ((((_la - 197)) & ~0x3f) == 0 and ((1 << (_la - 197)) & ((1 << (SqlBaseParser.PRIVILEGES - 197)) | (1 << (SqlBaseParser.PROPERTIES - 197)) | (1 << (SqlBaseParser.PRUNE - 197)) | (1 << (SqlBaseParser.QUOTES - 197)) | (1 << (SqlBaseParser.RANGE - 197)) | (1 << (SqlBaseParser.READ - 197)) | (1 << (SqlBaseParser.REFRESH - 197)) | (1 << (SqlBaseParser.RENAME - 197)) | (1 << (SqlBaseParser.REPEATABLE - 197)) | (1 << (SqlBaseParser.REPLACE - 197)) | (1 << (SqlBaseParser.RESET - 197)) | (1 << (SqlBaseParser.RESPECT - 197)) | (1 << (SqlBaseParser.RESTRICT - 197)) | (1 << (SqlBaseParser.RETURNING - 197)) | (1 << (SqlBaseParser.REVOKE - 197)) | (1 << (SqlBaseParser.ROLE - 197)) | (1 << (SqlBaseParser.ROLES - 197)) | (1 << (SqlBaseParser.ROLLBACK - 197)) | (1 << (SqlBaseParser.ROW - 197)) | (1 << (SqlBaseParser.ROWS - 197)) | (1 << (SqlBaseParser.RUNNING - 197)) | (1 << (SqlBaseParser.SCALAR - 197)) | (1 << (SqlBaseParser.SCHEMA - 197)) | (1 << (SqlBaseParser.SCHEMAS - 197)) | (1 << (SqlBaseParser.SECOND - 197)) | (1 << (SqlBaseParser.SECURITY - 197)) | (1 << (SqlBaseParser.SEEK - 197)) | (1 << (SqlBaseParser.SERIALIZABLE - 197)) | (1 << (SqlBaseParser.SESSION - 197)) | (1 << (SqlBaseParser.SET - 197)) | (1 << (SqlBaseParser.SETS - 197)) | (1 << (SqlBaseParser.SHOW - 197)) | (1 << (SqlBaseParser.SOME - 197)) | (1 << (SqlBaseParser.START - 197)) | (1 << (SqlBaseParser.STATS - 197)) | (1 << (SqlBaseParser.SUBSET - 197)) | (1 << (SqlBaseParser.SUBSTRING - 197)) | (1 << (SqlBaseParser.SYSTEM - 197)) | (1 << (SqlBaseParser.TABLES - 197)) | (1 << (SqlBaseParser.TABLESAMPLE - 197)) | (1 << (SqlBaseParser.TEXT - 197)) | (1 << (SqlBaseParser.TEXT_STRING - 197)) | (1 << (SqlBaseParser.TIES - 197)) | (1 << (SqlBaseParser.TIME - 197)) | (1 << (SqlBaseParser.TIMESTAMP - 197)) | (1 << (SqlBaseParser.TO - 197)) | (1 << (SqlBaseParser.TRAILING - 197)) | (1 << (SqlBaseParser.TRANSACTION - 197)) | (1 << (SqlBaseParser.TRUNCATE - 197)) | (1 << (SqlBaseParser.TRY_CAST - 197)) | (1 << (SqlBaseParser.TYPE - 197)) | (1 << (SqlBaseParser.UNBOUNDED - 197)) | (1 << (SqlBaseParser.UNCOMMITTED - 197)) | (1 << (SqlBaseParser.UNCONDITIONAL - 197)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (SqlBaseParser.UNIQUE - 261)) | (1 << (SqlBaseParser.UNKNOWN - 261)) | (1 << (SqlBaseParser.UNMATCHED - 261)) | (1 << (SqlBaseParser.UPDATE - 261)) | (1 << (SqlBaseParser.USE - 261)) | (1 << (SqlBaseParser.USER - 261)) | (1 << (SqlBaseParser.UTF16 - 261)) | (1 << (SqlBaseParser.UTF32 - 261)) | (1 << (SqlBaseParser.UTF8 - 261)) | (1 << (SqlBaseParser.VALIDATE - 261)) | (1 << (SqlBaseParser.VALUE - 261)) | (1 << (SqlBaseParser.VERBOSE - 261)) | (1 << (SqlBaseParser.VERSION - 261)) | (1 << (SqlBaseParser.VIEW - 261)) | (1 << (SqlBaseParser.WINDOW - 261)) | (1 << (SqlBaseParser.WITHIN - 261)) | (1 << (SqlBaseParser.WITHOUT - 261)) | (1 << (SqlBaseParser.WORK - 261)) | (1 << (SqlBaseParser.WRAPPER - 261)) | (1 << (SqlBaseParser.WRITE - 261)) | (1 << (SqlBaseParser.YEAR - 261)) | (1 << (SqlBaseParser.ZONE - 261)) | (1 << (SqlBaseParser.IDENTIFIER - 261)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 261)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 261)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 261)))) != 0):
                    self.state = 1954
                    localctx.label = self.identifier()
                    self.state = 1955
                    self.match(SqlBaseParser.T__0)


                self.state = 1959
                self.match(SqlBaseParser.ASTERISK)
                self.state = 1960
                self.match(SqlBaseParser.T__2)
                self.state = 1962
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,253,self._ctx)
                if la_ == 1:
                    self.state = 1961
                    self.filter_()


                self.state = 1965
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,254,self._ctx)
                if la_ == 1:
                    self.state = 1964
                    self.over()



            elif la_ == 15:
                localctx = SqlBaseParser.FunctionCallContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1968
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,255,self._ctx)
                if la_ == 1:
                    self.state = 1967
                    self.processingMode()


                self.state = 1970
                self.qualifiedName()
                self.state = 1971
                self.match(SqlBaseParser.T__1)
                self.state = 1983
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.T__1) | (1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CASE) | (1 << SqlBaseParser.CAST) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.CURRENT_CATALOG) | (1 << SqlBaseParser.CURRENT_DATE) | (1 << SqlBaseParser.CURRENT_PATH) | (1 << SqlBaseParser.CURRENT_SCHEMA) | (1 << SqlBaseParser.CURRENT_TIME) | (1 << SqlBaseParser.CURRENT_TIMESTAMP) | (1 << SqlBaseParser.CURRENT_USER) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTINCT - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXISTS - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.EXTRACT - 64)) | (1 << (SqlBaseParser.FALSE - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPING - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)) | (1 << (SqlBaseParser.JSON_ARRAY - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SqlBaseParser.JSON_EXISTS - 128)) | (1 << (SqlBaseParser.JSON_OBJECT - 128)) | (1 << (SqlBaseParser.JSON_QUERY - 128)) | (1 << (SqlBaseParser.JSON_VALUE - 128)) | (1 << (SqlBaseParser.KEEP - 128)) | (1 << (SqlBaseParser.KEY - 128)) | (1 << (SqlBaseParser.KEYS - 128)) | (1 << (SqlBaseParser.LAST - 128)) | (1 << (SqlBaseParser.LATERAL - 128)) | (1 << (SqlBaseParser.LEADING - 128)) | (1 << (SqlBaseParser.LEVEL - 128)) | (1 << (SqlBaseParser.LIMIT - 128)) | (1 << (SqlBaseParser.LISTAGG - 128)) | (1 << (SqlBaseParser.LOCAL - 128)) | (1 << (SqlBaseParser.LOCALTIME - 128)) | (1 << (SqlBaseParser.LOCALTIMESTAMP - 128)) | (1 << (SqlBaseParser.LOGICAL - 128)) | (1 << (SqlBaseParser.MAP - 128)) | (1 << (SqlBaseParser.MATCH - 128)) | (1 << (SqlBaseParser.MATCHED - 128)) | (1 << (SqlBaseParser.MATCHES - 128)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 128)) | (1 << (SqlBaseParser.MATERIALIZED - 128)) | (1 << (SqlBaseParser.MEASURES - 128)) | (1 << (SqlBaseParser.MERGE - 128)) | (1 << (SqlBaseParser.MINUTE - 128)) | (1 << (SqlBaseParser.MONTH - 128)) | (1 << (SqlBaseParser.NEXT - 128)) | (1 << (SqlBaseParser.NFC - 128)) | (1 << (SqlBaseParser.NFD - 128)) | (1 << (SqlBaseParser.NFKC - 128)) | (1 << (SqlBaseParser.NFKD - 128)) | (1 << (SqlBaseParser.NO - 128)) | (1 << (SqlBaseParser.NONE - 128)) | (1 << (SqlBaseParser.NORMALIZE - 128)) | (1 << (SqlBaseParser.NOT - 128)) | (1 << (SqlBaseParser.NULL - 128)) | (1 << (SqlBaseParser.NULLIF - 128)) | (1 << (SqlBaseParser.NULLS - 128)) | (1 << (SqlBaseParser.OBJECT - 128)) | (1 << (SqlBaseParser.OFFSET - 128)) | (1 << (SqlBaseParser.OMIT - 128)) | (1 << (SqlBaseParser.OF - 128)) | (1 << (SqlBaseParser.ONE - 128)) | (1 << (SqlBaseParser.ONLY - 128)) | (1 << (SqlBaseParser.OPTION - 128)) | (1 << (SqlBaseParser.ORDINALITY - 128)) | (1 << (SqlBaseParser.OUTPUT - 128)) | (1 << (SqlBaseParser.OVER - 128)) | (1 << (SqlBaseParser.OVERFLOW - 128)) | (1 << (SqlBaseParser.PARTITION - 128)) | (1 << (SqlBaseParser.PARTITIONS - 128)) | (1 << (SqlBaseParser.PASSING - 128)) | (1 << (SqlBaseParser.PAST - 128)) | (1 << (SqlBaseParser.PATH - 128)) | (1 << (SqlBaseParser.PATTERN - 128)) | (1 << (SqlBaseParser.PER - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (SqlBaseParser.PERMUTE - 192)) | (1 << (SqlBaseParser.POSITION - 192)) | (1 << (SqlBaseParser.PRECEDING - 192)) | (1 << (SqlBaseParser.PRECISION - 192)) | (1 << (SqlBaseParser.PRIVILEGES - 192)) | (1 << (SqlBaseParser.PROPERTIES - 192)) | (1 << (SqlBaseParser.PRUNE - 192)) | (1 << (SqlBaseParser.QUOTES - 192)) | (1 << (SqlBaseParser.RANGE - 192)) | (1 << (SqlBaseParser.READ - 192)) | (1 << (SqlBaseParser.REFRESH - 192)) | (1 << (SqlBaseParser.RENAME - 192)) | (1 << (SqlBaseParser.REPEATABLE - 192)) | (1 << (SqlBaseParser.REPLACE - 192)) | (1 << (SqlBaseParser.RESET - 192)) | (1 << (SqlBaseParser.RESPECT - 192)) | (1 << (SqlBaseParser.RESTRICT - 192)) | (1 << (SqlBaseParser.RETURNING - 192)) | (1 << (SqlBaseParser.REVOKE - 192)) | (1 << (SqlBaseParser.ROLE - 192)) | (1 << (SqlBaseParser.ROLES - 192)) | (1 << (SqlBaseParser.ROLLBACK - 192)) | (1 << (SqlBaseParser.ROW - 192)) | (1 << (SqlBaseParser.ROWS - 192)) | (1 << (SqlBaseParser.RUNNING - 192)) | (1 << (SqlBaseParser.SCALAR - 192)) | (1 << (SqlBaseParser.SCHEMA - 192)) | (1 << (SqlBaseParser.SCHEMAS - 192)) | (1 << (SqlBaseParser.SECOND - 192)) | (1 << (SqlBaseParser.SECURITY - 192)) | (1 << (SqlBaseParser.SEEK - 192)) | (1 << (SqlBaseParser.SERIALIZABLE - 192)) | (1 << (SqlBaseParser.SESSION - 192)) | (1 << (SqlBaseParser.SET - 192)) | (1 << (SqlBaseParser.SETS - 192)) | (1 << (SqlBaseParser.SHOW - 192)) | (1 << (SqlBaseParser.SOME - 192)) | (1 << (SqlBaseParser.START - 192)) | (1 << (SqlBaseParser.STATS - 192)) | (1 << (SqlBaseParser.SUBSET - 192)) | (1 << (SqlBaseParser.SUBSTRING - 192)) | (1 << (SqlBaseParser.SYSTEM - 192)) | (1 << (SqlBaseParser.TABLES - 192)) | (1 << (SqlBaseParser.TABLESAMPLE - 192)) | (1 << (SqlBaseParser.TEXT - 192)) | (1 << (SqlBaseParser.TEXT_STRING - 192)) | (1 << (SqlBaseParser.TIES - 192)) | (1 << (SqlBaseParser.TIME - 192)) | (1 << (SqlBaseParser.TIMESTAMP - 192)) | (1 << (SqlBaseParser.TO - 192)) | (1 << (SqlBaseParser.TRAILING - 192)) | (1 << (SqlBaseParser.TRANSACTION - 192)) | (1 << (SqlBaseParser.TRIM - 192)) | (1 << (SqlBaseParser.TRUE - 192)) | (1 << (SqlBaseParser.TRUNCATE - 192)) | (1 << (SqlBaseParser.TRY_CAST - 192)) | (1 << (SqlBaseParser.TYPE - 192)))) != 0) or ((((_la - 257)) & ~0x3f) == 0 and ((1 << (_la - 257)) & ((1 << (SqlBaseParser.UNBOUNDED - 257)) | (1 << (SqlBaseParser.UNCOMMITTED - 257)) | (1 << (SqlBaseParser.UNCONDITIONAL - 257)) | (1 << (SqlBaseParser.UNIQUE - 257)) | (1 << (SqlBaseParser.UNKNOWN - 257)) | (1 << (SqlBaseParser.UNMATCHED - 257)) | (1 << (SqlBaseParser.UPDATE - 257)) | (1 << (SqlBaseParser.USE - 257)) | (1 << (SqlBaseParser.USER - 257)) | (1 << (SqlBaseParser.UTF16 - 257)) | (1 << (SqlBaseParser.UTF32 - 257)) | (1 << (SqlBaseParser.UTF8 - 257)) | (1 << (SqlBaseParser.VALIDATE - 257)) | (1 << (SqlBaseParser.VALUE - 257)) | (1 << (SqlBaseParser.VERBOSE - 257)) | (1 << (SqlBaseParser.VERSION - 257)) | (1 << (SqlBaseParser.VIEW - 257)) | (1 << (SqlBaseParser.WINDOW - 257)) | (1 << (SqlBaseParser.WITHIN - 257)) | (1 << (SqlBaseParser.WITHOUT - 257)) | (1 << (SqlBaseParser.WORK - 257)) | (1 << (SqlBaseParser.WRAPPER - 257)) | (1 << (SqlBaseParser.WRITE - 257)) | (1 << (SqlBaseParser.YEAR - 257)) | (1 << (SqlBaseParser.ZONE - 257)) | (1 << (SqlBaseParser.PLUS - 257)) | (1 << (SqlBaseParser.MINUS - 257)) | (1 << (SqlBaseParser.QUESTION_MARK - 257)) | (1 << (SqlBaseParser.STRING - 257)) | (1 << (SqlBaseParser.UNICODE_STRING - 257)) | (1 << (SqlBaseParser.BINARY_LITERAL - 257)) | (1 << (SqlBaseParser.INTEGER_VALUE - 257)) | (1 << (SqlBaseParser.DECIMAL_VALUE - 257)) | (1 << (SqlBaseParser.DOUBLE_VALUE - 257)) | (1 << (SqlBaseParser.IDENTIFIER - 257)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 257)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 257)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 257)))) != 0):
                    self.state = 1973
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,256,self._ctx)
                    if la_ == 1:
                        self.state = 1972
                        self.setQuantifier()


                    self.state = 1975
                    self.expression()
                    self.state = 1980
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 1976
                        self.match(SqlBaseParser.T__3)
                        self.state = 1977
                        self.expression()
                        self.state = 1982
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1995
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.ORDER:
                    self.state = 1985
                    self.match(SqlBaseParser.ORDER)
                    self.state = 1986
                    self.match(SqlBaseParser.BY)
                    self.state = 1987
                    self.sortItem()
                    self.state = 1992
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 1988
                        self.match(SqlBaseParser.T__3)
                        self.state = 1989
                        self.sortItem()
                        self.state = 1994
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1997
                self.match(SqlBaseParser.T__2)
                self.state = 1999
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,261,self._ctx)
                if la_ == 1:
                    self.state = 1998
                    self.filter_()


                self.state = 2005
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,263,self._ctx)
                if la_ == 1:
                    self.state = 2002
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.IGNORE or _la==SqlBaseParser.RESPECT:
                        self.state = 2001
                        self.nullTreatment()


                    self.state = 2004
                    self.over()



            elif la_ == 16:
                localctx = SqlBaseParser.MeasureContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2007
                self.identifier()
                self.state = 2008
                self.over()

            elif la_ == 17:
                localctx = SqlBaseParser.Lambda_Context(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2010
                self.identifier()
                self.state = 2011
                self.match(SqlBaseParser.T__6)
                self.state = 2012
                self.expression()

            elif la_ == 18:
                localctx = SqlBaseParser.Lambda_Context(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2014
                self.match(SqlBaseParser.T__1)
                self.state = 2023
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (SqlBaseParser.KEEP - 132)) | (1 << (SqlBaseParser.KEY - 132)) | (1 << (SqlBaseParser.KEYS - 132)) | (1 << (SqlBaseParser.LAST - 132)) | (1 << (SqlBaseParser.LATERAL - 132)) | (1 << (SqlBaseParser.LEADING - 132)) | (1 << (SqlBaseParser.LEVEL - 132)) | (1 << (SqlBaseParser.LIMIT - 132)) | (1 << (SqlBaseParser.LOCAL - 132)) | (1 << (SqlBaseParser.LOGICAL - 132)) | (1 << (SqlBaseParser.MAP - 132)) | (1 << (SqlBaseParser.MATCH - 132)) | (1 << (SqlBaseParser.MATCHED - 132)) | (1 << (SqlBaseParser.MATCHES - 132)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 132)) | (1 << (SqlBaseParser.MATERIALIZED - 132)) | (1 << (SqlBaseParser.MEASURES - 132)) | (1 << (SqlBaseParser.MERGE - 132)) | (1 << (SqlBaseParser.MINUTE - 132)) | (1 << (SqlBaseParser.MONTH - 132)) | (1 << (SqlBaseParser.NEXT - 132)) | (1 << (SqlBaseParser.NFC - 132)) | (1 << (SqlBaseParser.NFD - 132)) | (1 << (SqlBaseParser.NFKC - 132)) | (1 << (SqlBaseParser.NFKD - 132)) | (1 << (SqlBaseParser.NO - 132)) | (1 << (SqlBaseParser.NONE - 132)) | (1 << (SqlBaseParser.NULLIF - 132)) | (1 << (SqlBaseParser.NULLS - 132)) | (1 << (SqlBaseParser.OBJECT - 132)) | (1 << (SqlBaseParser.OFFSET - 132)) | (1 << (SqlBaseParser.OMIT - 132)) | (1 << (SqlBaseParser.OF - 132)) | (1 << (SqlBaseParser.ONE - 132)) | (1 << (SqlBaseParser.ONLY - 132)) | (1 << (SqlBaseParser.OPTION - 132)) | (1 << (SqlBaseParser.ORDINALITY - 132)) | (1 << (SqlBaseParser.OUTPUT - 132)) | (1 << (SqlBaseParser.OVER - 132)) | (1 << (SqlBaseParser.OVERFLOW - 132)) | (1 << (SqlBaseParser.PARTITION - 132)) | (1 << (SqlBaseParser.PARTITIONS - 132)) | (1 << (SqlBaseParser.PASSING - 132)) | (1 << (SqlBaseParser.PAST - 132)) | (1 << (SqlBaseParser.PATH - 132)) | (1 << (SqlBaseParser.PATTERN - 132)) | (1 << (SqlBaseParser.PER - 132)) | (1 << (SqlBaseParser.PERMUTE - 132)) | (1 << (SqlBaseParser.POSITION - 132)) | (1 << (SqlBaseParser.PRECEDING - 132)) | (1 << (SqlBaseParser.PRECISION - 132)))) != 0) or ((((_la - 197)) & ~0x3f) == 0 and ((1 << (_la - 197)) & ((1 << (SqlBaseParser.PRIVILEGES - 197)) | (1 << (SqlBaseParser.PROPERTIES - 197)) | (1 << (SqlBaseParser.PRUNE - 197)) | (1 << (SqlBaseParser.QUOTES - 197)) | (1 << (SqlBaseParser.RANGE - 197)) | (1 << (SqlBaseParser.READ - 197)) | (1 << (SqlBaseParser.REFRESH - 197)) | (1 << (SqlBaseParser.RENAME - 197)) | (1 << (SqlBaseParser.REPEATABLE - 197)) | (1 << (SqlBaseParser.REPLACE - 197)) | (1 << (SqlBaseParser.RESET - 197)) | (1 << (SqlBaseParser.RESPECT - 197)) | (1 << (SqlBaseParser.RESTRICT - 197)) | (1 << (SqlBaseParser.RETURNING - 197)) | (1 << (SqlBaseParser.REVOKE - 197)) | (1 << (SqlBaseParser.ROLE - 197)) | (1 << (SqlBaseParser.ROLES - 197)) | (1 << (SqlBaseParser.ROLLBACK - 197)) | (1 << (SqlBaseParser.ROW - 197)) | (1 << (SqlBaseParser.ROWS - 197)) | (1 << (SqlBaseParser.RUNNING - 197)) | (1 << (SqlBaseParser.SCALAR - 197)) | (1 << (SqlBaseParser.SCHEMA - 197)) | (1 << (SqlBaseParser.SCHEMAS - 197)) | (1 << (SqlBaseParser.SECOND - 197)) | (1 << (SqlBaseParser.SECURITY - 197)) | (1 << (SqlBaseParser.SEEK - 197)) | (1 << (SqlBaseParser.SERIALIZABLE - 197)) | (1 << (SqlBaseParser.SESSION - 197)) | (1 << (SqlBaseParser.SET - 197)) | (1 << (SqlBaseParser.SETS - 197)) | (1 << (SqlBaseParser.SHOW - 197)) | (1 << (SqlBaseParser.SOME - 197)) | (1 << (SqlBaseParser.START - 197)) | (1 << (SqlBaseParser.STATS - 197)) | (1 << (SqlBaseParser.SUBSET - 197)) | (1 << (SqlBaseParser.SUBSTRING - 197)) | (1 << (SqlBaseParser.SYSTEM - 197)) | (1 << (SqlBaseParser.TABLES - 197)) | (1 << (SqlBaseParser.TABLESAMPLE - 197)) | (1 << (SqlBaseParser.TEXT - 197)) | (1 << (SqlBaseParser.TEXT_STRING - 197)) | (1 << (SqlBaseParser.TIES - 197)) | (1 << (SqlBaseParser.TIME - 197)) | (1 << (SqlBaseParser.TIMESTAMP - 197)) | (1 << (SqlBaseParser.TO - 197)) | (1 << (SqlBaseParser.TRAILING - 197)) | (1 << (SqlBaseParser.TRANSACTION - 197)) | (1 << (SqlBaseParser.TRUNCATE - 197)) | (1 << (SqlBaseParser.TRY_CAST - 197)) | (1 << (SqlBaseParser.TYPE - 197)) | (1 << (SqlBaseParser.UNBOUNDED - 197)) | (1 << (SqlBaseParser.UNCOMMITTED - 197)) | (1 << (SqlBaseParser.UNCONDITIONAL - 197)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (SqlBaseParser.UNIQUE - 261)) | (1 << (SqlBaseParser.UNKNOWN - 261)) | (1 << (SqlBaseParser.UNMATCHED - 261)) | (1 << (SqlBaseParser.UPDATE - 261)) | (1 << (SqlBaseParser.USE - 261)) | (1 << (SqlBaseParser.USER - 261)) | (1 << (SqlBaseParser.UTF16 - 261)) | (1 << (SqlBaseParser.UTF32 - 261)) | (1 << (SqlBaseParser.UTF8 - 261)) | (1 << (SqlBaseParser.VALIDATE - 261)) | (1 << (SqlBaseParser.VALUE - 261)) | (1 << (SqlBaseParser.VERBOSE - 261)) | (1 << (SqlBaseParser.VERSION - 261)) | (1 << (SqlBaseParser.VIEW - 261)) | (1 << (SqlBaseParser.WINDOW - 261)) | (1 << (SqlBaseParser.WITHIN - 261)) | (1 << (SqlBaseParser.WITHOUT - 261)) | (1 << (SqlBaseParser.WORK - 261)) | (1 << (SqlBaseParser.WRAPPER - 261)) | (1 << (SqlBaseParser.WRITE - 261)) | (1 << (SqlBaseParser.YEAR - 261)) | (1 << (SqlBaseParser.ZONE - 261)) | (1 << (SqlBaseParser.IDENTIFIER - 261)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 261)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 261)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 261)))) != 0):
                    self.state = 2015
                    self.identifier()
                    self.state = 2020
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 2016
                        self.match(SqlBaseParser.T__3)
                        self.state = 2017
                        self.identifier()
                        self.state = 2022
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 2025
                self.match(SqlBaseParser.T__2)
                self.state = 2026
                self.match(SqlBaseParser.T__6)
                self.state = 2027
                self.expression()

            elif la_ == 19:
                localctx = SqlBaseParser.SubqueryExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2028
                self.match(SqlBaseParser.T__1)
                self.state = 2029
                self.query()
                self.state = 2030
                self.match(SqlBaseParser.T__2)

            elif la_ == 20:
                localctx = SqlBaseParser.ExistsContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2032
                self.match(SqlBaseParser.EXISTS)
                self.state = 2033
                self.match(SqlBaseParser.T__1)
                self.state = 2034
                self.query()
                self.state = 2035
                self.match(SqlBaseParser.T__2)

            elif la_ == 21:
                localctx = SqlBaseParser.SimpleCaseContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2037
                self.match(SqlBaseParser.CASE)
                self.state = 2038
                localctx.operand = self.expression()
                self.state = 2040 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 2039
                    self.whenClause()
                    self.state = 2042 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==SqlBaseParser.WHEN):
                        break

                self.state = 2046
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.ELSE:
                    self.state = 2044
                    self.match(SqlBaseParser.ELSE)
                    self.state = 2045
                    localctx.elseExpression = self.expression()


                self.state = 2048
                self.match(SqlBaseParser.END)

            elif la_ == 22:
                localctx = SqlBaseParser.SearchedCaseContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2050
                self.match(SqlBaseParser.CASE)
                self.state = 2052 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 2051
                    self.whenClause()
                    self.state = 2054 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==SqlBaseParser.WHEN):
                        break

                self.state = 2058
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.ELSE:
                    self.state = 2056
                    self.match(SqlBaseParser.ELSE)
                    self.state = 2057
                    localctx.elseExpression = self.expression()


                self.state = 2060
                self.match(SqlBaseParser.END)

            elif la_ == 23:
                localctx = SqlBaseParser.CastContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2062
                self.match(SqlBaseParser.CAST)
                self.state = 2063
                self.match(SqlBaseParser.T__1)
                self.state = 2064
                self.expression()
                self.state = 2065
                self.match(SqlBaseParser.AS)
                self.state = 2066
                self.type_(0)
                self.state = 2067
                self.match(SqlBaseParser.T__2)

            elif la_ == 24:
                localctx = SqlBaseParser.CastContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2069
                self.match(SqlBaseParser.TRY_CAST)
                self.state = 2070
                self.match(SqlBaseParser.T__1)
                self.state = 2071
                self.expression()
                self.state = 2072
                self.match(SqlBaseParser.AS)
                self.state = 2073
                self.type_(0)
                self.state = 2074
                self.match(SqlBaseParser.T__2)

            elif la_ == 25:
                localctx = SqlBaseParser.ArrayConstructorContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2076
                self.match(SqlBaseParser.ARRAY)
                self.state = 2077
                self.match(SqlBaseParser.T__7)
                self.state = 2086
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.T__1) | (1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CASE) | (1 << SqlBaseParser.CAST) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.CURRENT_CATALOG) | (1 << SqlBaseParser.CURRENT_DATE) | (1 << SqlBaseParser.CURRENT_PATH) | (1 << SqlBaseParser.CURRENT_SCHEMA) | (1 << SqlBaseParser.CURRENT_TIME) | (1 << SqlBaseParser.CURRENT_TIMESTAMP) | (1 << SqlBaseParser.CURRENT_USER) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXISTS - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.EXTRACT - 64)) | (1 << (SqlBaseParser.FALSE - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPING - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)) | (1 << (SqlBaseParser.JSON_ARRAY - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SqlBaseParser.JSON_EXISTS - 128)) | (1 << (SqlBaseParser.JSON_OBJECT - 128)) | (1 << (SqlBaseParser.JSON_QUERY - 128)) | (1 << (SqlBaseParser.JSON_VALUE - 128)) | (1 << (SqlBaseParser.KEEP - 128)) | (1 << (SqlBaseParser.KEY - 128)) | (1 << (SqlBaseParser.KEYS - 128)) | (1 << (SqlBaseParser.LAST - 128)) | (1 << (SqlBaseParser.LATERAL - 128)) | (1 << (SqlBaseParser.LEADING - 128)) | (1 << (SqlBaseParser.LEVEL - 128)) | (1 << (SqlBaseParser.LIMIT - 128)) | (1 << (SqlBaseParser.LISTAGG - 128)) | (1 << (SqlBaseParser.LOCAL - 128)) | (1 << (SqlBaseParser.LOCALTIME - 128)) | (1 << (SqlBaseParser.LOCALTIMESTAMP - 128)) | (1 << (SqlBaseParser.LOGICAL - 128)) | (1 << (SqlBaseParser.MAP - 128)) | (1 << (SqlBaseParser.MATCH - 128)) | (1 << (SqlBaseParser.MATCHED - 128)) | (1 << (SqlBaseParser.MATCHES - 128)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 128)) | (1 << (SqlBaseParser.MATERIALIZED - 128)) | (1 << (SqlBaseParser.MEASURES - 128)) | (1 << (SqlBaseParser.MERGE - 128)) | (1 << (SqlBaseParser.MINUTE - 128)) | (1 << (SqlBaseParser.MONTH - 128)) | (1 << (SqlBaseParser.NEXT - 128)) | (1 << (SqlBaseParser.NFC - 128)) | (1 << (SqlBaseParser.NFD - 128)) | (1 << (SqlBaseParser.NFKC - 128)) | (1 << (SqlBaseParser.NFKD - 128)) | (1 << (SqlBaseParser.NO - 128)) | (1 << (SqlBaseParser.NONE - 128)) | (1 << (SqlBaseParser.NORMALIZE - 128)) | (1 << (SqlBaseParser.NOT - 128)) | (1 << (SqlBaseParser.NULL - 128)) | (1 << (SqlBaseParser.NULLIF - 128)) | (1 << (SqlBaseParser.NULLS - 128)) | (1 << (SqlBaseParser.OBJECT - 128)) | (1 << (SqlBaseParser.OFFSET - 128)) | (1 << (SqlBaseParser.OMIT - 128)) | (1 << (SqlBaseParser.OF - 128)) | (1 << (SqlBaseParser.ONE - 128)) | (1 << (SqlBaseParser.ONLY - 128)) | (1 << (SqlBaseParser.OPTION - 128)) | (1 << (SqlBaseParser.ORDINALITY - 128)) | (1 << (SqlBaseParser.OUTPUT - 128)) | (1 << (SqlBaseParser.OVER - 128)) | (1 << (SqlBaseParser.OVERFLOW - 128)) | (1 << (SqlBaseParser.PARTITION - 128)) | (1 << (SqlBaseParser.PARTITIONS - 128)) | (1 << (SqlBaseParser.PASSING - 128)) | (1 << (SqlBaseParser.PAST - 128)) | (1 << (SqlBaseParser.PATH - 128)) | (1 << (SqlBaseParser.PATTERN - 128)) | (1 << (SqlBaseParser.PER - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (SqlBaseParser.PERMUTE - 192)) | (1 << (SqlBaseParser.POSITION - 192)) | (1 << (SqlBaseParser.PRECEDING - 192)) | (1 << (SqlBaseParser.PRECISION - 192)) | (1 << (SqlBaseParser.PRIVILEGES - 192)) | (1 << (SqlBaseParser.PROPERTIES - 192)) | (1 << (SqlBaseParser.PRUNE - 192)) | (1 << (SqlBaseParser.QUOTES - 192)) | (1 << (SqlBaseParser.RANGE - 192)) | (1 << (SqlBaseParser.READ - 192)) | (1 << (SqlBaseParser.REFRESH - 192)) | (1 << (SqlBaseParser.RENAME - 192)) | (1 << (SqlBaseParser.REPEATABLE - 192)) | (1 << (SqlBaseParser.REPLACE - 192)) | (1 << (SqlBaseParser.RESET - 192)) | (1 << (SqlBaseParser.RESPECT - 192)) | (1 << (SqlBaseParser.RESTRICT - 192)) | (1 << (SqlBaseParser.RETURNING - 192)) | (1 << (SqlBaseParser.REVOKE - 192)) | (1 << (SqlBaseParser.ROLE - 192)) | (1 << (SqlBaseParser.ROLES - 192)) | (1 << (SqlBaseParser.ROLLBACK - 192)) | (1 << (SqlBaseParser.ROW - 192)) | (1 << (SqlBaseParser.ROWS - 192)) | (1 << (SqlBaseParser.RUNNING - 192)) | (1 << (SqlBaseParser.SCALAR - 192)) | (1 << (SqlBaseParser.SCHEMA - 192)) | (1 << (SqlBaseParser.SCHEMAS - 192)) | (1 << (SqlBaseParser.SECOND - 192)) | (1 << (SqlBaseParser.SECURITY - 192)) | (1 << (SqlBaseParser.SEEK - 192)) | (1 << (SqlBaseParser.SERIALIZABLE - 192)) | (1 << (SqlBaseParser.SESSION - 192)) | (1 << (SqlBaseParser.SET - 192)) | (1 << (SqlBaseParser.SETS - 192)) | (1 << (SqlBaseParser.SHOW - 192)) | (1 << (SqlBaseParser.SOME - 192)) | (1 << (SqlBaseParser.START - 192)) | (1 << (SqlBaseParser.STATS - 192)) | (1 << (SqlBaseParser.SUBSET - 192)) | (1 << (SqlBaseParser.SUBSTRING - 192)) | (1 << (SqlBaseParser.SYSTEM - 192)) | (1 << (SqlBaseParser.TABLES - 192)) | (1 << (SqlBaseParser.TABLESAMPLE - 192)) | (1 << (SqlBaseParser.TEXT - 192)) | (1 << (SqlBaseParser.TEXT_STRING - 192)) | (1 << (SqlBaseParser.TIES - 192)) | (1 << (SqlBaseParser.TIME - 192)) | (1 << (SqlBaseParser.TIMESTAMP - 192)) | (1 << (SqlBaseParser.TO - 192)) | (1 << (SqlBaseParser.TRAILING - 192)) | (1 << (SqlBaseParser.TRANSACTION - 192)) | (1 << (SqlBaseParser.TRIM - 192)) | (1 << (SqlBaseParser.TRUE - 192)) | (1 << (SqlBaseParser.TRUNCATE - 192)) | (1 << (SqlBaseParser.TRY_CAST - 192)) | (1 << (SqlBaseParser.TYPE - 192)))) != 0) or ((((_la - 257)) & ~0x3f) == 0 and ((1 << (_la - 257)) & ((1 << (SqlBaseParser.UNBOUNDED - 257)) | (1 << (SqlBaseParser.UNCOMMITTED - 257)) | (1 << (SqlBaseParser.UNCONDITIONAL - 257)) | (1 << (SqlBaseParser.UNIQUE - 257)) | (1 << (SqlBaseParser.UNKNOWN - 257)) | (1 << (SqlBaseParser.UNMATCHED - 257)) | (1 << (SqlBaseParser.UPDATE - 257)) | (1 << (SqlBaseParser.USE - 257)) | (1 << (SqlBaseParser.USER - 257)) | (1 << (SqlBaseParser.UTF16 - 257)) | (1 << (SqlBaseParser.UTF32 - 257)) | (1 << (SqlBaseParser.UTF8 - 257)) | (1 << (SqlBaseParser.VALIDATE - 257)) | (1 << (SqlBaseParser.VALUE - 257)) | (1 << (SqlBaseParser.VERBOSE - 257)) | (1 << (SqlBaseParser.VERSION - 257)) | (1 << (SqlBaseParser.VIEW - 257)) | (1 << (SqlBaseParser.WINDOW - 257)) | (1 << (SqlBaseParser.WITHIN - 257)) | (1 << (SqlBaseParser.WITHOUT - 257)) | (1 << (SqlBaseParser.WORK - 257)) | (1 << (SqlBaseParser.WRAPPER - 257)) | (1 << (SqlBaseParser.WRITE - 257)) | (1 << (SqlBaseParser.YEAR - 257)) | (1 << (SqlBaseParser.ZONE - 257)) | (1 << (SqlBaseParser.PLUS - 257)) | (1 << (SqlBaseParser.MINUS - 257)) | (1 << (SqlBaseParser.QUESTION_MARK - 257)) | (1 << (SqlBaseParser.STRING - 257)) | (1 << (SqlBaseParser.UNICODE_STRING - 257)) | (1 << (SqlBaseParser.BINARY_LITERAL - 257)) | (1 << (SqlBaseParser.INTEGER_VALUE - 257)) | (1 << (SqlBaseParser.DECIMAL_VALUE - 257)) | (1 << (SqlBaseParser.DOUBLE_VALUE - 257)) | (1 << (SqlBaseParser.IDENTIFIER - 257)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 257)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 257)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 257)))) != 0):
                    self.state = 2078
                    self.expression()
                    self.state = 2083
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 2079
                        self.match(SqlBaseParser.T__3)
                        self.state = 2080
                        self.expression()
                        self.state = 2085
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 2088
                self.match(SqlBaseParser.T__8)

            elif la_ == 26:
                localctx = SqlBaseParser.ColumnReferenceContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2089
                self.identifier()

            elif la_ == 27:
                localctx = SqlBaseParser.SpecialDateTimeFunctionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2090
                localctx.name = self.match(SqlBaseParser.CURRENT_DATE)

            elif la_ == 28:
                localctx = SqlBaseParser.SpecialDateTimeFunctionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2091
                localctx.name = self.match(SqlBaseParser.CURRENT_TIME)
                self.state = 2095
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,272,self._ctx)
                if la_ == 1:
                    self.state = 2092
                    self.match(SqlBaseParser.T__1)
                    self.state = 2093
                    localctx.precision = self.match(SqlBaseParser.INTEGER_VALUE)
                    self.state = 2094
                    self.match(SqlBaseParser.T__2)



            elif la_ == 29:
                localctx = SqlBaseParser.SpecialDateTimeFunctionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2097
                localctx.name = self.match(SqlBaseParser.CURRENT_TIMESTAMP)
                self.state = 2101
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,273,self._ctx)
                if la_ == 1:
                    self.state = 2098
                    self.match(SqlBaseParser.T__1)
                    self.state = 2099
                    localctx.precision = self.match(SqlBaseParser.INTEGER_VALUE)
                    self.state = 2100
                    self.match(SqlBaseParser.T__2)



            elif la_ == 30:
                localctx = SqlBaseParser.SpecialDateTimeFunctionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2103
                localctx.name = self.match(SqlBaseParser.LOCALTIME)
                self.state = 2107
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,274,self._ctx)
                if la_ == 1:
                    self.state = 2104
                    self.match(SqlBaseParser.T__1)
                    self.state = 2105
                    localctx.precision = self.match(SqlBaseParser.INTEGER_VALUE)
                    self.state = 2106
                    self.match(SqlBaseParser.T__2)



            elif la_ == 31:
                localctx = SqlBaseParser.SpecialDateTimeFunctionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2109
                localctx.name = self.match(SqlBaseParser.LOCALTIMESTAMP)
                self.state = 2113
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,275,self._ctx)
                if la_ == 1:
                    self.state = 2110
                    self.match(SqlBaseParser.T__1)
                    self.state = 2111
                    localctx.precision = self.match(SqlBaseParser.INTEGER_VALUE)
                    self.state = 2112
                    self.match(SqlBaseParser.T__2)



            elif la_ == 32:
                localctx = SqlBaseParser.CurrentUserContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2115
                localctx.name = self.match(SqlBaseParser.CURRENT_USER)

            elif la_ == 33:
                localctx = SqlBaseParser.CurrentCatalogContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2116
                localctx.name = self.match(SqlBaseParser.CURRENT_CATALOG)

            elif la_ == 34:
                localctx = SqlBaseParser.CurrentSchemaContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2117
                localctx.name = self.match(SqlBaseParser.CURRENT_SCHEMA)

            elif la_ == 35:
                localctx = SqlBaseParser.CurrentPathContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2118
                localctx.name = self.match(SqlBaseParser.CURRENT_PATH)

            elif la_ == 36:
                localctx = SqlBaseParser.TrimContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2119
                self.match(SqlBaseParser.TRIM)
                self.state = 2120
                self.match(SqlBaseParser.T__1)
                self.state = 2128
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,278,self._ctx)
                if la_ == 1:
                    self.state = 2122
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,276,self._ctx)
                    if la_ == 1:
                        self.state = 2121
                        self.trimsSpecification()


                    self.state = 2125
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.T__1) | (1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CASE) | (1 << SqlBaseParser.CAST) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.CURRENT_CATALOG) | (1 << SqlBaseParser.CURRENT_DATE) | (1 << SqlBaseParser.CURRENT_PATH) | (1 << SqlBaseParser.CURRENT_SCHEMA) | (1 << SqlBaseParser.CURRENT_TIME) | (1 << SqlBaseParser.CURRENT_TIMESTAMP) | (1 << SqlBaseParser.CURRENT_USER) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXISTS - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.EXTRACT - 64)) | (1 << (SqlBaseParser.FALSE - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPING - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)) | (1 << (SqlBaseParser.JSON_ARRAY - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SqlBaseParser.JSON_EXISTS - 128)) | (1 << (SqlBaseParser.JSON_OBJECT - 128)) | (1 << (SqlBaseParser.JSON_QUERY - 128)) | (1 << (SqlBaseParser.JSON_VALUE - 128)) | (1 << (SqlBaseParser.KEEP - 128)) | (1 << (SqlBaseParser.KEY - 128)) | (1 << (SqlBaseParser.KEYS - 128)) | (1 << (SqlBaseParser.LAST - 128)) | (1 << (SqlBaseParser.LATERAL - 128)) | (1 << (SqlBaseParser.LEADING - 128)) | (1 << (SqlBaseParser.LEVEL - 128)) | (1 << (SqlBaseParser.LIMIT - 128)) | (1 << (SqlBaseParser.LISTAGG - 128)) | (1 << (SqlBaseParser.LOCAL - 128)) | (1 << (SqlBaseParser.LOCALTIME - 128)) | (1 << (SqlBaseParser.LOCALTIMESTAMP - 128)) | (1 << (SqlBaseParser.LOGICAL - 128)) | (1 << (SqlBaseParser.MAP - 128)) | (1 << (SqlBaseParser.MATCH - 128)) | (1 << (SqlBaseParser.MATCHED - 128)) | (1 << (SqlBaseParser.MATCHES - 128)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 128)) | (1 << (SqlBaseParser.MATERIALIZED - 128)) | (1 << (SqlBaseParser.MEASURES - 128)) | (1 << (SqlBaseParser.MERGE - 128)) | (1 << (SqlBaseParser.MINUTE - 128)) | (1 << (SqlBaseParser.MONTH - 128)) | (1 << (SqlBaseParser.NEXT - 128)) | (1 << (SqlBaseParser.NFC - 128)) | (1 << (SqlBaseParser.NFD - 128)) | (1 << (SqlBaseParser.NFKC - 128)) | (1 << (SqlBaseParser.NFKD - 128)) | (1 << (SqlBaseParser.NO - 128)) | (1 << (SqlBaseParser.NONE - 128)) | (1 << (SqlBaseParser.NORMALIZE - 128)) | (1 << (SqlBaseParser.NULL - 128)) | (1 << (SqlBaseParser.NULLIF - 128)) | (1 << (SqlBaseParser.NULLS - 128)) | (1 << (SqlBaseParser.OBJECT - 128)) | (1 << (SqlBaseParser.OFFSET - 128)) | (1 << (SqlBaseParser.OMIT - 128)) | (1 << (SqlBaseParser.OF - 128)) | (1 << (SqlBaseParser.ONE - 128)) | (1 << (SqlBaseParser.ONLY - 128)) | (1 << (SqlBaseParser.OPTION - 128)) | (1 << (SqlBaseParser.ORDINALITY - 128)) | (1 << (SqlBaseParser.OUTPUT - 128)) | (1 << (SqlBaseParser.OVER - 128)) | (1 << (SqlBaseParser.OVERFLOW - 128)) | (1 << (SqlBaseParser.PARTITION - 128)) | (1 << (SqlBaseParser.PARTITIONS - 128)) | (1 << (SqlBaseParser.PASSING - 128)) | (1 << (SqlBaseParser.PAST - 128)) | (1 << (SqlBaseParser.PATH - 128)) | (1 << (SqlBaseParser.PATTERN - 128)) | (1 << (SqlBaseParser.PER - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (SqlBaseParser.PERMUTE - 192)) | (1 << (SqlBaseParser.POSITION - 192)) | (1 << (SqlBaseParser.PRECEDING - 192)) | (1 << (SqlBaseParser.PRECISION - 192)) | (1 << (SqlBaseParser.PRIVILEGES - 192)) | (1 << (SqlBaseParser.PROPERTIES - 192)) | (1 << (SqlBaseParser.PRUNE - 192)) | (1 << (SqlBaseParser.QUOTES - 192)) | (1 << (SqlBaseParser.RANGE - 192)) | (1 << (SqlBaseParser.READ - 192)) | (1 << (SqlBaseParser.REFRESH - 192)) | (1 << (SqlBaseParser.RENAME - 192)) | (1 << (SqlBaseParser.REPEATABLE - 192)) | (1 << (SqlBaseParser.REPLACE - 192)) | (1 << (SqlBaseParser.RESET - 192)) | (1 << (SqlBaseParser.RESPECT - 192)) | (1 << (SqlBaseParser.RESTRICT - 192)) | (1 << (SqlBaseParser.RETURNING - 192)) | (1 << (SqlBaseParser.REVOKE - 192)) | (1 << (SqlBaseParser.ROLE - 192)) | (1 << (SqlBaseParser.ROLES - 192)) | (1 << (SqlBaseParser.ROLLBACK - 192)) | (1 << (SqlBaseParser.ROW - 192)) | (1 << (SqlBaseParser.ROWS - 192)) | (1 << (SqlBaseParser.RUNNING - 192)) | (1 << (SqlBaseParser.SCALAR - 192)) | (1 << (SqlBaseParser.SCHEMA - 192)) | (1 << (SqlBaseParser.SCHEMAS - 192)) | (1 << (SqlBaseParser.SECOND - 192)) | (1 << (SqlBaseParser.SECURITY - 192)) | (1 << (SqlBaseParser.SEEK - 192)) | (1 << (SqlBaseParser.SERIALIZABLE - 192)) | (1 << (SqlBaseParser.SESSION - 192)) | (1 << (SqlBaseParser.SET - 192)) | (1 << (SqlBaseParser.SETS - 192)) | (1 << (SqlBaseParser.SHOW - 192)) | (1 << (SqlBaseParser.SOME - 192)) | (1 << (SqlBaseParser.START - 192)) | (1 << (SqlBaseParser.STATS - 192)) | (1 << (SqlBaseParser.SUBSET - 192)) | (1 << (SqlBaseParser.SUBSTRING - 192)) | (1 << (SqlBaseParser.SYSTEM - 192)) | (1 << (SqlBaseParser.TABLES - 192)) | (1 << (SqlBaseParser.TABLESAMPLE - 192)) | (1 << (SqlBaseParser.TEXT - 192)) | (1 << (SqlBaseParser.TEXT_STRING - 192)) | (1 << (SqlBaseParser.TIES - 192)) | (1 << (SqlBaseParser.TIME - 192)) | (1 << (SqlBaseParser.TIMESTAMP - 192)) | (1 << (SqlBaseParser.TO - 192)) | (1 << (SqlBaseParser.TRAILING - 192)) | (1 << (SqlBaseParser.TRANSACTION - 192)) | (1 << (SqlBaseParser.TRIM - 192)) | (1 << (SqlBaseParser.TRUE - 192)) | (1 << (SqlBaseParser.TRUNCATE - 192)) | (1 << (SqlBaseParser.TRY_CAST - 192)) | (1 << (SqlBaseParser.TYPE - 192)))) != 0) or ((((_la - 257)) & ~0x3f) == 0 and ((1 << (_la - 257)) & ((1 << (SqlBaseParser.UNBOUNDED - 257)) | (1 << (SqlBaseParser.UNCOMMITTED - 257)) | (1 << (SqlBaseParser.UNCONDITIONAL - 257)) | (1 << (SqlBaseParser.UNIQUE - 257)) | (1 << (SqlBaseParser.UNKNOWN - 257)) | (1 << (SqlBaseParser.UNMATCHED - 257)) | (1 << (SqlBaseParser.UPDATE - 257)) | (1 << (SqlBaseParser.USE - 257)) | (1 << (SqlBaseParser.USER - 257)) | (1 << (SqlBaseParser.UTF16 - 257)) | (1 << (SqlBaseParser.UTF32 - 257)) | (1 << (SqlBaseParser.UTF8 - 257)) | (1 << (SqlBaseParser.VALIDATE - 257)) | (1 << (SqlBaseParser.VALUE - 257)) | (1 << (SqlBaseParser.VERBOSE - 257)) | (1 << (SqlBaseParser.VERSION - 257)) | (1 << (SqlBaseParser.VIEW - 257)) | (1 << (SqlBaseParser.WINDOW - 257)) | (1 << (SqlBaseParser.WITHIN - 257)) | (1 << (SqlBaseParser.WITHOUT - 257)) | (1 << (SqlBaseParser.WORK - 257)) | (1 << (SqlBaseParser.WRAPPER - 257)) | (1 << (SqlBaseParser.WRITE - 257)) | (1 << (SqlBaseParser.YEAR - 257)) | (1 << (SqlBaseParser.ZONE - 257)) | (1 << (SqlBaseParser.PLUS - 257)) | (1 << (SqlBaseParser.MINUS - 257)) | (1 << (SqlBaseParser.QUESTION_MARK - 257)) | (1 << (SqlBaseParser.STRING - 257)) | (1 << (SqlBaseParser.UNICODE_STRING - 257)) | (1 << (SqlBaseParser.BINARY_LITERAL - 257)) | (1 << (SqlBaseParser.INTEGER_VALUE - 257)) | (1 << (SqlBaseParser.DECIMAL_VALUE - 257)) | (1 << (SqlBaseParser.DOUBLE_VALUE - 257)) | (1 << (SqlBaseParser.IDENTIFIER - 257)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 257)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 257)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 257)))) != 0):
                        self.state = 2124
                        localctx.trimChar = self.valueExpression(0)


                    self.state = 2127
                    self.match(SqlBaseParser.FROM)


                self.state = 2130
                localctx.trimSource = self.valueExpression(0)
                self.state = 2131
                self.match(SqlBaseParser.T__2)

            elif la_ == 37:
                localctx = SqlBaseParser.TrimContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2133
                self.match(SqlBaseParser.TRIM)
                self.state = 2134
                self.match(SqlBaseParser.T__1)
                self.state = 2135
                localctx.trimSource = self.valueExpression(0)
                self.state = 2136
                self.match(SqlBaseParser.T__3)
                self.state = 2137
                localctx.trimChar = self.valueExpression(0)
                self.state = 2138
                self.match(SqlBaseParser.T__2)

            elif la_ == 38:
                localctx = SqlBaseParser.SubstringContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2140
                self.match(SqlBaseParser.SUBSTRING)
                self.state = 2141
                self.match(SqlBaseParser.T__1)
                self.state = 2142
                self.valueExpression(0)
                self.state = 2143
                self.match(SqlBaseParser.FROM)
                self.state = 2144
                self.valueExpression(0)
                self.state = 2147
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.FOR:
                    self.state = 2145
                    self.match(SqlBaseParser.FOR)
                    self.state = 2146
                    self.valueExpression(0)


                self.state = 2149
                self.match(SqlBaseParser.T__2)

            elif la_ == 39:
                localctx = SqlBaseParser.NormalizeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2151
                self.match(SqlBaseParser.NORMALIZE)
                self.state = 2152
                self.match(SqlBaseParser.T__1)
                self.state = 2153
                self.valueExpression(0)
                self.state = 2156
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.T__3:
                    self.state = 2154
                    self.match(SqlBaseParser.T__3)
                    self.state = 2155
                    self.normalForm()


                self.state = 2158
                self.match(SqlBaseParser.T__2)

            elif la_ == 40:
                localctx = SqlBaseParser.ExtractContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2160
                self.match(SqlBaseParser.EXTRACT)
                self.state = 2161
                self.match(SqlBaseParser.T__1)
                self.state = 2162
                self.identifier()
                self.state = 2163
                self.match(SqlBaseParser.FROM)
                self.state = 2164
                self.valueExpression(0)
                self.state = 2165
                self.match(SqlBaseParser.T__2)

            elif la_ == 41:
                localctx = SqlBaseParser.ParenthesizedExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2167
                self.match(SqlBaseParser.T__1)
                self.state = 2168
                self.expression()
                self.state = 2169
                self.match(SqlBaseParser.T__2)

            elif la_ == 42:
                localctx = SqlBaseParser.GroupingOperationContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2171
                self.match(SqlBaseParser.GROUPING)
                self.state = 2172
                self.match(SqlBaseParser.T__1)
                self.state = 2181
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (SqlBaseParser.KEEP - 132)) | (1 << (SqlBaseParser.KEY - 132)) | (1 << (SqlBaseParser.KEYS - 132)) | (1 << (SqlBaseParser.LAST - 132)) | (1 << (SqlBaseParser.LATERAL - 132)) | (1 << (SqlBaseParser.LEADING - 132)) | (1 << (SqlBaseParser.LEVEL - 132)) | (1 << (SqlBaseParser.LIMIT - 132)) | (1 << (SqlBaseParser.LOCAL - 132)) | (1 << (SqlBaseParser.LOGICAL - 132)) | (1 << (SqlBaseParser.MAP - 132)) | (1 << (SqlBaseParser.MATCH - 132)) | (1 << (SqlBaseParser.MATCHED - 132)) | (1 << (SqlBaseParser.MATCHES - 132)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 132)) | (1 << (SqlBaseParser.MATERIALIZED - 132)) | (1 << (SqlBaseParser.MEASURES - 132)) | (1 << (SqlBaseParser.MERGE - 132)) | (1 << (SqlBaseParser.MINUTE - 132)) | (1 << (SqlBaseParser.MONTH - 132)) | (1 << (SqlBaseParser.NEXT - 132)) | (1 << (SqlBaseParser.NFC - 132)) | (1 << (SqlBaseParser.NFD - 132)) | (1 << (SqlBaseParser.NFKC - 132)) | (1 << (SqlBaseParser.NFKD - 132)) | (1 << (SqlBaseParser.NO - 132)) | (1 << (SqlBaseParser.NONE - 132)) | (1 << (SqlBaseParser.NULLIF - 132)) | (1 << (SqlBaseParser.NULLS - 132)) | (1 << (SqlBaseParser.OBJECT - 132)) | (1 << (SqlBaseParser.OFFSET - 132)) | (1 << (SqlBaseParser.OMIT - 132)) | (1 << (SqlBaseParser.OF - 132)) | (1 << (SqlBaseParser.ONE - 132)) | (1 << (SqlBaseParser.ONLY - 132)) | (1 << (SqlBaseParser.OPTION - 132)) | (1 << (SqlBaseParser.ORDINALITY - 132)) | (1 << (SqlBaseParser.OUTPUT - 132)) | (1 << (SqlBaseParser.OVER - 132)) | (1 << (SqlBaseParser.OVERFLOW - 132)) | (1 << (SqlBaseParser.PARTITION - 132)) | (1 << (SqlBaseParser.PARTITIONS - 132)) | (1 << (SqlBaseParser.PASSING - 132)) | (1 << (SqlBaseParser.PAST - 132)) | (1 << (SqlBaseParser.PATH - 132)) | (1 << (SqlBaseParser.PATTERN - 132)) | (1 << (SqlBaseParser.PER - 132)) | (1 << (SqlBaseParser.PERMUTE - 132)) | (1 << (SqlBaseParser.POSITION - 132)) | (1 << (SqlBaseParser.PRECEDING - 132)) | (1 << (SqlBaseParser.PRECISION - 132)))) != 0) or ((((_la - 197)) & ~0x3f) == 0 and ((1 << (_la - 197)) & ((1 << (SqlBaseParser.PRIVILEGES - 197)) | (1 << (SqlBaseParser.PROPERTIES - 197)) | (1 << (SqlBaseParser.PRUNE - 197)) | (1 << (SqlBaseParser.QUOTES - 197)) | (1 << (SqlBaseParser.RANGE - 197)) | (1 << (SqlBaseParser.READ - 197)) | (1 << (SqlBaseParser.REFRESH - 197)) | (1 << (SqlBaseParser.RENAME - 197)) | (1 << (SqlBaseParser.REPEATABLE - 197)) | (1 << (SqlBaseParser.REPLACE - 197)) | (1 << (SqlBaseParser.RESET - 197)) | (1 << (SqlBaseParser.RESPECT - 197)) | (1 << (SqlBaseParser.RESTRICT - 197)) | (1 << (SqlBaseParser.RETURNING - 197)) | (1 << (SqlBaseParser.REVOKE - 197)) | (1 << (SqlBaseParser.ROLE - 197)) | (1 << (SqlBaseParser.ROLES - 197)) | (1 << (SqlBaseParser.ROLLBACK - 197)) | (1 << (SqlBaseParser.ROW - 197)) | (1 << (SqlBaseParser.ROWS - 197)) | (1 << (SqlBaseParser.RUNNING - 197)) | (1 << (SqlBaseParser.SCALAR - 197)) | (1 << (SqlBaseParser.SCHEMA - 197)) | (1 << (SqlBaseParser.SCHEMAS - 197)) | (1 << (SqlBaseParser.SECOND - 197)) | (1 << (SqlBaseParser.SECURITY - 197)) | (1 << (SqlBaseParser.SEEK - 197)) | (1 << (SqlBaseParser.SERIALIZABLE - 197)) | (1 << (SqlBaseParser.SESSION - 197)) | (1 << (SqlBaseParser.SET - 197)) | (1 << (SqlBaseParser.SETS - 197)) | (1 << (SqlBaseParser.SHOW - 197)) | (1 << (SqlBaseParser.SOME - 197)) | (1 << (SqlBaseParser.START - 197)) | (1 << (SqlBaseParser.STATS - 197)) | (1 << (SqlBaseParser.SUBSET - 197)) | (1 << (SqlBaseParser.SUBSTRING - 197)) | (1 << (SqlBaseParser.SYSTEM - 197)) | (1 << (SqlBaseParser.TABLES - 197)) | (1 << (SqlBaseParser.TABLESAMPLE - 197)) | (1 << (SqlBaseParser.TEXT - 197)) | (1 << (SqlBaseParser.TEXT_STRING - 197)) | (1 << (SqlBaseParser.TIES - 197)) | (1 << (SqlBaseParser.TIME - 197)) | (1 << (SqlBaseParser.TIMESTAMP - 197)) | (1 << (SqlBaseParser.TO - 197)) | (1 << (SqlBaseParser.TRAILING - 197)) | (1 << (SqlBaseParser.TRANSACTION - 197)) | (1 << (SqlBaseParser.TRUNCATE - 197)) | (1 << (SqlBaseParser.TRY_CAST - 197)) | (1 << (SqlBaseParser.TYPE - 197)) | (1 << (SqlBaseParser.UNBOUNDED - 197)) | (1 << (SqlBaseParser.UNCOMMITTED - 197)) | (1 << (SqlBaseParser.UNCONDITIONAL - 197)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (SqlBaseParser.UNIQUE - 261)) | (1 << (SqlBaseParser.UNKNOWN - 261)) | (1 << (SqlBaseParser.UNMATCHED - 261)) | (1 << (SqlBaseParser.UPDATE - 261)) | (1 << (SqlBaseParser.USE - 261)) | (1 << (SqlBaseParser.USER - 261)) | (1 << (SqlBaseParser.UTF16 - 261)) | (1 << (SqlBaseParser.UTF32 - 261)) | (1 << (SqlBaseParser.UTF8 - 261)) | (1 << (SqlBaseParser.VALIDATE - 261)) | (1 << (SqlBaseParser.VALUE - 261)) | (1 << (SqlBaseParser.VERBOSE - 261)) | (1 << (SqlBaseParser.VERSION - 261)) | (1 << (SqlBaseParser.VIEW - 261)) | (1 << (SqlBaseParser.WINDOW - 261)) | (1 << (SqlBaseParser.WITHIN - 261)) | (1 << (SqlBaseParser.WITHOUT - 261)) | (1 << (SqlBaseParser.WORK - 261)) | (1 << (SqlBaseParser.WRAPPER - 261)) | (1 << (SqlBaseParser.WRITE - 261)) | (1 << (SqlBaseParser.YEAR - 261)) | (1 << (SqlBaseParser.ZONE - 261)) | (1 << (SqlBaseParser.IDENTIFIER - 261)) | (1 << (SqlBaseParser.DIGIT_IDENTIFIER - 261)) | (1 << (SqlBaseParser.QUOTED_IDENTIFIER - 261)) | (1 << (SqlBaseParser.BACKQUOTED_IDENTIFIER - 261)))) != 0):
                    self.state = 2173
                    self.qualifiedName()
                    self.state = 2178
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 2174
                        self.match(SqlBaseParser.T__3)
                        self.state = 2175
                        self.qualifiedName()
                        self.state = 2180
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 2183
                self.match(SqlBaseParser.T__2)

            elif la_ == 43:
                localctx = SqlBaseParser.JsonExistsContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2184
                self.match(SqlBaseParser.JSON_EXISTS)
                self.state = 2185
                self.match(SqlBaseParser.T__1)
                self.state = 2186
                self.jsonPathInvocation()
                self.state = 2191
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.ERROR or _la==SqlBaseParser.FALSE or _la==SqlBaseParser.TRUE or _la==SqlBaseParser.UNKNOWN:
                    self.state = 2187
                    self.jsonExistsErrorBehavior()
                    self.state = 2188
                    self.match(SqlBaseParser.ON)
                    self.state = 2189
                    self.match(SqlBaseParser.ERROR)


                self.state = 2193
                self.match(SqlBaseParser.T__2)

            elif la_ == 44:
                localctx = SqlBaseParser.JsonValueContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2195
                self.match(SqlBaseParser.JSON_VALUE)
                self.state = 2196
                self.match(SqlBaseParser.T__1)
                self.state = 2197
                self.jsonPathInvocation()
                self.state = 2200
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.RETURNING:
                    self.state = 2198
                    self.match(SqlBaseParser.RETURNING)
                    self.state = 2199
                    self.type_(0)


                self.state = 2206
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,285,self._ctx)
                if la_ == 1:
                    self.state = 2202
                    localctx.emptyBehavior = self.jsonValueBehavior()
                    self.state = 2203
                    self.match(SqlBaseParser.ON)
                    self.state = 2204
                    self.match(SqlBaseParser.EMPTY)


                self.state = 2212
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.DEFAULT or _la==SqlBaseParser.ERROR or _la==SqlBaseParser.NULL:
                    self.state = 2208
                    localctx.errorBehavior = self.jsonValueBehavior()
                    self.state = 2209
                    self.match(SqlBaseParser.ON)
                    self.state = 2210
                    self.match(SqlBaseParser.ERROR)


                self.state = 2214
                self.match(SqlBaseParser.T__2)

            elif la_ == 45:
                localctx = SqlBaseParser.JsonQueryContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2216
                self.match(SqlBaseParser.JSON_QUERY)
                self.state = 2217
                self.match(SqlBaseParser.T__1)
                self.state = 2218
                self.jsonPathInvocation()
                self.state = 2225
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.RETURNING:
                    self.state = 2219
                    self.match(SqlBaseParser.RETURNING)
                    self.state = 2220
                    self.type_(0)
                    self.state = 2223
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.FORMAT:
                        self.state = 2221
                        self.match(SqlBaseParser.FORMAT)
                        self.state = 2222
                        self.jsonRepresentation()




                self.state = 2230
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.WITH or _la==SqlBaseParser.WITHOUT:
                    self.state = 2227
                    self.jsonQueryWrapperBehavior()
                    self.state = 2228
                    self.match(SqlBaseParser.WRAPPER)


                self.state = 2239
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.KEEP or _la==SqlBaseParser.OMIT:
                    self.state = 2232
                    _la = self._input.LA(1)
                    if not(_la==SqlBaseParser.KEEP or _la==SqlBaseParser.OMIT):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 2233
                    self.match(SqlBaseParser.QUOTES)
                    self.state = 2237
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.ON:
                        self.state = 2234
                        self.match(SqlBaseParser.ON)
                        self.state = 2235
                        self.match(SqlBaseParser.SCALAR)
                        self.state = 2236
                        self.match(SqlBaseParser.TEXT_STRING)




                self.state = 2245
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,292,self._ctx)
                if la_ == 1:
                    self.state = 2241
                    localctx.emptyBehavior = self.jsonQueryBehavior()
                    self.state = 2242
                    self.match(SqlBaseParser.ON)
                    self.state = 2243
                    self.match(SqlBaseParser.EMPTY)


                self.state = 2251
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.EMPTY or _la==SqlBaseParser.ERROR or _la==SqlBaseParser.NULL:
                    self.state = 2247
                    localctx.errorBehavior = self.jsonQueryBehavior()
                    self.state = 2248
                    self.match(SqlBaseParser.ON)
                    self.state = 2249
                    self.match(SqlBaseParser.ERROR)


                self.state = 2253
                self.match(SqlBaseParser.T__2)

            elif la_ == 46:
                localctx = SqlBaseParser.JsonObjectContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2255
                self.match(SqlBaseParser.JSON_OBJECT)
                self.state = 2256
                self.match(SqlBaseParser.T__1)
                self.state = 2285
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,299,self._ctx)
                if la_ == 1:
                    self.state = 2257
                    self.jsonObjectMember()
                    self.state = 2262
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 2258
                        self.match(SqlBaseParser.T__3)
                        self.state = 2259
                        self.jsonObjectMember()
                        self.state = 2264
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 2271
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [SqlBaseParser.NULL]:
                        self.state = 2265
                        self.match(SqlBaseParser.NULL)
                        self.state = 2266
                        self.match(SqlBaseParser.ON)
                        self.state = 2267
                        self.match(SqlBaseParser.NULL)
                    elif token in [SqlBaseParser.ABSENT]:
                        self.state = 2268
                        self.match(SqlBaseParser.ABSENT)
                        self.state = 2269
                        self.match(SqlBaseParser.ON)
                        self.state = 2270
                        self.match(SqlBaseParser.NULL)
                    elif token in [SqlBaseParser.T__2, SqlBaseParser.RETURNING, SqlBaseParser.WITH, SqlBaseParser.WITHOUT]:
                        pass
                    else:
                        pass
                    self.state = 2283
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [SqlBaseParser.WITH]:
                        self.state = 2273
                        self.match(SqlBaseParser.WITH)
                        self.state = 2274
                        self.match(SqlBaseParser.UNIQUE)
                        self.state = 2276
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==SqlBaseParser.KEYS:
                            self.state = 2275
                            self.match(SqlBaseParser.KEYS)


                    elif token in [SqlBaseParser.WITHOUT]:
                        self.state = 2278
                        self.match(SqlBaseParser.WITHOUT)
                        self.state = 2279
                        self.match(SqlBaseParser.UNIQUE)
                        self.state = 2281
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==SqlBaseParser.KEYS:
                            self.state = 2280
                            self.match(SqlBaseParser.KEYS)


                    elif token in [SqlBaseParser.T__2, SqlBaseParser.RETURNING]:
                        pass
                    else:
                        pass


                self.state = 2293
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.RETURNING:
                    self.state = 2287
                    self.match(SqlBaseParser.RETURNING)
                    self.state = 2288
                    self.type_(0)
                    self.state = 2291
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.FORMAT:
                        self.state = 2289
                        self.match(SqlBaseParser.FORMAT)
                        self.state = 2290
                        self.jsonRepresentation()




                self.state = 2295
                self.match(SqlBaseParser.T__2)

            elif la_ == 47:
                localctx = SqlBaseParser.JsonArrayContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2296
                self.match(SqlBaseParser.JSON_ARRAY)
                self.state = 2297
                self.match(SqlBaseParser.T__1)
                self.state = 2314
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,304,self._ctx)
                if la_ == 1:
                    self.state = 2298
                    self.jsonValueExpression()
                    self.state = 2303
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 2299
                        self.match(SqlBaseParser.T__3)
                        self.state = 2300
                        self.jsonValueExpression()
                        self.state = 2305
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 2312
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [SqlBaseParser.NULL]:
                        self.state = 2306
                        self.match(SqlBaseParser.NULL)
                        self.state = 2307
                        self.match(SqlBaseParser.ON)
                        self.state = 2308
                        self.match(SqlBaseParser.NULL)
                    elif token in [SqlBaseParser.ABSENT]:
                        self.state = 2309
                        self.match(SqlBaseParser.ABSENT)
                        self.state = 2310
                        self.match(SqlBaseParser.ON)
                        self.state = 2311
                        self.match(SqlBaseParser.NULL)
                    elif token in [SqlBaseParser.T__2, SqlBaseParser.RETURNING]:
                        pass
                    else:
                        pass


                self.state = 2322
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.RETURNING:
                    self.state = 2316
                    self.match(SqlBaseParser.RETURNING)
                    self.state = 2317
                    self.type_(0)
                    self.state = 2320
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SqlBaseParser.FORMAT:
                        self.state = 2318
                        self.match(SqlBaseParser.FORMAT)
                        self.state = 2319
                        self.jsonRepresentation()




                self.state = 2324
                self.match(SqlBaseParser.T__2)


            self._ctx.stop = self._input.LT(-1)
            self.state = 2337
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,309,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 2335
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,308,self._ctx)
                    if la_ == 1:
                        localctx = SqlBaseParser.SubscriptContext(self, SqlBaseParser.PrimaryExpressionContext(self, _parentctx, _parentState))
                        localctx.value = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_primaryExpression)
                        self.state = 2327
                        if not self.precpred(self._ctx, 24):
                            from antlr4.error.Errors import (
                                FailedPredicateException,
                            )
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 24)")
                        self.state = 2328
                        self.match(SqlBaseParser.T__7)
                        self.state = 2329
                        localctx.index = self.valueExpression(0)
                        self.state = 2330
                        self.match(SqlBaseParser.T__8)

                    elif la_ == 2:
                        localctx = SqlBaseParser.DereferenceContext(self, SqlBaseParser.PrimaryExpressionContext(self, _parentctx, _parentState))
                        localctx.base = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_primaryExpression)
                        self.state = 2332
                        if not self.precpred(self._ctx, 22):
                            from antlr4.error.Errors import (
                                FailedPredicateException,
                            )
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 22)")
                        self.state = 2333
                        self.match(SqlBaseParser.T__0)
                        self.state = 2334
                        localctx.fieldName = self.identifier()

             
                self.state = 2339
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,309,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class JsonPathInvocationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.path = None # StringContext

        def jsonValueExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.JsonValueExpressionContext,0)


        def string(self):
            return self.getTypedRuleContext(SqlBaseParser.StringContext,0)


        def PASSING(self):
            return self.getToken(SqlBaseParser.PASSING, 0)

        def jsonArgument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.JsonArgumentContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.JsonArgumentContext,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_jsonPathInvocation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJsonPathInvocation" ):
                listener.enterJsonPathInvocation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJsonPathInvocation" ):
                listener.exitJsonPathInvocation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJsonPathInvocation" ):
                return visitor.visitJsonPathInvocation(self)
            else:
                return visitor.visitChildren(self)




    def jsonPathInvocation(self):

        localctx = SqlBaseParser.JsonPathInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_jsonPathInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2340
            self.jsonValueExpression()
            self.state = 2341
            self.match(SqlBaseParser.T__3)
            self.state = 2342
            localctx.path = self.string()
            self.state = 2352
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.PASSING:
                self.state = 2343
                self.match(SqlBaseParser.PASSING)
                self.state = 2344
                self.jsonArgument()
                self.state = 2349
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 2345
                    self.match(SqlBaseParser.T__3)
                    self.state = 2346
                    self.jsonArgument()
                    self.state = 2351
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JsonValueExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def FORMAT(self):
            return self.getToken(SqlBaseParser.FORMAT, 0)

        def jsonRepresentation(self):
            return self.getTypedRuleContext(SqlBaseParser.JsonRepresentationContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_jsonValueExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJsonValueExpression" ):
                listener.enterJsonValueExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJsonValueExpression" ):
                listener.exitJsonValueExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJsonValueExpression" ):
                return visitor.visitJsonValueExpression(self)
            else:
                return visitor.visitChildren(self)




    def jsonValueExpression(self):

        localctx = SqlBaseParser.JsonValueExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_jsonValueExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2354
            self.expression()
            self.state = 2357
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.FORMAT:
                self.state = 2355
                self.match(SqlBaseParser.FORMAT)
                self.state = 2356
                self.jsonRepresentation()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JsonRepresentationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def JSON(self):
            return self.getToken(SqlBaseParser.JSON, 0)

        def ENCODING(self):
            return self.getToken(SqlBaseParser.ENCODING, 0)

        def UTF8(self):
            return self.getToken(SqlBaseParser.UTF8, 0)

        def UTF16(self):
            return self.getToken(SqlBaseParser.UTF16, 0)

        def UTF32(self):
            return self.getToken(SqlBaseParser.UTF32, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_jsonRepresentation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJsonRepresentation" ):
                listener.enterJsonRepresentation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJsonRepresentation" ):
                listener.exitJsonRepresentation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJsonRepresentation" ):
                return visitor.visitJsonRepresentation(self)
            else:
                return visitor.visitChildren(self)




    def jsonRepresentation(self):

        localctx = SqlBaseParser.JsonRepresentationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_jsonRepresentation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2359
            self.match(SqlBaseParser.JSON)
            self.state = 2362
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.ENCODING:
                self.state = 2360
                self.match(SqlBaseParser.ENCODING)
                self.state = 2361
                _la = self._input.LA(1)
                if not(((((_la - 269)) & ~0x3f) == 0 and ((1 << (_la - 269)) & ((1 << (SqlBaseParser.UTF16 - 269)) | (1 << (SqlBaseParser.UTF32 - 269)) | (1 << (SqlBaseParser.UTF8 - 269)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JsonArgumentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def jsonValueExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.JsonValueExpressionContext,0)


        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_jsonArgument

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJsonArgument" ):
                listener.enterJsonArgument(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJsonArgument" ):
                listener.exitJsonArgument(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJsonArgument" ):
                return visitor.visitJsonArgument(self)
            else:
                return visitor.visitChildren(self)




    def jsonArgument(self):

        localctx = SqlBaseParser.JsonArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_jsonArgument)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2364
            self.jsonValueExpression()
            self.state = 2365
            self.match(SqlBaseParser.AS)
            self.state = 2366
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JsonExistsErrorBehaviorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TRUE(self):
            return self.getToken(SqlBaseParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(SqlBaseParser.FALSE, 0)

        def UNKNOWN(self):
            return self.getToken(SqlBaseParser.UNKNOWN, 0)

        def ERROR(self):
            return self.getToken(SqlBaseParser.ERROR, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_jsonExistsErrorBehavior

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJsonExistsErrorBehavior" ):
                listener.enterJsonExistsErrorBehavior(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJsonExistsErrorBehavior" ):
                listener.exitJsonExistsErrorBehavior(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJsonExistsErrorBehavior" ):
                return visitor.visitJsonExistsErrorBehavior(self)
            else:
                return visitor.visitChildren(self)




    def jsonExistsErrorBehavior(self):

        localctx = SqlBaseParser.JsonExistsErrorBehaviorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_jsonExistsErrorBehavior)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2368
            _la = self._input.LA(1)
            if not(_la==SqlBaseParser.ERROR or _la==SqlBaseParser.FALSE or _la==SqlBaseParser.TRUE or _la==SqlBaseParser.UNKNOWN):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JsonValueBehaviorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ERROR(self):
            return self.getToken(SqlBaseParser.ERROR, 0)

        def NULL(self):
            return self.getToken(SqlBaseParser.NULL, 0)

        def DEFAULT(self):
            return self.getToken(SqlBaseParser.DEFAULT, 0)

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_jsonValueBehavior

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJsonValueBehavior" ):
                listener.enterJsonValueBehavior(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJsonValueBehavior" ):
                listener.exitJsonValueBehavior(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJsonValueBehavior" ):
                return visitor.visitJsonValueBehavior(self)
            else:
                return visitor.visitChildren(self)




    def jsonValueBehavior(self):

        localctx = SqlBaseParser.JsonValueBehaviorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_jsonValueBehavior)
        try:
            self.state = 2374
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.ERROR]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2370
                self.match(SqlBaseParser.ERROR)
            elif token in [SqlBaseParser.NULL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2371
                self.match(SqlBaseParser.NULL)
            elif token in [SqlBaseParser.DEFAULT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2372
                self.match(SqlBaseParser.DEFAULT)
                self.state = 2373
                self.expression()
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JsonQueryWrapperBehaviorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WITHOUT(self):
            return self.getToken(SqlBaseParser.WITHOUT, 0)

        def ARRAY(self):
            return self.getToken(SqlBaseParser.ARRAY, 0)

        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)

        def CONDITIONAL(self):
            return self.getToken(SqlBaseParser.CONDITIONAL, 0)

        def UNCONDITIONAL(self):
            return self.getToken(SqlBaseParser.UNCONDITIONAL, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_jsonQueryWrapperBehavior

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJsonQueryWrapperBehavior" ):
                listener.enterJsonQueryWrapperBehavior(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJsonQueryWrapperBehavior" ):
                listener.exitJsonQueryWrapperBehavior(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJsonQueryWrapperBehavior" ):
                return visitor.visitJsonQueryWrapperBehavior(self)
            else:
                return visitor.visitChildren(self)




    def jsonQueryWrapperBehavior(self):

        localctx = SqlBaseParser.JsonQueryWrapperBehaviorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_jsonQueryWrapperBehavior)
        self._la = 0 # Token type
        try:
            self.state = 2387
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.WITHOUT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2376
                self.match(SqlBaseParser.WITHOUT)
                self.state = 2378
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.ARRAY:
                    self.state = 2377
                    self.match(SqlBaseParser.ARRAY)


            elif token in [SqlBaseParser.WITH]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2380
                self.match(SqlBaseParser.WITH)
                self.state = 2382
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.CONDITIONAL or _la==SqlBaseParser.UNCONDITIONAL:
                    self.state = 2381
                    _la = self._input.LA(1)
                    if not(_la==SqlBaseParser.CONDITIONAL or _la==SqlBaseParser.UNCONDITIONAL):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 2385
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.ARRAY:
                    self.state = 2384
                    self.match(SqlBaseParser.ARRAY)


            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JsonQueryBehaviorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ERROR(self):
            return self.getToken(SqlBaseParser.ERROR, 0)

        def NULL(self):
            return self.getToken(SqlBaseParser.NULL, 0)

        def EMPTY(self):
            return self.getToken(SqlBaseParser.EMPTY, 0)

        def ARRAY(self):
            return self.getToken(SqlBaseParser.ARRAY, 0)

        def OBJECT(self):
            return self.getToken(SqlBaseParser.OBJECT, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_jsonQueryBehavior

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJsonQueryBehavior" ):
                listener.enterJsonQueryBehavior(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJsonQueryBehavior" ):
                listener.exitJsonQueryBehavior(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJsonQueryBehavior" ):
                return visitor.visitJsonQueryBehavior(self)
            else:
                return visitor.visitChildren(self)




    def jsonQueryBehavior(self):

        localctx = SqlBaseParser.JsonQueryBehaviorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_jsonQueryBehavior)
        try:
            self.state = 2395
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,319,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2389
                self.match(SqlBaseParser.ERROR)

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2390
                self.match(SqlBaseParser.NULL)

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2391
                self.match(SqlBaseParser.EMPTY)
                self.state = 2392
                self.match(SqlBaseParser.ARRAY)

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2393
                self.match(SqlBaseParser.EMPTY)
                self.state = 2394
                self.match(SqlBaseParser.OBJECT)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JsonObjectMemberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def VALUE(self):
            return self.getToken(SqlBaseParser.VALUE, 0)

        def jsonValueExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.JsonValueExpressionContext,0)


        def KEY(self):
            return self.getToken(SqlBaseParser.KEY, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_jsonObjectMember

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJsonObjectMember" ):
                listener.enterJsonObjectMember(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJsonObjectMember" ):
                listener.exitJsonObjectMember(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJsonObjectMember" ):
                return visitor.visitJsonObjectMember(self)
            else:
                return visitor.visitChildren(self)




    def jsonObjectMember(self):

        localctx = SqlBaseParser.JsonObjectMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_jsonObjectMember)
        try:
            self.state = 2408
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,321,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2398
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,320,self._ctx)
                if la_ == 1:
                    self.state = 2397
                    self.match(SqlBaseParser.KEY)


                self.state = 2400
                self.expression()
                self.state = 2401
                self.match(SqlBaseParser.VALUE)
                self.state = 2402
                self.jsonValueExpression()

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2404
                self.expression()
                self.state = 2405
                self.match(SqlBaseParser.T__9)
                self.state = 2406
                self.jsonValueExpression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ProcessingModeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RUNNING(self):
            return self.getToken(SqlBaseParser.RUNNING, 0)

        def FINAL(self):
            return self.getToken(SqlBaseParser.FINAL, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_processingMode

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProcessingMode" ):
                listener.enterProcessingMode(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProcessingMode" ):
                listener.exitProcessingMode(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitProcessingMode" ):
                return visitor.visitProcessingMode(self)
            else:
                return visitor.visitChildren(self)




    def processingMode(self):

        localctx = SqlBaseParser.ProcessingModeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_processingMode)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2410
            _la = self._input.LA(1)
            if not(_la==SqlBaseParser.FINAL or _la==SqlBaseParser.RUNNING):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NullTreatmentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IGNORE(self):
            return self.getToken(SqlBaseParser.IGNORE, 0)

        def NULLS(self):
            return self.getToken(SqlBaseParser.NULLS, 0)

        def RESPECT(self):
            return self.getToken(SqlBaseParser.RESPECT, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_nullTreatment

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNullTreatment" ):
                listener.enterNullTreatment(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNullTreatment" ):
                listener.exitNullTreatment(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNullTreatment" ):
                return visitor.visitNullTreatment(self)
            else:
                return visitor.visitChildren(self)




    def nullTreatment(self):

        localctx = SqlBaseParser.NullTreatmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_nullTreatment)
        try:
            self.state = 2416
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.IGNORE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2412
                self.match(SqlBaseParser.IGNORE)
                self.state = 2413
                self.match(SqlBaseParser.NULLS)
            elif token in [SqlBaseParser.RESPECT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2414
                self.match(SqlBaseParser.RESPECT)
                self.state = 2415
                self.match(SqlBaseParser.NULLS)
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StringContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_string

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class UnicodeStringLiteralContext(StringContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StringContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def UNICODE_STRING(self):
            return self.getToken(SqlBaseParser.UNICODE_STRING, 0)
        def UESCAPE(self):
            return self.getToken(SqlBaseParser.UESCAPE, 0)
        def STRING(self):
            return self.getToken(SqlBaseParser.STRING, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnicodeStringLiteral" ):
                listener.enterUnicodeStringLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnicodeStringLiteral" ):
                listener.exitUnicodeStringLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnicodeStringLiteral" ):
                return visitor.visitUnicodeStringLiteral(self)
            else:
                return visitor.visitChildren(self)


    class BasicStringLiteralContext(StringContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.StringContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def STRING(self):
            return self.getToken(SqlBaseParser.STRING, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBasicStringLiteral" ):
                listener.enterBasicStringLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBasicStringLiteral" ):
                listener.exitBasicStringLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBasicStringLiteral" ):
                return visitor.visitBasicStringLiteral(self)
            else:
                return visitor.visitChildren(self)



    def string(self):

        localctx = SqlBaseParser.StringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_string)
        try:
            self.state = 2424
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.STRING]:
                localctx = SqlBaseParser.BasicStringLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2418
                self.match(SqlBaseParser.STRING)
            elif token in [SqlBaseParser.UNICODE_STRING]:
                localctx = SqlBaseParser.UnicodeStringLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2419
                self.match(SqlBaseParser.UNICODE_STRING)
                self.state = 2422
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,323,self._ctx)
                if la_ == 1:
                    self.state = 2420
                    self.match(SqlBaseParser.UESCAPE)
                    self.state = 2421
                    self.match(SqlBaseParser.STRING)


            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TimeZoneSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_timeZoneSpecifier

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class TimeZoneIntervalContext(TimeZoneSpecifierContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.TimeZoneSpecifierContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TIME(self):
            return self.getToken(SqlBaseParser.TIME, 0)
        def ZONE(self):
            return self.getToken(SqlBaseParser.ZONE, 0)
        def interval(self):
            return self.getTypedRuleContext(SqlBaseParser.IntervalContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTimeZoneInterval" ):
                listener.enterTimeZoneInterval(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTimeZoneInterval" ):
                listener.exitTimeZoneInterval(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTimeZoneInterval" ):
                return visitor.visitTimeZoneInterval(self)
            else:
                return visitor.visitChildren(self)


    class TimeZoneStringContext(TimeZoneSpecifierContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.TimeZoneSpecifierContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TIME(self):
            return self.getToken(SqlBaseParser.TIME, 0)
        def ZONE(self):
            return self.getToken(SqlBaseParser.ZONE, 0)
        def string(self):
            return self.getTypedRuleContext(SqlBaseParser.StringContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTimeZoneString" ):
                listener.enterTimeZoneString(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTimeZoneString" ):
                listener.exitTimeZoneString(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTimeZoneString" ):
                return visitor.visitTimeZoneString(self)
            else:
                return visitor.visitChildren(self)



    def timeZoneSpecifier(self):

        localctx = SqlBaseParser.TimeZoneSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_timeZoneSpecifier)
        try:
            self.state = 2432
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,325,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.TimeZoneIntervalContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2426
                self.match(SqlBaseParser.TIME)
                self.state = 2427
                self.match(SqlBaseParser.ZONE)
                self.state = 2428
                self.interval()

            elif la_ == 2:
                localctx = SqlBaseParser.TimeZoneStringContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2429
                self.match(SqlBaseParser.TIME)
                self.state = 2430
                self.match(SqlBaseParser.ZONE)
                self.state = 2431
                self.string()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ComparisonOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EQ(self):
            return self.getToken(SqlBaseParser.EQ, 0)

        def NEQ(self):
            return self.getToken(SqlBaseParser.NEQ, 0)

        def LT(self):
            return self.getToken(SqlBaseParser.LT, 0)

        def LTE(self):
            return self.getToken(SqlBaseParser.LTE, 0)

        def GT(self):
            return self.getToken(SqlBaseParser.GT, 0)

        def GTE(self):
            return self.getToken(SqlBaseParser.GTE, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_comparisonOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterComparisonOperator" ):
                listener.enterComparisonOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitComparisonOperator" ):
                listener.exitComparisonOperator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitComparisonOperator" ):
                return visitor.visitComparisonOperator(self)
            else:
                return visitor.visitChildren(self)




    def comparisonOperator(self):

        localctx = SqlBaseParser.ComparisonOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_comparisonOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2434
            _la = self._input.LA(1)
            if not(((((_la - 289)) & ~0x3f) == 0 and ((1 << (_la - 289)) & ((1 << (SqlBaseParser.EQ - 289)) | (1 << (SqlBaseParser.NEQ - 289)) | (1 << (SqlBaseParser.LT - 289)) | (1 << (SqlBaseParser.LTE - 289)) | (1 << (SqlBaseParser.GT - 289)) | (1 << (SqlBaseParser.GTE - 289)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ComparisonQuantifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ALL(self):
            return self.getToken(SqlBaseParser.ALL, 0)

        def SOME(self):
            return self.getToken(SqlBaseParser.SOME, 0)

        def ANY(self):
            return self.getToken(SqlBaseParser.ANY, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_comparisonQuantifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterComparisonQuantifier" ):
                listener.enterComparisonQuantifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitComparisonQuantifier" ):
                listener.exitComparisonQuantifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitComparisonQuantifier" ):
                return visitor.visitComparisonQuantifier(self)
            else:
                return visitor.visitChildren(self)




    def comparisonQuantifier(self):

        localctx = SqlBaseParser.ComparisonQuantifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_comparisonQuantifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2436
            _la = self._input.LA(1)
            if not(_la==SqlBaseParser.ALL or _la==SqlBaseParser.ANY or _la==SqlBaseParser.SOME):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BooleanValueContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TRUE(self):
            return self.getToken(SqlBaseParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(SqlBaseParser.FALSE, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_booleanValue

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBooleanValue" ):
                listener.enterBooleanValue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBooleanValue" ):
                listener.exitBooleanValue(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBooleanValue" ):
                return visitor.visitBooleanValue(self)
            else:
                return visitor.visitChildren(self)




    def booleanValue(self):

        localctx = SqlBaseParser.BooleanValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_booleanValue)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2438
            _la = self._input.LA(1)
            if not(_la==SqlBaseParser.FALSE or _la==SqlBaseParser.TRUE):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IntervalContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.sign = None # Token
            self.from_ = None # IntervalFieldContext
            self.to = None # IntervalFieldContext

        def INTERVAL(self):
            return self.getToken(SqlBaseParser.INTERVAL, 0)

        def string(self):
            return self.getTypedRuleContext(SqlBaseParser.StringContext,0)


        def intervalField(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IntervalFieldContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IntervalFieldContext,i)


        def TO(self):
            return self.getToken(SqlBaseParser.TO, 0)

        def PLUS(self):
            return self.getToken(SqlBaseParser.PLUS, 0)

        def MINUS(self):
            return self.getToken(SqlBaseParser.MINUS, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_interval

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterval" ):
                listener.enterInterval(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterval" ):
                listener.exitInterval(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInterval" ):
                return visitor.visitInterval(self)
            else:
                return visitor.visitChildren(self)




    def interval(self):

        localctx = SqlBaseParser.IntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_interval)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2440
            self.match(SqlBaseParser.INTERVAL)
            self.state = 2442
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.PLUS or _la==SqlBaseParser.MINUS:
                self.state = 2441
                localctx.sign = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==SqlBaseParser.PLUS or _la==SqlBaseParser.MINUS):
                    localctx.sign = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 2444
            self.string()
            self.state = 2445
            localctx.from_ = self.intervalField()
            self.state = 2448
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,327,self._ctx)
            if la_ == 1:
                self.state = 2446
                self.match(SqlBaseParser.TO)
                self.state = 2447
                localctx.to = self.intervalField()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IntervalFieldContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def YEAR(self):
            return self.getToken(SqlBaseParser.YEAR, 0)

        def MONTH(self):
            return self.getToken(SqlBaseParser.MONTH, 0)

        def DAY(self):
            return self.getToken(SqlBaseParser.DAY, 0)

        def HOUR(self):
            return self.getToken(SqlBaseParser.HOUR, 0)

        def MINUTE(self):
            return self.getToken(SqlBaseParser.MINUTE, 0)

        def SECOND(self):
            return self.getToken(SqlBaseParser.SECOND, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_intervalField

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIntervalField" ):
                listener.enterIntervalField(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIntervalField" ):
                listener.exitIntervalField(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIntervalField" ):
                return visitor.visitIntervalField(self)
            else:
                return visitor.visitChildren(self)




    def intervalField(self):

        localctx = SqlBaseParser.IntervalFieldContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_intervalField)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2450
            _la = self._input.LA(1)
            if not(_la==SqlBaseParser.DAY or _la==SqlBaseParser.HOUR or _la==SqlBaseParser.MINUTE or _la==SqlBaseParser.MONTH or _la==SqlBaseParser.SECOND or _la==SqlBaseParser.YEAR):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NormalFormContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NFD(self):
            return self.getToken(SqlBaseParser.NFD, 0)

        def NFC(self):
            return self.getToken(SqlBaseParser.NFC, 0)

        def NFKD(self):
            return self.getToken(SqlBaseParser.NFKD, 0)

        def NFKC(self):
            return self.getToken(SqlBaseParser.NFKC, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_normalForm

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNormalForm" ):
                listener.enterNormalForm(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNormalForm" ):
                listener.exitNormalForm(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNormalForm" ):
                return visitor.visitNormalForm(self)
            else:
                return visitor.visitChildren(self)




    def normalForm(self):

        localctx = SqlBaseParser.NormalFormContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_normalForm)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2452
            _la = self._input.LA(1)
            if not(((((_la - 159)) & ~0x3f) == 0 and ((1 << (_la - 159)) & ((1 << (SqlBaseParser.NFC - 159)) | (1 << (SqlBaseParser.NFD - 159)) | (1 << (SqlBaseParser.NFKC - 159)) | (1 << (SqlBaseParser.NFKD - 159)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_type_

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class RowTypeContext(Type_Context):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.Type_Context
            super().__init__(parser)
            self.copyFrom(ctx)

        def ROW(self):
            return self.getToken(SqlBaseParser.ROW, 0)
        def rowField(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.RowFieldContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.RowFieldContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRowType" ):
                listener.enterRowType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRowType" ):
                listener.exitRowType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRowType" ):
                return visitor.visitRowType(self)
            else:
                return visitor.visitChildren(self)


    class IntervalTypeContext(Type_Context):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.Type_Context
            super().__init__(parser)
            self.from_ = None # IntervalFieldContext
            self.to = None # IntervalFieldContext
            self.copyFrom(ctx)

        def INTERVAL(self):
            return self.getToken(SqlBaseParser.INTERVAL, 0)
        def intervalField(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IntervalFieldContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IntervalFieldContext,i)

        def TO(self):
            return self.getToken(SqlBaseParser.TO, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIntervalType" ):
                listener.enterIntervalType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIntervalType" ):
                listener.exitIntervalType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIntervalType" ):
                return visitor.visitIntervalType(self)
            else:
                return visitor.visitChildren(self)


    class ArrayTypeContext(Type_Context):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.Type_Context
            super().__init__(parser)
            self.copyFrom(ctx)

        def type_(self):
            return self.getTypedRuleContext(SqlBaseParser.Type_Context,0)

        def ARRAY(self):
            return self.getToken(SqlBaseParser.ARRAY, 0)
        def INTEGER_VALUE(self):
            return self.getToken(SqlBaseParser.INTEGER_VALUE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArrayType" ):
                listener.enterArrayType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArrayType" ):
                listener.exitArrayType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArrayType" ):
                return visitor.visitArrayType(self)
            else:
                return visitor.visitChildren(self)


    class DoublePrecisionTypeContext(Type_Context):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.Type_Context
            super().__init__(parser)
            self.copyFrom(ctx)

        def DOUBLE(self):
            return self.getToken(SqlBaseParser.DOUBLE, 0)
        def PRECISION(self):
            return self.getToken(SqlBaseParser.PRECISION, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDoublePrecisionType" ):
                listener.enterDoublePrecisionType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDoublePrecisionType" ):
                listener.exitDoublePrecisionType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDoublePrecisionType" ):
                return visitor.visitDoublePrecisionType(self)
            else:
                return visitor.visitChildren(self)


    class LegacyArrayTypeContext(Type_Context):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.Type_Context
            super().__init__(parser)
            self.copyFrom(ctx)

        def ARRAY(self):
            return self.getToken(SqlBaseParser.ARRAY, 0)
        def LT(self):
            return self.getToken(SqlBaseParser.LT, 0)
        def type_(self):
            return self.getTypedRuleContext(SqlBaseParser.Type_Context,0)

        def GT(self):
            return self.getToken(SqlBaseParser.GT, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLegacyArrayType" ):
                listener.enterLegacyArrayType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLegacyArrayType" ):
                listener.exitLegacyArrayType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLegacyArrayType" ):
                return visitor.visitLegacyArrayType(self)
            else:
                return visitor.visitChildren(self)


    class GenericTypeContext(Type_Context):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.Type_Context
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def typeParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.TypeParameterContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.TypeParameterContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGenericType" ):
                listener.enterGenericType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGenericType" ):
                listener.exitGenericType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGenericType" ):
                return visitor.visitGenericType(self)
            else:
                return visitor.visitChildren(self)


    class DateTimeTypeContext(Type_Context):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.Type_Context
            super().__init__(parser)
            self.base = None # Token
            self.precision = None # TypeParameterContext
            self.copyFrom(ctx)

        def TIMESTAMP(self):
            return self.getToken(SqlBaseParser.TIMESTAMP, 0)
        def WITHOUT(self):
            return self.getToken(SqlBaseParser.WITHOUT, 0)
        def TIME(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.TIME)
            else:
                return self.getToken(SqlBaseParser.TIME, i)
        def ZONE(self):
            return self.getToken(SqlBaseParser.ZONE, 0)
        def typeParameter(self):
            return self.getTypedRuleContext(SqlBaseParser.TypeParameterContext,0)

        def WITH(self):
            return self.getToken(SqlBaseParser.WITH, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDateTimeType" ):
                listener.enterDateTimeType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDateTimeType" ):
                listener.exitDateTimeType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDateTimeType" ):
                return visitor.visitDateTimeType(self)
            else:
                return visitor.visitChildren(self)


    class LegacyMapTypeContext(Type_Context):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.Type_Context
            super().__init__(parser)
            self.keyType = None # Type_Context
            self.valueType = None # Type_Context
            self.copyFrom(ctx)

        def MAP(self):
            return self.getToken(SqlBaseParser.MAP, 0)
        def LT(self):
            return self.getToken(SqlBaseParser.LT, 0)
        def GT(self):
            return self.getToken(SqlBaseParser.GT, 0)
        def type_(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.Type_Context)
            else:
                return self.getTypedRuleContext(SqlBaseParser.Type_Context,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLegacyMapType" ):
                listener.enterLegacyMapType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLegacyMapType" ):
                listener.exitLegacyMapType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLegacyMapType" ):
                return visitor.visitLegacyMapType(self)
            else:
                return visitor.visitChildren(self)



    def type_(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SqlBaseParser.Type_Context(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 158
        self.enterRecursionRule(localctx, 158, self.RULE_type_, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2545
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,338,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.RowTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 2455
                self.match(SqlBaseParser.ROW)
                self.state = 2456
                self.match(SqlBaseParser.T__1)
                self.state = 2457
                self.rowField()
                self.state = 2462
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 2458
                    self.match(SqlBaseParser.T__3)
                    self.state = 2459
                    self.rowField()
                    self.state = 2464
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2465
                self.match(SqlBaseParser.T__2)

            elif la_ == 2:
                localctx = SqlBaseParser.IntervalTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2467
                self.match(SqlBaseParser.INTERVAL)
                self.state = 2468
                localctx.from_ = self.intervalField()
                self.state = 2471
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,329,self._ctx)
                if la_ == 1:
                    self.state = 2469
                    self.match(SqlBaseParser.TO)
                    self.state = 2470
                    localctx.to = self.intervalField()



            elif la_ == 3:
                localctx = SqlBaseParser.DateTimeTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2473
                localctx.base = self.match(SqlBaseParser.TIMESTAMP)
                self.state = 2478
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,330,self._ctx)
                if la_ == 1:
                    self.state = 2474
                    self.match(SqlBaseParser.T__1)
                    self.state = 2475
                    localctx.precision = self.typeParameter()
                    self.state = 2476
                    self.match(SqlBaseParser.T__2)


                self.state = 2483
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,331,self._ctx)
                if la_ == 1:
                    self.state = 2480
                    self.match(SqlBaseParser.WITHOUT)
                    self.state = 2481
                    self.match(SqlBaseParser.TIME)
                    self.state = 2482
                    self.match(SqlBaseParser.ZONE)



            elif la_ == 4:
                localctx = SqlBaseParser.DateTimeTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2485
                localctx.base = self.match(SqlBaseParser.TIMESTAMP)
                self.state = 2490
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.T__1:
                    self.state = 2486
                    self.match(SqlBaseParser.T__1)
                    self.state = 2487
                    localctx.precision = self.typeParameter()
                    self.state = 2488
                    self.match(SqlBaseParser.T__2)


                self.state = 2492
                self.match(SqlBaseParser.WITH)
                self.state = 2493
                self.match(SqlBaseParser.TIME)
                self.state = 2494
                self.match(SqlBaseParser.ZONE)

            elif la_ == 5:
                localctx = SqlBaseParser.DateTimeTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2495
                localctx.base = self.match(SqlBaseParser.TIME)
                self.state = 2500
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,333,self._ctx)
                if la_ == 1:
                    self.state = 2496
                    self.match(SqlBaseParser.T__1)
                    self.state = 2497
                    localctx.precision = self.typeParameter()
                    self.state = 2498
                    self.match(SqlBaseParser.T__2)


                self.state = 2505
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,334,self._ctx)
                if la_ == 1:
                    self.state = 2502
                    self.match(SqlBaseParser.WITHOUT)
                    self.state = 2503
                    self.match(SqlBaseParser.TIME)
                    self.state = 2504
                    self.match(SqlBaseParser.ZONE)



            elif la_ == 6:
                localctx = SqlBaseParser.DateTimeTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2507
                localctx.base = self.match(SqlBaseParser.TIME)
                self.state = 2512
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.T__1:
                    self.state = 2508
                    self.match(SqlBaseParser.T__1)
                    self.state = 2509
                    localctx.precision = self.typeParameter()
                    self.state = 2510
                    self.match(SqlBaseParser.T__2)


                self.state = 2514
                self.match(SqlBaseParser.WITH)
                self.state = 2515
                self.match(SqlBaseParser.TIME)
                self.state = 2516
                self.match(SqlBaseParser.ZONE)

            elif la_ == 7:
                localctx = SqlBaseParser.DoublePrecisionTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2517
                self.match(SqlBaseParser.DOUBLE)
                self.state = 2518
                self.match(SqlBaseParser.PRECISION)

            elif la_ == 8:
                localctx = SqlBaseParser.LegacyArrayTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2519
                self.match(SqlBaseParser.ARRAY)
                self.state = 2520
                self.match(SqlBaseParser.LT)
                self.state = 2521
                self.type_(0)
                self.state = 2522
                self.match(SqlBaseParser.GT)

            elif la_ == 9:
                localctx = SqlBaseParser.LegacyMapTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2524
                self.match(SqlBaseParser.MAP)
                self.state = 2525
                self.match(SqlBaseParser.LT)
                self.state = 2526
                localctx.keyType = self.type_(0)
                self.state = 2527
                self.match(SqlBaseParser.T__3)
                self.state = 2528
                localctx.valueType = self.type_(0)
                self.state = 2529
                self.match(SqlBaseParser.GT)

            elif la_ == 10:
                localctx = SqlBaseParser.GenericTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2531
                self.identifier()
                self.state = 2543
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,337,self._ctx)
                if la_ == 1:
                    self.state = 2532
                    self.match(SqlBaseParser.T__1)
                    self.state = 2533
                    self.typeParameter()
                    self.state = 2538
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 2534
                        self.match(SqlBaseParser.T__3)
                        self.state = 2535
                        self.typeParameter()
                        self.state = 2540
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 2541
                    self.match(SqlBaseParser.T__2)




            self._ctx.stop = self._input.LT(-1)
            self.state = 2556
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,340,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = SqlBaseParser.ArrayTypeContext(self, SqlBaseParser.Type_Context(self, _parentctx, _parentState))
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_type_)
                    self.state = 2547
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 2548
                    self.match(SqlBaseParser.ARRAY)
                    self.state = 2552
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,339,self._ctx)
                    if la_ == 1:
                        self.state = 2549
                        self.match(SqlBaseParser.T__7)
                        self.state = 2550
                        self.match(SqlBaseParser.INTEGER_VALUE)
                        self.state = 2551
                        self.match(SqlBaseParser.T__8)

             
                self.state = 2558
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,340,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class RowFieldContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def type_(self):
            return self.getTypedRuleContext(SqlBaseParser.Type_Context,0)


        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_rowField

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRowField" ):
                listener.enterRowField(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRowField" ):
                listener.exitRowField(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRowField" ):
                return visitor.visitRowField(self)
            else:
                return visitor.visitChildren(self)




    def rowField(self):

        localctx = SqlBaseParser.RowFieldContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_rowField)
        try:
            self.state = 2563
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,341,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2559
                self.type_(0)

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2560
                self.identifier()
                self.state = 2561
                self.type_(0)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeParameterContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INTEGER_VALUE(self):
            return self.getToken(SqlBaseParser.INTEGER_VALUE, 0)

        def type_(self):
            return self.getTypedRuleContext(SqlBaseParser.Type_Context,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_typeParameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeParameter" ):
                listener.enterTypeParameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeParameter" ):
                listener.exitTypeParameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeParameter" ):
                return visitor.visitTypeParameter(self)
            else:
                return visitor.visitChildren(self)




    def typeParameter(self):

        localctx = SqlBaseParser.TypeParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_typeParameter)
        try:
            self.state = 2567
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.INTEGER_VALUE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2565
                self.match(SqlBaseParser.INTEGER_VALUE)
            elif token in [SqlBaseParser.ABSENT, SqlBaseParser.ADD, SqlBaseParser.ADMIN, SqlBaseParser.AFTER, SqlBaseParser.ALL, SqlBaseParser.ANALYZE, SqlBaseParser.ANY, SqlBaseParser.ARRAY, SqlBaseParser.ASC, SqlBaseParser.AT, SqlBaseParser.AUTHORIZATION, SqlBaseParser.BERNOULLI, SqlBaseParser.BOTH, SqlBaseParser.CALL, SqlBaseParser.CASCADE, SqlBaseParser.CATALOGS, SqlBaseParser.COLUMN, SqlBaseParser.COLUMNS, SqlBaseParser.COMMENT, SqlBaseParser.COMMIT, SqlBaseParser.COMMITTED, SqlBaseParser.CONDITIONAL, SqlBaseParser.COUNT, SqlBaseParser.COPARTITION, SqlBaseParser.CURRENT, SqlBaseParser.DATA, SqlBaseParser.DATE, SqlBaseParser.DAY, SqlBaseParser.DEFAULT, SqlBaseParser.DEFINER, SqlBaseParser.DENY, SqlBaseParser.DESC, SqlBaseParser.DESCRIPTOR, SqlBaseParser.DEFINE, SqlBaseParser.DISTRIBUTED, SqlBaseParser.DOUBLE, SqlBaseParser.EMPTY, SqlBaseParser.ENCODING, SqlBaseParser.ERROR, SqlBaseParser.EXCLUDING, SqlBaseParser.EXPLAIN, SqlBaseParser.FETCH, SqlBaseParser.FILTER, SqlBaseParser.FINAL, SqlBaseParser.FIRST, SqlBaseParser.FOLLOWING, SqlBaseParser.FORMAT, SqlBaseParser.FUNCTIONS, SqlBaseParser.GRANT, SqlBaseParser.GRANTED, SqlBaseParser.GRANTS, SqlBaseParser.GRAPHVIZ, SqlBaseParser.GROUPS, SqlBaseParser.HOUR, SqlBaseParser.IF, SqlBaseParser.IGNORE, SqlBaseParser.INCLUDING, SqlBaseParser.INITIAL, SqlBaseParser.INPUT, SqlBaseParser.INTERVAL, SqlBaseParser.INVOKER, SqlBaseParser.IO, SqlBaseParser.ISOLATION, SqlBaseParser.JSON, SqlBaseParser.KEEP, SqlBaseParser.KEY, SqlBaseParser.KEYS, SqlBaseParser.LAST, SqlBaseParser.LATERAL, SqlBaseParser.LEADING, SqlBaseParser.LEVEL, SqlBaseParser.LIMIT, SqlBaseParser.LOCAL, SqlBaseParser.LOGICAL, SqlBaseParser.MAP, SqlBaseParser.MATCH, SqlBaseParser.MATCHED, SqlBaseParser.MATCHES, SqlBaseParser.MATCH_RECOGNIZE, SqlBaseParser.MATERIALIZED, SqlBaseParser.MEASURES, SqlBaseParser.MERGE, SqlBaseParser.MINUTE, SqlBaseParser.MONTH, SqlBaseParser.NEXT, SqlBaseParser.NFC, SqlBaseParser.NFD, SqlBaseParser.NFKC, SqlBaseParser.NFKD, SqlBaseParser.NO, SqlBaseParser.NONE, SqlBaseParser.NULLIF, SqlBaseParser.NULLS, SqlBaseParser.OBJECT, SqlBaseParser.OFFSET, SqlBaseParser.OMIT, SqlBaseParser.OF, SqlBaseParser.ONE, SqlBaseParser.ONLY, SqlBaseParser.OPTION, SqlBaseParser.ORDINALITY, SqlBaseParser.OUTPUT, SqlBaseParser.OVER, SqlBaseParser.OVERFLOW, SqlBaseParser.PARTITION, SqlBaseParser.PARTITIONS, SqlBaseParser.PASSING, SqlBaseParser.PAST, SqlBaseParser.PATH, SqlBaseParser.PATTERN, SqlBaseParser.PER, SqlBaseParser.PERMUTE, SqlBaseParser.POSITION, SqlBaseParser.PRECEDING, SqlBaseParser.PRECISION, SqlBaseParser.PRIVILEGES, SqlBaseParser.PROPERTIES, SqlBaseParser.PRUNE, SqlBaseParser.QUOTES, SqlBaseParser.RANGE, SqlBaseParser.READ, SqlBaseParser.REFRESH, SqlBaseParser.RENAME, SqlBaseParser.REPEATABLE, SqlBaseParser.REPLACE, SqlBaseParser.RESET, SqlBaseParser.RESPECT, SqlBaseParser.RESTRICT, SqlBaseParser.RETURNING, SqlBaseParser.REVOKE, SqlBaseParser.ROLE, SqlBaseParser.ROLES, SqlBaseParser.ROLLBACK, SqlBaseParser.ROW, SqlBaseParser.ROWS, SqlBaseParser.RUNNING, SqlBaseParser.SCALAR, SqlBaseParser.SCHEMA, SqlBaseParser.SCHEMAS, SqlBaseParser.SECOND, SqlBaseParser.SECURITY, SqlBaseParser.SEEK, SqlBaseParser.SERIALIZABLE, SqlBaseParser.SESSION, SqlBaseParser.SET, SqlBaseParser.SETS, SqlBaseParser.SHOW, SqlBaseParser.SOME, SqlBaseParser.START, SqlBaseParser.STATS, SqlBaseParser.SUBSET, SqlBaseParser.SUBSTRING, SqlBaseParser.SYSTEM, SqlBaseParser.TABLES, SqlBaseParser.TABLESAMPLE, SqlBaseParser.TEXT, SqlBaseParser.TEXT_STRING, SqlBaseParser.TIES, SqlBaseParser.TIME, SqlBaseParser.TIMESTAMP, SqlBaseParser.TO, SqlBaseParser.TRAILING, SqlBaseParser.TRANSACTION, SqlBaseParser.TRUNCATE, SqlBaseParser.TRY_CAST, SqlBaseParser.TYPE, SqlBaseParser.UNBOUNDED, SqlBaseParser.UNCOMMITTED, SqlBaseParser.UNCONDITIONAL, SqlBaseParser.UNIQUE, SqlBaseParser.UNKNOWN, SqlBaseParser.UNMATCHED, SqlBaseParser.UPDATE, SqlBaseParser.USE, SqlBaseParser.USER, SqlBaseParser.UTF16, SqlBaseParser.UTF32, SqlBaseParser.UTF8, SqlBaseParser.VALIDATE, SqlBaseParser.VALUE, SqlBaseParser.VERBOSE, SqlBaseParser.VERSION, SqlBaseParser.VIEW, SqlBaseParser.WINDOW, SqlBaseParser.WITHIN, SqlBaseParser.WITHOUT, SqlBaseParser.WORK, SqlBaseParser.WRAPPER, SqlBaseParser.WRITE, SqlBaseParser.YEAR, SqlBaseParser.ZONE, SqlBaseParser.IDENTIFIER, SqlBaseParser.DIGIT_IDENTIFIER, SqlBaseParser.QUOTED_IDENTIFIER, SqlBaseParser.BACKQUOTED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2566
                self.type_(0)
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WhenClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.condition = None # ExpressionContext
            self.result = None # ExpressionContext

        def WHEN(self):
            return self.getToken(SqlBaseParser.WHEN, 0)

        def THEN(self):
            return self.getToken(SqlBaseParser.THEN, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_whenClause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWhenClause" ):
                listener.enterWhenClause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWhenClause" ):
                listener.exitWhenClause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWhenClause" ):
                return visitor.visitWhenClause(self)
            else:
                return visitor.visitChildren(self)




    def whenClause(self):

        localctx = SqlBaseParser.WhenClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_whenClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2569
            self.match(SqlBaseParser.WHEN)
            self.state = 2570
            localctx.condition = self.expression()
            self.state = 2571
            self.match(SqlBaseParser.THEN)
            self.state = 2572
            localctx.result = self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Filter_Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FILTER(self):
            return self.getToken(SqlBaseParser.FILTER, 0)

        def WHERE(self):
            return self.getToken(SqlBaseParser.WHERE, 0)

        def booleanExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_filter_

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFilter_" ):
                listener.enterFilter_(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFilter_" ):
                listener.exitFilter_(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFilter_" ):
                return visitor.visitFilter_(self)
            else:
                return visitor.visitChildren(self)




    def filter_(self):

        localctx = SqlBaseParser.Filter_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_filter_)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2574
            self.match(SqlBaseParser.FILTER)
            self.state = 2575
            self.match(SqlBaseParser.T__1)
            self.state = 2576
            self.match(SqlBaseParser.WHERE)
            self.state = 2577
            self.booleanExpression(0)
            self.state = 2578
            self.match(SqlBaseParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MergeCaseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_mergeCase

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class MergeInsertContext(MergeCaseContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.MergeCaseContext
            super().__init__(parser)
            self.condition = None # ExpressionContext
            self._identifier = None # IdentifierContext
            self.targets = list() # of IdentifierContexts
            self._expression = None # ExpressionContext
            self.values = list() # of ExpressionContexts
            self.copyFrom(ctx)

        def WHEN(self):
            return self.getToken(SqlBaseParser.WHEN, 0)
        def NOT(self):
            return self.getToken(SqlBaseParser.NOT, 0)
        def MATCHED(self):
            return self.getToken(SqlBaseParser.MATCHED, 0)
        def THEN(self):
            return self.getToken(SqlBaseParser.THEN, 0)
        def INSERT(self):
            return self.getToken(SqlBaseParser.INSERT, 0)
        def VALUES(self):
            return self.getToken(SqlBaseParser.VALUES, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)

        def AND(self):
            return self.getToken(SqlBaseParser.AND, 0)
        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMergeInsert" ):
                listener.enterMergeInsert(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMergeInsert" ):
                listener.exitMergeInsert(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMergeInsert" ):
                return visitor.visitMergeInsert(self)
            else:
                return visitor.visitChildren(self)


    class MergeUpdateContext(MergeCaseContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.MergeCaseContext
            super().__init__(parser)
            self.condition = None # ExpressionContext
            self._identifier = None # IdentifierContext
            self.targets = list() # of IdentifierContexts
            self._expression = None # ExpressionContext
            self.values = list() # of ExpressionContexts
            self.copyFrom(ctx)

        def WHEN(self):
            return self.getToken(SqlBaseParser.WHEN, 0)
        def MATCHED(self):
            return self.getToken(SqlBaseParser.MATCHED, 0)
        def THEN(self):
            return self.getToken(SqlBaseParser.THEN, 0)
        def UPDATE(self):
            return self.getToken(SqlBaseParser.UPDATE, 0)
        def SET(self):
            return self.getToken(SqlBaseParser.SET, 0)
        def EQ(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.EQ)
            else:
                return self.getToken(SqlBaseParser.EQ, i)
        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,i)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,i)

        def AND(self):
            return self.getToken(SqlBaseParser.AND, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMergeUpdate" ):
                listener.enterMergeUpdate(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMergeUpdate" ):
                listener.exitMergeUpdate(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMergeUpdate" ):
                return visitor.visitMergeUpdate(self)
            else:
                return visitor.visitChildren(self)


    class MergeDeleteContext(MergeCaseContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.MergeCaseContext
            super().__init__(parser)
            self.condition = None # ExpressionContext
            self.copyFrom(ctx)

        def WHEN(self):
            return self.getToken(SqlBaseParser.WHEN, 0)
        def MATCHED(self):
            return self.getToken(SqlBaseParser.MATCHED, 0)
        def THEN(self):
            return self.getToken(SqlBaseParser.THEN, 0)
        def DELETE(self):
            return self.getToken(SqlBaseParser.DELETE, 0)
        def AND(self):
            return self.getToken(SqlBaseParser.AND, 0)
        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMergeDelete" ):
                listener.enterMergeDelete(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMergeDelete" ):
                listener.exitMergeDelete(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMergeDelete" ):
                return visitor.visitMergeDelete(self)
            else:
                return visitor.visitChildren(self)



    def mergeCase(self):

        localctx = SqlBaseParser.MergeCaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_mergeCase)
        self._la = 0 # Token type
        try:
            self.state = 2644
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,350,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.MergeUpdateContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2580
                self.match(SqlBaseParser.WHEN)
                self.state = 2581
                self.match(SqlBaseParser.MATCHED)
                self.state = 2584
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.AND:
                    self.state = 2582
                    self.match(SqlBaseParser.AND)
                    self.state = 2583
                    localctx.condition = self.expression()


                self.state = 2586
                self.match(SqlBaseParser.THEN)
                self.state = 2587
                self.match(SqlBaseParser.UPDATE)
                self.state = 2588
                self.match(SqlBaseParser.SET)
                self.state = 2589
                localctx._identifier = self.identifier()
                localctx.targets.append(localctx._identifier)
                self.state = 2590
                self.match(SqlBaseParser.EQ)
                self.state = 2591
                localctx._expression = self.expression()
                localctx.values.append(localctx._expression)
                self.state = 2599
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 2592
                    self.match(SqlBaseParser.T__3)
                    self.state = 2593
                    localctx._identifier = self.identifier()
                    localctx.targets.append(localctx._identifier)
                    self.state = 2594
                    self.match(SqlBaseParser.EQ)
                    self.state = 2595
                    localctx._expression = self.expression()
                    localctx.values.append(localctx._expression)
                    self.state = 2601
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)


            elif la_ == 2:
                localctx = SqlBaseParser.MergeDeleteContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2602
                self.match(SqlBaseParser.WHEN)
                self.state = 2603
                self.match(SqlBaseParser.MATCHED)
                self.state = 2606
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.AND:
                    self.state = 2604
                    self.match(SqlBaseParser.AND)
                    self.state = 2605
                    localctx.condition = self.expression()


                self.state = 2608
                self.match(SqlBaseParser.THEN)
                self.state = 2609
                self.match(SqlBaseParser.DELETE)

            elif la_ == 3:
                localctx = SqlBaseParser.MergeInsertContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2610
                self.match(SqlBaseParser.WHEN)
                self.state = 2611
                self.match(SqlBaseParser.NOT)
                self.state = 2612
                self.match(SqlBaseParser.MATCHED)
                self.state = 2615
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.AND:
                    self.state = 2613
                    self.match(SqlBaseParser.AND)
                    self.state = 2614
                    localctx.condition = self.expression()


                self.state = 2617
                self.match(SqlBaseParser.THEN)
                self.state = 2618
                self.match(SqlBaseParser.INSERT)
                self.state = 2630
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.T__1:
                    self.state = 2619
                    self.match(SqlBaseParser.T__1)
                    self.state = 2620
                    localctx._identifier = self.identifier()
                    localctx.targets.append(localctx._identifier)
                    self.state = 2625
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SqlBaseParser.T__3:
                        self.state = 2621
                        self.match(SqlBaseParser.T__3)
                        self.state = 2622
                        localctx._identifier = self.identifier()
                        localctx.targets.append(localctx._identifier)
                        self.state = 2627
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 2628
                    self.match(SqlBaseParser.T__2)


                self.state = 2632
                self.match(SqlBaseParser.VALUES)
                self.state = 2633
                self.match(SqlBaseParser.T__1)
                self.state = 2634
                localctx._expression = self.expression()
                localctx.values.append(localctx._expression)
                self.state = 2639
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 2635
                    self.match(SqlBaseParser.T__3)
                    self.state = 2636
                    localctx._expression = self.expression()
                    localctx.values.append(localctx._expression)
                    self.state = 2641
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2642
                self.match(SqlBaseParser.T__2)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OverContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.windowName = None # IdentifierContext

        def OVER(self):
            return self.getToken(SqlBaseParser.OVER, 0)

        def windowSpecification(self):
            return self.getTypedRuleContext(SqlBaseParser.WindowSpecificationContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_over

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOver" ):
                listener.enterOver(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOver" ):
                listener.exitOver(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOver" ):
                return visitor.visitOver(self)
            else:
                return visitor.visitChildren(self)




    def over(self):

        localctx = SqlBaseParser.OverContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_over)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2646
            self.match(SqlBaseParser.OVER)
            self.state = 2652
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.ABSENT, SqlBaseParser.ADD, SqlBaseParser.ADMIN, SqlBaseParser.AFTER, SqlBaseParser.ALL, SqlBaseParser.ANALYZE, SqlBaseParser.ANY, SqlBaseParser.ARRAY, SqlBaseParser.ASC, SqlBaseParser.AT, SqlBaseParser.AUTHORIZATION, SqlBaseParser.BERNOULLI, SqlBaseParser.BOTH, SqlBaseParser.CALL, SqlBaseParser.CASCADE, SqlBaseParser.CATALOGS, SqlBaseParser.COLUMN, SqlBaseParser.COLUMNS, SqlBaseParser.COMMENT, SqlBaseParser.COMMIT, SqlBaseParser.COMMITTED, SqlBaseParser.CONDITIONAL, SqlBaseParser.COUNT, SqlBaseParser.COPARTITION, SqlBaseParser.CURRENT, SqlBaseParser.DATA, SqlBaseParser.DATE, SqlBaseParser.DAY, SqlBaseParser.DEFAULT, SqlBaseParser.DEFINER, SqlBaseParser.DENY, SqlBaseParser.DESC, SqlBaseParser.DESCRIPTOR, SqlBaseParser.DEFINE, SqlBaseParser.DISTRIBUTED, SqlBaseParser.DOUBLE, SqlBaseParser.EMPTY, SqlBaseParser.ENCODING, SqlBaseParser.ERROR, SqlBaseParser.EXCLUDING, SqlBaseParser.EXPLAIN, SqlBaseParser.FETCH, SqlBaseParser.FILTER, SqlBaseParser.FINAL, SqlBaseParser.FIRST, SqlBaseParser.FOLLOWING, SqlBaseParser.FORMAT, SqlBaseParser.FUNCTIONS, SqlBaseParser.GRANT, SqlBaseParser.GRANTED, SqlBaseParser.GRANTS, SqlBaseParser.GRAPHVIZ, SqlBaseParser.GROUPS, SqlBaseParser.HOUR, SqlBaseParser.IF, SqlBaseParser.IGNORE, SqlBaseParser.INCLUDING, SqlBaseParser.INITIAL, SqlBaseParser.INPUT, SqlBaseParser.INTERVAL, SqlBaseParser.INVOKER, SqlBaseParser.IO, SqlBaseParser.ISOLATION, SqlBaseParser.JSON, SqlBaseParser.KEEP, SqlBaseParser.KEY, SqlBaseParser.KEYS, SqlBaseParser.LAST, SqlBaseParser.LATERAL, SqlBaseParser.LEADING, SqlBaseParser.LEVEL, SqlBaseParser.LIMIT, SqlBaseParser.LOCAL, SqlBaseParser.LOGICAL, SqlBaseParser.MAP, SqlBaseParser.MATCH, SqlBaseParser.MATCHED, SqlBaseParser.MATCHES, SqlBaseParser.MATCH_RECOGNIZE, SqlBaseParser.MATERIALIZED, SqlBaseParser.MEASURES, SqlBaseParser.MERGE, SqlBaseParser.MINUTE, SqlBaseParser.MONTH, SqlBaseParser.NEXT, SqlBaseParser.NFC, SqlBaseParser.NFD, SqlBaseParser.NFKC, SqlBaseParser.NFKD, SqlBaseParser.NO, SqlBaseParser.NONE, SqlBaseParser.NULLIF, SqlBaseParser.NULLS, SqlBaseParser.OBJECT, SqlBaseParser.OFFSET, SqlBaseParser.OMIT, SqlBaseParser.OF, SqlBaseParser.ONE, SqlBaseParser.ONLY, SqlBaseParser.OPTION, SqlBaseParser.ORDINALITY, SqlBaseParser.OUTPUT, SqlBaseParser.OVER, SqlBaseParser.OVERFLOW, SqlBaseParser.PARTITION, SqlBaseParser.PARTITIONS, SqlBaseParser.PASSING, SqlBaseParser.PAST, SqlBaseParser.PATH, SqlBaseParser.PATTERN, SqlBaseParser.PER, SqlBaseParser.PERMUTE, SqlBaseParser.POSITION, SqlBaseParser.PRECEDING, SqlBaseParser.PRECISION, SqlBaseParser.PRIVILEGES, SqlBaseParser.PROPERTIES, SqlBaseParser.PRUNE, SqlBaseParser.QUOTES, SqlBaseParser.RANGE, SqlBaseParser.READ, SqlBaseParser.REFRESH, SqlBaseParser.RENAME, SqlBaseParser.REPEATABLE, SqlBaseParser.REPLACE, SqlBaseParser.RESET, SqlBaseParser.RESPECT, SqlBaseParser.RESTRICT, SqlBaseParser.RETURNING, SqlBaseParser.REVOKE, SqlBaseParser.ROLE, SqlBaseParser.ROLES, SqlBaseParser.ROLLBACK, SqlBaseParser.ROW, SqlBaseParser.ROWS, SqlBaseParser.RUNNING, SqlBaseParser.SCALAR, SqlBaseParser.SCHEMA, SqlBaseParser.SCHEMAS, SqlBaseParser.SECOND, SqlBaseParser.SECURITY, SqlBaseParser.SEEK, SqlBaseParser.SERIALIZABLE, SqlBaseParser.SESSION, SqlBaseParser.SET, SqlBaseParser.SETS, SqlBaseParser.SHOW, SqlBaseParser.SOME, SqlBaseParser.START, SqlBaseParser.STATS, SqlBaseParser.SUBSET, SqlBaseParser.SUBSTRING, SqlBaseParser.SYSTEM, SqlBaseParser.TABLES, SqlBaseParser.TABLESAMPLE, SqlBaseParser.TEXT, SqlBaseParser.TEXT_STRING, SqlBaseParser.TIES, SqlBaseParser.TIME, SqlBaseParser.TIMESTAMP, SqlBaseParser.TO, SqlBaseParser.TRAILING, SqlBaseParser.TRANSACTION, SqlBaseParser.TRUNCATE, SqlBaseParser.TRY_CAST, SqlBaseParser.TYPE, SqlBaseParser.UNBOUNDED, SqlBaseParser.UNCOMMITTED, SqlBaseParser.UNCONDITIONAL, SqlBaseParser.UNIQUE, SqlBaseParser.UNKNOWN, SqlBaseParser.UNMATCHED, SqlBaseParser.UPDATE, SqlBaseParser.USE, SqlBaseParser.USER, SqlBaseParser.UTF16, SqlBaseParser.UTF32, SqlBaseParser.UTF8, SqlBaseParser.VALIDATE, SqlBaseParser.VALUE, SqlBaseParser.VERBOSE, SqlBaseParser.VERSION, SqlBaseParser.VIEW, SqlBaseParser.WINDOW, SqlBaseParser.WITHIN, SqlBaseParser.WITHOUT, SqlBaseParser.WORK, SqlBaseParser.WRAPPER, SqlBaseParser.WRITE, SqlBaseParser.YEAR, SqlBaseParser.ZONE, SqlBaseParser.IDENTIFIER, SqlBaseParser.DIGIT_IDENTIFIER, SqlBaseParser.QUOTED_IDENTIFIER, SqlBaseParser.BACKQUOTED_IDENTIFIER]:
                self.state = 2647
                localctx.windowName = self.identifier()
            elif token in [SqlBaseParser.T__1]:
                self.state = 2648
                self.match(SqlBaseParser.T__1)
                self.state = 2649
                self.windowSpecification()
                self.state = 2650
                self.match(SqlBaseParser.T__2)
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WindowFrameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def frameExtent(self):
            return self.getTypedRuleContext(SqlBaseParser.FrameExtentContext,0)


        def MEASURES(self):
            return self.getToken(SqlBaseParser.MEASURES, 0)

        def measureDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.MeasureDefinitionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.MeasureDefinitionContext,i)


        def AFTER(self):
            return self.getToken(SqlBaseParser.AFTER, 0)

        def MATCH(self):
            return self.getToken(SqlBaseParser.MATCH, 0)

        def skipTo(self):
            return self.getTypedRuleContext(SqlBaseParser.SkipToContext,0)


        def PATTERN(self):
            return self.getToken(SqlBaseParser.PATTERN, 0)

        def rowPattern(self):
            return self.getTypedRuleContext(SqlBaseParser.RowPatternContext,0)


        def SUBSET(self):
            return self.getToken(SqlBaseParser.SUBSET, 0)

        def subsetDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.SubsetDefinitionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.SubsetDefinitionContext,i)


        def DEFINE(self):
            return self.getToken(SqlBaseParser.DEFINE, 0)

        def variableDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.VariableDefinitionContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.VariableDefinitionContext,i)


        def INITIAL(self):
            return self.getToken(SqlBaseParser.INITIAL, 0)

        def SEEK(self):
            return self.getToken(SqlBaseParser.SEEK, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_windowFrame

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWindowFrame" ):
                listener.enterWindowFrame(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWindowFrame" ):
                listener.exitWindowFrame(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWindowFrame" ):
                return visitor.visitWindowFrame(self)
            else:
                return visitor.visitChildren(self)




    def windowFrame(self):

        localctx = SqlBaseParser.WindowFrameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_windowFrame)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2663
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.MEASURES:
                self.state = 2654
                self.match(SqlBaseParser.MEASURES)
                self.state = 2655
                self.measureDefinition()
                self.state = 2660
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 2656
                    self.match(SqlBaseParser.T__3)
                    self.state = 2657
                    self.measureDefinition()
                    self.state = 2662
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 2665
            self.frameExtent()
            self.state = 2669
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.AFTER:
                self.state = 2666
                self.match(SqlBaseParser.AFTER)
                self.state = 2667
                self.match(SqlBaseParser.MATCH)
                self.state = 2668
                self.skipTo()


            self.state = 2672
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.INITIAL or _la==SqlBaseParser.SEEK:
                self.state = 2671
                _la = self._input.LA(1)
                if not(_la==SqlBaseParser.INITIAL or _la==SqlBaseParser.SEEK):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 2679
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.PATTERN:
                self.state = 2674
                self.match(SqlBaseParser.PATTERN)
                self.state = 2675
                self.match(SqlBaseParser.T__1)
                self.state = 2676
                self.rowPattern(0)
                self.state = 2677
                self.match(SqlBaseParser.T__2)


            self.state = 2690
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.SUBSET:
                self.state = 2681
                self.match(SqlBaseParser.SUBSET)
                self.state = 2682
                self.subsetDefinition()
                self.state = 2687
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 2683
                    self.match(SqlBaseParser.T__3)
                    self.state = 2684
                    self.subsetDefinition()
                    self.state = 2689
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 2701
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SqlBaseParser.DEFINE:
                self.state = 2692
                self.match(SqlBaseParser.DEFINE)
                self.state = 2693
                self.variableDefinition()
                self.state = 2698
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 2694
                    self.match(SqlBaseParser.T__3)
                    self.state = 2695
                    self.variableDefinition()
                    self.state = 2700
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FrameExtentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.frameType = None # Token
            self.start = None # FrameBoundContext
            self.end = None # FrameBoundContext

        def RANGE(self):
            return self.getToken(SqlBaseParser.RANGE, 0)

        def frameBound(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.FrameBoundContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.FrameBoundContext,i)


        def ROWS(self):
            return self.getToken(SqlBaseParser.ROWS, 0)

        def GROUPS(self):
            return self.getToken(SqlBaseParser.GROUPS, 0)

        def BETWEEN(self):
            return self.getToken(SqlBaseParser.BETWEEN, 0)

        def AND(self):
            return self.getToken(SqlBaseParser.AND, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_frameExtent

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFrameExtent" ):
                listener.enterFrameExtent(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFrameExtent" ):
                listener.exitFrameExtent(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFrameExtent" ):
                return visitor.visitFrameExtent(self)
            else:
                return visitor.visitChildren(self)




    def frameExtent(self):

        localctx = SqlBaseParser.FrameExtentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_frameExtent)
        try:
            self.state = 2727
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,361,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2703
                localctx.frameType = self.match(SqlBaseParser.RANGE)
                self.state = 2704
                localctx.start = self.frameBound()

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2705
                localctx.frameType = self.match(SqlBaseParser.ROWS)
                self.state = 2706
                localctx.start = self.frameBound()

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2707
                localctx.frameType = self.match(SqlBaseParser.GROUPS)
                self.state = 2708
                localctx.start = self.frameBound()

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2709
                localctx.frameType = self.match(SqlBaseParser.RANGE)
                self.state = 2710
                self.match(SqlBaseParser.BETWEEN)
                self.state = 2711
                localctx.start = self.frameBound()
                self.state = 2712
                self.match(SqlBaseParser.AND)
                self.state = 2713
                localctx.end = self.frameBound()

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2715
                localctx.frameType = self.match(SqlBaseParser.ROWS)
                self.state = 2716
                self.match(SqlBaseParser.BETWEEN)
                self.state = 2717
                localctx.start = self.frameBound()
                self.state = 2718
                self.match(SqlBaseParser.AND)
                self.state = 2719
                localctx.end = self.frameBound()

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2721
                localctx.frameType = self.match(SqlBaseParser.GROUPS)
                self.state = 2722
                self.match(SqlBaseParser.BETWEEN)
                self.state = 2723
                localctx.start = self.frameBound()
                self.state = 2724
                self.match(SqlBaseParser.AND)
                self.state = 2725
                localctx.end = self.frameBound()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FrameBoundContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_frameBound

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class BoundedFrameContext(FrameBoundContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.FrameBoundContext
            super().__init__(parser)
            self.boundType = None # Token
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)

        def PRECEDING(self):
            return self.getToken(SqlBaseParser.PRECEDING, 0)
        def FOLLOWING(self):
            return self.getToken(SqlBaseParser.FOLLOWING, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBoundedFrame" ):
                listener.enterBoundedFrame(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBoundedFrame" ):
                listener.exitBoundedFrame(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBoundedFrame" ):
                return visitor.visitBoundedFrame(self)
            else:
                return visitor.visitChildren(self)


    class UnboundedFrameContext(FrameBoundContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.FrameBoundContext
            super().__init__(parser)
            self.boundType = None # Token
            self.copyFrom(ctx)

        def UNBOUNDED(self):
            return self.getToken(SqlBaseParser.UNBOUNDED, 0)
        def PRECEDING(self):
            return self.getToken(SqlBaseParser.PRECEDING, 0)
        def FOLLOWING(self):
            return self.getToken(SqlBaseParser.FOLLOWING, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnboundedFrame" ):
                listener.enterUnboundedFrame(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnboundedFrame" ):
                listener.exitUnboundedFrame(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnboundedFrame" ):
                return visitor.visitUnboundedFrame(self)
            else:
                return visitor.visitChildren(self)


    class CurrentRowBoundContext(FrameBoundContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.FrameBoundContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CURRENT(self):
            return self.getToken(SqlBaseParser.CURRENT, 0)
        def ROW(self):
            return self.getToken(SqlBaseParser.ROW, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCurrentRowBound" ):
                listener.enterCurrentRowBound(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCurrentRowBound" ):
                listener.exitCurrentRowBound(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCurrentRowBound" ):
                return visitor.visitCurrentRowBound(self)
            else:
                return visitor.visitChildren(self)



    def frameBound(self):

        localctx = SqlBaseParser.FrameBoundContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_frameBound)
        self._la = 0 # Token type
        try:
            self.state = 2738
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,362,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.UnboundedFrameContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2729
                self.match(SqlBaseParser.UNBOUNDED)
                self.state = 2730
                localctx.boundType = self.match(SqlBaseParser.PRECEDING)

            elif la_ == 2:
                localctx = SqlBaseParser.UnboundedFrameContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2731
                self.match(SqlBaseParser.UNBOUNDED)
                self.state = 2732
                localctx.boundType = self.match(SqlBaseParser.FOLLOWING)

            elif la_ == 3:
                localctx = SqlBaseParser.CurrentRowBoundContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2733
                self.match(SqlBaseParser.CURRENT)
                self.state = 2734
                self.match(SqlBaseParser.ROW)

            elif la_ == 4:
                localctx = SqlBaseParser.BoundedFrameContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2735
                self.expression()
                self.state = 2736
                localctx.boundType = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==SqlBaseParser.FOLLOWING or _la==SqlBaseParser.PRECEDING):
                    localctx.boundType = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RowPatternContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_rowPattern

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class QuantifiedPrimaryContext(RowPatternContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.RowPatternContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def patternPrimary(self):
            return self.getTypedRuleContext(SqlBaseParser.PatternPrimaryContext,0)

        def patternQuantifier(self):
            return self.getTypedRuleContext(SqlBaseParser.PatternQuantifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQuantifiedPrimary" ):
                listener.enterQuantifiedPrimary(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQuantifiedPrimary" ):
                listener.exitQuantifiedPrimary(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQuantifiedPrimary" ):
                return visitor.visitQuantifiedPrimary(self)
            else:
                return visitor.visitChildren(self)


    class PatternConcatenationContext(RowPatternContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.RowPatternContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def rowPattern(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.RowPatternContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.RowPatternContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPatternConcatenation" ):
                listener.enterPatternConcatenation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPatternConcatenation" ):
                listener.exitPatternConcatenation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPatternConcatenation" ):
                return visitor.visitPatternConcatenation(self)
            else:
                return visitor.visitChildren(self)


    class PatternAlternationContext(RowPatternContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.RowPatternContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def rowPattern(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.RowPatternContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.RowPatternContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPatternAlternation" ):
                listener.enterPatternAlternation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPatternAlternation" ):
                listener.exitPatternAlternation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPatternAlternation" ):
                return visitor.visitPatternAlternation(self)
            else:
                return visitor.visitChildren(self)



    def rowPattern(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SqlBaseParser.RowPatternContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 178
        self.enterRecursionRule(localctx, 178, self.RULE_rowPattern, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            localctx = SqlBaseParser.QuantifiedPrimaryContext(self, localctx)
            self._ctx = localctx
            _prevctx = localctx

            self.state = 2741
            self.patternPrimary()
            self.state = 2743
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,363,self._ctx)
            if la_ == 1:
                self.state = 2742
                self.patternQuantifier()


            self._ctx.stop = self._input.LT(-1)
            self.state = 2752
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,365,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 2750
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,364,self._ctx)
                    if la_ == 1:
                        localctx = SqlBaseParser.PatternConcatenationContext(self, SqlBaseParser.RowPatternContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_rowPattern)
                        self.state = 2745
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import (
                                FailedPredicateException,
                            )
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 2746
                        self.rowPattern(3)

                    elif la_ == 2:
                        localctx = SqlBaseParser.PatternAlternationContext(self, SqlBaseParser.RowPatternContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_rowPattern)
                        self.state = 2747
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import (
                                FailedPredicateException,
                            )
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 2748
                        self.match(SqlBaseParser.T__10)
                        self.state = 2749
                        self.rowPattern(2)

             
                self.state = 2754
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,365,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class PatternPrimaryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_patternPrimary

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class PatternPermutationContext(PatternPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PatternPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def PERMUTE(self):
            return self.getToken(SqlBaseParser.PERMUTE, 0)
        def rowPattern(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.RowPatternContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.RowPatternContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPatternPermutation" ):
                listener.enterPatternPermutation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPatternPermutation" ):
                listener.exitPatternPermutation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPatternPermutation" ):
                return visitor.visitPatternPermutation(self)
            else:
                return visitor.visitChildren(self)


    class PartitionEndAnchorContext(PatternPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PatternPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPartitionEndAnchor" ):
                listener.enterPartitionEndAnchor(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPartitionEndAnchor" ):
                listener.exitPartitionEndAnchor(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPartitionEndAnchor" ):
                return visitor.visitPartitionEndAnchor(self)
            else:
                return visitor.visitChildren(self)


    class PatternVariableContext(PatternPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PatternPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPatternVariable" ):
                listener.enterPatternVariable(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPatternVariable" ):
                listener.exitPatternVariable(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPatternVariable" ):
                return visitor.visitPatternVariable(self)
            else:
                return visitor.visitChildren(self)


    class ExcludedPatternContext(PatternPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PatternPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def rowPattern(self):
            return self.getTypedRuleContext(SqlBaseParser.RowPatternContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExcludedPattern" ):
                listener.enterExcludedPattern(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExcludedPattern" ):
                listener.exitExcludedPattern(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExcludedPattern" ):
                return visitor.visitExcludedPattern(self)
            else:
                return visitor.visitChildren(self)


    class PartitionStartAnchorContext(PatternPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PatternPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPartitionStartAnchor" ):
                listener.enterPartitionStartAnchor(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPartitionStartAnchor" ):
                listener.exitPartitionStartAnchor(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPartitionStartAnchor" ):
                return visitor.visitPartitionStartAnchor(self)
            else:
                return visitor.visitChildren(self)


    class EmptyPatternContext(PatternPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PatternPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEmptyPattern" ):
                listener.enterEmptyPattern(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEmptyPattern" ):
                listener.exitEmptyPattern(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEmptyPattern" ):
                return visitor.visitEmptyPattern(self)
            else:
                return visitor.visitChildren(self)


    class GroupedPatternContext(PatternPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PatternPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def rowPattern(self):
            return self.getTypedRuleContext(SqlBaseParser.RowPatternContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGroupedPattern" ):
                listener.enterGroupedPattern(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGroupedPattern" ):
                listener.exitGroupedPattern(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGroupedPattern" ):
                return visitor.visitGroupedPattern(self)
            else:
                return visitor.visitChildren(self)



    def patternPrimary(self):

        localctx = SqlBaseParser.PatternPrimaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_patternPrimary)
        self._la = 0 # Token type
        try:
            self.state = 2780
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,367,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.PatternVariableContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2755
                self.identifier()

            elif la_ == 2:
                localctx = SqlBaseParser.EmptyPatternContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2756
                self.match(SqlBaseParser.T__1)
                self.state = 2757
                self.match(SqlBaseParser.T__2)

            elif la_ == 3:
                localctx = SqlBaseParser.PatternPermutationContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2758
                self.match(SqlBaseParser.PERMUTE)
                self.state = 2759
                self.match(SqlBaseParser.T__1)
                self.state = 2760
                self.rowPattern(0)
                self.state = 2765
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SqlBaseParser.T__3:
                    self.state = 2761
                    self.match(SqlBaseParser.T__3)
                    self.state = 2762
                    self.rowPattern(0)
                    self.state = 2767
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2768
                self.match(SqlBaseParser.T__2)

            elif la_ == 4:
                localctx = SqlBaseParser.GroupedPatternContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2770
                self.match(SqlBaseParser.T__1)
                self.state = 2771
                self.rowPattern(0)
                self.state = 2772
                self.match(SqlBaseParser.T__2)

            elif la_ == 5:
                localctx = SqlBaseParser.PartitionStartAnchorContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 2774
                self.match(SqlBaseParser.T__11)

            elif la_ == 6:
                localctx = SqlBaseParser.PartitionEndAnchorContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 2775
                self.match(SqlBaseParser.T__12)

            elif la_ == 7:
                localctx = SqlBaseParser.ExcludedPatternContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 2776
                self.match(SqlBaseParser.T__13)
                self.state = 2777
                self.rowPattern(0)
                self.state = 2778
                self.match(SqlBaseParser.T__14)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PatternQuantifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_patternQuantifier

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class ZeroOrMoreQuantifierContext(PatternQuantifierContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PatternQuantifierContext
            super().__init__(parser)
            self.reluctant = None # Token
            self.copyFrom(ctx)

        def ASTERISK(self):
            return self.getToken(SqlBaseParser.ASTERISK, 0)
        def QUESTION_MARK(self):
            return self.getToken(SqlBaseParser.QUESTION_MARK, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterZeroOrMoreQuantifier" ):
                listener.enterZeroOrMoreQuantifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitZeroOrMoreQuantifier" ):
                listener.exitZeroOrMoreQuantifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitZeroOrMoreQuantifier" ):
                return visitor.visitZeroOrMoreQuantifier(self)
            else:
                return visitor.visitChildren(self)


    class OneOrMoreQuantifierContext(PatternQuantifierContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PatternQuantifierContext
            super().__init__(parser)
            self.reluctant = None # Token
            self.copyFrom(ctx)

        def PLUS(self):
            return self.getToken(SqlBaseParser.PLUS, 0)
        def QUESTION_MARK(self):
            return self.getToken(SqlBaseParser.QUESTION_MARK, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOneOrMoreQuantifier" ):
                listener.enterOneOrMoreQuantifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOneOrMoreQuantifier" ):
                listener.exitOneOrMoreQuantifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOneOrMoreQuantifier" ):
                return visitor.visitOneOrMoreQuantifier(self)
            else:
                return visitor.visitChildren(self)


    class ZeroOrOneQuantifierContext(PatternQuantifierContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PatternQuantifierContext
            super().__init__(parser)
            self.reluctant = None # Token
            self.copyFrom(ctx)

        def QUESTION_MARK(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.QUESTION_MARK)
            else:
                return self.getToken(SqlBaseParser.QUESTION_MARK, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterZeroOrOneQuantifier" ):
                listener.enterZeroOrOneQuantifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitZeroOrOneQuantifier" ):
                listener.exitZeroOrOneQuantifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitZeroOrOneQuantifier" ):
                return visitor.visitZeroOrOneQuantifier(self)
            else:
                return visitor.visitChildren(self)


    class RangeQuantifierContext(PatternQuantifierContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PatternQuantifierContext
            super().__init__(parser)
            self.exactly = None # Token
            self.reluctant = None # Token
            self.atLeast = None # Token
            self.atMost = None # Token
            self.copyFrom(ctx)

        def INTEGER_VALUE(self, i:int=None):
            if i is None:
                return self.getTokens(SqlBaseParser.INTEGER_VALUE)
            else:
                return self.getToken(SqlBaseParser.INTEGER_VALUE, i)
        def QUESTION_MARK(self):
            return self.getToken(SqlBaseParser.QUESTION_MARK, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRangeQuantifier" ):
                listener.enterRangeQuantifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRangeQuantifier" ):
                listener.exitRangeQuantifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRangeQuantifier" ):
                return visitor.visitRangeQuantifier(self)
            else:
                return visitor.visitChildren(self)



    def patternQuantifier(self):

        localctx = SqlBaseParser.PatternQuantifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_patternQuantifier)
        self._la = 0 # Token type
        try:
            self.state = 2812
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,375,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.ZeroOrMoreQuantifierContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2782
                self.match(SqlBaseParser.ASTERISK)
                self.state = 2784
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,368,self._ctx)
                if la_ == 1:
                    self.state = 2783
                    localctx.reluctant = self.match(SqlBaseParser.QUESTION_MARK)



            elif la_ == 2:
                localctx = SqlBaseParser.OneOrMoreQuantifierContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2786
                self.match(SqlBaseParser.PLUS)
                self.state = 2788
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,369,self._ctx)
                if la_ == 1:
                    self.state = 2787
                    localctx.reluctant = self.match(SqlBaseParser.QUESTION_MARK)



            elif la_ == 3:
                localctx = SqlBaseParser.ZeroOrOneQuantifierContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2790
                self.match(SqlBaseParser.QUESTION_MARK)
                self.state = 2792
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,370,self._ctx)
                if la_ == 1:
                    self.state = 2791
                    localctx.reluctant = self.match(SqlBaseParser.QUESTION_MARK)



            elif la_ == 4:
                localctx = SqlBaseParser.RangeQuantifierContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2794
                self.match(SqlBaseParser.T__15)
                self.state = 2795
                localctx.exactly = self.match(SqlBaseParser.INTEGER_VALUE)
                self.state = 2796
                self.match(SqlBaseParser.T__16)
                self.state = 2798
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,371,self._ctx)
                if la_ == 1:
                    self.state = 2797
                    localctx.reluctant = self.match(SqlBaseParser.QUESTION_MARK)



            elif la_ == 5:
                localctx = SqlBaseParser.RangeQuantifierContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 2800
                self.match(SqlBaseParser.T__15)
                self.state = 2802
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.INTEGER_VALUE:
                    self.state = 2801
                    localctx.atLeast = self.match(SqlBaseParser.INTEGER_VALUE)


                self.state = 2804
                self.match(SqlBaseParser.T__3)
                self.state = 2806
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.INTEGER_VALUE:
                    self.state = 2805
                    localctx.atMost = self.match(SqlBaseParser.INTEGER_VALUE)


                self.state = 2808
                self.match(SqlBaseParser.T__16)
                self.state = 2810
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,374,self._ctx)
                if la_ == 1:
                    self.state = 2809
                    localctx.reluctant = self.match(SqlBaseParser.QUESTION_MARK)




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UpdateAssignmentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def EQ(self):
            return self.getToken(SqlBaseParser.EQ, 0)

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_updateAssignment

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUpdateAssignment" ):
                listener.enterUpdateAssignment(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUpdateAssignment" ):
                listener.exitUpdateAssignment(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUpdateAssignment" ):
                return visitor.visitUpdateAssignment(self)
            else:
                return visitor.visitChildren(self)




    def updateAssignment(self):

        localctx = SqlBaseParser.UpdateAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_updateAssignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2814
            self.identifier()
            self.state = 2815
            self.match(SqlBaseParser.EQ)
            self.state = 2816
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExplainOptionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_explainOption

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class ExplainFormatContext(ExplainOptionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.ExplainOptionContext
            super().__init__(parser)
            self.value = None # Token
            self.copyFrom(ctx)

        def FORMAT(self):
            return self.getToken(SqlBaseParser.FORMAT, 0)
        def TEXT(self):
            return self.getToken(SqlBaseParser.TEXT, 0)
        def GRAPHVIZ(self):
            return self.getToken(SqlBaseParser.GRAPHVIZ, 0)
        def JSON(self):
            return self.getToken(SqlBaseParser.JSON, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExplainFormat" ):
                listener.enterExplainFormat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExplainFormat" ):
                listener.exitExplainFormat(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExplainFormat" ):
                return visitor.visitExplainFormat(self)
            else:
                return visitor.visitChildren(self)


    class ExplainTypeContext(ExplainOptionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.ExplainOptionContext
            super().__init__(parser)
            self.value = None # Token
            self.copyFrom(ctx)

        def TYPE(self):
            return self.getToken(SqlBaseParser.TYPE, 0)
        def LOGICAL(self):
            return self.getToken(SqlBaseParser.LOGICAL, 0)
        def DISTRIBUTED(self):
            return self.getToken(SqlBaseParser.DISTRIBUTED, 0)
        def VALIDATE(self):
            return self.getToken(SqlBaseParser.VALIDATE, 0)
        def IO(self):
            return self.getToken(SqlBaseParser.IO, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExplainType" ):
                listener.enterExplainType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExplainType" ):
                listener.exitExplainType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExplainType" ):
                return visitor.visitExplainType(self)
            else:
                return visitor.visitChildren(self)



    def explainOption(self):

        localctx = SqlBaseParser.ExplainOptionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_explainOption)
        self._la = 0 # Token type
        try:
            self.state = 2822
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.FORMAT]:
                localctx = SqlBaseParser.ExplainFormatContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2818
                self.match(SqlBaseParser.FORMAT)
                self.state = 2819
                localctx.value = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==SqlBaseParser.GRAPHVIZ or _la==SqlBaseParser.JSON or _la==SqlBaseParser.TEXT):
                    localctx.value = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
            elif token in [SqlBaseParser.TYPE]:
                localctx = SqlBaseParser.ExplainTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2820
                self.match(SqlBaseParser.TYPE)
                self.state = 2821
                localctx.value = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==SqlBaseParser.DISTRIBUTED or _la==SqlBaseParser.IO or _la==SqlBaseParser.LOGICAL or _la==SqlBaseParser.VALIDATE):
                    localctx.value = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TransactionModeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_transactionMode

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class TransactionAccessModeContext(TransactionModeContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.TransactionModeContext
            super().__init__(parser)
            self.accessMode = None # Token
            self.copyFrom(ctx)

        def READ(self):
            return self.getToken(SqlBaseParser.READ, 0)
        def ONLY(self):
            return self.getToken(SqlBaseParser.ONLY, 0)
        def WRITE(self):
            return self.getToken(SqlBaseParser.WRITE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTransactionAccessMode" ):
                listener.enterTransactionAccessMode(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTransactionAccessMode" ):
                listener.exitTransactionAccessMode(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTransactionAccessMode" ):
                return visitor.visitTransactionAccessMode(self)
            else:
                return visitor.visitChildren(self)


    class IsolationLevelContext(TransactionModeContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.TransactionModeContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ISOLATION(self):
            return self.getToken(SqlBaseParser.ISOLATION, 0)
        def LEVEL(self):
            return self.getToken(SqlBaseParser.LEVEL, 0)
        def levelOfIsolation(self):
            return self.getTypedRuleContext(SqlBaseParser.LevelOfIsolationContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIsolationLevel" ):
                listener.enterIsolationLevel(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIsolationLevel" ):
                listener.exitIsolationLevel(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIsolationLevel" ):
                return visitor.visitIsolationLevel(self)
            else:
                return visitor.visitChildren(self)



    def transactionMode(self):

        localctx = SqlBaseParser.TransactionModeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_transactionMode)
        self._la = 0 # Token type
        try:
            self.state = 2829
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.ISOLATION]:
                localctx = SqlBaseParser.IsolationLevelContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2824
                self.match(SqlBaseParser.ISOLATION)
                self.state = 2825
                self.match(SqlBaseParser.LEVEL)
                self.state = 2826
                self.levelOfIsolation()
            elif token in [SqlBaseParser.READ]:
                localctx = SqlBaseParser.TransactionAccessModeContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2827
                self.match(SqlBaseParser.READ)
                self.state = 2828
                localctx.accessMode = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==SqlBaseParser.ONLY or _la==SqlBaseParser.WRITE):
                    localctx.accessMode = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LevelOfIsolationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_levelOfIsolation

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class ReadUncommittedContext(LevelOfIsolationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.LevelOfIsolationContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def READ(self):
            return self.getToken(SqlBaseParser.READ, 0)
        def UNCOMMITTED(self):
            return self.getToken(SqlBaseParser.UNCOMMITTED, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterReadUncommitted" ):
                listener.enterReadUncommitted(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitReadUncommitted" ):
                listener.exitReadUncommitted(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReadUncommitted" ):
                return visitor.visitReadUncommitted(self)
            else:
                return visitor.visitChildren(self)


    class SerializableContext(LevelOfIsolationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.LevelOfIsolationContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SERIALIZABLE(self):
            return self.getToken(SqlBaseParser.SERIALIZABLE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSerializable" ):
                listener.enterSerializable(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSerializable" ):
                listener.exitSerializable(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSerializable" ):
                return visitor.visitSerializable(self)
            else:
                return visitor.visitChildren(self)


    class ReadCommittedContext(LevelOfIsolationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.LevelOfIsolationContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def READ(self):
            return self.getToken(SqlBaseParser.READ, 0)
        def COMMITTED(self):
            return self.getToken(SqlBaseParser.COMMITTED, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterReadCommitted" ):
                listener.enterReadCommitted(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitReadCommitted" ):
                listener.exitReadCommitted(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReadCommitted" ):
                return visitor.visitReadCommitted(self)
            else:
                return visitor.visitChildren(self)


    class RepeatableReadContext(LevelOfIsolationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.LevelOfIsolationContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def REPEATABLE(self):
            return self.getToken(SqlBaseParser.REPEATABLE, 0)
        def READ(self):
            return self.getToken(SqlBaseParser.READ, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRepeatableRead" ):
                listener.enterRepeatableRead(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRepeatableRead" ):
                listener.exitRepeatableRead(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRepeatableRead" ):
                return visitor.visitRepeatableRead(self)
            else:
                return visitor.visitChildren(self)



    def levelOfIsolation(self):

        localctx = SqlBaseParser.LevelOfIsolationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_levelOfIsolation)
        try:
            self.state = 2838
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,378,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.ReadUncommittedContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2831
                self.match(SqlBaseParser.READ)
                self.state = 2832
                self.match(SqlBaseParser.UNCOMMITTED)

            elif la_ == 2:
                localctx = SqlBaseParser.ReadCommittedContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2833
                self.match(SqlBaseParser.READ)
                self.state = 2834
                self.match(SqlBaseParser.COMMITTED)

            elif la_ == 3:
                localctx = SqlBaseParser.RepeatableReadContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2835
                self.match(SqlBaseParser.REPEATABLE)
                self.state = 2836
                self.match(SqlBaseParser.READ)

            elif la_ == 4:
                localctx = SqlBaseParser.SerializableContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2837
                self.match(SqlBaseParser.SERIALIZABLE)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CallArgumentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_callArgument

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class PositionalArgumentContext(CallArgumentContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.CallArgumentContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPositionalArgument" ):
                listener.enterPositionalArgument(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPositionalArgument" ):
                listener.exitPositionalArgument(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPositionalArgument" ):
                return visitor.visitPositionalArgument(self)
            else:
                return visitor.visitChildren(self)


    class NamedArgumentContext(CallArgumentContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.CallArgumentContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)

        def expression(self):
            return self.getTypedRuleContext(SqlBaseParser.ExpressionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamedArgument" ):
                listener.enterNamedArgument(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamedArgument" ):
                listener.exitNamedArgument(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamedArgument" ):
                return visitor.visitNamedArgument(self)
            else:
                return visitor.visitChildren(self)



    def callArgument(self):

        localctx = SqlBaseParser.CallArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_callArgument)
        try:
            self.state = 2845
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,379,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.PositionalArgumentContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2840
                self.expression()

            elif la_ == 2:
                localctx = SqlBaseParser.NamedArgumentContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2841
                self.identifier()
                self.state = 2842
                self.match(SqlBaseParser.T__5)
                self.state = 2843
                self.expression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PathElementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_pathElement

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class QualifiedArgumentContext(PathElementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PathElementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQualifiedArgument" ):
                listener.enterQualifiedArgument(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQualifiedArgument" ):
                listener.exitQualifiedArgument(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQualifiedArgument" ):
                return visitor.visitQualifiedArgument(self)
            else:
                return visitor.visitChildren(self)


    class UnqualifiedArgumentContext(PathElementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PathElementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnqualifiedArgument" ):
                listener.enterUnqualifiedArgument(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnqualifiedArgument" ):
                listener.exitUnqualifiedArgument(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnqualifiedArgument" ):
                return visitor.visitUnqualifiedArgument(self)
            else:
                return visitor.visitChildren(self)



    def pathElement(self):

        localctx = SqlBaseParser.PathElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_pathElement)
        try:
            self.state = 2852
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,380,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.QualifiedArgumentContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2847
                self.identifier()
                self.state = 2848
                self.match(SqlBaseParser.T__0)
                self.state = 2849
                self.identifier()

            elif la_ == 2:
                localctx = SqlBaseParser.UnqualifiedArgumentContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2851
                self.identifier()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PathSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pathElement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.PathElementContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.PathElementContext,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_pathSpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPathSpecification" ):
                listener.enterPathSpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPathSpecification" ):
                listener.exitPathSpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPathSpecification" ):
                return visitor.visitPathSpecification(self)
            else:
                return visitor.visitChildren(self)




    def pathSpecification(self):

        localctx = SqlBaseParser.PathSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_pathSpecification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2854
            self.pathElement()
            self.state = 2859
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SqlBaseParser.T__3:
                self.state = 2855
                self.match(SqlBaseParser.T__3)
                self.state = 2856
                self.pathElement()
                self.state = 2861
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PrivilegeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CREATE(self):
            return self.getToken(SqlBaseParser.CREATE, 0)

        def SELECT(self):
            return self.getToken(SqlBaseParser.SELECT, 0)

        def DELETE(self):
            return self.getToken(SqlBaseParser.DELETE, 0)

        def INSERT(self):
            return self.getToken(SqlBaseParser.INSERT, 0)

        def UPDATE(self):
            return self.getToken(SqlBaseParser.UPDATE, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_privilege

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPrivilege" ):
                listener.enterPrivilege(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPrivilege" ):
                listener.exitPrivilege(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPrivilege" ):
                return visitor.visitPrivilege(self)
            else:
                return visitor.visitChildren(self)




    def privilege(self):

        localctx = SqlBaseParser.PrivilegeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_privilege)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2862
            _la = self._input.LA(1)
            if not(_la==SqlBaseParser.CREATE or _la==SqlBaseParser.DELETE or _la==SqlBaseParser.INSERT or _la==SqlBaseParser.SELECT or _la==SqlBaseParser.UPDATE):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QualifiedNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_qualifiedName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQualifiedName" ):
                listener.enterQualifiedName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQualifiedName" ):
                listener.exitQualifiedName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQualifiedName" ):
                return visitor.visitQualifiedName(self)
            else:
                return visitor.visitChildren(self)




    def qualifiedName(self):

        localctx = SqlBaseParser.QualifiedNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_qualifiedName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2864
            self.identifier()
            self.state = 2869
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,382,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2865
                    self.match(SqlBaseParser.T__0)
                    self.state = 2866
                    self.identifier() 
                self.state = 2871
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,382,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QueryPeriodContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.end = None # ValueExpressionContext

        def FOR(self):
            return self.getToken(SqlBaseParser.FOR, 0)

        def rangeType(self):
            return self.getTypedRuleContext(SqlBaseParser.RangeTypeContext,0)


        def AS(self):
            return self.getToken(SqlBaseParser.AS, 0)

        def OF(self):
            return self.getToken(SqlBaseParser.OF, 0)

        def valueExpression(self):
            return self.getTypedRuleContext(SqlBaseParser.ValueExpressionContext,0)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_queryPeriod

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQueryPeriod" ):
                listener.enterQueryPeriod(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQueryPeriod" ):
                listener.exitQueryPeriod(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQueryPeriod" ):
                return visitor.visitQueryPeriod(self)
            else:
                return visitor.visitChildren(self)




    def queryPeriod(self):

        localctx = SqlBaseParser.QueryPeriodContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_queryPeriod)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2872
            self.match(SqlBaseParser.FOR)
            self.state = 2873
            self.rangeType()
            self.state = 2874
            self.match(SqlBaseParser.AS)
            self.state = 2875
            self.match(SqlBaseParser.OF)
            self.state = 2876
            localctx.end = self.valueExpression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RangeTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TIMESTAMP(self):
            return self.getToken(SqlBaseParser.TIMESTAMP, 0)

        def VERSION(self):
            return self.getToken(SqlBaseParser.VERSION, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_rangeType

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRangeType" ):
                listener.enterRangeType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRangeType" ):
                listener.exitRangeType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRangeType" ):
                return visitor.visitRangeType(self)
            else:
                return visitor.visitChildren(self)




    def rangeType(self):

        localctx = SqlBaseParser.RangeTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_rangeType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2878
            _la = self._input.LA(1)
            if not(_la==SqlBaseParser.TIMESTAMP or _la==SqlBaseParser.VERSION):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GrantorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_grantor

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class CurrentUserGrantorContext(GrantorContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.GrantorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CURRENT_USER(self):
            return self.getToken(SqlBaseParser.CURRENT_USER, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCurrentUserGrantor" ):
                listener.enterCurrentUserGrantor(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCurrentUserGrantor" ):
                listener.exitCurrentUserGrantor(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCurrentUserGrantor" ):
                return visitor.visitCurrentUserGrantor(self)
            else:
                return visitor.visitChildren(self)


    class SpecifiedPrincipalContext(GrantorContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.GrantorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def principal(self):
            return self.getTypedRuleContext(SqlBaseParser.PrincipalContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSpecifiedPrincipal" ):
                listener.enterSpecifiedPrincipal(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSpecifiedPrincipal" ):
                listener.exitSpecifiedPrincipal(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSpecifiedPrincipal" ):
                return visitor.visitSpecifiedPrincipal(self)
            else:
                return visitor.visitChildren(self)


    class CurrentRoleGrantorContext(GrantorContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.GrantorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CURRENT_ROLE(self):
            return self.getToken(SqlBaseParser.CURRENT_ROLE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCurrentRoleGrantor" ):
                listener.enterCurrentRoleGrantor(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCurrentRoleGrantor" ):
                listener.exitCurrentRoleGrantor(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCurrentRoleGrantor" ):
                return visitor.visitCurrentRoleGrantor(self)
            else:
                return visitor.visitChildren(self)



    def grantor(self):

        localctx = SqlBaseParser.GrantorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_grantor)
        try:
            self.state = 2883
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.ABSENT, SqlBaseParser.ADD, SqlBaseParser.ADMIN, SqlBaseParser.AFTER, SqlBaseParser.ALL, SqlBaseParser.ANALYZE, SqlBaseParser.ANY, SqlBaseParser.ARRAY, SqlBaseParser.ASC, SqlBaseParser.AT, SqlBaseParser.AUTHORIZATION, SqlBaseParser.BERNOULLI, SqlBaseParser.BOTH, SqlBaseParser.CALL, SqlBaseParser.CASCADE, SqlBaseParser.CATALOGS, SqlBaseParser.COLUMN, SqlBaseParser.COLUMNS, SqlBaseParser.COMMENT, SqlBaseParser.COMMIT, SqlBaseParser.COMMITTED, SqlBaseParser.CONDITIONAL, SqlBaseParser.COUNT, SqlBaseParser.COPARTITION, SqlBaseParser.CURRENT, SqlBaseParser.DATA, SqlBaseParser.DATE, SqlBaseParser.DAY, SqlBaseParser.DEFAULT, SqlBaseParser.DEFINER, SqlBaseParser.DENY, SqlBaseParser.DESC, SqlBaseParser.DESCRIPTOR, SqlBaseParser.DEFINE, SqlBaseParser.DISTRIBUTED, SqlBaseParser.DOUBLE, SqlBaseParser.EMPTY, SqlBaseParser.ENCODING, SqlBaseParser.ERROR, SqlBaseParser.EXCLUDING, SqlBaseParser.EXPLAIN, SqlBaseParser.FETCH, SqlBaseParser.FILTER, SqlBaseParser.FINAL, SqlBaseParser.FIRST, SqlBaseParser.FOLLOWING, SqlBaseParser.FORMAT, SqlBaseParser.FUNCTIONS, SqlBaseParser.GRANT, SqlBaseParser.GRANTED, SqlBaseParser.GRANTS, SqlBaseParser.GRAPHVIZ, SqlBaseParser.GROUPS, SqlBaseParser.HOUR, SqlBaseParser.IF, SqlBaseParser.IGNORE, SqlBaseParser.INCLUDING, SqlBaseParser.INITIAL, SqlBaseParser.INPUT, SqlBaseParser.INTERVAL, SqlBaseParser.INVOKER, SqlBaseParser.IO, SqlBaseParser.ISOLATION, SqlBaseParser.JSON, SqlBaseParser.KEEP, SqlBaseParser.KEY, SqlBaseParser.KEYS, SqlBaseParser.LAST, SqlBaseParser.LATERAL, SqlBaseParser.LEADING, SqlBaseParser.LEVEL, SqlBaseParser.LIMIT, SqlBaseParser.LOCAL, SqlBaseParser.LOGICAL, SqlBaseParser.MAP, SqlBaseParser.MATCH, SqlBaseParser.MATCHED, SqlBaseParser.MATCHES, SqlBaseParser.MATCH_RECOGNIZE, SqlBaseParser.MATERIALIZED, SqlBaseParser.MEASURES, SqlBaseParser.MERGE, SqlBaseParser.MINUTE, SqlBaseParser.MONTH, SqlBaseParser.NEXT, SqlBaseParser.NFC, SqlBaseParser.NFD, SqlBaseParser.NFKC, SqlBaseParser.NFKD, SqlBaseParser.NO, SqlBaseParser.NONE, SqlBaseParser.NULLIF, SqlBaseParser.NULLS, SqlBaseParser.OBJECT, SqlBaseParser.OFFSET, SqlBaseParser.OMIT, SqlBaseParser.OF, SqlBaseParser.ONE, SqlBaseParser.ONLY, SqlBaseParser.OPTION, SqlBaseParser.ORDINALITY, SqlBaseParser.OUTPUT, SqlBaseParser.OVER, SqlBaseParser.OVERFLOW, SqlBaseParser.PARTITION, SqlBaseParser.PARTITIONS, SqlBaseParser.PASSING, SqlBaseParser.PAST, SqlBaseParser.PATH, SqlBaseParser.PATTERN, SqlBaseParser.PER, SqlBaseParser.PERMUTE, SqlBaseParser.POSITION, SqlBaseParser.PRECEDING, SqlBaseParser.PRECISION, SqlBaseParser.PRIVILEGES, SqlBaseParser.PROPERTIES, SqlBaseParser.PRUNE, SqlBaseParser.QUOTES, SqlBaseParser.RANGE, SqlBaseParser.READ, SqlBaseParser.REFRESH, SqlBaseParser.RENAME, SqlBaseParser.REPEATABLE, SqlBaseParser.REPLACE, SqlBaseParser.RESET, SqlBaseParser.RESPECT, SqlBaseParser.RESTRICT, SqlBaseParser.RETURNING, SqlBaseParser.REVOKE, SqlBaseParser.ROLE, SqlBaseParser.ROLES, SqlBaseParser.ROLLBACK, SqlBaseParser.ROW, SqlBaseParser.ROWS, SqlBaseParser.RUNNING, SqlBaseParser.SCALAR, SqlBaseParser.SCHEMA, SqlBaseParser.SCHEMAS, SqlBaseParser.SECOND, SqlBaseParser.SECURITY, SqlBaseParser.SEEK, SqlBaseParser.SERIALIZABLE, SqlBaseParser.SESSION, SqlBaseParser.SET, SqlBaseParser.SETS, SqlBaseParser.SHOW, SqlBaseParser.SOME, SqlBaseParser.START, SqlBaseParser.STATS, SqlBaseParser.SUBSET, SqlBaseParser.SUBSTRING, SqlBaseParser.SYSTEM, SqlBaseParser.TABLES, SqlBaseParser.TABLESAMPLE, SqlBaseParser.TEXT, SqlBaseParser.TEXT_STRING, SqlBaseParser.TIES, SqlBaseParser.TIME, SqlBaseParser.TIMESTAMP, SqlBaseParser.TO, SqlBaseParser.TRAILING, SqlBaseParser.TRANSACTION, SqlBaseParser.TRUNCATE, SqlBaseParser.TRY_CAST, SqlBaseParser.TYPE, SqlBaseParser.UNBOUNDED, SqlBaseParser.UNCOMMITTED, SqlBaseParser.UNCONDITIONAL, SqlBaseParser.UNIQUE, SqlBaseParser.UNKNOWN, SqlBaseParser.UNMATCHED, SqlBaseParser.UPDATE, SqlBaseParser.USE, SqlBaseParser.USER, SqlBaseParser.UTF16, SqlBaseParser.UTF32, SqlBaseParser.UTF8, SqlBaseParser.VALIDATE, SqlBaseParser.VALUE, SqlBaseParser.VERBOSE, SqlBaseParser.VERSION, SqlBaseParser.VIEW, SqlBaseParser.WINDOW, SqlBaseParser.WITHIN, SqlBaseParser.WITHOUT, SqlBaseParser.WORK, SqlBaseParser.WRAPPER, SqlBaseParser.WRITE, SqlBaseParser.YEAR, SqlBaseParser.ZONE, SqlBaseParser.IDENTIFIER, SqlBaseParser.DIGIT_IDENTIFIER, SqlBaseParser.QUOTED_IDENTIFIER, SqlBaseParser.BACKQUOTED_IDENTIFIER]:
                localctx = SqlBaseParser.SpecifiedPrincipalContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2880
                self.principal()
            elif token in [SqlBaseParser.CURRENT_USER]:
                localctx = SqlBaseParser.CurrentUserGrantorContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2881
                self.match(SqlBaseParser.CURRENT_USER)
            elif token in [SqlBaseParser.CURRENT_ROLE]:
                localctx = SqlBaseParser.CurrentRoleGrantorContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2882
                self.match(SqlBaseParser.CURRENT_ROLE)
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PrincipalContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_principal

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class UnspecifiedPrincipalContext(PrincipalContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrincipalContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnspecifiedPrincipal" ):
                listener.enterUnspecifiedPrincipal(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnspecifiedPrincipal" ):
                listener.exitUnspecifiedPrincipal(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnspecifiedPrincipal" ):
                return visitor.visitUnspecifiedPrincipal(self)
            else:
                return visitor.visitChildren(self)


    class UserPrincipalContext(PrincipalContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrincipalContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def USER(self):
            return self.getToken(SqlBaseParser.USER, 0)
        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUserPrincipal" ):
                listener.enterUserPrincipal(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUserPrincipal" ):
                listener.exitUserPrincipal(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUserPrincipal" ):
                return visitor.visitUserPrincipal(self)
            else:
                return visitor.visitChildren(self)


    class RolePrincipalContext(PrincipalContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.PrincipalContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ROLE(self):
            return self.getToken(SqlBaseParser.ROLE, 0)
        def identifier(self):
            return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRolePrincipal" ):
                listener.enterRolePrincipal(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRolePrincipal" ):
                listener.exitRolePrincipal(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRolePrincipal" ):
                return visitor.visitRolePrincipal(self)
            else:
                return visitor.visitChildren(self)



    def principal(self):

        localctx = SqlBaseParser.PrincipalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_principal)
        try:
            self.state = 2890
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,384,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.UnspecifiedPrincipalContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2885
                self.identifier()

            elif la_ == 2:
                localctx = SqlBaseParser.UserPrincipalContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2886
                self.match(SqlBaseParser.USER)
                self.state = 2887
                self.identifier()

            elif la_ == 3:
                localctx = SqlBaseParser.RolePrincipalContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2888
                self.match(SqlBaseParser.ROLE)
                self.state = 2889
                self.identifier()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RolesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SqlBaseParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SqlBaseParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SqlBaseParser.RULE_roles

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRoles" ):
                listener.enterRoles(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRoles" ):
                listener.exitRoles(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRoles" ):
                return visitor.visitRoles(self)
            else:
                return visitor.visitChildren(self)




    def roles(self):

        localctx = SqlBaseParser.RolesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_roles)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2892
            self.identifier()
            self.state = 2897
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SqlBaseParser.T__3:
                self.state = 2893
                self.match(SqlBaseParser.T__3)
                self.state = 2894
                self.identifier()
                self.state = 2899
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_identifier

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class BackQuotedIdentifierContext(IdentifierContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.IdentifierContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def BACKQUOTED_IDENTIFIER(self):
            return self.getToken(SqlBaseParser.BACKQUOTED_IDENTIFIER, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBackQuotedIdentifier" ):
                listener.enterBackQuotedIdentifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBackQuotedIdentifier" ):
                listener.exitBackQuotedIdentifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBackQuotedIdentifier" ):
                return visitor.visitBackQuotedIdentifier(self)
            else:
                return visitor.visitChildren(self)


    class QuotedIdentifierContext(IdentifierContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.IdentifierContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def QUOTED_IDENTIFIER(self):
            return self.getToken(SqlBaseParser.QUOTED_IDENTIFIER, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQuotedIdentifier" ):
                listener.enterQuotedIdentifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQuotedIdentifier" ):
                listener.exitQuotedIdentifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQuotedIdentifier" ):
                return visitor.visitQuotedIdentifier(self)
            else:
                return visitor.visitChildren(self)


    class DigitIdentifierContext(IdentifierContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.IdentifierContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DIGIT_IDENTIFIER(self):
            return self.getToken(SqlBaseParser.DIGIT_IDENTIFIER, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDigitIdentifier" ):
                listener.enterDigitIdentifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDigitIdentifier" ):
                listener.exitDigitIdentifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDigitIdentifier" ):
                return visitor.visitDigitIdentifier(self)
            else:
                return visitor.visitChildren(self)


    class UnquotedIdentifierContext(IdentifierContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.IdentifierContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def IDENTIFIER(self):
            return self.getToken(SqlBaseParser.IDENTIFIER, 0)
        def nonReserved(self):
            return self.getTypedRuleContext(SqlBaseParser.NonReservedContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnquotedIdentifier" ):
                listener.enterUnquotedIdentifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnquotedIdentifier" ):
                listener.exitUnquotedIdentifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnquotedIdentifier" ):
                return visitor.visitUnquotedIdentifier(self)
            else:
                return visitor.visitChildren(self)



    def identifier(self):

        localctx = SqlBaseParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_identifier)
        try:
            self.state = 2905
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SqlBaseParser.IDENTIFIER]:
                localctx = SqlBaseParser.UnquotedIdentifierContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2900
                self.match(SqlBaseParser.IDENTIFIER)
            elif token in [SqlBaseParser.QUOTED_IDENTIFIER]:
                localctx = SqlBaseParser.QuotedIdentifierContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2901
                self.match(SqlBaseParser.QUOTED_IDENTIFIER)
            elif token in [SqlBaseParser.ABSENT, SqlBaseParser.ADD, SqlBaseParser.ADMIN, SqlBaseParser.AFTER, SqlBaseParser.ALL, SqlBaseParser.ANALYZE, SqlBaseParser.ANY, SqlBaseParser.ARRAY, SqlBaseParser.ASC, SqlBaseParser.AT, SqlBaseParser.AUTHORIZATION, SqlBaseParser.BERNOULLI, SqlBaseParser.BOTH, SqlBaseParser.CALL, SqlBaseParser.CASCADE, SqlBaseParser.CATALOGS, SqlBaseParser.COLUMN, SqlBaseParser.COLUMNS, SqlBaseParser.COMMENT, SqlBaseParser.COMMIT, SqlBaseParser.COMMITTED, SqlBaseParser.CONDITIONAL, SqlBaseParser.COUNT, SqlBaseParser.COPARTITION, SqlBaseParser.CURRENT, SqlBaseParser.DATA, SqlBaseParser.DATE, SqlBaseParser.DAY, SqlBaseParser.DEFAULT, SqlBaseParser.DEFINER, SqlBaseParser.DENY, SqlBaseParser.DESC, SqlBaseParser.DESCRIPTOR, SqlBaseParser.DEFINE, SqlBaseParser.DISTRIBUTED, SqlBaseParser.DOUBLE, SqlBaseParser.EMPTY, SqlBaseParser.ENCODING, SqlBaseParser.ERROR, SqlBaseParser.EXCLUDING, SqlBaseParser.EXPLAIN, SqlBaseParser.FETCH, SqlBaseParser.FILTER, SqlBaseParser.FINAL, SqlBaseParser.FIRST, SqlBaseParser.FOLLOWING, SqlBaseParser.FORMAT, SqlBaseParser.FUNCTIONS, SqlBaseParser.GRANT, SqlBaseParser.GRANTED, SqlBaseParser.GRANTS, SqlBaseParser.GRAPHVIZ, SqlBaseParser.GROUPS, SqlBaseParser.HOUR, SqlBaseParser.IF, SqlBaseParser.IGNORE, SqlBaseParser.INCLUDING, SqlBaseParser.INITIAL, SqlBaseParser.INPUT, SqlBaseParser.INTERVAL, SqlBaseParser.INVOKER, SqlBaseParser.IO, SqlBaseParser.ISOLATION, SqlBaseParser.JSON, SqlBaseParser.KEEP, SqlBaseParser.KEY, SqlBaseParser.KEYS, SqlBaseParser.LAST, SqlBaseParser.LATERAL, SqlBaseParser.LEADING, SqlBaseParser.LEVEL, SqlBaseParser.LIMIT, SqlBaseParser.LOCAL, SqlBaseParser.LOGICAL, SqlBaseParser.MAP, SqlBaseParser.MATCH, SqlBaseParser.MATCHED, SqlBaseParser.MATCHES, SqlBaseParser.MATCH_RECOGNIZE, SqlBaseParser.MATERIALIZED, SqlBaseParser.MEASURES, SqlBaseParser.MERGE, SqlBaseParser.MINUTE, SqlBaseParser.MONTH, SqlBaseParser.NEXT, SqlBaseParser.NFC, SqlBaseParser.NFD, SqlBaseParser.NFKC, SqlBaseParser.NFKD, SqlBaseParser.NO, SqlBaseParser.NONE, SqlBaseParser.NULLIF, SqlBaseParser.NULLS, SqlBaseParser.OBJECT, SqlBaseParser.OFFSET, SqlBaseParser.OMIT, SqlBaseParser.OF, SqlBaseParser.ONE, SqlBaseParser.ONLY, SqlBaseParser.OPTION, SqlBaseParser.ORDINALITY, SqlBaseParser.OUTPUT, SqlBaseParser.OVER, SqlBaseParser.OVERFLOW, SqlBaseParser.PARTITION, SqlBaseParser.PARTITIONS, SqlBaseParser.PASSING, SqlBaseParser.PAST, SqlBaseParser.PATH, SqlBaseParser.PATTERN, SqlBaseParser.PER, SqlBaseParser.PERMUTE, SqlBaseParser.POSITION, SqlBaseParser.PRECEDING, SqlBaseParser.PRECISION, SqlBaseParser.PRIVILEGES, SqlBaseParser.PROPERTIES, SqlBaseParser.PRUNE, SqlBaseParser.QUOTES, SqlBaseParser.RANGE, SqlBaseParser.READ, SqlBaseParser.REFRESH, SqlBaseParser.RENAME, SqlBaseParser.REPEATABLE, SqlBaseParser.REPLACE, SqlBaseParser.RESET, SqlBaseParser.RESPECT, SqlBaseParser.RESTRICT, SqlBaseParser.RETURNING, SqlBaseParser.REVOKE, SqlBaseParser.ROLE, SqlBaseParser.ROLES, SqlBaseParser.ROLLBACK, SqlBaseParser.ROW, SqlBaseParser.ROWS, SqlBaseParser.RUNNING, SqlBaseParser.SCALAR, SqlBaseParser.SCHEMA, SqlBaseParser.SCHEMAS, SqlBaseParser.SECOND, SqlBaseParser.SECURITY, SqlBaseParser.SEEK, SqlBaseParser.SERIALIZABLE, SqlBaseParser.SESSION, SqlBaseParser.SET, SqlBaseParser.SETS, SqlBaseParser.SHOW, SqlBaseParser.SOME, SqlBaseParser.START, SqlBaseParser.STATS, SqlBaseParser.SUBSET, SqlBaseParser.SUBSTRING, SqlBaseParser.SYSTEM, SqlBaseParser.TABLES, SqlBaseParser.TABLESAMPLE, SqlBaseParser.TEXT, SqlBaseParser.TEXT_STRING, SqlBaseParser.TIES, SqlBaseParser.TIME, SqlBaseParser.TIMESTAMP, SqlBaseParser.TO, SqlBaseParser.TRAILING, SqlBaseParser.TRANSACTION, SqlBaseParser.TRUNCATE, SqlBaseParser.TRY_CAST, SqlBaseParser.TYPE, SqlBaseParser.UNBOUNDED, SqlBaseParser.UNCOMMITTED, SqlBaseParser.UNCONDITIONAL, SqlBaseParser.UNIQUE, SqlBaseParser.UNKNOWN, SqlBaseParser.UNMATCHED, SqlBaseParser.UPDATE, SqlBaseParser.USE, SqlBaseParser.USER, SqlBaseParser.UTF16, SqlBaseParser.UTF32, SqlBaseParser.UTF8, SqlBaseParser.VALIDATE, SqlBaseParser.VALUE, SqlBaseParser.VERBOSE, SqlBaseParser.VERSION, SqlBaseParser.VIEW, SqlBaseParser.WINDOW, SqlBaseParser.WITHIN, SqlBaseParser.WITHOUT, SqlBaseParser.WORK, SqlBaseParser.WRAPPER, SqlBaseParser.WRITE, SqlBaseParser.YEAR, SqlBaseParser.ZONE]:
                localctx = SqlBaseParser.UnquotedIdentifierContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2902
                self.nonReserved()
            elif token in [SqlBaseParser.BACKQUOTED_IDENTIFIER]:
                localctx = SqlBaseParser.BackQuotedIdentifierContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2903
                self.match(SqlBaseParser.BACKQUOTED_IDENTIFIER)
            elif token in [SqlBaseParser.DIGIT_IDENTIFIER]:
                localctx = SqlBaseParser.DigitIdentifierContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 2904
                self.match(SqlBaseParser.DIGIT_IDENTIFIER)
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NumberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return SqlBaseParser.RULE_number

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class DecimalLiteralContext(NumberContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DECIMAL_VALUE(self):
            return self.getToken(SqlBaseParser.DECIMAL_VALUE, 0)
        def MINUS(self):
            return self.getToken(SqlBaseParser.MINUS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDecimalLiteral" ):
                listener.enterDecimalLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDecimalLiteral" ):
                listener.exitDecimalLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDecimalLiteral" ):
                return visitor.visitDecimalLiteral(self)
            else:
                return visitor.visitChildren(self)


    class DoubleLiteralContext(NumberContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DOUBLE_VALUE(self):
            return self.getToken(SqlBaseParser.DOUBLE_VALUE, 0)
        def MINUS(self):
            return self.getToken(SqlBaseParser.MINUS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDoubleLiteral" ):
                listener.enterDoubleLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDoubleLiteral" ):
                listener.exitDoubleLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDoubleLiteral" ):
                return visitor.visitDoubleLiteral(self)
            else:
                return visitor.visitChildren(self)


    class IntegerLiteralContext(NumberContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a SqlBaseParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def INTEGER_VALUE(self):
            return self.getToken(SqlBaseParser.INTEGER_VALUE, 0)
        def MINUS(self):
            return self.getToken(SqlBaseParser.MINUS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIntegerLiteral" ):
                listener.enterIntegerLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIntegerLiteral" ):
                listener.exitIntegerLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIntegerLiteral" ):
                return visitor.visitIntegerLiteral(self)
            else:
                return visitor.visitChildren(self)



    def number(self):

        localctx = SqlBaseParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_number)
        self._la = 0 # Token type
        try:
            self.state = 2919
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,390,self._ctx)
            if la_ == 1:
                localctx = SqlBaseParser.DecimalLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2908
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.MINUS:
                    self.state = 2907
                    self.match(SqlBaseParser.MINUS)


                self.state = 2910
                self.match(SqlBaseParser.DECIMAL_VALUE)

            elif la_ == 2:
                localctx = SqlBaseParser.DoubleLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2912
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.MINUS:
                    self.state = 2911
                    self.match(SqlBaseParser.MINUS)


                self.state = 2914
                self.match(SqlBaseParser.DOUBLE_VALUE)

            elif la_ == 3:
                localctx = SqlBaseParser.IntegerLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2916
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SqlBaseParser.MINUS:
                    self.state = 2915
                    self.match(SqlBaseParser.MINUS)


                self.state = 2918
                self.match(SqlBaseParser.INTEGER_VALUE)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NonReservedContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ABSENT(self):
            return self.getToken(SqlBaseParser.ABSENT, 0)

        def ADD(self):
            return self.getToken(SqlBaseParser.ADD, 0)

        def ADMIN(self):
            return self.getToken(SqlBaseParser.ADMIN, 0)

        def AFTER(self):
            return self.getToken(SqlBaseParser.AFTER, 0)

        def ALL(self):
            return self.getToken(SqlBaseParser.ALL, 0)

        def ANALYZE(self):
            return self.getToken(SqlBaseParser.ANALYZE, 0)

        def ANY(self):
            return self.getToken(SqlBaseParser.ANY, 0)

        def ARRAY(self):
            return self.getToken(SqlBaseParser.ARRAY, 0)

        def ASC(self):
            return self.getToken(SqlBaseParser.ASC, 0)

        def AT(self):
            return self.getToken(SqlBaseParser.AT, 0)

        def AUTHORIZATION(self):
            return self.getToken(SqlBaseParser.AUTHORIZATION, 0)

        def BERNOULLI(self):
            return self.getToken(SqlBaseParser.BERNOULLI, 0)

        def BOTH(self):
            return self.getToken(SqlBaseParser.BOTH, 0)

        def CALL(self):
            return self.getToken(SqlBaseParser.CALL, 0)

        def CASCADE(self):
            return self.getToken(SqlBaseParser.CASCADE, 0)

        def CATALOGS(self):
            return self.getToken(SqlBaseParser.CATALOGS, 0)

        def COLUMN(self):
            return self.getToken(SqlBaseParser.COLUMN, 0)

        def COLUMNS(self):
            return self.getToken(SqlBaseParser.COLUMNS, 0)

        def COMMENT(self):
            return self.getToken(SqlBaseParser.COMMENT, 0)

        def COMMIT(self):
            return self.getToken(SqlBaseParser.COMMIT, 0)

        def COMMITTED(self):
            return self.getToken(SqlBaseParser.COMMITTED, 0)

        def CONDITIONAL(self):
            return self.getToken(SqlBaseParser.CONDITIONAL, 0)

        def COPARTITION(self):
            return self.getToken(SqlBaseParser.COPARTITION, 0)

        def COUNT(self):
            return self.getToken(SqlBaseParser.COUNT, 0)

        def CURRENT(self):
            return self.getToken(SqlBaseParser.CURRENT, 0)

        def DATA(self):
            return self.getToken(SqlBaseParser.DATA, 0)

        def DATE(self):
            return self.getToken(SqlBaseParser.DATE, 0)

        def DAY(self):
            return self.getToken(SqlBaseParser.DAY, 0)

        def DEFAULT(self):
            return self.getToken(SqlBaseParser.DEFAULT, 0)

        def DEFINE(self):
            return self.getToken(SqlBaseParser.DEFINE, 0)

        def DEFINER(self):
            return self.getToken(SqlBaseParser.DEFINER, 0)

        def DESC(self):
            return self.getToken(SqlBaseParser.DESC, 0)

        def DESCRIPTOR(self):
            return self.getToken(SqlBaseParser.DESCRIPTOR, 0)

        def DISTRIBUTED(self):
            return self.getToken(SqlBaseParser.DISTRIBUTED, 0)

        def DOUBLE(self):
            return self.getToken(SqlBaseParser.DOUBLE, 0)

        def EMPTY(self):
            return self.getToken(SqlBaseParser.EMPTY, 0)

        def ENCODING(self):
            return self.getToken(SqlBaseParser.ENCODING, 0)

        def ERROR(self):
            return self.getToken(SqlBaseParser.ERROR, 0)

        def EXCLUDING(self):
            return self.getToken(SqlBaseParser.EXCLUDING, 0)

        def EXPLAIN(self):
            return self.getToken(SqlBaseParser.EXPLAIN, 0)

        def FETCH(self):
            return self.getToken(SqlBaseParser.FETCH, 0)

        def FILTER(self):
            return self.getToken(SqlBaseParser.FILTER, 0)

        def FINAL(self):
            return self.getToken(SqlBaseParser.FINAL, 0)

        def FIRST(self):
            return self.getToken(SqlBaseParser.FIRST, 0)

        def FOLLOWING(self):
            return self.getToken(SqlBaseParser.FOLLOWING, 0)

        def FORMAT(self):
            return self.getToken(SqlBaseParser.FORMAT, 0)

        def FUNCTIONS(self):
            return self.getToken(SqlBaseParser.FUNCTIONS, 0)

        def GRANT(self):
            return self.getToken(SqlBaseParser.GRANT, 0)

        def DENY(self):
            return self.getToken(SqlBaseParser.DENY, 0)

        def GRANTED(self):
            return self.getToken(SqlBaseParser.GRANTED, 0)

        def GRANTS(self):
            return self.getToken(SqlBaseParser.GRANTS, 0)

        def GRAPHVIZ(self):
            return self.getToken(SqlBaseParser.GRAPHVIZ, 0)

        def GROUPS(self):
            return self.getToken(SqlBaseParser.GROUPS, 0)

        def HOUR(self):
            return self.getToken(SqlBaseParser.HOUR, 0)

        def IF(self):
            return self.getToken(SqlBaseParser.IF, 0)

        def IGNORE(self):
            return self.getToken(SqlBaseParser.IGNORE, 0)

        def INCLUDING(self):
            return self.getToken(SqlBaseParser.INCLUDING, 0)

        def INITIAL(self):
            return self.getToken(SqlBaseParser.INITIAL, 0)

        def INPUT(self):
            return self.getToken(SqlBaseParser.INPUT, 0)

        def INTERVAL(self):
            return self.getToken(SqlBaseParser.INTERVAL, 0)

        def INVOKER(self):
            return self.getToken(SqlBaseParser.INVOKER, 0)

        def IO(self):
            return self.getToken(SqlBaseParser.IO, 0)

        def ISOLATION(self):
            return self.getToken(SqlBaseParser.ISOLATION, 0)

        def JSON(self):
            return self.getToken(SqlBaseParser.JSON, 0)

        def KEEP(self):
            return self.getToken(SqlBaseParser.KEEP, 0)

        def KEY(self):
            return self.getToken(SqlBaseParser.KEY, 0)

        def KEYS(self):
            return self.getToken(SqlBaseParser.KEYS, 0)

        def LAST(self):
            return self.getToken(SqlBaseParser.LAST, 0)

        def LATERAL(self):
            return self.getToken(SqlBaseParser.LATERAL, 0)

        def LEADING(self):
            return self.getToken(SqlBaseParser.LEADING, 0)

        def LEVEL(self):
            return self.getToken(SqlBaseParser.LEVEL, 0)

        def LIMIT(self):
            return self.getToken(SqlBaseParser.LIMIT, 0)

        def LOCAL(self):
            return self.getToken(SqlBaseParser.LOCAL, 0)

        def LOGICAL(self):
            return self.getToken(SqlBaseParser.LOGICAL, 0)

        def MAP(self):
            return self.getToken(SqlBaseParser.MAP, 0)

        def MATCH(self):
            return self.getToken(SqlBaseParser.MATCH, 0)

        def MATCHED(self):
            return self.getToken(SqlBaseParser.MATCHED, 0)

        def MATCHES(self):
            return self.getToken(SqlBaseParser.MATCHES, 0)

        def MATCH_RECOGNIZE(self):
            return self.getToken(SqlBaseParser.MATCH_RECOGNIZE, 0)

        def MATERIALIZED(self):
            return self.getToken(SqlBaseParser.MATERIALIZED, 0)

        def MEASURES(self):
            return self.getToken(SqlBaseParser.MEASURES, 0)

        def MERGE(self):
            return self.getToken(SqlBaseParser.MERGE, 0)

        def MINUTE(self):
            return self.getToken(SqlBaseParser.MINUTE, 0)

        def MONTH(self):
            return self.getToken(SqlBaseParser.MONTH, 0)

        def NEXT(self):
            return self.getToken(SqlBaseParser.NEXT, 0)

        def NFC(self):
            return self.getToken(SqlBaseParser.NFC, 0)

        def NFD(self):
            return self.getToken(SqlBaseParser.NFD, 0)

        def NFKC(self):
            return self.getToken(SqlBaseParser.NFKC, 0)

        def NFKD(self):
            return self.getToken(SqlBaseParser.NFKD, 0)

        def NO(self):
            return self.getToken(SqlBaseParser.NO, 0)

        def NONE(self):
            return self.getToken(SqlBaseParser.NONE, 0)

        def NULLIF(self):
            return self.getToken(SqlBaseParser.NULLIF, 0)

        def NULLS(self):
            return self.getToken(SqlBaseParser.NULLS, 0)

        def OBJECT(self):
            return self.getToken(SqlBaseParser.OBJECT, 0)

        def OF(self):
            return self.getToken(SqlBaseParser.OF, 0)

        def OFFSET(self):
            return self.getToken(SqlBaseParser.OFFSET, 0)

        def OMIT(self):
            return self.getToken(SqlBaseParser.OMIT, 0)

        def ONE(self):
            return self.getToken(SqlBaseParser.ONE, 0)

        def ONLY(self):
            return self.getToken(SqlBaseParser.ONLY, 0)

        def OPTION(self):
            return self.getToken(SqlBaseParser.OPTION, 0)

        def ORDINALITY(self):
            return self.getToken(SqlBaseParser.ORDINALITY, 0)

        def OUTPUT(self):
            return self.getToken(SqlBaseParser.OUTPUT, 0)

        def OVER(self):
            return self.getToken(SqlBaseParser.OVER, 0)

        def OVERFLOW(self):
            return self.getToken(SqlBaseParser.OVERFLOW, 0)

        def PARTITION(self):
            return self.getToken(SqlBaseParser.PARTITION, 0)

        def PARTITIONS(self):
            return self.getToken(SqlBaseParser.PARTITIONS, 0)

        def PASSING(self):
            return self.getToken(SqlBaseParser.PASSING, 0)

        def PAST(self):
            return self.getToken(SqlBaseParser.PAST, 0)

        def PATH(self):
            return self.getToken(SqlBaseParser.PATH, 0)

        def PATTERN(self):
            return self.getToken(SqlBaseParser.PATTERN, 0)

        def PER(self):
            return self.getToken(SqlBaseParser.PER, 0)

        def PERMUTE(self):
            return self.getToken(SqlBaseParser.PERMUTE, 0)

        def POSITION(self):
            return self.getToken(SqlBaseParser.POSITION, 0)

        def PRECEDING(self):
            return self.getToken(SqlBaseParser.PRECEDING, 0)

        def PRECISION(self):
            return self.getToken(SqlBaseParser.PRECISION, 0)

        def PRIVILEGES(self):
            return self.getToken(SqlBaseParser.PRIVILEGES, 0)

        def PROPERTIES(self):
            return self.getToken(SqlBaseParser.PROPERTIES, 0)

        def PRUNE(self):
            return self.getToken(SqlBaseParser.PRUNE, 0)

        def QUOTES(self):
            return self.getToken(SqlBaseParser.QUOTES, 0)

        def RANGE(self):
            return self.getToken(SqlBaseParser.RANGE, 0)

        def READ(self):
            return self.getToken(SqlBaseParser.READ, 0)

        def REFRESH(self):
            return self.getToken(SqlBaseParser.REFRESH, 0)

        def RENAME(self):
            return self.getToken(SqlBaseParser.RENAME, 0)

        def REPEATABLE(self):
            return self.getToken(SqlBaseParser.REPEATABLE, 0)

        def REPLACE(self):
            return self.getToken(SqlBaseParser.REPLACE, 0)

        def RESET(self):
            return self.getToken(SqlBaseParser.RESET, 0)

        def RESPECT(self):
            return self.getToken(SqlBaseParser.RESPECT, 0)

        def RESTRICT(self):
            return self.getToken(SqlBaseParser.RESTRICT, 0)

        def RETURNING(self):
            return self.getToken(SqlBaseParser.RETURNING, 0)

        def REVOKE(self):
            return self.getToken(SqlBaseParser.REVOKE, 0)

        def ROLE(self):
            return self.getToken(SqlBaseParser.ROLE, 0)

        def ROLES(self):
            return self.getToken(SqlBaseParser.ROLES, 0)

        def ROLLBACK(self):
            return self.getToken(SqlBaseParser.ROLLBACK, 0)

        def ROW(self):
            return self.getToken(SqlBaseParser.ROW, 0)

        def ROWS(self):
            return self.getToken(SqlBaseParser.ROWS, 0)

        def RUNNING(self):
            return self.getToken(SqlBaseParser.RUNNING, 0)

        def SCALAR(self):
            return self.getToken(SqlBaseParser.SCALAR, 0)

        def SCHEMA(self):
            return self.getToken(SqlBaseParser.SCHEMA, 0)

        def SCHEMAS(self):
            return self.getToken(SqlBaseParser.SCHEMAS, 0)

        def SECOND(self):
            return self.getToken(SqlBaseParser.SECOND, 0)

        def SECURITY(self):
            return self.getToken(SqlBaseParser.SECURITY, 0)

        def SEEK(self):
            return self.getToken(SqlBaseParser.SEEK, 0)

        def SERIALIZABLE(self):
            return self.getToken(SqlBaseParser.SERIALIZABLE, 0)

        def SESSION(self):
            return self.getToken(SqlBaseParser.SESSION, 0)

        def SET(self):
            return self.getToken(SqlBaseParser.SET, 0)

        def SETS(self):
            return self.getToken(SqlBaseParser.SETS, 0)

        def SHOW(self):
            return self.getToken(SqlBaseParser.SHOW, 0)

        def SOME(self):
            return self.getToken(SqlBaseParser.SOME, 0)

        def START(self):
            return self.getToken(SqlBaseParser.START, 0)

        def STATS(self):
            return self.getToken(SqlBaseParser.STATS, 0)

        def SUBSET(self):
            return self.getToken(SqlBaseParser.SUBSET, 0)

        def SUBSTRING(self):
            return self.getToken(SqlBaseParser.SUBSTRING, 0)

        def SYSTEM(self):
            return self.getToken(SqlBaseParser.SYSTEM, 0)

        def TABLES(self):
            return self.getToken(SqlBaseParser.TABLES, 0)

        def TABLESAMPLE(self):
            return self.getToken(SqlBaseParser.TABLESAMPLE, 0)

        def TEXT(self):
            return self.getToken(SqlBaseParser.TEXT, 0)

        def TEXT_STRING(self):
            return self.getToken(SqlBaseParser.TEXT_STRING, 0)

        def TIES(self):
            return self.getToken(SqlBaseParser.TIES, 0)

        def TIME(self):
            return self.getToken(SqlBaseParser.TIME, 0)

        def TIMESTAMP(self):
            return self.getToken(SqlBaseParser.TIMESTAMP, 0)

        def TO(self):
            return self.getToken(SqlBaseParser.TO, 0)

        def TRAILING(self):
            return self.getToken(SqlBaseParser.TRAILING, 0)

        def TRANSACTION(self):
            return self.getToken(SqlBaseParser.TRANSACTION, 0)

        def TRUNCATE(self):
            return self.getToken(SqlBaseParser.TRUNCATE, 0)

        def TRY_CAST(self):
            return self.getToken(SqlBaseParser.TRY_CAST, 0)

        def TYPE(self):
            return self.getToken(SqlBaseParser.TYPE, 0)

        def UNBOUNDED(self):
            return self.getToken(SqlBaseParser.UNBOUNDED, 0)

        def UNCOMMITTED(self):
            return self.getToken(SqlBaseParser.UNCOMMITTED, 0)

        def UNCONDITIONAL(self):
            return self.getToken(SqlBaseParser.UNCONDITIONAL, 0)

        def UNIQUE(self):
            return self.getToken(SqlBaseParser.UNIQUE, 0)

        def UNKNOWN(self):
            return self.getToken(SqlBaseParser.UNKNOWN, 0)

        def UNMATCHED(self):
            return self.getToken(SqlBaseParser.UNMATCHED, 0)

        def UPDATE(self):
            return self.getToken(SqlBaseParser.UPDATE, 0)

        def USE(self):
            return self.getToken(SqlBaseParser.USE, 0)

        def USER(self):
            return self.getToken(SqlBaseParser.USER, 0)

        def UTF16(self):
            return self.getToken(SqlBaseParser.UTF16, 0)

        def UTF32(self):
            return self.getToken(SqlBaseParser.UTF32, 0)

        def UTF8(self):
            return self.getToken(SqlBaseParser.UTF8, 0)

        def VALIDATE(self):
            return self.getToken(SqlBaseParser.VALIDATE, 0)

        def VALUE(self):
            return self.getToken(SqlBaseParser.VALUE, 0)

        def VERBOSE(self):
            return self.getToken(SqlBaseParser.VERBOSE, 0)

        def VERSION(self):
            return self.getToken(SqlBaseParser.VERSION, 0)

        def VIEW(self):
            return self.getToken(SqlBaseParser.VIEW, 0)

        def WINDOW(self):
            return self.getToken(SqlBaseParser.WINDOW, 0)

        def WITHIN(self):
            return self.getToken(SqlBaseParser.WITHIN, 0)

        def WITHOUT(self):
            return self.getToken(SqlBaseParser.WITHOUT, 0)

        def WORK(self):
            return self.getToken(SqlBaseParser.WORK, 0)

        def WRAPPER(self):
            return self.getToken(SqlBaseParser.WRAPPER, 0)

        def WRITE(self):
            return self.getToken(SqlBaseParser.WRITE, 0)

        def YEAR(self):
            return self.getToken(SqlBaseParser.YEAR, 0)

        def ZONE(self):
            return self.getToken(SqlBaseParser.ZONE, 0)

        def getRuleIndex(self):
            return SqlBaseParser.RULE_nonReserved

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNonReserved" ):
                listener.enterNonReserved(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNonReserved" ):
                listener.exitNonReserved(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNonReserved" ):
                return visitor.visitNonReserved(self)
            else:
                return visitor.visitChildren(self)




    def nonReserved(self):

        localctx = SqlBaseParser.NonReservedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_nonReserved)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2921
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SqlBaseParser.ABSENT) | (1 << SqlBaseParser.ADD) | (1 << SqlBaseParser.ADMIN) | (1 << SqlBaseParser.AFTER) | (1 << SqlBaseParser.ALL) | (1 << SqlBaseParser.ANALYZE) | (1 << SqlBaseParser.ANY) | (1 << SqlBaseParser.ARRAY) | (1 << SqlBaseParser.ASC) | (1 << SqlBaseParser.AT) | (1 << SqlBaseParser.AUTHORIZATION) | (1 << SqlBaseParser.BERNOULLI) | (1 << SqlBaseParser.BOTH) | (1 << SqlBaseParser.CALL) | (1 << SqlBaseParser.CASCADE) | (1 << SqlBaseParser.CATALOGS) | (1 << SqlBaseParser.COLUMN) | (1 << SqlBaseParser.COLUMNS) | (1 << SqlBaseParser.COMMENT) | (1 << SqlBaseParser.COMMIT) | (1 << SqlBaseParser.COMMITTED) | (1 << SqlBaseParser.CONDITIONAL) | (1 << SqlBaseParser.COUNT) | (1 << SqlBaseParser.COPARTITION) | (1 << SqlBaseParser.CURRENT) | (1 << SqlBaseParser.DATA) | (1 << SqlBaseParser.DATE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SqlBaseParser.DAY - 64)) | (1 << (SqlBaseParser.DEFAULT - 64)) | (1 << (SqlBaseParser.DEFINER - 64)) | (1 << (SqlBaseParser.DENY - 64)) | (1 << (SqlBaseParser.DESC - 64)) | (1 << (SqlBaseParser.DESCRIPTOR - 64)) | (1 << (SqlBaseParser.DEFINE - 64)) | (1 << (SqlBaseParser.DISTRIBUTED - 64)) | (1 << (SqlBaseParser.DOUBLE - 64)) | (1 << (SqlBaseParser.EMPTY - 64)) | (1 << (SqlBaseParser.ENCODING - 64)) | (1 << (SqlBaseParser.ERROR - 64)) | (1 << (SqlBaseParser.EXCLUDING - 64)) | (1 << (SqlBaseParser.EXPLAIN - 64)) | (1 << (SqlBaseParser.FETCH - 64)) | (1 << (SqlBaseParser.FILTER - 64)) | (1 << (SqlBaseParser.FINAL - 64)) | (1 << (SqlBaseParser.FIRST - 64)) | (1 << (SqlBaseParser.FOLLOWING - 64)) | (1 << (SqlBaseParser.FORMAT - 64)) | (1 << (SqlBaseParser.FUNCTIONS - 64)) | (1 << (SqlBaseParser.GRANT - 64)) | (1 << (SqlBaseParser.GRANTED - 64)) | (1 << (SqlBaseParser.GRANTS - 64)) | (1 << (SqlBaseParser.GRAPHVIZ - 64)) | (1 << (SqlBaseParser.GROUPS - 64)) | (1 << (SqlBaseParser.HOUR - 64)) | (1 << (SqlBaseParser.IF - 64)) | (1 << (SqlBaseParser.IGNORE - 64)) | (1 << (SqlBaseParser.INCLUDING - 64)) | (1 << (SqlBaseParser.INITIAL - 64)) | (1 << (SqlBaseParser.INPUT - 64)) | (1 << (SqlBaseParser.INTERVAL - 64)) | (1 << (SqlBaseParser.INVOKER - 64)) | (1 << (SqlBaseParser.IO - 64)) | (1 << (SqlBaseParser.ISOLATION - 64)) | (1 << (SqlBaseParser.JSON - 64)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (SqlBaseParser.KEEP - 132)) | (1 << (SqlBaseParser.KEY - 132)) | (1 << (SqlBaseParser.KEYS - 132)) | (1 << (SqlBaseParser.LAST - 132)) | (1 << (SqlBaseParser.LATERAL - 132)) | (1 << (SqlBaseParser.LEADING - 132)) | (1 << (SqlBaseParser.LEVEL - 132)) | (1 << (SqlBaseParser.LIMIT - 132)) | (1 << (SqlBaseParser.LOCAL - 132)) | (1 << (SqlBaseParser.LOGICAL - 132)) | (1 << (SqlBaseParser.MAP - 132)) | (1 << (SqlBaseParser.MATCH - 132)) | (1 << (SqlBaseParser.MATCHED - 132)) | (1 << (SqlBaseParser.MATCHES - 132)) | (1 << (SqlBaseParser.MATCH_RECOGNIZE - 132)) | (1 << (SqlBaseParser.MATERIALIZED - 132)) | (1 << (SqlBaseParser.MEASURES - 132)) | (1 << (SqlBaseParser.MERGE - 132)) | (1 << (SqlBaseParser.MINUTE - 132)) | (1 << (SqlBaseParser.MONTH - 132)) | (1 << (SqlBaseParser.NEXT - 132)) | (1 << (SqlBaseParser.NFC - 132)) | (1 << (SqlBaseParser.NFD - 132)) | (1 << (SqlBaseParser.NFKC - 132)) | (1 << (SqlBaseParser.NFKD - 132)) | (1 << (SqlBaseParser.NO - 132)) | (1 << (SqlBaseParser.NONE - 132)) | (1 << (SqlBaseParser.NULLIF - 132)) | (1 << (SqlBaseParser.NULLS - 132)) | (1 << (SqlBaseParser.OBJECT - 132)) | (1 << (SqlBaseParser.OFFSET - 132)) | (1 << (SqlBaseParser.OMIT - 132)) | (1 << (SqlBaseParser.OF - 132)) | (1 << (SqlBaseParser.ONE - 132)) | (1 << (SqlBaseParser.ONLY - 132)) | (1 << (SqlBaseParser.OPTION - 132)) | (1 << (SqlBaseParser.ORDINALITY - 132)) | (1 << (SqlBaseParser.OUTPUT - 132)) | (1 << (SqlBaseParser.OVER - 132)) | (1 << (SqlBaseParser.OVERFLOW - 132)) | (1 << (SqlBaseParser.PARTITION - 132)) | (1 << (SqlBaseParser.PARTITIONS - 132)) | (1 << (SqlBaseParser.PASSING - 132)) | (1 << (SqlBaseParser.PAST - 132)) | (1 << (SqlBaseParser.PATH - 132)) | (1 << (SqlBaseParser.PATTERN - 132)) | (1 << (SqlBaseParser.PER - 132)) | (1 << (SqlBaseParser.PERMUTE - 132)) | (1 << (SqlBaseParser.POSITION - 132)) | (1 << (SqlBaseParser.PRECEDING - 132)) | (1 << (SqlBaseParser.PRECISION - 132)))) != 0) or ((((_la - 197)) & ~0x3f) == 0 and ((1 << (_la - 197)) & ((1 << (SqlBaseParser.PRIVILEGES - 197)) | (1 << (SqlBaseParser.PROPERTIES - 197)) | (1 << (SqlBaseParser.PRUNE - 197)) | (1 << (SqlBaseParser.QUOTES - 197)) | (1 << (SqlBaseParser.RANGE - 197)) | (1 << (SqlBaseParser.READ - 197)) | (1 << (SqlBaseParser.REFRESH - 197)) | (1 << (SqlBaseParser.RENAME - 197)) | (1 << (SqlBaseParser.REPEATABLE - 197)) | (1 << (SqlBaseParser.REPLACE - 197)) | (1 << (SqlBaseParser.RESET - 197)) | (1 << (SqlBaseParser.RESPECT - 197)) | (1 << (SqlBaseParser.RESTRICT - 197)) | (1 << (SqlBaseParser.RETURNING - 197)) | (1 << (SqlBaseParser.REVOKE - 197)) | (1 << (SqlBaseParser.ROLE - 197)) | (1 << (SqlBaseParser.ROLES - 197)) | (1 << (SqlBaseParser.ROLLBACK - 197)) | (1 << (SqlBaseParser.ROW - 197)) | (1 << (SqlBaseParser.ROWS - 197)) | (1 << (SqlBaseParser.RUNNING - 197)) | (1 << (SqlBaseParser.SCALAR - 197)) | (1 << (SqlBaseParser.SCHEMA - 197)) | (1 << (SqlBaseParser.SCHEMAS - 197)) | (1 << (SqlBaseParser.SECOND - 197)) | (1 << (SqlBaseParser.SECURITY - 197)) | (1 << (SqlBaseParser.SEEK - 197)) | (1 << (SqlBaseParser.SERIALIZABLE - 197)) | (1 << (SqlBaseParser.SESSION - 197)) | (1 << (SqlBaseParser.SET - 197)) | (1 << (SqlBaseParser.SETS - 197)) | (1 << (SqlBaseParser.SHOW - 197)) | (1 << (SqlBaseParser.SOME - 197)) | (1 << (SqlBaseParser.START - 197)) | (1 << (SqlBaseParser.STATS - 197)) | (1 << (SqlBaseParser.SUBSET - 197)) | (1 << (SqlBaseParser.SUBSTRING - 197)) | (1 << (SqlBaseParser.SYSTEM - 197)) | (1 << (SqlBaseParser.TABLES - 197)) | (1 << (SqlBaseParser.TABLESAMPLE - 197)) | (1 << (SqlBaseParser.TEXT - 197)) | (1 << (SqlBaseParser.TEXT_STRING - 197)) | (1 << (SqlBaseParser.TIES - 197)) | (1 << (SqlBaseParser.TIME - 197)) | (1 << (SqlBaseParser.TIMESTAMP - 197)) | (1 << (SqlBaseParser.TO - 197)) | (1 << (SqlBaseParser.TRAILING - 197)) | (1 << (SqlBaseParser.TRANSACTION - 197)) | (1 << (SqlBaseParser.TRUNCATE - 197)) | (1 << (SqlBaseParser.TRY_CAST - 197)) | (1 << (SqlBaseParser.TYPE - 197)) | (1 << (SqlBaseParser.UNBOUNDED - 197)) | (1 << (SqlBaseParser.UNCOMMITTED - 197)) | (1 << (SqlBaseParser.UNCONDITIONAL - 197)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (SqlBaseParser.UNIQUE - 261)) | (1 << (SqlBaseParser.UNKNOWN - 261)) | (1 << (SqlBaseParser.UNMATCHED - 261)) | (1 << (SqlBaseParser.UPDATE - 261)) | (1 << (SqlBaseParser.USE - 261)) | (1 << (SqlBaseParser.USER - 261)) | (1 << (SqlBaseParser.UTF16 - 261)) | (1 << (SqlBaseParser.UTF32 - 261)) | (1 << (SqlBaseParser.UTF8 - 261)) | (1 << (SqlBaseParser.VALIDATE - 261)) | (1 << (SqlBaseParser.VALUE - 261)) | (1 << (SqlBaseParser.VERBOSE - 261)) | (1 << (SqlBaseParser.VERSION - 261)) | (1 << (SqlBaseParser.VIEW - 261)) | (1 << (SqlBaseParser.WINDOW - 261)) | (1 << (SqlBaseParser.WITHIN - 261)) | (1 << (SqlBaseParser.WITHOUT - 261)) | (1 << (SqlBaseParser.WORK - 261)) | (1 << (SqlBaseParser.WRAPPER - 261)) | (1 << (SqlBaseParser.WRITE - 261)) | (1 << (SqlBaseParser.YEAR - 261)) | (1 << (SqlBaseParser.ZONE - 261)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[18] = self.queryTerm_sempred
        self._predicates[30] = self.relation_sempred
        self._predicates[56] = self.booleanExpression_sempred
        self._predicates[58] = self.valueExpression_sempred
        self._predicates[59] = self.primaryExpression_sempred
        self._predicates[79] = self.type__sempred
        self._predicates[89] = self.rowPattern_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def queryTerm_sempred(self, localctx:QueryTermContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 1:
                return self.precpred(self._ctx, 1)
         

    def relation_sempred(self, localctx:RelationContext, predIndex:int):
            if predIndex == 2:
                return self.precpred(self._ctx, 2)
         

    def booleanExpression_sempred(self, localctx:BooleanExpressionContext, predIndex:int):
            if predIndex == 3:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 1)
         

    def valueExpression_sempred(self, localctx:ValueExpressionContext, predIndex:int):
            if predIndex == 5:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 6:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 1)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 5)
         

    def primaryExpression_sempred(self, localctx:PrimaryExpressionContext, predIndex:int):
            if predIndex == 9:
                return self.precpred(self._ctx, 24)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 22)
         

    def type__sempred(self, localctx:Type_Context, predIndex:int):
            if predIndex == 11:
                return self.precpred(self._ctx, 2)
         

    def rowPattern_sempred(self, localctx:RowPatternContext, predIndex:int):
            if predIndex == 12:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 13:
                return self.precpred(self._ctx, 1)
         




